← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_lockdir.py

  • Committer: Vincent Ladeuil
  • Date: 2010-02-03 07:18:36 UTC
  • mto: (5008.1.1 integration)
  • mto: This revision was merged to the branch mainline in revision 5009.
  • Revision ID: v.ladeuil+lp@free.fr-20100203071836-u9b86q68fr9ri5s6
Fix NEWS.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_lockdir.py
1
 
# Copyright (C) 2006 Canonical Ltd
 
1
# Copyright (C) 2006, 2007, 2008, 2010 Canonical Ltd
2
2
#
3
3
# This program is free software; you can redistribute it and/or modify
4
4
# it under the terms of the GNU General Public License as published by
12
12
#
13
13
# You should have received a copy of the GNU General Public License
14
14
# along with this program; if not, write to the Free Software
15
 
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
16
16
 
17
17
"""Tests for LockDir"""
18
18
 
19
19
from cStringIO import StringIO
20
 
from threading import Thread
 
20
import os
 
21
from threading import Thread, Lock
21
22
import time
22
23
 
23
24
import bzrlib
 
25
from bzrlib import (
 
26
    config,
 
27
    errors,
 
28
    lock,
 
29
    osutils,
 
30
    tests,
 
31
    transport,
 
32
    )
24
33
from bzrlib.errors import (
25
 
        LockBreakMismatch,
26
 
        LockContention, LockError, UnlockableTransport,
27
 
        LockNotHeld, LockBroken
28
 
        )
 
34
    LockBreakMismatch,
 
35
    LockBroken,
 
36
    LockContention,
 
37
    LockError,
 
38
    LockFailed,
 
39
    LockNotHeld,
 
40
    )
29
41
from bzrlib.lockdir import LockDir
30
42
from bzrlib.tests import TestCaseWithTransport
 
43
from bzrlib.trace import note
31
44
 
32
45
# These tests sometimes use threads to test the behaviour of lock files with
33
46
# concurrent actors.  This is not a typical (or necessarily supported) use;
42
55
class TestLockDir(TestCaseWithTransport):
43
56
    """Test LockDir operations"""
44
57
 
 
58
    def logging_report_function(self, fmt, *args):
 
59
        self._logged_reports.append((fmt, args))
 
60
 
 
61
    def setup_log_reporter(self, lock_dir):
 
62
        self._logged_reports = []
 
63
        lock_dir._report_function = self.logging_report_function
 
64
 
45
65
    def test_00_lock_creation(self):
46
66
        """Creation of lock file on a transport"""
47
67
        t = self.get_transport()
89
109
        """Fail to create lock on readonly transport"""
90
110
        t = self.get_readonly_transport()
91
111
        lf = LockDir(t, 'test_lock')
92
 
        self.assertRaises(UnlockableTransport, lf.create)
 
112
        self.assertRaises(LockFailed, lf.create)
93
113
 
94
114
    def test_12_lock_readonly_transport(self):
95
115
        """Fail to lock on readonly transport"""
96
116
        lf = LockDir(self.get_transport(), 'test_lock')
97
117
        lf.create()
98
118
        lf = LockDir(self.get_readonly_transport(), 'test_lock')
99
 
        self.assertRaises(UnlockableTransport, lf.attempt_lock)
 
119
        self.assertRaises(LockFailed, lf.attempt_lock)
100
120
 
101
121
    def test_20_lock_contested(self):
102
122
        """Contention to get a lock"""
106
126
        lf1.attempt_lock()
107
127
        lf2 = LockDir(t, 'test_lock')
108
128
        try:
109
 
            # locking is between LockDir instances; aliases within 
 
129
            # locking is between LockDir instances; aliases within
110
130
            # a single process are not detected
111
131
            lf2.attempt_lock()
112
132
            self.fail('Failed to detect lock collision')
122
142
        lf1 = LockDir(t, 'test_lock')
123
143
        lf1.create()
124
144
        lf1.attempt_lock()
 
145
        self.addCleanup(lf1.unlock)
125
146
        # lock is held, should get some info on it
126
147
        info1 = lf1.peek()
127
148
        self.assertEqual(set(info1.keys()),
141
162
        lf2 = LockDir(self.get_readonly_transport(), 'test_lock')
142
163
        self.assertEqual(lf2.peek(), None)
143
164
        lf1.attempt_lock()
 
165
        self.addCleanup(lf1.unlock)
144
166
        info2 = lf2.peek()
145
167
        self.assertTrue(info2)
146
168
        self.assertEqual(info2['nonce'], lf1.nonce)
147
169
 
148
170
    def test_30_lock_wait_fail(self):
149
171
        """Wait on a lock, then fail
150
 
        
 
172
 
151
173
        We ask to wait up to 400ms; this should fail within at most one
152
174
        second.  (Longer times are more realistic but we don't want the test
153
175
        suite to take too long, and this should do for now.)
156
178
        lf1 = LockDir(t, 'test_lock')
157
179
        lf1.create()
158
180
        lf2 = LockDir(t, 'test_lock')
 
181
        self.setup_log_reporter(lf2)
159
182
        lf1.attempt_lock()
160
183
        try:
161
184
            before = time.time()
164
187
            after = time.time()
165
188
            # it should only take about 0.4 seconds, but we allow more time in
166
189
            # case the machine is heavily loaded
167
 
            self.assertTrue(after - before <= 8.0, 
 
190
            self.assertTrue(after - before <= 8.0,
168
191
                    "took %f seconds to detect lock contention" % (after - before))
169
192
        finally:
170
193
            lf1.unlock()
 
194
        lock_base = lf2.transport.abspath(lf2.path)
 
195
        self.assertEqual(1, len(self._logged_reports))
 
196
        lock_url = lf2.transport.abspath(lf2.path)
 
197
        self.assertEqual('%s %s\n'
 
198
                         '%s\n%s\n'
 
199
                         'Will continue to try until %s, unless '
 
200
                         'you press Ctrl-C.\n'
 
201
                         'See "bzr help break-lock" for more.',
 
202
                         self._logged_reports[0][0])
 
203
        args = self._logged_reports[0][1]
 
204
        self.assertEqual('Unable to obtain', args[0])
 
205
        self.assertEqual('lock %s' % (lock_base,), args[1])
 
206
        self.assertStartsWith(args[2], 'held by ')
 
207
        self.assertStartsWith(args[3], 'locked ')
 
208
        self.assertEndsWith(args[3], ' ago')
 
209
        self.assertContainsRe(args[4], r'\d\d:\d\d:\d\d')
171
210
 
172
211
    def test_31_lock_wait_easy(self):
173
212
        """Succeed when waiting on a lock with no contention.
175
214
        t = self.get_transport()
176
215
        lf1 = LockDir(t, 'test_lock')
177
216
        lf1.create()
 
217
        self.setup_log_reporter(lf1)
178
218
        try:
179
219
            before = time.time()
180
220
            lf1.wait_lock(timeout=0.4, poll=0.1)
182
222
            self.assertTrue(after - before <= 1.0)
183
223
        finally:
184
224
            lf1.unlock()
 
225
        self.assertEqual([], self._logged_reports)
185
226
 
186
227
    def test_32_lock_wait_succeed(self):
187
228
        """Succeed when trying to acquire a lock that gets released
188
229
 
189
 
        One thread holds on a lock and then releases it; another 
 
230
        One thread holds on a lock and then releases it; another
190
231
        tries to lock it.
191
232
        """
 
233
        # This test sometimes fails like this:
 
234
        # Traceback (most recent call last):
 
235
 
 
236
        #   File "/home/pqm/bzr-pqm-workdir/home/+trunk/bzrlib/tests/
 
237
        # test_lockdir.py", line 247, in test_32_lock_wait_succeed
 
238
        #     self.assertEqual(1, len(self._logged_reports))
 
239
        # AssertionError: not equal:
 
240
        # a = 1
 
241
        # b = 0
 
242
        raise tests.TestSkipped("Test fails intermittently")
192
243
        t = self.get_transport()
193
244
        lf1 = LockDir(t, 'test_lock')
194
245
        lf1.create()
201
252
        unlocker.start()
202
253
        try:
203
254
            lf2 = LockDir(t, 'test_lock')
 
255
            self.setup_log_reporter(lf2)
204
256
            before = time.time()
205
257
            # wait and then lock
206
258
            lf2.wait_lock(timeout=0.4, poll=0.1)
209
261
        finally:
210
262
            unlocker.join()
211
263
 
212
 
    def test_33_wait(self):
213
 
        """Succeed when waiting on a lock that gets released
 
264
        # There should be only 1 report, even though it should have to
 
265
        # wait for a while
 
266
        lock_base = lf2.transport.abspath(lf2.path)
 
267
        self.assertEqual(1, len(self._logged_reports))
 
268
        self.assertEqual('%s %s\n'
 
269
                         '%s\n%s\n'
 
270
                         'Will continue to try until %s\n',
 
271
                         self._logged_reports[0][0])
 
272
        args = self._logged_reports[0][1]
 
273
        self.assertEqual('Unable to obtain', args[0])
 
274
        self.assertEqual('lock %s' % (lock_base,), args[1])
 
275
        self.assertStartsWith(args[2], 'held by ')
 
276
        self.assertStartsWith(args[3], 'locked ')
 
277
        self.assertEndsWith(args[3], ' ago')
 
278
        self.assertContainsRe(args[4], r'\d\d:\d\d:\d\d')
214
279
 
215
 
        The difference from test_32_lock_wait_succeed is that the second 
216
 
        caller does not actually acquire the lock, but just waits for it
217
 
        to be released.  This is done over a readonly transport.
218
 
        """
 
280
    def test_34_lock_write_waits(self):
 
281
        """LockDir.lock_write() will wait for the lock."""
 
282
        # the test suite sets the default to 0 to make deadlocks fail fast.
 
283
        # change it for this test, as we want to try a manual deadlock.
 
284
        raise tests.TestSkipped('Timing-sensitive test')
 
285
        bzrlib.lockdir._DEFAULT_TIMEOUT_SECONDS = 300
219
286
        t = self.get_transport()
220
287
        lf1 = LockDir(t, 'test_lock')
221
288
        lf1.create()
227
294
        unlocker = Thread(target=wait_and_unlock)
228
295
        unlocker.start()
229
296
        try:
230
 
            lf2 = LockDir(self.get_readonly_transport(), 'test_lock')
 
297
            lf2 = LockDir(t, 'test_lock')
 
298
            self.setup_log_reporter(lf2)
231
299
            before = time.time()
232
 
            # wait but don't lock
233
 
            lf2.wait(timeout=0.4, poll=0.1)
 
300
            # wait and then lock
 
301
            lf2.lock_write()
234
302
            after = time.time()
235
 
            self.assertTrue(after - before <= 1.0)
236
 
        finally:
237
 
            unlocker.join()
 
303
        finally:
 
304
            unlocker.join()
 
305
 
 
306
        # There should be only 1 report, even though it should have to
 
307
        # wait for a while
 
308
        lock_base = lf2.transport.abspath(lf2.path)
 
309
        self.assertEqual(1, len(self._logged_reports))
 
310
        self.assertEqual('%s %s\n'
 
311
                         '%s\n%s\n'
 
312
                         'Will continue to try until %s\n',
 
313
                         self._logged_reports[0][0])
 
314
        args = self._logged_reports[0][1]
 
315
        self.assertEqual('Unable to obtain', args[0])
 
316
        self.assertEqual('lock %s' % (lock_base,), args[1])
 
317
        self.assertStartsWith(args[2], 'held by ')
 
318
        self.assertStartsWith(args[3], 'locked ')
 
319
        self.assertEndsWith(args[3], ' ago')
 
320
        self.assertContainsRe(args[4], r'\d\d:\d\d:\d\d')
 
321
 
 
322
    def test_35_wait_lock_changing(self):
 
323
        """LockDir.wait_lock() will report if the lock changes underneath.
 
324
 
 
325
        This is the stages we want to happen:
 
326
 
 
327
        0) Synchronization locks are created and locked.
 
328
        1) Lock1 obtains the lockdir, and releases the 'check' lock.
 
329
        2) Lock2 grabs the 'check' lock, and checks the lockdir.
 
330
           It sees the lockdir is already acquired, reports the fact,
 
331
           and unsets the 'checked' lock.
 
332
        3) Thread1 blocks on acquiring the 'checked' lock, and then tells
 
333
           Lock1 to release and acquire the lockdir. This resets the 'check'
 
334
           lock.
 
335
        4) Lock2 acquires the 'check' lock, and checks again. It notices
 
336
           that the holder of the lock has changed, and so reports a new
 
337
           lock holder.
 
338
        5) Thread1 blocks on the 'checked' lock, this time, it completely
 
339
           unlocks the lockdir, allowing Lock2 to acquire the lock.
 
340
        """
 
341
 
 
342
        raise tests.KnownFailure(
 
343
            "timing dependency in lock tests (#213182)")
 
344
 
 
345
        wait_to_check_lock = Lock()
 
346
        wait_until_checked_lock = Lock()
 
347
 
 
348
        wait_to_check_lock.acquire()
 
349
        wait_until_checked_lock.acquire()
 
350
        note('locked check and checked locks')
 
351
 
 
352
        class LockDir1(LockDir):
 
353
            """Use the synchronization points for the first lock."""
 
354
 
 
355
            def attempt_lock(self):
 
356
                # Once we have acquired the lock, it is okay for
 
357
                # the other lock to check it
 
358
                try:
 
359
                    return super(LockDir1, self).attempt_lock()
 
360
                finally:
 
361
                    note('lock1: releasing check lock')
 
362
                    wait_to_check_lock.release()
 
363
 
 
364
        class LockDir2(LockDir):
 
365
            """Use the synchronization points for the second lock."""
 
366
 
 
367
            def attempt_lock(self):
 
368
                note('lock2: waiting for check lock')
 
369
                wait_to_check_lock.acquire()
 
370
                note('lock2: acquired check lock')
 
371
                try:
 
372
                    return super(LockDir2, self).attempt_lock()
 
373
                finally:
 
374
                    note('lock2: releasing checked lock')
 
375
                    wait_until_checked_lock.release()
 
376
 
 
377
        t = self.get_transport()
 
378
        lf1 = LockDir1(t, 'test_lock')
 
379
        lf1.create()
 
380
 
 
381
        lf2 = LockDir2(t, 'test_lock')
 
382
        self.setup_log_reporter(lf2)
 
383
 
 
384
        def wait_and_switch():
 
385
            lf1.attempt_lock()
 
386
            # Block until lock2 has had a chance to check
 
387
            note('lock1: waiting 1 for checked lock')
 
388
            wait_until_checked_lock.acquire()
 
389
            note('lock1: acquired for checked lock')
 
390
            note('lock1: released lockdir')
 
391
            lf1.unlock()
 
392
            note('lock1: acquiring lockdir')
 
393
            # Create a new nonce, so the lock looks different.
 
394
            lf1.nonce = osutils.rand_chars(20)
 
395
            lf1.lock_write()
 
396
            note('lock1: acquired lockdir')
 
397
 
 
398
            # Block until lock2 has peeked again
 
399
            note('lock1: waiting 2 for checked lock')
 
400
            wait_until_checked_lock.acquire()
 
401
            note('lock1: acquired for checked lock')
 
402
            # Now unlock, and let lock 2 grab the lock
 
403
            lf1.unlock()
 
404
            wait_to_check_lock.release()
 
405
 
 
406
        unlocker = Thread(target=wait_and_switch)
 
407
        unlocker.start()
 
408
        try:
 
409
            # Wait and play against the other thread
 
410
            lf2.wait_lock(timeout=20.0, poll=0.01)
 
411
        finally:
 
412
            unlocker.join()
 
413
        lf2.unlock()
 
414
 
 
415
        # There should be 2 reports, because the lock changed
 
416
        lock_base = lf2.transport.abspath(lf2.path)
 
417
        self.assertEqual(2, len(self._logged_reports))
 
418
        lock_url = lf2.transport.abspath(lf2.path)
 
419
        self.assertEqual('%s %s\n'
 
420
                         '%s\n%s\n'
 
421
                         'Will continue to try until %s, unless '
 
422
                         'you press Ctrl-C.\n'
 
423
                         'See "bzr help break-lock" for more.',
 
424
                         self._logged_reports[0][0])
 
425
        args = self._logged_reports[0][1]
 
426
        self.assertEqual('Unable to obtain', args[0])
 
427
        self.assertEqual('lock %s' % (lock_base,), args[1])
 
428
        self.assertStartsWith(args[2], 'held by ')
 
429
        self.assertStartsWith(args[3], 'locked ')
 
430
        self.assertEndsWith(args[3], ' ago')
 
431
        self.assertContainsRe(args[4], r'\d\d:\d\d:\d\d')
 
432
 
 
433
        self.assertEqual('%s %s\n'
 
434
                         '%s\n%s\n'
 
435
                         'Will continue to try until %s, unless '
 
436
                         'you press Ctrl-C.\n'
 
437
                         'See "bzr help break-lock" for more.',
 
438
                         self._logged_reports[1][0])
 
439
        args = self._logged_reports[1][1]
 
440
        self.assertEqual('Lock owner changed for', args[0])
 
441
        self.assertEqual('lock %s' % (lock_base,), args[1])
 
442
        self.assertStartsWith(args[2], 'held by ')
 
443
        self.assertStartsWith(args[3], 'locked ')
 
444
        self.assertEndsWith(args[3], ' ago')
 
445
        self.assertContainsRe(args[4], r'\d\d:\d\d:\d\d')
238
446
 
239
447
    def test_40_confirm_easy(self):
240
448
        """Confirm a lock that's already held"""
242
450
        lf1 = LockDir(t, 'test_lock')
243
451
        lf1.create()
244
452
        lf1.attempt_lock()
 
453
        self.addCleanup(lf1.unlock)
245
454
        lf1.confirm()
246
455
 
247
456
    def test_41_confirm_not_held(self):
259
468
        lf1.attempt_lock()
260
469
        t.move('test_lock', 'lock_gone_now')
261
470
        self.assertRaises(LockBroken, lf1.confirm)
 
471
        # Clean up
 
472
        t.move('lock_gone_now', 'test_lock')
 
473
        lf1.unlock()
262
474
 
263
475
    def test_43_break(self):
264
476
        """Break a lock whose caller has forgotten it"""
275
487
        lf2.force_break(holder_info)
276
488
        # now we should be able to take it
277
489
        lf2.attempt_lock()
 
490
        self.addCleanup(lf2.unlock)
278
491
        lf2.confirm()
279
492
 
280
493
    def test_44_break_already_released(self):
292
505
        lf2.force_break(holder_info)
293
506
        # now we should be able to take it
294
507
        lf2.attempt_lock()
 
508
        self.addCleanup(lf2.unlock)
295
509
        lf2.confirm()
296
510
 
297
511
    def test_45_break_mismatch(self):
323
537
        """Check the on-disk representation of LockDirs is as expected.
324
538
 
325
539
        There should always be a top-level directory named by the lock.
326
 
        When the lock is held, there should be a lockname/held directory 
 
540
        When the lock is held, there should be a lockname/held directory
327
541
        containing an info file.
328
542
        """
329
543
        t = self.get_transport()
344
558
        # do this without IO redirection to ensure it doesn't prompt.
345
559
        self.assertRaises(AssertionError, ld1.break_lock)
346
560
        orig_factory = bzrlib.ui.ui_factory
347
 
        # silent ui - no need for stdout
348
 
        bzrlib.ui.ui_factory = bzrlib.ui.SilentUIFactory()
349
 
        bzrlib.ui.ui_factory.stdin = StringIO("y\n")
 
561
        bzrlib.ui.ui_factory = bzrlib.ui.CannedInputUIFactory([True])
350
562
        try:
351
563
            ld2.break_lock()
352
564
            self.assertRaises(LockBroken, ld1.unlock)
353
565
        finally:
354
566
            bzrlib.ui.ui_factory = orig_factory
 
567
 
 
568
    def test_create_missing_base_directory(self):
 
569
        """If LockDir.path doesn't exist, it can be created
 
570
 
 
571
        Some people manually remove the entire lock/ directory trying
 
572
        to unlock a stuck repository/branch/etc. Rather than failing
 
573
        after that, just create the lock directory when needed.
 
574
        """
 
575
        t = self.get_transport()
 
576
        lf1 = LockDir(t, 'test_lock')
 
577
 
 
578
        lf1.create()
 
579
        self.failUnless(t.has('test_lock'))
 
580
 
 
581
        t.rmdir('test_lock')
 
582
        self.failIf(t.has('test_lock'))
 
583
 
 
584
        # This will create 'test_lock' if it needs to
 
585
        lf1.lock_write()
 
586
        self.failUnless(t.has('test_lock'))
 
587
        self.failUnless(t.has('test_lock/held/info'))
 
588
 
 
589
        lf1.unlock()
 
590
        self.failIf(t.has('test_lock/held/info'))
 
591
 
 
592
    def test__format_lock_info(self):
 
593
        ld1 = self.get_lock()
 
594
        ld1.create()
 
595
        ld1.lock_write()
 
596
        try:
 
597
            info_list = ld1._format_lock_info(ld1.peek())
 
598
        finally:
 
599
            ld1.unlock()
 
600
        self.assertEqual('lock %s' % (ld1.transport.abspath(ld1.path),),
 
601
                         info_list[0])
 
602
        self.assertContainsRe(info_list[1],
 
603
                              r'^held by .* on host .* \[process #\d*\]$')
 
604
        self.assertContainsRe(info_list[2], r'locked \d+ seconds? ago$')
 
605
 
 
606
    def test_lock_without_email(self):
 
607
        global_config = config.GlobalConfig()
 
608
        # Intentionally has no email address
 
609
        global_config.set_user_option('email', 'User Identity')
 
610
        ld1 = self.get_lock()
 
611
        ld1.create()
 
612
        ld1.lock_write()
 
613
        ld1.unlock()
 
614
 
 
615
    def test_lock_permission(self):
 
616
        if not osutils.supports_posix_readonly():
 
617
            raise tests.TestSkipped('Cannot induce a permission failure')
 
618
        ld1 = self.get_lock()
 
619
        lock_path = ld1.transport.local_abspath('test_lock')
 
620
        os.mkdir(lock_path)
 
621
        osutils.make_readonly(lock_path)
 
622
        self.assertRaises(errors.LockFailed, ld1.attempt_lock)
 
623
 
 
624
    def test_lock_by_token(self):
 
625
        ld1 = self.get_lock()
 
626
        token = ld1.lock_write()
 
627
        self.addCleanup(ld1.unlock)
 
628
        self.assertNotEqual(None, token)
 
629
        ld2 = self.get_lock()
 
630
        t2 = ld2.lock_write(token)
 
631
        self.addCleanup(ld2.unlock)
 
632
        self.assertEqual(token, t2)
 
633
 
 
634
    def test_lock_with_buggy_rename(self):
 
635
        # test that lock acquisition handles servers which pretend they
 
636
        # renamed correctly but that actually fail
 
637
        t = transport.get_transport('brokenrename+' + self.get_url())
 
638
        ld1 = LockDir(t, 'test_lock')
 
639
        ld1.create()
 
640
        ld1.attempt_lock()
 
641
        ld2 = LockDir(t, 'test_lock')
 
642
        # we should fail to lock
 
643
        e = self.assertRaises(errors.LockContention, ld2.attempt_lock)
 
644
        # now the original caller should succeed in unlocking
 
645
        ld1.unlock()
 
646
        # and there should be nothing left over
 
647
        self.assertEquals([], t.list_dir('test_lock'))
 
648
 
 
649
    def test_failed_lock_leaves_no_trash(self):
 
650
        # if we fail to acquire the lock, we don't leave pending directories
 
651
        # behind -- https://bugs.launchpad.net/bzr/+bug/109169
 
652
        ld1 = self.get_lock()
 
653
        ld2 = self.get_lock()
 
654
        # should be nothing before we start
 
655
        ld1.create()
 
656
        t = self.get_transport().clone('test_lock')
 
657
        def check_dir(a):
 
658
            self.assertEquals(a, t.list_dir('.'))
 
659
        check_dir([])
 
660
        # when held, that's all we see
 
661
        ld1.attempt_lock()
 
662
        self.addCleanup(ld1.unlock)
 
663
        check_dir(['held'])
 
664
        # second guy should fail
 
665
        self.assertRaises(errors.LockContention, ld2.attempt_lock)
 
666
        # no kibble
 
667
        check_dir(['held'])
 
668
 
 
669
 
 
670
class TestLockDirHooks(TestCaseWithTransport):
 
671
 
 
672
    def setUp(self):
 
673
        super(TestLockDirHooks, self).setUp()
 
674
        self._calls = []
 
675
 
 
676
    def get_lock(self):
 
677
        return LockDir(self.get_transport(), 'test_lock')
 
678
 
 
679
    def record_hook(self, result):
 
680
        self._calls.append(result)
 
681
 
 
682
    def test_LockDir_acquired_success(self):
 
683
        # the LockDir.lock_acquired hook fires when a lock is acquired.
 
684
        LockDir.hooks.install_named_hook('lock_acquired',
 
685
                                         self.record_hook, 'record_hook')
 
686
        ld = self.get_lock()
 
687
        ld.create()
 
688
        self.assertEqual([], self._calls)
 
689
        result = ld.attempt_lock()
 
690
        lock_path = ld.transport.abspath(ld.path)
 
691
        self.assertEqual([lock.LockResult(lock_path, result)], self._calls)
 
692
        ld.unlock()
 
693
        self.assertEqual([lock.LockResult(lock_path, result)], self._calls)
 
694
 
 
695
    def test_LockDir_acquired_fail(self):
 
696
        # the LockDir.lock_acquired hook does not fire on failure.
 
697
        ld = self.get_lock()
 
698
        ld.create()
 
699
        ld2 = self.get_lock()
 
700
        ld2.attempt_lock()
 
701
        # install a lock hook now, when the disk lock is locked
 
702
        LockDir.hooks.install_named_hook('lock_acquired',
 
703
                                         self.record_hook, 'record_hook')
 
704
        self.assertRaises(errors.LockContention, ld.attempt_lock)
 
705
        self.assertEqual([], self._calls)
 
706
        ld2.unlock()
 
707
        self.assertEqual([], self._calls)
 
708
 
 
709
    def test_LockDir_released_success(self):
 
710
        # the LockDir.lock_released hook fires when a lock is acquired.
 
711
        LockDir.hooks.install_named_hook('lock_released',
 
712
                                         self.record_hook, 'record_hook')
 
713
        ld = self.get_lock()
 
714
        ld.create()
 
715
        self.assertEqual([], self._calls)
 
716
        result = ld.attempt_lock()
 
717
        self.assertEqual([], self._calls)
 
718
        ld.unlock()
 
719
        lock_path = ld.transport.abspath(ld.path)
 
720
        self.assertEqual([lock.LockResult(lock_path, result)], self._calls)
 
721
 
 
722
    def test_LockDir_released_fail(self):
 
723
        # the LockDir.lock_released hook does not fire on failure.
 
724
        ld = self.get_lock()
 
725
        ld.create()
 
726
        ld2 = self.get_lock()
 
727
        ld.attempt_lock()
 
728
        ld2.force_break(ld2.peek())
 
729
        LockDir.hooks.install_named_hook('lock_released',
 
730
                                         self.record_hook, 'record_hook')
 
731
        self.assertRaises(LockBroken, ld.unlock)
 
732
        self.assertEqual([], self._calls)
 
733
 
 
734
    def test_LockDir_broken_success(self):
 
735
        # the LockDir.lock_broken hook fires when a lock is broken.
 
736
        ld = self.get_lock()
 
737
        ld.create()
 
738
        ld2 = self.get_lock()
 
739
        result = ld.attempt_lock()
 
740
        LockDir.hooks.install_named_hook('lock_broken',
 
741
                                         self.record_hook, 'record_hook')
 
742
        ld2.force_break(ld2.peek())
 
743
        lock_path = ld.transport.abspath(ld.path)
 
744
        self.assertEqual([lock.LockResult(lock_path, result)], self._calls)
 
745
 
 
746
    def test_LockDir_broken_failure(self):
 
747
        # the LockDir.lock_broken hook does not fires when a lock is already
 
748
        # released.
 
749
        ld = self.get_lock()
 
750
        ld.create()
 
751
        ld2 = self.get_lock()
 
752
        result = ld.attempt_lock()
 
753
        holder_info = ld2.peek()
 
754
        ld.unlock()
 
755
        LockDir.hooks.install_named_hook('lock_broken',
 
756
                                         self.record_hook, 'record_hook')
 
757
        ld2.force_break(holder_info)
 
758
        lock_path = ld.transport.abspath(ld.path)
 
759
        self.assertEqual([], self._calls)