← 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: Aaron Bentley
  • Date: 2007-01-16 13:12:54 UTC
  • mto: (2230.3.47 branch6)
  • mto: This revision was merged to the branch mainline in revision 2290.
  • Revision ID: aaron.bentley@utoronto.ca-20070116131254-sjruli93timappd4
work in progress bind stuff

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
 
19
19
from cStringIO import StringIO
20
 
import os
21
20
from threading import Thread, Lock
22
21
import time
23
22
 
24
23
import bzrlib
25
24
from bzrlib import (
26
25
    config,
27
 
    errors,
28
 
    lock,
29
26
    osutils,
30
 
    tests,
31
 
    transport,
32
27
    )
33
28
from bzrlib.errors import (
34
 
    LockBreakMismatch,
35
 
    LockBroken,
36
 
    LockContention,
37
 
    LockError,
38
 
    LockFailed,
39
 
    LockNotHeld,
40
 
    )
41
 
from bzrlib.lockdir import LockDir
 
29
        LockBreakMismatch,
 
30
        LockContention, LockError, UnlockableTransport,
 
31
        LockNotHeld, LockBroken
 
32
        )
 
33
from bzrlib.lockdir import LockDir, _DEFAULT_TIMEOUT_SECONDS
42
34
from bzrlib.tests import TestCaseWithTransport
43
35
from bzrlib.trace import note
44
36
 
109
101
        """Fail to create lock on readonly transport"""
110
102
        t = self.get_readonly_transport()
111
103
        lf = LockDir(t, 'test_lock')
112
 
        self.assertRaises(LockFailed, lf.create)
 
104
        self.assertRaises(UnlockableTransport, lf.create)
113
105
 
114
106
    def test_12_lock_readonly_transport(self):
115
107
        """Fail to lock on readonly transport"""
116
108
        lf = LockDir(self.get_transport(), 'test_lock')
117
109
        lf.create()
118
110
        lf = LockDir(self.get_readonly_transport(), 'test_lock')
119
 
        self.assertRaises(LockFailed, lf.attempt_lock)
 
111
        self.assertRaises(UnlockableTransport, lf.attempt_lock)
120
112
 
121
113
    def test_20_lock_contested(self):
122
114
        """Contention to get a lock"""
126
118
        lf1.attempt_lock()
127
119
        lf2 = LockDir(t, 'test_lock')
128
120
        try:
129
 
            # locking is between LockDir instances; aliases within
 
121
            # locking is between LockDir instances; aliases within 
130
122
            # a single process are not detected
131
123
            lf2.attempt_lock()
132
124
            self.fail('Failed to detect lock collision')
142
134
        lf1 = LockDir(t, 'test_lock')
143
135
        lf1.create()
144
136
        lf1.attempt_lock()
145
 
        self.addCleanup(lf1.unlock)
146
137
        # lock is held, should get some info on it
147
138
        info1 = lf1.peek()
148
139
        self.assertEqual(set(info1.keys()),
162
153
        lf2 = LockDir(self.get_readonly_transport(), 'test_lock')
163
154
        self.assertEqual(lf2.peek(), None)
164
155
        lf1.attempt_lock()
165
 
        self.addCleanup(lf1.unlock)
166
156
        info2 = lf2.peek()
167
157
        self.assertTrue(info2)
168
158
        self.assertEqual(info2['nonce'], lf1.nonce)
169
159
 
170
160
    def test_30_lock_wait_fail(self):
171
161
        """Wait on a lock, then fail
172
 
 
 
162
        
173
163
        We ask to wait up to 400ms; this should fail within at most one
174
164
        second.  (Longer times are more realistic but we don't want the test
175
165
        suite to take too long, and this should do for now.)
187
177
            after = time.time()
188
178
            # it should only take about 0.4 seconds, but we allow more time in
189
179
            # case the machine is heavily loaded
190
 
            self.assertTrue(after - before <= 8.0,
 
180
            self.assertTrue(after - before <= 8.0, 
191
181
                    "took %f seconds to detect lock contention" % (after - before))
192
182
        finally:
193
183
            lf1.unlock()
194
184
        lock_base = lf2.transport.abspath(lf2.path)
195
185
        self.assertEqual(1, len(self._logged_reports))
196
 
        lock_url = lf2.transport.abspath(lf2.path)
197
186
        self.assertEqual('%s %s\n'
198
187
                         '%s\n%s\n'
199
 
                         'Will continue to try until %s, unless '
200
 
                         'you press Ctrl-C\n'
201
 
                         'If you\'re sure that it\'s not being '
202
 
                         'modified, use bzr break-lock %s',
 
188
                         'Will continue to try until %s\n',
203
189
                         self._logged_reports[0][0])
204
190
        args = self._logged_reports[0][1]
205
191
        self.assertEqual('Unable to obtain', args[0])
228
214
    def test_32_lock_wait_succeed(self):
229
215
        """Succeed when trying to acquire a lock that gets released
230
216
 
231
 
        One thread holds on a lock and then releases it; another
 
217
        One thread holds on a lock and then releases it; another 
232
218
        tries to lock it.
233
219
        """
234
 
        # This test sometimes fails like this:
235
 
        # Traceback (most recent call last):
236
 
 
237
 
        #   File "/home/pqm/bzr-pqm-workdir/home/+trunk/bzrlib/tests/
238
 
        # test_lockdir.py", line 247, in test_32_lock_wait_succeed
239
 
        #     self.assertEqual(1, len(self._logged_reports))
240
 
        # AssertionError: not equal:
241
 
        # a = 1
242
 
        # b = 0
243
 
        raise tests.TestSkipped("Test fails intermittently")
244
220
        t = self.get_transport()
245
221
        lf1 = LockDir(t, 'test_lock')
246
222
        lf1.create()
278
254
        self.assertEndsWith(args[3], ' ago')
279
255
        self.assertContainsRe(args[4], r'\d\d:\d\d:\d\d')
280
256
 
 
257
    def test_33_wait(self):
 
258
        """Succeed when waiting on a lock that gets released
 
259
 
 
260
        The difference from test_32_lock_wait_succeed is that the second 
 
261
        caller does not actually acquire the lock, but just waits for it
 
262
        to be released.  This is done over a readonly transport.
 
263
        """
 
264
        t = self.get_transport()
 
265
        lf1 = LockDir(t, 'test_lock')
 
266
        lf1.create()
 
267
        lf1.attempt_lock()
 
268
 
 
269
        def wait_and_unlock():
 
270
            time.sleep(0.1)
 
271
            lf1.unlock()
 
272
        unlocker = Thread(target=wait_and_unlock)
 
273
        unlocker.start()
 
274
        try:
 
275
            lf2 = LockDir(self.get_readonly_transport(), 'test_lock')
 
276
            before = time.time()
 
277
            # wait but don't lock
 
278
            lf2.wait(timeout=0.4, poll=0.1)
 
279
            after = time.time()
 
280
            self.assertTrue(after - before <= 1.0)
 
281
        finally:
 
282
            unlocker.join()
 
283
 
281
284
    def test_34_lock_write_waits(self):
282
 
        """LockDir.lock_write() will wait for the lock."""
283
 
        # the test suite sets the default to 0 to make deadlocks fail fast.
284
 
        # change it for this test, as we want to try a manual deadlock.
285
 
        raise tests.TestSkipped('Timing-sensitive test')
286
 
        bzrlib.lockdir._DEFAULT_TIMEOUT_SECONDS = 300
 
285
        """LockDir.lock_write() will wait for the lock.""" 
287
286
        t = self.get_transport()
288
287
        lf1 = LockDir(t, 'test_lock')
289
288
        lf1.create()
322
321
 
323
322
    def test_35_wait_lock_changing(self):
324
323
        """LockDir.wait_lock() will report if the lock changes underneath.
325
 
 
 
324
        
326
325
        This is the stages we want to happen:
327
326
 
328
327
        0) Synchronization locks are created and locked.
329
328
        1) Lock1 obtains the lockdir, and releases the 'check' lock.
330
329
        2) Lock2 grabs the 'check' lock, and checks the lockdir.
331
 
           It sees the lockdir is already acquired, reports the fact,
 
330
           It sees the lockdir is already acquired, reports the fact, 
332
331
           and unsets the 'checked' lock.
333
332
        3) Thread1 blocks on acquiring the 'checked' lock, and then tells
334
333
           Lock1 to release and acquire the lockdir. This resets the 'check'
335
334
           lock.
336
335
        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
 
336
           that the holder of the lock has changed, and so reports a new 
338
337
           lock holder.
339
338
        5) Thread1 blocks on the 'checked' lock, this time, it completely
340
339
           unlocks the lockdir, allowing Lock2 to acquire the lock.
341
340
        """
342
341
 
343
 
        raise tests.KnownFailure(
344
 
            "timing dependency in lock tests (#213182)")
345
 
 
346
342
        wait_to_check_lock = Lock()
347
343
        wait_until_checked_lock = Lock()
348
344
 
408
404
        unlocker.start()
409
405
        try:
410
406
            # Wait and play against the other thread
411
 
            lf2.wait_lock(timeout=20.0, poll=0.01)
 
407
            lf2.wait_lock(timeout=1.0, poll=0.01)
412
408
        finally:
413
409
            unlocker.join()
414
410
        lf2.unlock()
416
412
        # There should be 2 reports, because the lock changed
417
413
        lock_base = lf2.transport.abspath(lf2.path)
418
414
        self.assertEqual(2, len(self._logged_reports))
419
 
        lock_url = lf2.transport.abspath(lf2.path)
 
415
 
420
416
        self.assertEqual('%s %s\n'
421
417
                         '%s\n%s\n'
422
 
                         'Will continue to try until %s, unless '
423
 
                         'you press Ctrl-C\n'
424
 
                         'If you\'re sure that it\'s not being '
425
 
                         'modified, use bzr break-lock %s',
 
418
                         'Will continue to try until %s\n',
426
419
                         self._logged_reports[0][0])
427
420
        args = self._logged_reports[0][1]
428
421
        self.assertEqual('Unable to obtain', args[0])
434
427
 
435
428
        self.assertEqual('%s %s\n'
436
429
                         '%s\n%s\n'
437
 
                         'Will continue to try until %s, unless '
438
 
                         'you press Ctrl-C\n'
439
 
                         'If you\'re sure that it\'s not being '
440
 
                         'modified, use bzr break-lock %s',
 
430
                         'Will continue to try until %s\n',
441
431
                         self._logged_reports[1][0])
442
432
        args = self._logged_reports[1][1]
443
433
        self.assertEqual('Lock owner changed for', args[0])
453
443
        lf1 = LockDir(t, 'test_lock')
454
444
        lf1.create()
455
445
        lf1.attempt_lock()
456
 
        self.addCleanup(lf1.unlock)
457
446
        lf1.confirm()
458
447
 
459
448
    def test_41_confirm_not_held(self):
471
460
        lf1.attempt_lock()
472
461
        t.move('test_lock', 'lock_gone_now')
473
462
        self.assertRaises(LockBroken, lf1.confirm)
474
 
        # Clean up
475
 
        t.move('lock_gone_now', 'test_lock')
476
 
        lf1.unlock()
477
463
 
478
464
    def test_43_break(self):
479
465
        """Break a lock whose caller has forgotten it"""
490
476
        lf2.force_break(holder_info)
491
477
        # now we should be able to take it
492
478
        lf2.attempt_lock()
493
 
        self.addCleanup(lf2.unlock)
494
479
        lf2.confirm()
495
480
 
496
481
    def test_44_break_already_released(self):
508
493
        lf2.force_break(holder_info)
509
494
        # now we should be able to take it
510
495
        lf2.attempt_lock()
511
 
        self.addCleanup(lf2.unlock)
512
496
        lf2.confirm()
513
497
 
514
498
    def test_45_break_mismatch(self):
540
524
        """Check the on-disk representation of LockDirs is as expected.
541
525
 
542
526
        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
 
527
        When the lock is held, there should be a lockname/held directory 
544
528
        containing an info file.
545
529
        """
546
530
        t = self.get_transport()
561
545
        # do this without IO redirection to ensure it doesn't prompt.
562
546
        self.assertRaises(AssertionError, ld1.break_lock)
563
547
        orig_factory = bzrlib.ui.ui_factory
564
 
        bzrlib.ui.ui_factory = bzrlib.ui.CannedInputUIFactory([True])
 
548
        # silent ui - no need for stdout
 
549
        bzrlib.ui.ui_factory = bzrlib.ui.SilentUIFactory()
 
550
        bzrlib.ui.ui_factory.stdin = StringIO("y\n")
565
551
        try:
566
552
            ld2.break_lock()
567
553
            self.assertRaises(LockBroken, ld1.unlock)
614
600
        ld1.create()
615
601
        ld1.lock_write()
616
602
        ld1.unlock()
617
 
 
618
 
    def test_lock_permission(self):
619
 
        if not osutils.supports_posix_readonly():
620
 
            raise tests.TestSkipped('Cannot induce a permission failure')
621
 
        ld1 = self.get_lock()
622
 
        lock_path = ld1.transport.local_abspath('test_lock')
623
 
        os.mkdir(lock_path)
624
 
        osutils.make_readonly(lock_path)
625
 
        self.assertRaises(errors.LockFailed, ld1.attempt_lock)
626
 
 
627
 
    def test_lock_by_token(self):
628
 
        ld1 = self.get_lock()
629
 
        token = ld1.lock_write()
630
 
        self.addCleanup(ld1.unlock)
631
 
        self.assertNotEqual(None, token)
632
 
        ld2 = self.get_lock()
633
 
        t2 = ld2.lock_write(token)
634
 
        self.addCleanup(ld2.unlock)
635
 
        self.assertEqual(token, t2)
636
 
 
637
 
    def test_lock_with_buggy_rename(self):
638
 
        # test that lock acquisition handles servers which pretend they
639
 
        # renamed correctly but that actually fail
640
 
        t = transport.get_transport('brokenrename+' + self.get_url())
641
 
        ld1 = LockDir(t, 'test_lock')
642
 
        ld1.create()
643
 
        ld1.attempt_lock()
644
 
        ld2 = LockDir(t, 'test_lock')
645
 
        # we should fail to lock
646
 
        e = self.assertRaises(errors.LockContention, ld2.attempt_lock)
647
 
        # now the original caller should succeed in unlocking
648
 
        ld1.unlock()
649
 
        # and there should be nothing left over
650
 
        self.assertEquals([], t.list_dir('test_lock'))
651
 
 
652
 
    def test_failed_lock_leaves_no_trash(self):
653
 
        # if we fail to acquire the lock, we don't leave pending directories
654
 
        # behind -- https://bugs.launchpad.net/bzr/+bug/109169
655
 
        ld1 = self.get_lock()
656
 
        ld2 = self.get_lock()
657
 
        # should be nothing before we start
658
 
        ld1.create()
659
 
        t = self.get_transport().clone('test_lock')
660
 
        def check_dir(a):
661
 
            self.assertEquals(a, t.list_dir('.'))
662
 
        check_dir([])
663
 
        # when held, that's all we see
664
 
        ld1.attempt_lock()
665
 
        self.addCleanup(ld1.unlock)
666
 
        check_dir(['held'])
667
 
        # second guy should fail
668
 
        self.assertRaises(errors.LockContention, ld2.attempt_lock)
669
 
        # no kibble
670
 
        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)