← 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
  • Date: 2006-10-11 23:08:27 UTC
  • mto: This revision was merged to the branch mainline in revision 2080.
  • Revision ID: john@arbash-meinel.com-20061011230827-2bdfc45020695281
Change Copyright .. by Canonical to Copyright ... Canonical

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
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"""
191
182
            lf1.unlock()
192
183
        lock_base = lf2.transport.abspath(lf2.path)
193
184
        self.assertEqual(1, len(self._logged_reports))
194
 
        lock_url = lf2.transport.abspath(lf2.path)
195
185
        self.assertEqual('%s %s\n'
196
186
                         '%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',
 
187
                         'Will continue to try until %s\n',
201
188
                         self._logged_reports[0][0])
202
189
        args = self._logged_reports[0][1]
203
190
        self.assertEqual('Unable to obtain', args[0])
229
216
        One thread holds on a lock and then releases it; another 
230
217
        tries to lock it.
231
218
        """
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
219
        t = self.get_transport()
243
220
        lf1 = LockDir(t, 'test_lock')
244
221
        lf1.create()
276
253
        self.assertEndsWith(args[3], ' ago')
277
254
        self.assertContainsRe(args[4], r'\d\d:\d\d:\d\d')
278
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
 
279
283
    def test_34_lock_write_waits(self):
280
284
        """LockDir.lock_write() will wait for the lock.""" 
281
 
        # the test suite sets the default to 0 to make deadlocks fail fast.
282
 
        # change it for this test, as we want to try a manual deadlock.
283
 
        raise tests.TestSkipped('Timing-sensitive test')
284
 
        bzrlib.lockdir._DEFAULT_TIMEOUT_SECONDS = 300
285
285
        t = self.get_transport()
286
286
        lf1 = LockDir(t, 'test_lock')
287
287
        lf1.create()
338
338
           unlocks the lockdir, allowing Lock2 to acquire the lock.
339
339
        """
340
340
 
341
 
        raise tests.KnownFailure(
342
 
            "timing dependency in lock tests (#213182)")
343
 
 
344
341
        wait_to_check_lock = Lock()
345
342
        wait_until_checked_lock = Lock()
346
343
 
406
403
        unlocker.start()
407
404
        try:
408
405
            # Wait and play against the other thread
409
 
            lf2.wait_lock(timeout=20.0, poll=0.01)
 
406
            lf2.wait_lock(timeout=1.0, poll=0.01)
410
407
        finally:
411
408
            unlocker.join()
412
409
        lf2.unlock()
414
411
        # There should be 2 reports, because the lock changed
415
412
        lock_base = lf2.transport.abspath(lf2.path)
416
413
        self.assertEqual(2, len(self._logged_reports))
417
 
        lock_url = lf2.transport.abspath(lf2.path)
 
414
 
418
415
        self.assertEqual('%s %s\n'
419
416
                         '%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',
 
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
 
                         'If you\'re sure that it\'s not being '
438
 
                         'modified, use bzr break-lock %s',
 
429
                         'Will continue to try until %s\n',
439
430
                         self._logged_reports[1][0])
440
431
        args = self._logged_reports[1][1]
441
432
        self.assertEqual('Lock owner changed for', args[0])
599
590
        self.assertContainsRe(info_list[1],
600
591
                              r'^held by .* on host .* \[process #\d*\]$')
601
592
        self.assertContainsRe(info_list[2], r'locked \d+ seconds? ago$')
602
 
 
603
 
    def test_lock_without_email(self):
604
 
        global_config = config.GlobalConfig()
605
 
        # Intentionally has no email address
606
 
        global_config.set_user_option('email', 'User Identity')
607
 
        ld1 = self.get_lock()
608
 
        ld1.create()
609
 
        ld1.lock_write()
610
 
        ld1.unlock()
611
 
 
612
 
    def test_lock_permission(self):
613
 
        if not osutils.supports_posix_readonly():
614
 
            raise tests.TestSkipped('Cannot induce a permission failure')
615
 
        ld1 = self.get_lock()
616
 
        lock_path = ld1.transport.local_abspath('test_lock')
617
 
        os.mkdir(lock_path)
618
 
        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)