← 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: Martin Pool
  • Date: 2008-10-20 23:58:12 UTC
  • mto: This revision was merged to the branch mainline in revision 3787.
  • Revision ID: mbp@sourcefrog.net-20081020235812-itg90mk0u4dez92z
lp-upload-release now handles names like bzr-1.8.tar.gz

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, 2007, 2008 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
 
126
126
        lf1.attempt_lock()
127
127
        lf2 = LockDir(t, 'test_lock')
128
128
        try:
129
 
            # locking is between LockDir instances; aliases within
 
129
            # locking is between LockDir instances; aliases within 
130
130
            # a single process are not detected
131
131
            lf2.attempt_lock()
132
132
            self.fail('Failed to detect lock collision')
142
142
        lf1 = LockDir(t, 'test_lock')
143
143
        lf1.create()
144
144
        lf1.attempt_lock()
145
 
        self.addCleanup(lf1.unlock)
146
145
        # lock is held, should get some info on it
147
146
        info1 = lf1.peek()
148
147
        self.assertEqual(set(info1.keys()),
162
161
        lf2 = LockDir(self.get_readonly_transport(), 'test_lock')
163
162
        self.assertEqual(lf2.peek(), None)
164
163
        lf1.attempt_lock()
165
 
        self.addCleanup(lf1.unlock)
166
164
        info2 = lf2.peek()
167
165
        self.assertTrue(info2)
168
166
        self.assertEqual(info2['nonce'], lf1.nonce)
169
167
 
170
168
    def test_30_lock_wait_fail(self):
171
169
        """Wait on a lock, then fail
172
 
 
 
170
        
173
171
        We ask to wait up to 400ms; this should fail within at most one
174
172
        second.  (Longer times are more realistic but we don't want the test
175
173
        suite to take too long, and this should do for now.)
187
185
            after = time.time()
188
186
            # it should only take about 0.4 seconds, but we allow more time in
189
187
            # case the machine is heavily loaded
190
 
            self.assertTrue(after - before <= 8.0,
 
188
            self.assertTrue(after - before <= 8.0, 
191
189
                    "took %f seconds to detect lock contention" % (after - before))
192
190
        finally:
193
191
            lf1.unlock()
197
195
        self.assertEqual('%s %s\n'
198
196
                         '%s\n%s\n'
199
197
                         'Will continue to try until %s, unless '
200
 
                         'you press Ctrl-C.\n'
201
 
                         'See "bzr help break-lock" for more.',
 
198
                         'you press Ctrl-C\n'
 
199
                         'If you\'re sure that it\'s not being '
 
200
                         'modified, use bzr break-lock %s',
202
201
                         self._logged_reports[0][0])
203
202
        args = self._logged_reports[0][1]
204
203
        self.assertEqual('Unable to obtain', args[0])
227
226
    def test_32_lock_wait_succeed(self):
228
227
        """Succeed when trying to acquire a lock that gets released
229
228
 
230
 
        One thread holds on a lock and then releases it; another
 
229
        One thread holds on a lock and then releases it; another 
231
230
        tries to lock it.
232
231
        """
233
232
        # This test sometimes fails like this:
278
277
        self.assertContainsRe(args[4], r'\d\d:\d\d:\d\d')
279
278
 
280
279
    def test_34_lock_write_waits(self):
281
 
        """LockDir.lock_write() will wait for the lock."""
 
280
        """LockDir.lock_write() will wait for the lock.""" 
282
281
        # the test suite sets the default to 0 to make deadlocks fail fast.
283
282
        # change it for this test, as we want to try a manual deadlock.
284
283
        raise tests.TestSkipped('Timing-sensitive test')
321
320
 
322
321
    def test_35_wait_lock_changing(self):
323
322
        """LockDir.wait_lock() will report if the lock changes underneath.
324
 
 
 
323
        
325
324
        This is the stages we want to happen:
326
325
 
327
326
        0) Synchronization locks are created and locked.
328
327
        1) Lock1 obtains the lockdir, and releases the 'check' lock.
329
328
        2) Lock2 grabs the 'check' lock, and checks the lockdir.
330
 
           It sees the lockdir is already acquired, reports the fact,
 
329
           It sees the lockdir is already acquired, reports the fact, 
331
330
           and unsets the 'checked' lock.
332
331
        3) Thread1 blocks on acquiring the 'checked' lock, and then tells
333
332
           Lock1 to release and acquire the lockdir. This resets the 'check'
334
333
           lock.
335
334
        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
 
335
           that the holder of the lock has changed, and so reports a new 
337
336
           lock holder.
338
337
        5) Thread1 blocks on the 'checked' lock, this time, it completely
339
338
           unlocks the lockdir, allowing Lock2 to acquire the lock.
419
418
        self.assertEqual('%s %s\n'
420
419
                         '%s\n%s\n'
421
420
                         'Will continue to try until %s, unless '
422
 
                         'you press Ctrl-C.\n'
423
 
                         'See "bzr help break-lock" for more.',
 
421
                         'you press Ctrl-C\n'
 
422
                         'If you\'re sure that it\'s not being '
 
423
                         'modified, use bzr break-lock %s',
424
424
                         self._logged_reports[0][0])
425
425
        args = self._logged_reports[0][1]
426
426
        self.assertEqual('Unable to obtain', args[0])
433
433
        self.assertEqual('%s %s\n'
434
434
                         '%s\n%s\n'
435
435
                         'Will continue to try until %s, unless '
436
 
                         'you press Ctrl-C.\n'
437
 
                         'See "bzr help break-lock" for more.',
 
436
                         'you press Ctrl-C\n'
 
437
                         'If you\'re sure that it\'s not being '
 
438
                         'modified, use bzr break-lock %s',
438
439
                         self._logged_reports[1][0])
439
440
        args = self._logged_reports[1][1]
440
441
        self.assertEqual('Lock owner changed for', args[0])
450
451
        lf1 = LockDir(t, 'test_lock')
451
452
        lf1.create()
452
453
        lf1.attempt_lock()
453
 
        self.addCleanup(lf1.unlock)
454
454
        lf1.confirm()
455
455
 
456
456
    def test_41_confirm_not_held(self):
468
468
        lf1.attempt_lock()
469
469
        t.move('test_lock', 'lock_gone_now')
470
470
        self.assertRaises(LockBroken, lf1.confirm)
471
 
        # Clean up
472
 
        t.move('lock_gone_now', 'test_lock')
473
 
        lf1.unlock()
474
471
 
475
472
    def test_43_break(self):
476
473
        """Break a lock whose caller has forgotten it"""
487
484
        lf2.force_break(holder_info)
488
485
        # now we should be able to take it
489
486
        lf2.attempt_lock()
490
 
        self.addCleanup(lf2.unlock)
491
487
        lf2.confirm()
492
488
 
493
489
    def test_44_break_already_released(self):
505
501
        lf2.force_break(holder_info)
506
502
        # now we should be able to take it
507
503
        lf2.attempt_lock()
508
 
        self.addCleanup(lf2.unlock)
509
504
        lf2.confirm()
510
505
 
511
506
    def test_45_break_mismatch(self):
537
532
        """Check the on-disk representation of LockDirs is as expected.
538
533
 
539
534
        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
 
535
        When the lock is held, there should be a lockname/held directory 
541
536
        containing an info file.
542
537
        """
543
538
        t = self.get_transport()
558
553
        # do this without IO redirection to ensure it doesn't prompt.
559
554
        self.assertRaises(AssertionError, ld1.break_lock)
560
555
        orig_factory = bzrlib.ui.ui_factory
561
 
        bzrlib.ui.ui_factory = bzrlib.ui.CannedInputUIFactory([True])
 
556
        # silent ui - no need for stdout
 
557
        bzrlib.ui.ui_factory = bzrlib.ui.SilentUIFactory()
 
558
        bzrlib.ui.ui_factory.stdin = StringIO("y\n")
562
559
        try:
563
560
            ld2.break_lock()
564
561
            self.assertRaises(LockBroken, ld1.unlock)
624
621
    def test_lock_by_token(self):
625
622
        ld1 = self.get_lock()
626
623
        token = ld1.lock_write()
627
 
        self.addCleanup(ld1.unlock)
628
624
        self.assertNotEqual(None, token)
629
625
        ld2 = self.get_lock()
630
626
        t2 = ld2.lock_write(token)
631
 
        self.addCleanup(ld2.unlock)
632
627
        self.assertEqual(token, t2)
633
628
 
634
629
    def test_lock_with_buggy_rename(self):
659
654
        check_dir([])
660
655
        # when held, that's all we see
661
656
        ld1.attempt_lock()
662
 
        self.addCleanup(ld1.unlock)
663
657
        check_dir(['held'])
664
658
        # second guy should fail
665
659
        self.assertRaises(errors.LockContention, ld2.attempt_lock)
666
660
        # no kibble
667
661
        check_dir(['held'])
668
662
 
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
663
    def record_hook(self, result):
680
664
        self._calls.append(result)
681
665
 
 
666
    def reset_hooks(self):
 
667
        self._old_hooks = lock.Lock.hooks
 
668
        self.addCleanup(self.restore_hooks)
 
669
        lock.Lock.hooks = lock.LockHooks()
 
670
 
 
671
    def restore_hooks(self):
 
672
        lock.Lock.hooks = self._old_hooks
 
673
 
682
674
    def test_LockDir_acquired_success(self):
683
675
        # the LockDir.lock_acquired hook fires when a lock is acquired.
 
676
        self._calls = []
 
677
        self.reset_hooks()
684
678
        LockDir.hooks.install_named_hook('lock_acquired',
685
 
                                         self.record_hook, 'record_hook')
 
679
            self.record_hook, 'record_hook')
686
680
        ld = self.get_lock()
687
681
        ld.create()
688
682
        self.assertEqual([], self._calls)
694
688
 
695
689
    def test_LockDir_acquired_fail(self):
696
690
        # the LockDir.lock_acquired hook does not fire on failure.
 
691
        self._calls = []
 
692
        self.reset_hooks()
697
693
        ld = self.get_lock()
698
694
        ld.create()
699
695
        ld2 = self.get_lock()
700
696
        ld2.attempt_lock()
701
697
        # install a lock hook now, when the disk lock is locked
702
698
        LockDir.hooks.install_named_hook('lock_acquired',
703
 
                                         self.record_hook, 'record_hook')
 
699
            self.record_hook, 'record_hook')
704
700
        self.assertRaises(errors.LockContention, ld.attempt_lock)
705
701
        self.assertEqual([], self._calls)
706
702
        ld2.unlock()
708
704
 
709
705
    def test_LockDir_released_success(self):
710
706
        # the LockDir.lock_released hook fires when a lock is acquired.
 
707
        self._calls = []
 
708
        self.reset_hooks()
711
709
        LockDir.hooks.install_named_hook('lock_released',
712
 
                                         self.record_hook, 'record_hook')
 
710
            self.record_hook, 'record_hook')
713
711
        ld = self.get_lock()
714
712
        ld.create()
715
713
        self.assertEqual([], self._calls)
721
719
 
722
720
    def test_LockDir_released_fail(self):
723
721
        # the LockDir.lock_released hook does not fire on failure.
 
722
        self._calls = []
 
723
        self.reset_hooks()
724
724
        ld = self.get_lock()
725
725
        ld.create()
726
726
        ld2 = self.get_lock()
727
727
        ld.attempt_lock()
728
728
        ld2.force_break(ld2.peek())
729
729
        LockDir.hooks.install_named_hook('lock_released',
730
 
                                         self.record_hook, 'record_hook')
 
730
            self.record_hook, 'record_hook')
731
731
        self.assertRaises(LockBroken, ld.unlock)
732
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)