← 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: 2007-04-04 06:17:31 UTC
  • mto: This revision was merged to the branch mainline in revision 2397.
  • Revision ID: mbp@sourcefrog.net-20070404061731-tt2xrzllqhbodn83
Contents of TODO file moved into bug tracker

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 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
 
    transport,
32
30
    )
33
31
from bzrlib.errors import (
34
 
    LockBreakMismatch,
35
 
    LockBroken,
36
 
    LockContention,
37
 
    LockError,
38
 
    LockFailed,
39
 
    LockNotHeld,
40
 
    )
 
32
        LockBreakMismatch,
 
33
        LockContention, LockError, UnlockableTransport,
 
34
        LockNotHeld, LockBroken
 
35
        )
41
36
from bzrlib.lockdir import LockDir
42
37
from bzrlib.tests import TestCaseWithTransport
43
38
from bzrlib.trace import note
109
104
        """Fail to create lock on readonly transport"""
110
105
        t = self.get_readonly_transport()
111
106
        lf = LockDir(t, 'test_lock')
112
 
        self.assertRaises(LockFailed, lf.create)
 
107
        self.assertRaises(UnlockableTransport, lf.create)
113
108
 
114
109
    def test_12_lock_readonly_transport(self):
115
110
        """Fail to lock on readonly transport"""
116
111
        lf = LockDir(self.get_transport(), 'test_lock')
117
112
        lf.create()
118
113
        lf = LockDir(self.get_readonly_transport(), 'test_lock')
119
 
        self.assertRaises(LockFailed, lf.attempt_lock)
 
114
        self.assertRaises(UnlockableTransport, lf.attempt_lock)
120
115
 
121
116
    def test_20_lock_contested(self):
122
117
        """Contention to get a lock"""
126
121
        lf1.attempt_lock()
127
122
        lf2 = LockDir(t, 'test_lock')
128
123
        try:
129
 
            # locking is between LockDir instances; aliases within
 
124
            # locking is between LockDir instances; aliases within 
130
125
            # a single process are not detected
131
126
            lf2.attempt_lock()
132
127
            self.fail('Failed to detect lock collision')
167
162
 
168
163
    def test_30_lock_wait_fail(self):
169
164
        """Wait on a lock, then fail
170
 
 
 
165
        
171
166
        We ask to wait up to 400ms; this should fail within at most one
172
167
        second.  (Longer times are more realistic but we don't want the test
173
168
        suite to take too long, and this should do for now.)
185
180
            after = time.time()
186
181
            # it should only take about 0.4 seconds, but we allow more time in
187
182
            # case the machine is heavily loaded
188
 
            self.assertTrue(after - before <= 8.0,
 
183
            self.assertTrue(after - before <= 8.0, 
189
184
                    "took %f seconds to detect lock contention" % (after - before))
190
185
        finally:
191
186
            lf1.unlock()
192
187
        lock_base = lf2.transport.abspath(lf2.path)
193
188
        self.assertEqual(1, len(self._logged_reports))
194
 
        lock_url = lf2.transport.abspath(lf2.path)
195
189
        self.assertEqual('%s %s\n'
196
190
                         '%s\n%s\n'
197
 
                         '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',
 
191
                         'Will continue to try until %s\n',
201
192
                         self._logged_reports[0][0])
202
193
        args = self._logged_reports[0][1]
203
194
        self.assertEqual('Unable to obtain', args[0])
226
217
    def test_32_lock_wait_succeed(self):
227
218
        """Succeed when trying to acquire a lock that gets released
228
219
 
229
 
        One thread holds on a lock and then releases it; another
 
220
        One thread holds on a lock and then releases it; another 
230
221
        tries to lock it.
231
222
        """
232
 
        # This test sometimes fails like this:
233
 
        # Traceback (most recent call last):
234
 
 
235
 
        #   File "/home/pqm/bzr-pqm-workdir/home/+trunk/bzrlib/tests/
236
 
        # test_lockdir.py", line 247, in test_32_lock_wait_succeed
237
 
        #     self.assertEqual(1, len(self._logged_reports))
238
 
        # AssertionError: not equal:
239
 
        # a = 1
240
 
        # b = 0
241
 
        raise tests.TestSkipped("Test fails intermittently")
242
223
        t = self.get_transport()
243
224
        lf1 = LockDir(t, 'test_lock')
244
225
        lf1.create()
276
257
        self.assertEndsWith(args[3], ' ago')
277
258
        self.assertContainsRe(args[4], r'\d\d:\d\d:\d\d')
278
259
 
 
260
    def test_33_wait(self):
 
261
        """Succeed when waiting on a lock that gets released
 
262
 
 
263
        The difference from test_32_lock_wait_succeed is that the second 
 
264
        caller does not actually acquire the lock, but just waits for it
 
265
        to be released.  This is done over a readonly transport.
 
266
        """
 
267
        t = self.get_transport()
 
268
        lf1 = LockDir(t, 'test_lock')
 
269
        lf1.create()
 
270
        lf1.attempt_lock()
 
271
 
 
272
        def wait_and_unlock():
 
273
            time.sleep(0.1)
 
274
            lf1.unlock()
 
275
        unlocker = Thread(target=wait_and_unlock)
 
276
        unlocker.start()
 
277
        try:
 
278
            lf2 = LockDir(self.get_readonly_transport(), 'test_lock')
 
279
            before = time.time()
 
280
            # wait but don't lock
 
281
            lf2.wait(timeout=0.4, poll=0.1)
 
282
            after = time.time()
 
283
            self.assertTrue(after - before <= 1.0)
 
284
        finally:
 
285
            unlocker.join()
 
286
 
279
287
    def test_34_lock_write_waits(self):
280
 
        """LockDir.lock_write() will wait for the lock."""
 
288
        """LockDir.lock_write() will wait for the lock.""" 
281
289
        # the test suite sets the default to 0 to make deadlocks fail fast.
282
290
        # change it for this test, as we want to try a manual deadlock.
283
 
        raise tests.TestSkipped('Timing-sensitive test')
284
291
        bzrlib.lockdir._DEFAULT_TIMEOUT_SECONDS = 300
285
292
        t = self.get_transport()
286
293
        lf1 = LockDir(t, 'test_lock')
320
327
 
321
328
    def test_35_wait_lock_changing(self):
322
329
        """LockDir.wait_lock() will report if the lock changes underneath.
323
 
 
 
330
        
324
331
        This is the stages we want to happen:
325
332
 
326
333
        0) Synchronization locks are created and locked.
327
334
        1) Lock1 obtains the lockdir, and releases the 'check' lock.
328
335
        2) Lock2 grabs the 'check' lock, and checks the lockdir.
329
 
           It sees the lockdir is already acquired, reports the fact,
 
336
           It sees the lockdir is already acquired, reports the fact, 
330
337
           and unsets the 'checked' lock.
331
338
        3) Thread1 blocks on acquiring the 'checked' lock, and then tells
332
339
           Lock1 to release and acquire the lockdir. This resets the 'check'
333
340
           lock.
334
341
        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
 
342
           that the holder of the lock has changed, and so reports a new 
336
343
           lock holder.
337
344
        5) Thread1 blocks on the 'checked' lock, this time, it completely
338
345
           unlocks the lockdir, allowing Lock2 to acquire the lock.
339
346
        """
340
347
 
341
 
        raise tests.KnownFailure(
342
 
            "timing dependency in lock tests (#213182)")
343
 
 
344
348
        wait_to_check_lock = Lock()
345
349
        wait_until_checked_lock = Lock()
346
350
 
406
410
        unlocker.start()
407
411
        try:
408
412
            # Wait and play against the other thread
409
 
            lf2.wait_lock(timeout=20.0, poll=0.01)
 
413
            lf2.wait_lock(timeout=1.0, poll=0.01)
410
414
        finally:
411
415
            unlocker.join()
412
416
        lf2.unlock()
414
418
        # There should be 2 reports, because the lock changed
415
419
        lock_base = lf2.transport.abspath(lf2.path)
416
420
        self.assertEqual(2, len(self._logged_reports))
417
 
        lock_url = lf2.transport.abspath(lf2.path)
 
421
 
418
422
        self.assertEqual('%s %s\n'
419
423
                         '%s\n%s\n'
420
 
                         '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',
 
424
                         'Will continue to try until %s\n',
424
425
                         self._logged_reports[0][0])
425
426
        args = self._logged_reports[0][1]
426
427
        self.assertEqual('Unable to obtain', args[0])
432
433
 
433
434
        self.assertEqual('%s %s\n'
434
435
                         '%s\n%s\n'
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
                         'Will continue to try until %s\n',
439
437
                         self._logged_reports[1][0])
440
438
        args = self._logged_reports[1][1]
441
439
        self.assertEqual('Lock owner changed for', args[0])
532
530
        """Check the on-disk representation of LockDirs is as expected.
533
531
 
534
532
        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
 
533
        When the lock is held, there should be a lockname/held directory 
536
534
        containing an info file.
537
535
        """
538
536
        t = self.get_transport()
616
614
        lock_path = ld1.transport.local_abspath('test_lock')
617
615
        os.mkdir(lock_path)
618
616
        osutils.make_readonly(lock_path)
619
 
        self.assertRaises(errors.LockFailed, ld1.attempt_lock)
620
 
 
621
 
    def test_lock_by_token(self):
622
 
        ld1 = self.get_lock()
623
 
        token = ld1.lock_write()
624
 
        self.assertNotEqual(None, token)
625
 
        ld2 = self.get_lock()
626
 
        t2 = ld2.lock_write(token)
627
 
        self.assertEqual(token, t2)
628
 
 
629
 
    def test_lock_with_buggy_rename(self):
630
 
        # test that lock acquisition handles servers which pretend they
631
 
        # renamed correctly but that actually fail
632
 
        t = transport.get_transport('brokenrename+' + self.get_url())
633
 
        ld1 = LockDir(t, 'test_lock')
634
 
        ld1.create()
635
 
        ld1.attempt_lock()
636
 
        ld2 = LockDir(t, 'test_lock')
637
 
        # we should fail to lock
638
 
        e = self.assertRaises(errors.LockContention, ld2.attempt_lock)
639
 
        # now the original caller should succeed in unlocking
640
 
        ld1.unlock()
641
 
        # and there should be nothing left over
642
 
        self.assertEquals([], t.list_dir('test_lock'))
643
 
 
644
 
    def test_failed_lock_leaves_no_trash(self):
645
 
        # if we fail to acquire the lock, we don't leave pending directories
646
 
        # behind -- https://bugs.launchpad.net/bzr/+bug/109169
647
 
        ld1 = self.get_lock()
648
 
        ld2 = self.get_lock()
649
 
        # should be nothing before we start
650
 
        ld1.create()
651
 
        t = self.get_transport().clone('test_lock')
652
 
        def check_dir(a):
653
 
            self.assertEquals(a, t.list_dir('.'))
654
 
        check_dir([])
655
 
        # when held, that's all we see
656
 
        ld1.attempt_lock()
657
 
        check_dir(['held'])
658
 
        # second guy should fail
659
 
        self.assertRaises(errors.LockContention, ld2.attempt_lock)
660
 
        # no kibble
661
 
        check_dir(['held'])
662
 
 
663
 
    def record_hook(self, result):
664
 
        self._calls.append(result)
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
 
 
674
 
    def test_LockDir_acquired_success(self):
675
 
        # the LockDir.lock_acquired hook fires when a lock is acquired.
676
 
        self._calls = []
677
 
        self.reset_hooks()
678
 
        LockDir.hooks.install_named_hook('lock_acquired',
679
 
            self.record_hook, 'record_hook')
680
 
        ld = self.get_lock()
681
 
        ld.create()
682
 
        self.assertEqual([], self._calls)
683
 
        result = ld.attempt_lock()
684
 
        lock_path = ld.transport.abspath(ld.path)
685
 
        self.assertEqual([lock.LockResult(lock_path, result)], self._calls)
686
 
        ld.unlock()
687
 
        self.assertEqual([lock.LockResult(lock_path, result)], self._calls)
688
 
 
689
 
    def test_LockDir_acquired_fail(self):
690
 
        # the LockDir.lock_acquired hook does not fire on failure.
691
 
        self._calls = []
692
 
        self.reset_hooks()
693
 
        ld = self.get_lock()
694
 
        ld.create()
695
 
        ld2 = self.get_lock()
696
 
        ld2.attempt_lock()
697
 
        # install a lock hook now, when the disk lock is locked
698
 
        LockDir.hooks.install_named_hook('lock_acquired',
699
 
            self.record_hook, 'record_hook')
700
 
        self.assertRaises(errors.LockContention, ld.attempt_lock)
701
 
        self.assertEqual([], self._calls)
702
 
        ld2.unlock()
703
 
        self.assertEqual([], self._calls)
704
 
 
705
 
    def test_LockDir_released_success(self):
706
 
        # the LockDir.lock_released hook fires when a lock is acquired.
707
 
        self._calls = []
708
 
        self.reset_hooks()
709
 
        LockDir.hooks.install_named_hook('lock_released',
710
 
            self.record_hook, 'record_hook')
711
 
        ld = self.get_lock()
712
 
        ld.create()
713
 
        self.assertEqual([], self._calls)
714
 
        result = ld.attempt_lock()
715
 
        self.assertEqual([], self._calls)
716
 
        ld.unlock()
717
 
        lock_path = ld.transport.abspath(ld.path)
718
 
        self.assertEqual([lock.LockResult(lock_path, result)], self._calls)
719
 
 
720
 
    def test_LockDir_released_fail(self):
721
 
        # the LockDir.lock_released hook does not fire on failure.
722
 
        self._calls = []
723
 
        self.reset_hooks()
724
 
        ld = self.get_lock()
725
 
        ld.create()
726
 
        ld2 = self.get_lock()
727
 
        ld.attempt_lock()
728
 
        ld2.force_break(ld2.peek())
729
 
        LockDir.hooks.install_named_hook('lock_released',
730
 
            self.record_hook, 'record_hook')
731
 
        self.assertRaises(LockBroken, ld.unlock)
732
 
        self.assertEqual([], self._calls)
 
617
        self.assertRaises(errors.PermissionDenied, ld1.attempt_lock)