/brz/remove-bazaar

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_lockdir.py

  • Committer: John Arbash Meinel
  • Date: 2006-10-11 23:32:09 UTC
  • mto: This revision was merged to the branch mainline in revision 2080.
  • Revision ID: john@arbash-meinel.com-20061011233209-9ee5ee88a8ae79a2
Add (c) Canonical to files that Aaron has approved

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