← 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: Canonical.com Patch Queue Manager
  • Date: 2008-08-14 17:25:43 UTC
  • mfrom: (3620.2.2 rules.disable)
  • Revision ID: pqm@pqm.ubuntu.com-20080814172543-nl22gdcodusa8rt0
(robertc) Disable .bzrrules from being read from the WT

Show diffs side-by-side

added added

removed removed

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