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