← 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: John Arbash Meinel
  • Date: 2007-04-12 21:33:07 UTC
  • mfrom: (2413.4.1 api-doc-builders)
  • mto: This revision was merged to the branch mainline in revision 2566.
  • Revision ID: john@arbash-meinel.com-20070412213307-kuh07cnzaud12wx1
[merge] api-doc-builder and remove the pydoctor build code for now.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_lockdir.py
1
 
# Copyright (C) 2006, 2007, 2008, 2010 Canonical Ltd
 
1
# Copyright (C) 2006 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
16
16
 
17
17
"""Tests for LockDir"""
18
18
 
25
25
from bzrlib import (
26
26
    config,
27
27
    errors,
28
 
    lock,
29
28
    osutils,
30
29
    tests,
31
 
    transport,
32
30
    )
33
31
from bzrlib.errors import (
34
 
    LockBreakMismatch,
35
 
    LockBroken,
36
 
    LockContention,
37
 
    LockError,
38
 
    LockFailed,
39
 
    LockNotHeld,
40
 
    )
 
32
        LockBreakMismatch,
 
33
        LockContention, LockError, UnlockableTransport,
 
34
        LockNotHeld, LockBroken
 
35
        )
41
36
from bzrlib.lockdir import LockDir
42
37
from bzrlib.tests import TestCaseWithTransport
43
38
from bzrlib.trace import note
109
104
        """Fail to create lock on readonly transport"""
110
105
        t = self.get_readonly_transport()
111
106
        lf = LockDir(t, 'test_lock')
112
 
        self.assertRaises(LockFailed, lf.create)
 
107
        self.assertRaises(UnlockableTransport, lf.create)
113
108
 
114
109
    def test_12_lock_readonly_transport(self):
115
110
        """Fail to lock on readonly transport"""
116
111
        lf = LockDir(self.get_transport(), 'test_lock')
117
112
        lf.create()
118
113
        lf = LockDir(self.get_readonly_transport(), 'test_lock')
119
 
        self.assertRaises(LockFailed, lf.attempt_lock)
 
114
        self.assertRaises(UnlockableTransport, lf.attempt_lock)
120
115
 
121
116
    def test_20_lock_contested(self):
122
117
        """Contention to get a lock"""
126
121
        lf1.attempt_lock()
127
122
        lf2 = LockDir(t, 'test_lock')
128
123
        try:
129
 
            # locking is between LockDir instances; aliases within
 
124
            # locking is between LockDir instances; aliases within 
130
125
            # a single process are not detected
131
126
            lf2.attempt_lock()
132
127
            self.fail('Failed to detect lock collision')
142
137
        lf1 = LockDir(t, 'test_lock')
143
138
        lf1.create()
144
139
        lf1.attempt_lock()
145
 
        self.addCleanup(lf1.unlock)
146
140
        # lock is held, should get some info on it
147
141
        info1 = lf1.peek()
148
142
        self.assertEqual(set(info1.keys()),
162
156
        lf2 = LockDir(self.get_readonly_transport(), 'test_lock')
163
157
        self.assertEqual(lf2.peek(), None)
164
158
        lf1.attempt_lock()
165
 
        self.addCleanup(lf1.unlock)
166
159
        info2 = lf2.peek()
167
160
        self.assertTrue(info2)
168
161
        self.assertEqual(info2['nonce'], lf1.nonce)
169
162
 
170
163
    def test_30_lock_wait_fail(self):
171
164
        """Wait on a lock, then fail
172
 
 
 
165
        
173
166
        We ask to wait up to 400ms; this should fail within at most one
174
167
        second.  (Longer times are more realistic but we don't want the test
175
168
        suite to take too long, and this should do for now.)
187
180
            after = time.time()
188
181
            # it should only take about 0.4 seconds, but we allow more time in
189
182
            # case the machine is heavily loaded
190
 
            self.assertTrue(after - before <= 8.0,
 
183
            self.assertTrue(after - before <= 8.0, 
191
184
                    "took %f seconds to detect lock contention" % (after - before))
192
185
        finally:
193
186
            lf1.unlock()
194
187
        lock_base = lf2.transport.abspath(lf2.path)
195
188
        self.assertEqual(1, len(self._logged_reports))
196
 
        lock_url = lf2.transport.abspath(lf2.path)
197
189
        self.assertEqual('%s %s\n'
198
190
                         '%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.',
 
191
                         'Will continue to try until %s\n',
202
192
                         self._logged_reports[0][0])
203
193
        args = self._logged_reports[0][1]
204
194
        self.assertEqual('Unable to obtain', args[0])
227
217
    def test_32_lock_wait_succeed(self):
228
218
        """Succeed when trying to acquire a lock that gets released
229
219
 
230
 
        One thread holds on a lock and then releases it; another
 
220
        One thread holds on a lock and then releases it; another 
231
221
        tries to lock it.
232
222
        """
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")
243
223
        t = self.get_transport()
244
224
        lf1 = LockDir(t, 'test_lock')
245
225
        lf1.create()
277
257
        self.assertEndsWith(args[3], ' ago')
278
258
        self.assertContainsRe(args[4], r'\d\d:\d\d:\d\d')
279
259
 
 
260
    def test_33_wait(self):
 
261
        """Succeed when waiting on a lock that gets released
 
262
 
 
263
        The difference from test_32_lock_wait_succeed is that the second 
 
264
        caller does not actually acquire the lock, but just waits for it
 
265
        to be released.  This is done over a readonly transport.
 
266
        """
 
267
        t = self.get_transport()
 
268
        lf1 = LockDir(t, 'test_lock')
 
269
        lf1.create()
 
270
        lf1.attempt_lock()
 
271
 
 
272
        def wait_and_unlock():
 
273
            time.sleep(0.1)
 
274
            lf1.unlock()
 
275
        unlocker = Thread(target=wait_and_unlock)
 
276
        unlocker.start()
 
277
        try:
 
278
            lf2 = LockDir(self.get_readonly_transport(), 'test_lock')
 
279
            before = time.time()
 
280
            # wait but don't lock
 
281
            lf2.wait(timeout=0.4, poll=0.1)
 
282
            after = time.time()
 
283
            self.assertTrue(after - before <= 1.0)
 
284
        finally:
 
285
            unlocker.join()
 
286
 
280
287
    def test_34_lock_write_waits(self):
281
 
        """LockDir.lock_write() will wait for the lock."""
 
288
        """LockDir.lock_write() will wait for the lock.""" 
282
289
        # the test suite sets the default to 0 to make deadlocks fail fast.
283
290
        # change it for this test, as we want to try a manual deadlock.
284
 
        raise tests.TestSkipped('Timing-sensitive test')
285
291
        bzrlib.lockdir._DEFAULT_TIMEOUT_SECONDS = 300
286
292
        t = self.get_transport()
287
293
        lf1 = LockDir(t, 'test_lock')
321
327
 
322
328
    def test_35_wait_lock_changing(self):
323
329
        """LockDir.wait_lock() will report if the lock changes underneath.
324
 
 
 
330
        
325
331
        This is the stages we want to happen:
326
332
 
327
333
        0) Synchronization locks are created and locked.
328
334
        1) Lock1 obtains the lockdir, and releases the 'check' lock.
329
335
        2) Lock2 grabs the 'check' lock, and checks the lockdir.
330
 
           It sees the lockdir is already acquired, reports the fact,
 
336
           It sees the lockdir is already acquired, reports the fact, 
331
337
           and unsets the 'checked' lock.
332
338
        3) Thread1 blocks on acquiring the 'checked' lock, and then tells
333
339
           Lock1 to release and acquire the lockdir. This resets the 'check'
334
340
           lock.
335
341
        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
 
342
           that the holder of the lock has changed, and so reports a new 
337
343
           lock holder.
338
344
        5) Thread1 blocks on the 'checked' lock, this time, it completely
339
345
           unlocks the lockdir, allowing Lock2 to acquire the lock.
340
346
        """
341
347
 
342
 
        raise tests.KnownFailure(
343
 
            "timing dependency in lock tests (#213182)")
344
 
 
345
348
        wait_to_check_lock = Lock()
346
349
        wait_until_checked_lock = Lock()
347
350
 
407
410
        unlocker.start()
408
411
        try:
409
412
            # Wait and play against the other thread
410
 
            lf2.wait_lock(timeout=20.0, poll=0.01)
 
413
            lf2.wait_lock(timeout=1.0, poll=0.01)
411
414
        finally:
412
415
            unlocker.join()
413
416
        lf2.unlock()
415
418
        # There should be 2 reports, because the lock changed
416
419
        lock_base = lf2.transport.abspath(lf2.path)
417
420
        self.assertEqual(2, len(self._logged_reports))
418
 
        lock_url = lf2.transport.abspath(lf2.path)
 
421
 
419
422
        self.assertEqual('%s %s\n'
420
423
                         '%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
                         'Will continue to try until %s\n',
424
425
                         self._logged_reports[0][0])
425
426
        args = self._logged_reports[0][1]
426
427
        self.assertEqual('Unable to obtain', args[0])
432
433
 
433
434
        self.assertEqual('%s %s\n'
434
435
                         '%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.',
 
436
                         'Will continue to try until %s\n',
438
437
                         self._logged_reports[1][0])
439
438
        args = self._logged_reports[1][1]
440
439
        self.assertEqual('Lock owner changed for', args[0])
450
449
        lf1 = LockDir(t, 'test_lock')
451
450
        lf1.create()
452
451
        lf1.attempt_lock()
453
 
        self.addCleanup(lf1.unlock)
454
452
        lf1.confirm()
455
453
 
456
454
    def test_41_confirm_not_held(self):
468
466
        lf1.attempt_lock()
469
467
        t.move('test_lock', 'lock_gone_now')
470
468
        self.assertRaises(LockBroken, lf1.confirm)
471
 
        # Clean up
472
 
        t.move('lock_gone_now', 'test_lock')
473
 
        lf1.unlock()
474
469
 
475
470
    def test_43_break(self):
476
471
        """Break a lock whose caller has forgotten it"""
487
482
        lf2.force_break(holder_info)
488
483
        # now we should be able to take it
489
484
        lf2.attempt_lock()
490
 
        self.addCleanup(lf2.unlock)
491
485
        lf2.confirm()
492
486
 
493
487
    def test_44_break_already_released(self):
505
499
        lf2.force_break(holder_info)
506
500
        # now we should be able to take it
507
501
        lf2.attempt_lock()
508
 
        self.addCleanup(lf2.unlock)
509
502
        lf2.confirm()
510
503
 
511
504
    def test_45_break_mismatch(self):
537
530
        """Check the on-disk representation of LockDirs is as expected.
538
531
 
539
532
        There should always be a top-level directory named by the lock.
540
 
        When the lock is held, there should be a lockname/held directory
 
533
        When the lock is held, there should be a lockname/held directory 
541
534
        containing an info file.
542
535
        """
543
536
        t = self.get_transport()
558
551
        # do this without IO redirection to ensure it doesn't prompt.
559
552
        self.assertRaises(AssertionError, ld1.break_lock)
560
553
        orig_factory = bzrlib.ui.ui_factory
561
 
        bzrlib.ui.ui_factory = bzrlib.ui.CannedInputUIFactory([True])
 
554
        # silent ui - no need for stdout
 
555
        bzrlib.ui.ui_factory = bzrlib.ui.SilentUIFactory()
 
556
        bzrlib.ui.ui_factory.stdin = StringIO("y\n")
562
557
        try:
563
558
            ld2.break_lock()
564
559
            self.assertRaises(LockBroken, ld1.unlock)
619
614
        lock_path = ld1.transport.local_abspath('test_lock')
620
615
        os.mkdir(lock_path)
621
616
        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)
 
617
        self.assertRaises(errors.PermissionDenied, ld1.attempt_lock)