← 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: Mark Hammond
  • Date: 2009-01-12 01:55:34 UTC
  • mto: (3995.8.2 prepare-1.12)
  • mto: This revision was merged to the branch mainline in revision 4007.
  • Revision ID: mhammond@skippinet.com.au-20090112015534-yfxg50p7mpds9j4v
Include all .html files from the tortoise doc directory.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_lockdir.py
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()
228
226
    def test_32_lock_wait_succeed(self):
229
227
        """Succeed when trying to acquire a lock that gets released
230
228
 
231
 
        One thread holds on a lock and then releases it; another
 
229
        One thread holds on a lock and then releases it; another 
232
230
        tries to lock it.
233
231
        """
234
232
        # This test sometimes fails like this:
279
277
        self.assertContainsRe(args[4], r'\d\d:\d\d:\d\d')
280
278
 
281
279
    def test_34_lock_write_waits(self):
282
 
        """LockDir.lock_write() will wait for the lock."""
 
280
        """LockDir.lock_write() will wait for the lock.""" 
283
281
        # the test suite sets the default to 0 to make deadlocks fail fast.
284
282
        # change it for this test, as we want to try a manual deadlock.
285
283
        raise tests.TestSkipped('Timing-sensitive test')
322
320
 
323
321
    def test_35_wait_lock_changing(self):
324
322
        """LockDir.wait_lock() will report if the lock changes underneath.
325
 
 
 
323
        
326
324
        This is the stages we want to happen:
327
325
 
328
326
        0) Synchronization locks are created and locked.
329
327
        1) Lock1 obtains the lockdir, and releases the 'check' lock.
330
328
        2) Lock2 grabs the 'check' lock, and checks the lockdir.
331
 
           It sees the lockdir is already acquired, reports the fact,
 
329
           It sees the lockdir is already acquired, reports the fact, 
332
330
           and unsets the 'checked' lock.
333
331
        3) Thread1 blocks on acquiring the 'checked' lock, and then tells
334
332
           Lock1 to release and acquire the lockdir. This resets the 'check'
335
333
           lock.
336
334
        4) Lock2 acquires the 'check' lock, and checks again. It notices
337
 
           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 
338
336
           lock holder.
339
337
        5) Thread1 blocks on the 'checked' lock, this time, it completely
340
338
           unlocks the lockdir, allowing Lock2 to acquire the lock.
453
451
        lf1 = LockDir(t, 'test_lock')
454
452
        lf1.create()
455
453
        lf1.attempt_lock()
456
 
        self.addCleanup(lf1.unlock)
457
454
        lf1.confirm()
458
455
 
459
456
    def test_41_confirm_not_held(self):
471
468
        lf1.attempt_lock()
472
469
        t.move('test_lock', 'lock_gone_now')
473
470
        self.assertRaises(LockBroken, lf1.confirm)
474
 
        # Clean up
475
 
        t.move('lock_gone_now', 'test_lock')
476
 
        lf1.unlock()
477
471
 
478
472
    def test_43_break(self):
479
473
        """Break a lock whose caller has forgotten it"""
490
484
        lf2.force_break(holder_info)
491
485
        # now we should be able to take it
492
486
        lf2.attempt_lock()
493
 
        self.addCleanup(lf2.unlock)
494
487
        lf2.confirm()
495
488
 
496
489
    def test_44_break_already_released(self):
508
501
        lf2.force_break(holder_info)
509
502
        # now we should be able to take it
510
503
        lf2.attempt_lock()
511
 
        self.addCleanup(lf2.unlock)
512
504
        lf2.confirm()
513
505
 
514
506
    def test_45_break_mismatch(self):
540
532
        """Check the on-disk representation of LockDirs is as expected.
541
533
 
542
534
        There should always be a top-level directory named by the lock.
543
 
        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 
544
536
        containing an info file.
545
537
        """
546
538
        t = self.get_transport()
629
621
    def test_lock_by_token(self):
630
622
        ld1 = self.get_lock()
631
623
        token = ld1.lock_write()
632
 
        self.addCleanup(ld1.unlock)
633
624
        self.assertNotEqual(None, token)
634
625
        ld2 = self.get_lock()
635
626
        t2 = ld2.lock_write(token)
636
 
        self.addCleanup(ld2.unlock)
637
627
        self.assertEqual(token, t2)
638
628
 
639
629
    def test_lock_with_buggy_rename(self):
664
654
        check_dir([])
665
655
        # when held, that's all we see
666
656
        ld1.attempt_lock()
667
 
        self.addCleanup(ld1.unlock)
668
657
        check_dir(['held'])
669
658
        # second guy should fail
670
659
        self.assertRaises(errors.LockContention, ld2.attempt_lock)
671
660
        # no kibble
672
661
        check_dir(['held'])
673
662
 
674
 
 
675
 
class TestLockDirHooks(TestCaseWithTransport):
676
 
 
677
 
    def setUp(self):
678
 
        super(TestLockDirHooks, self).setUp()
679
 
        self._calls = []
680
 
 
681
 
    def get_lock(self):
682
 
        return LockDir(self.get_transport(), 'test_lock')
683
 
 
684
663
    def record_hook(self, result):
685
664
        self._calls.append(result)
686
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
 
687
674
    def test_LockDir_acquired_success(self):
688
675
        # the LockDir.lock_acquired hook fires when a lock is acquired.
 
676
        self._calls = []
 
677
        self.reset_hooks()
689
678
        LockDir.hooks.install_named_hook('lock_acquired',
690
 
                                         self.record_hook, 'record_hook')
 
679
            self.record_hook, 'record_hook')
691
680
        ld = self.get_lock()
692
681
        ld.create()
693
682
        self.assertEqual([], self._calls)
699
688
 
700
689
    def test_LockDir_acquired_fail(self):
701
690
        # the LockDir.lock_acquired hook does not fire on failure.
 
691
        self._calls = []
 
692
        self.reset_hooks()
702
693
        ld = self.get_lock()
703
694
        ld.create()
704
695
        ld2 = self.get_lock()
705
696
        ld2.attempt_lock()
706
697
        # install a lock hook now, when the disk lock is locked
707
698
        LockDir.hooks.install_named_hook('lock_acquired',
708
 
                                         self.record_hook, 'record_hook')
 
699
            self.record_hook, 'record_hook')
709
700
        self.assertRaises(errors.LockContention, ld.attempt_lock)
710
701
        self.assertEqual([], self._calls)
711
702
        ld2.unlock()
713
704
 
714
705
    def test_LockDir_released_success(self):
715
706
        # the LockDir.lock_released hook fires when a lock is acquired.
 
707
        self._calls = []
 
708
        self.reset_hooks()
716
709
        LockDir.hooks.install_named_hook('lock_released',
717
 
                                         self.record_hook, 'record_hook')
 
710
            self.record_hook, 'record_hook')
718
711
        ld = self.get_lock()
719
712
        ld.create()
720
713
        self.assertEqual([], self._calls)
726
719
 
727
720
    def test_LockDir_released_fail(self):
728
721
        # the LockDir.lock_released hook does not fire on failure.
 
722
        self._calls = []
 
723
        self.reset_hooks()
729
724
        ld = self.get_lock()
730
725
        ld.create()
731
726
        ld2 = self.get_lock()
732
727
        ld.attempt_lock()
733
728
        ld2.force_break(ld2.peek())
734
729
        LockDir.hooks.install_named_hook('lock_released',
735
 
                                         self.record_hook, 'record_hook')
 
730
            self.record_hook, 'record_hook')
736
731
        self.assertRaises(LockBroken, ld.unlock)
737
732
        self.assertEqual([], self._calls)
738
 
 
739
 
    def test_LockDir_broken_success(self):
740
 
        # the LockDir.lock_broken hook fires when a lock is broken.
741
 
        ld = self.get_lock()
742
 
        ld.create()
743
 
        ld2 = self.get_lock()
744
 
        result = ld.attempt_lock()
745
 
        LockDir.hooks.install_named_hook('lock_broken',
746
 
                                         self.record_hook, 'record_hook')
747
 
        ld2.force_break(ld2.peek())
748
 
        lock_path = ld.transport.abspath(ld.path)
749
 
        self.assertEqual([lock.LockResult(lock_path, result)], self._calls)
750
 
 
751
 
    def test_LockDir_broken_failure(self):
752
 
        # the LockDir.lock_broken hook does not fires when a lock is already
753
 
        # released.
754
 
        ld = self.get_lock()
755
 
        ld.create()
756
 
        ld2 = self.get_lock()
757
 
        result = ld.attempt_lock()
758
 
        holder_info = ld2.peek()
759
 
        ld.unlock()
760
 
        LockDir.hooks.install_named_hook('lock_broken',
761
 
                                         self.record_hook, 'record_hook')
762
 
        ld2.force_break(holder_info)
763
 
        lock_path = ld.transport.abspath(ld.path)
764
 
        self.assertEqual([], self._calls)