/brz/remove-bazaar

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_lockdir.py

  • Committer: Andrew Bennetts
  • Date: 2010-04-13 04:33:55 UTC
  • mfrom: (5147 +trunk)
  • mto: This revision was merged to the branch mainline in revision 5149.
  • Revision ID: andrew.bennetts@canonical.com-20100413043355-lg3id0uwtju0k3zs
Merge lp:bzr.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_lockdir.py
1
 
# Copyright (C) 2006, 2007, 2008 Canonical Ltd
 
1
# Copyright (C) 2006-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
 
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)
145
146
        # lock is held, should get some info on it
146
147
        info1 = lf1.peek()
147
148
        self.assertEqual(set(info1.keys()),
161
162
        lf2 = LockDir(self.get_readonly_transport(), 'test_lock')
162
163
        self.assertEqual(lf2.peek(), None)
163
164
        lf1.attempt_lock()
 
165
        self.addCleanup(lf1.unlock)
164
166
        info2 = lf2.peek()
165
167
        self.assertTrue(info2)
166
168
        self.assertEqual(info2['nonce'], lf1.nonce)
167
169
 
168
170
    def test_30_lock_wait_fail(self):
169
171
        """Wait on a lock, then fail
170
 
        
 
172
 
171
173
        We ask to wait up to 400ms; this should fail within at most one
172
174
        second.  (Longer times are more realistic but we don't want the test
173
175
        suite to take too long, and this should do for now.)
185
187
            after = time.time()
186
188
            # it should only take about 0.4 seconds, but we allow more time in
187
189
            # case the machine is heavily loaded
188
 
            self.assertTrue(after - before <= 8.0, 
 
190
            self.assertTrue(after - before <= 8.0,
189
191
                    "took %f seconds to detect lock contention" % (after - before))
190
192
        finally:
191
193
            lf1.unlock()
195
197
        self.assertEqual('%s %s\n'
196
198
                         '%s\n%s\n'
197
199
                         'Will continue to try until %s, unless '
198
 
                         'you press Ctrl-C\n'
199
 
                         'If you\'re sure that it\'s not being '
200
 
                         'modified, use bzr break-lock %s',
 
200
                         'you press Ctrl-C.\n'
 
201
                         'See "bzr help break-lock" for more.',
201
202
                         self._logged_reports[0][0])
202
203
        args = self._logged_reports[0][1]
203
204
        self.assertEqual('Unable to obtain', args[0])
226
227
    def test_32_lock_wait_succeed(self):
227
228
        """Succeed when trying to acquire a lock that gets released
228
229
 
229
 
        One thread holds on a lock and then releases it; another 
 
230
        One thread holds on a lock and then releases it; another
230
231
        tries to lock it.
231
232
        """
232
233
        # This test sometimes fails like this:
277
278
        self.assertContainsRe(args[4], r'\d\d:\d\d:\d\d')
278
279
 
279
280
    def test_34_lock_write_waits(self):
280
 
        """LockDir.lock_write() will wait for the lock.""" 
 
281
        """LockDir.lock_write() will wait for the lock."""
281
282
        # the test suite sets the default to 0 to make deadlocks fail fast.
282
283
        # change it for this test, as we want to try a manual deadlock.
283
284
        raise tests.TestSkipped('Timing-sensitive test')
320
321
 
321
322
    def test_35_wait_lock_changing(self):
322
323
        """LockDir.wait_lock() will report if the lock changes underneath.
323
 
        
 
324
 
324
325
        This is the stages we want to happen:
325
326
 
326
327
        0) Synchronization locks are created and locked.
327
328
        1) Lock1 obtains the lockdir, and releases the 'check' lock.
328
329
        2) Lock2 grabs the 'check' lock, and checks the lockdir.
329
 
           It sees the lockdir is already acquired, reports the fact, 
 
330
           It sees the lockdir is already acquired, reports the fact,
330
331
           and unsets the 'checked' lock.
331
332
        3) Thread1 blocks on acquiring the 'checked' lock, and then tells
332
333
           Lock1 to release and acquire the lockdir. This resets the 'check'
333
334
           lock.
334
335
        4) Lock2 acquires the 'check' lock, and checks again. It notices
335
 
           that the holder of the lock has changed, and so reports a new 
 
336
           that the holder of the lock has changed, and so reports a new
336
337
           lock holder.
337
338
        5) Thread1 blocks on the 'checked' lock, this time, it completely
338
339
           unlocks the lockdir, allowing Lock2 to acquire the lock.
418
419
        self.assertEqual('%s %s\n'
419
420
                         '%s\n%s\n'
420
421
                         'Will continue to try until %s, unless '
421
 
                         'you press Ctrl-C\n'
422
 
                         'If you\'re sure that it\'s not being '
423
 
                         'modified, use bzr break-lock %s',
 
422
                         'you press Ctrl-C.\n'
 
423
                         'See "bzr help break-lock" for more.',
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
 
                         'If you\'re sure that it\'s not being '
438
 
                         'modified, use bzr break-lock %s',
 
436
                         'you press Ctrl-C.\n'
 
437
                         'See "bzr help break-lock" for more.',
439
438
                         self._logged_reports[1][0])
440
439
        args = self._logged_reports[1][1]
441
440
        self.assertEqual('Lock owner changed for', args[0])
451
450
        lf1 = LockDir(t, 'test_lock')
452
451
        lf1.create()
453
452
        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()
471
474
 
472
475
    def test_43_break(self):
473
476
        """Break a lock whose caller has forgotten it"""
484
487
        lf2.force_break(holder_info)
485
488
        # now we should be able to take it
486
489
        lf2.attempt_lock()
 
490
        self.addCleanup(lf2.unlock)
487
491
        lf2.confirm()
488
492
 
489
493
    def test_44_break_already_released(self):
501
505
        lf2.force_break(holder_info)
502
506
        # now we should be able to take it
503
507
        lf2.attempt_lock()
 
508
        self.addCleanup(lf2.unlock)
504
509
        lf2.confirm()
505
510
 
506
511
    def test_45_break_mismatch(self):
532
537
        """Check the on-disk representation of LockDirs is as expected.
533
538
 
534
539
        There should always be a top-level directory named by the lock.
535
 
        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
536
541
        containing an info file.
537
542
        """
538
543
        t = self.get_transport()
553
558
        # do this without IO redirection to ensure it doesn't prompt.
554
559
        self.assertRaises(AssertionError, ld1.break_lock)
555
560
        orig_factory = bzrlib.ui.ui_factory
556
 
        # silent ui - no need for stdout
557
 
        bzrlib.ui.ui_factory = bzrlib.ui.SilentUIFactory()
558
 
        bzrlib.ui.ui_factory.stdin = StringIO("y\n")
 
561
        bzrlib.ui.ui_factory = bzrlib.ui.CannedInputUIFactory([True])
559
562
        try:
560
563
            ld2.break_lock()
561
564
            self.assertRaises(LockBroken, ld1.unlock)
621
624
    def test_lock_by_token(self):
622
625
        ld1 = self.get_lock()
623
626
        token = ld1.lock_write()
 
627
        self.addCleanup(ld1.unlock)
624
628
        self.assertNotEqual(None, token)
625
629
        ld2 = self.get_lock()
626
630
        t2 = ld2.lock_write(token)
 
631
        self.addCleanup(ld2.unlock)
627
632
        self.assertEqual(token, t2)
628
633
 
629
634
    def test_lock_with_buggy_rename(self):
654
659
        check_dir([])
655
660
        # when held, that's all we see
656
661
        ld1.attempt_lock()
 
662
        self.addCleanup(ld1.unlock)
657
663
        check_dir(['held'])
658
664
        # second guy should fail
659
665
        self.assertRaises(errors.LockContention, ld2.attempt_lock)
660
666
        # no kibble
661
667
        check_dir(['held'])
662
668
 
 
669
    def test_no_lockdir_info(self):
 
670
        """We can cope with empty info files."""
 
671
        # This seems like a fairly common failure case - see
 
672
        # <https://bugs.edge.launchpad.net/bzr/+bug/185103> and all its dupes.
 
673
        # Processes are often interrupted after opening the file
 
674
        # before the actual contents are committed.
 
675
        t = self.get_transport()
 
676
        t.mkdir('test_lock')
 
677
        t.mkdir('test_lock/held')
 
678
        t.put_bytes('test_lock/held/info', '')
 
679
        lf = LockDir(t, 'test_lock')
 
680
        info = lf.peek()
 
681
        formatted_info = lf._format_lock_info(info)
 
682
        self.assertEquals(
 
683
            ['lock %s' % t.abspath('test_lock'),
 
684
             'held by <unknown> on host <unknown> [process #<unknown>]',
 
685
             'locked (unknown)'],
 
686
            formatted_info)
 
687
 
 
688
 
 
689
class TestLockDirHooks(TestCaseWithTransport):
 
690
 
 
691
    def setUp(self):
 
692
        super(TestLockDirHooks, self).setUp()
 
693
        self._calls = []
 
694
 
 
695
    def get_lock(self):
 
696
        return LockDir(self.get_transport(), 'test_lock')
 
697
 
663
698
    def record_hook(self, result):
664
699
        self._calls.append(result)
665
700
 
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
 
 
674
701
    def test_LockDir_acquired_success(self):
675
702
        # the LockDir.lock_acquired hook fires when a lock is acquired.
676
 
        self._calls = []
677
 
        self.reset_hooks()
678
703
        LockDir.hooks.install_named_hook('lock_acquired',
679
 
            self.record_hook, 'record_hook')
 
704
                                         self.record_hook, 'record_hook')
680
705
        ld = self.get_lock()
681
706
        ld.create()
682
707
        self.assertEqual([], self._calls)
688
713
 
689
714
    def test_LockDir_acquired_fail(self):
690
715
        # the LockDir.lock_acquired hook does not fire on failure.
691
 
        self._calls = []
692
 
        self.reset_hooks()
693
716
        ld = self.get_lock()
694
717
        ld.create()
695
718
        ld2 = self.get_lock()
696
719
        ld2.attempt_lock()
697
720
        # install a lock hook now, when the disk lock is locked
698
721
        LockDir.hooks.install_named_hook('lock_acquired',
699
 
            self.record_hook, 'record_hook')
 
722
                                         self.record_hook, 'record_hook')
700
723
        self.assertRaises(errors.LockContention, ld.attempt_lock)
701
724
        self.assertEqual([], self._calls)
702
725
        ld2.unlock()
704
727
 
705
728
    def test_LockDir_released_success(self):
706
729
        # the LockDir.lock_released hook fires when a lock is acquired.
707
 
        self._calls = []
708
 
        self.reset_hooks()
709
730
        LockDir.hooks.install_named_hook('lock_released',
710
 
            self.record_hook, 'record_hook')
 
731
                                         self.record_hook, 'record_hook')
711
732
        ld = self.get_lock()
712
733
        ld.create()
713
734
        self.assertEqual([], self._calls)
719
740
 
720
741
    def test_LockDir_released_fail(self):
721
742
        # the LockDir.lock_released hook does not fire on failure.
722
 
        self._calls = []
723
 
        self.reset_hooks()
724
743
        ld = self.get_lock()
725
744
        ld.create()
726
745
        ld2 = self.get_lock()
727
746
        ld.attempt_lock()
728
747
        ld2.force_break(ld2.peek())
729
748
        LockDir.hooks.install_named_hook('lock_released',
730
 
            self.record_hook, 'record_hook')
 
749
                                         self.record_hook, 'record_hook')
731
750
        self.assertRaises(LockBroken, ld.unlock)
732
751
        self.assertEqual([], self._calls)
 
752
 
 
753
    def test_LockDir_broken_success(self):
 
754
        # the LockDir.lock_broken hook fires when a lock is broken.
 
755
        ld = self.get_lock()
 
756
        ld.create()
 
757
        ld2 = self.get_lock()
 
758
        result = ld.attempt_lock()
 
759
        LockDir.hooks.install_named_hook('lock_broken',
 
760
                                         self.record_hook, 'record_hook')
 
761
        ld2.force_break(ld2.peek())
 
762
        lock_path = ld.transport.abspath(ld.path)
 
763
        self.assertEqual([lock.LockResult(lock_path, result)], self._calls)
 
764
 
 
765
    def test_LockDir_broken_failure(self):
 
766
        # the LockDir.lock_broken hook does not fires when a lock is already
 
767
        # released.
 
768
        ld = self.get_lock()
 
769
        ld.create()
 
770
        ld2 = self.get_lock()
 
771
        result = ld.attempt_lock()
 
772
        holder_info = ld2.peek()
 
773
        ld.unlock()
 
774
        LockDir.hooks.install_named_hook('lock_broken',
 
775
                                         self.record_hook, 'record_hook')
 
776
        ld2.force_break(holder_info)
 
777
        lock_path = ld.transport.abspath(ld.path)
 
778
        self.assertEqual([], self._calls)