1
# Copyright (C) 2006, 2007, 2008 Canonical Ltd
3
# This program is free software; you can redistribute it and/or modify
4
# it under the terms of the GNU General Public License as published by
5
# the Free Software Foundation; either version 2 of the License, or
6
# (at your option) any later version.
8
# This program is distributed in the hope that it will be useful,
9
# but WITHOUT ANY WARRANTY; without even the implied warranty of
10
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
11
# GNU General Public License for more details.
13
# You should have received a copy of the GNU General Public License
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
17
"""Tests for LockDir"""
19
from cStringIO import StringIO
21
from threading import Thread, Lock
33
from bzrlib.errors import (
41
from bzrlib.lockdir import LockDir
42
from bzrlib.tests import TestCaseWithTransport
43
from bzrlib.trace import note
45
# These tests sometimes use threads to test the behaviour of lock files with
46
# concurrent actors. This is not a typical (or necessarily supported) use;
47
# they're really meant for guarding between processes.
49
# These tests are run on the default transport provided by the test framework
50
# (typically a local disk transport). That can be changed by the --transport
51
# option to bzr selftest. The required properties of the transport
52
# implementation are tested separately. (The main requirement is just that
53
# they don't allow overwriting nonempty directories.)
55
class TestLockDir(TestCaseWithTransport):
56
"""Test LockDir operations"""
58
def logging_report_function(self, fmt, *args):
59
self._logged_reports.append((fmt, args))
61
def setup_log_reporter(self, lock_dir):
62
self._logged_reports = []
63
lock_dir._report_function = self.logging_report_function
65
def test_00_lock_creation(self):
66
"""Creation of lock file on a transport"""
67
t = self.get_transport()
68
lf = LockDir(t, 'test_lock')
69
self.assertFalse(lf.is_held)
71
def test_01_lock_repr(self):
72
"""Lock string representation"""
73
lf = LockDir(self.get_transport(), 'test_lock')
75
self.assertContainsRe(r, r'^LockDir\(.*/test_lock\)$')
77
def test_02_unlocked_peek(self):
78
lf = LockDir(self.get_transport(), 'test_lock')
79
self.assertEqual(lf.peek(), None)
82
return LockDir(self.get_transport(), 'test_lock')
84
def test_unlock_after_break_raises(self):
89
ld2.force_break(ld2.peek())
90
self.assertRaises(LockBroken, ld.unlock)
92
def test_03_readonly_peek(self):
93
lf = LockDir(self.get_readonly_transport(), 'test_lock')
94
self.assertEqual(lf.peek(), None)
96
def test_10_lock_uncontested(self):
97
"""Acquire and release a lock"""
98
t = self.get_transport()
99
lf = LockDir(t, 'test_lock')
103
self.assertTrue(lf.is_held)
106
self.assertFalse(lf.is_held)
108
def test_11_create_readonly_transport(self):
109
"""Fail to create lock on readonly transport"""
110
t = self.get_readonly_transport()
111
lf = LockDir(t, 'test_lock')
112
self.assertRaises(LockFailed, lf.create)
114
def test_12_lock_readonly_transport(self):
115
"""Fail to lock on readonly transport"""
116
lf = LockDir(self.get_transport(), 'test_lock')
118
lf = LockDir(self.get_readonly_transport(), 'test_lock')
119
self.assertRaises(LockFailed, lf.attempt_lock)
121
def test_20_lock_contested(self):
122
"""Contention to get a lock"""
123
t = self.get_transport()
124
lf1 = LockDir(t, 'test_lock')
127
lf2 = LockDir(t, 'test_lock')
129
# locking is between LockDir instances; aliases within
130
# a single process are not detected
132
self.fail('Failed to detect lock collision')
133
except LockContention, e:
134
self.assertEqual(e.lock, lf2)
135
self.assertContainsRe(str(e),
136
r'^Could not acquire.*test_lock.*$')
139
def test_20_lock_peek(self):
140
"""Peek at the state of a lock"""
141
t = self.get_transport()
142
lf1 = LockDir(t, 'test_lock')
145
self.addCleanup(lf1.unlock)
146
# lock is held, should get some info on it
148
self.assertEqual(set(info1.keys()),
149
set(['user', 'nonce', 'hostname', 'pid', 'start_time']))
150
# should get the same info if we look at it through a different
152
info2 = LockDir(t, 'test_lock').peek()
153
self.assertEqual(info1, info2)
154
# locks which are never used should be not-held
155
self.assertEqual(LockDir(t, 'other_lock').peek(), None)
157
def test_21_peek_readonly(self):
158
"""Peek over a readonly transport"""
159
t = self.get_transport()
160
lf1 = LockDir(t, 'test_lock')
162
lf2 = LockDir(self.get_readonly_transport(), 'test_lock')
163
self.assertEqual(lf2.peek(), None)
165
self.addCleanup(lf1.unlock)
167
self.assertTrue(info2)
168
self.assertEqual(info2['nonce'], lf1.nonce)
170
def test_30_lock_wait_fail(self):
171
"""Wait on a lock, then fail
173
We ask to wait up to 400ms; this should fail within at most one
174
second. (Longer times are more realistic but we don't want the test
175
suite to take too long, and this should do for now.)
177
t = self.get_transport()
178
lf1 = LockDir(t, 'test_lock')
180
lf2 = LockDir(t, 'test_lock')
181
self.setup_log_reporter(lf2)
185
self.assertRaises(LockContention, lf2.wait_lock,
186
timeout=0.4, poll=0.1)
188
# it should only take about 0.4 seconds, but we allow more time in
189
# case the machine is heavily loaded
190
self.assertTrue(after - before <= 8.0,
191
"took %f seconds to detect lock contention" % (after - before))
194
lock_base = lf2.transport.abspath(lf2.path)
195
self.assertEqual(1, len(self._logged_reports))
196
lock_url = lf2.transport.abspath(lf2.path)
197
self.assertEqual('%s %s\n'
199
'Will continue to try until %s, unless '
201
'If you\'re sure that it\'s not being '
202
'modified, use bzr break-lock %s',
203
self._logged_reports[0][0])
204
args = self._logged_reports[0][1]
205
self.assertEqual('Unable to obtain', args[0])
206
self.assertEqual('lock %s' % (lock_base,), args[1])
207
self.assertStartsWith(args[2], 'held by ')
208
self.assertStartsWith(args[3], 'locked ')
209
self.assertEndsWith(args[3], ' ago')
210
self.assertContainsRe(args[4], r'\d\d:\d\d:\d\d')
212
def test_31_lock_wait_easy(self):
213
"""Succeed when waiting on a lock with no contention.
215
t = self.get_transport()
216
lf1 = LockDir(t, 'test_lock')
218
self.setup_log_reporter(lf1)
221
lf1.wait_lock(timeout=0.4, poll=0.1)
223
self.assertTrue(after - before <= 1.0)
226
self.assertEqual([], self._logged_reports)
228
def test_32_lock_wait_succeed(self):
229
"""Succeed when trying to acquire a lock that gets released
231
One thread holds on a lock and then releases it; another
234
# This test sometimes fails like this:
235
# Traceback (most recent call last):
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:
243
raise tests.TestSkipped("Test fails intermittently")
244
t = self.get_transport()
245
lf1 = LockDir(t, 'test_lock')
249
def wait_and_unlock():
252
unlocker = Thread(target=wait_and_unlock)
255
lf2 = LockDir(t, 'test_lock')
256
self.setup_log_reporter(lf2)
259
lf2.wait_lock(timeout=0.4, poll=0.1)
261
self.assertTrue(after - before <= 1.0)
265
# There should be only 1 report, even though it should have to
267
lock_base = lf2.transport.abspath(lf2.path)
268
self.assertEqual(1, len(self._logged_reports))
269
self.assertEqual('%s %s\n'
271
'Will continue to try until %s\n',
272
self._logged_reports[0][0])
273
args = self._logged_reports[0][1]
274
self.assertEqual('Unable to obtain', args[0])
275
self.assertEqual('lock %s' % (lock_base,), args[1])
276
self.assertStartsWith(args[2], 'held by ')
277
self.assertStartsWith(args[3], 'locked ')
278
self.assertEndsWith(args[3], ' ago')
279
self.assertContainsRe(args[4], r'\d\d:\d\d:\d\d')
281
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
287
t = self.get_transport()
288
lf1 = LockDir(t, 'test_lock')
292
def wait_and_unlock():
295
unlocker = Thread(target=wait_and_unlock)
298
lf2 = LockDir(t, 'test_lock')
299
self.setup_log_reporter(lf2)
307
# There should be only 1 report, even though it should have to
309
lock_base = lf2.transport.abspath(lf2.path)
310
self.assertEqual(1, len(self._logged_reports))
311
self.assertEqual('%s %s\n'
313
'Will continue to try until %s\n',
314
self._logged_reports[0][0])
315
args = self._logged_reports[0][1]
316
self.assertEqual('Unable to obtain', args[0])
317
self.assertEqual('lock %s' % (lock_base,), args[1])
318
self.assertStartsWith(args[2], 'held by ')
319
self.assertStartsWith(args[3], 'locked ')
320
self.assertEndsWith(args[3], ' ago')
321
self.assertContainsRe(args[4], r'\d\d:\d\d:\d\d')
323
def test_35_wait_lock_changing(self):
324
"""LockDir.wait_lock() will report if the lock changes underneath.
326
This is the stages we want to happen:
328
0) Synchronization locks are created and locked.
329
1) Lock1 obtains the lockdir, and releases the 'check' lock.
330
2) Lock2 grabs the 'check' lock, and checks the lockdir.
331
It sees the lockdir is already acquired, reports the fact,
332
and unsets the 'checked' lock.
333
3) Thread1 blocks on acquiring the 'checked' lock, and then tells
334
Lock1 to release and acquire the lockdir. This resets the 'check'
336
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
339
5) Thread1 blocks on the 'checked' lock, this time, it completely
340
unlocks the lockdir, allowing Lock2 to acquire the lock.
343
raise tests.KnownFailure(
344
"timing dependency in lock tests (#213182)")
346
wait_to_check_lock = Lock()
347
wait_until_checked_lock = Lock()
349
wait_to_check_lock.acquire()
350
wait_until_checked_lock.acquire()
351
note('locked check and checked locks')
353
class LockDir1(LockDir):
354
"""Use the synchronization points for the first lock."""
356
def attempt_lock(self):
357
# Once we have acquired the lock, it is okay for
358
# the other lock to check it
360
return super(LockDir1, self).attempt_lock()
362
note('lock1: releasing check lock')
363
wait_to_check_lock.release()
365
class LockDir2(LockDir):
366
"""Use the synchronization points for the second lock."""
368
def attempt_lock(self):
369
note('lock2: waiting for check lock')
370
wait_to_check_lock.acquire()
371
note('lock2: acquired check lock')
373
return super(LockDir2, self).attempt_lock()
375
note('lock2: releasing checked lock')
376
wait_until_checked_lock.release()
378
t = self.get_transport()
379
lf1 = LockDir1(t, 'test_lock')
382
lf2 = LockDir2(t, 'test_lock')
383
self.setup_log_reporter(lf2)
385
def wait_and_switch():
387
# Block until lock2 has had a chance to check
388
note('lock1: waiting 1 for checked lock')
389
wait_until_checked_lock.acquire()
390
note('lock1: acquired for checked lock')
391
note('lock1: released lockdir')
393
note('lock1: acquiring lockdir')
394
# Create a new nonce, so the lock looks different.
395
lf1.nonce = osutils.rand_chars(20)
397
note('lock1: acquired lockdir')
399
# Block until lock2 has peeked again
400
note('lock1: waiting 2 for checked lock')
401
wait_until_checked_lock.acquire()
402
note('lock1: acquired for checked lock')
403
# Now unlock, and let lock 2 grab the lock
405
wait_to_check_lock.release()
407
unlocker = Thread(target=wait_and_switch)
410
# Wait and play against the other thread
411
lf2.wait_lock(timeout=20.0, poll=0.01)
416
# There should be 2 reports, because the lock changed
417
lock_base = lf2.transport.abspath(lf2.path)
418
self.assertEqual(2, len(self._logged_reports))
419
lock_url = lf2.transport.abspath(lf2.path)
420
self.assertEqual('%s %s\n'
422
'Will continue to try until %s, unless '
424
'If you\'re sure that it\'s not being '
425
'modified, use bzr break-lock %s',
426
self._logged_reports[0][0])
427
args = self._logged_reports[0][1]
428
self.assertEqual('Unable to obtain', args[0])
429
self.assertEqual('lock %s' % (lock_base,), args[1])
430
self.assertStartsWith(args[2], 'held by ')
431
self.assertStartsWith(args[3], 'locked ')
432
self.assertEndsWith(args[3], ' ago')
433
self.assertContainsRe(args[4], r'\d\d:\d\d:\d\d')
435
self.assertEqual('%s %s\n'
437
'Will continue to try until %s, unless '
439
'If you\'re sure that it\'s not being '
440
'modified, use bzr break-lock %s',
441
self._logged_reports[1][0])
442
args = self._logged_reports[1][1]
443
self.assertEqual('Lock owner changed for', args[0])
444
self.assertEqual('lock %s' % (lock_base,), args[1])
445
self.assertStartsWith(args[2], 'held by ')
446
self.assertStartsWith(args[3], 'locked ')
447
self.assertEndsWith(args[3], ' ago')
448
self.assertContainsRe(args[4], r'\d\d:\d\d:\d\d')
450
def test_40_confirm_easy(self):
451
"""Confirm a lock that's already held"""
452
t = self.get_transport()
453
lf1 = LockDir(t, 'test_lock')
456
self.addCleanup(lf1.unlock)
459
def test_41_confirm_not_held(self):
460
"""Confirm a lock that's already held"""
461
t = self.get_transport()
462
lf1 = LockDir(t, 'test_lock')
464
self.assertRaises(LockNotHeld, lf1.confirm)
466
def test_42_confirm_broken_manually(self):
467
"""Confirm a lock broken by hand"""
468
t = self.get_transport()
469
lf1 = LockDir(t, 'test_lock')
472
t.move('test_lock', 'lock_gone_now')
473
self.assertRaises(LockBroken, lf1.confirm)
475
t.move('lock_gone_now', 'test_lock')
478
def test_43_break(self):
479
"""Break a lock whose caller has forgotten it"""
480
t = self.get_transport()
481
lf1 = LockDir(t, 'test_lock')
484
# we incorrectly discard the lock object without unlocking it
486
# someone else sees it's still locked
487
lf2 = LockDir(t, 'test_lock')
488
holder_info = lf2.peek()
489
self.assertTrue(holder_info)
490
lf2.force_break(holder_info)
491
# now we should be able to take it
493
self.addCleanup(lf2.unlock)
496
def test_44_break_already_released(self):
497
"""Lock break races with regular release"""
498
t = self.get_transport()
499
lf1 = LockDir(t, 'test_lock')
502
# someone else sees it's still locked
503
lf2 = LockDir(t, 'test_lock')
504
holder_info = lf2.peek()
505
# in the interim the lock is released
507
# break should succeed
508
lf2.force_break(holder_info)
509
# now we should be able to take it
511
self.addCleanup(lf2.unlock)
514
def test_45_break_mismatch(self):
515
"""Lock break races with someone else acquiring it"""
516
t = self.get_transport()
517
lf1 = LockDir(t, 'test_lock')
520
# someone else sees it's still locked
521
lf2 = LockDir(t, 'test_lock')
522
holder_info = lf2.peek()
523
# in the interim the lock is released
525
lf3 = LockDir(t, 'test_lock')
527
# break should now *fail*
528
self.assertRaises(LockBreakMismatch, lf2.force_break,
532
def test_46_fake_read_lock(self):
533
t = self.get_transport()
534
lf1 = LockDir(t, 'test_lock')
539
def test_50_lockdir_representation(self):
540
"""Check the on-disk representation of LockDirs is as expected.
542
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
544
containing an info file.
546
t = self.get_transport()
547
lf1 = LockDir(t, 'test_lock')
549
self.assertTrue(t.has('test_lock'))
551
self.assertTrue(t.has('test_lock/held/info'))
553
self.assertFalse(t.has('test_lock/held/info'))
555
def test_break_lock(self):
556
# the ui based break_lock routine should Just Work (tm)
557
ld1 = self.get_lock()
558
ld2 = self.get_lock()
561
# do this without IO redirection to ensure it doesn't prompt.
562
self.assertRaises(AssertionError, ld1.break_lock)
563
orig_factory = bzrlib.ui.ui_factory
564
# silent ui - no need for stdout
565
bzrlib.ui.ui_factory = bzrlib.ui.SilentUIFactory()
566
bzrlib.ui.ui_factory.stdin = StringIO("y\n")
569
self.assertRaises(LockBroken, ld1.unlock)
571
bzrlib.ui.ui_factory = orig_factory
573
def test_create_missing_base_directory(self):
574
"""If LockDir.path doesn't exist, it can be created
576
Some people manually remove the entire lock/ directory trying
577
to unlock a stuck repository/branch/etc. Rather than failing
578
after that, just create the lock directory when needed.
580
t = self.get_transport()
581
lf1 = LockDir(t, 'test_lock')
584
self.failUnless(t.has('test_lock'))
587
self.failIf(t.has('test_lock'))
589
# This will create 'test_lock' if it needs to
591
self.failUnless(t.has('test_lock'))
592
self.failUnless(t.has('test_lock/held/info'))
595
self.failIf(t.has('test_lock/held/info'))
597
def test__format_lock_info(self):
598
ld1 = self.get_lock()
602
info_list = ld1._format_lock_info(ld1.peek())
605
self.assertEqual('lock %s' % (ld1.transport.abspath(ld1.path),),
607
self.assertContainsRe(info_list[1],
608
r'^held by .* on host .* \[process #\d*\]$')
609
self.assertContainsRe(info_list[2], r'locked \d+ seconds? ago$')
611
def test_lock_without_email(self):
612
global_config = config.GlobalConfig()
613
# Intentionally has no email address
614
global_config.set_user_option('email', 'User Identity')
615
ld1 = self.get_lock()
620
def test_lock_permission(self):
621
if not osutils.supports_posix_readonly():
622
raise tests.TestSkipped('Cannot induce a permission failure')
623
ld1 = self.get_lock()
624
lock_path = ld1.transport.local_abspath('test_lock')
626
osutils.make_readonly(lock_path)
627
self.assertRaises(errors.LockFailed, ld1.attempt_lock)
629
def test_lock_by_token(self):
630
ld1 = self.get_lock()
631
token = ld1.lock_write()
632
self.addCleanup(ld1.unlock)
633
self.assertNotEqual(None, token)
634
ld2 = self.get_lock()
635
t2 = ld2.lock_write(token)
636
self.addCleanup(ld2.unlock)
637
self.assertEqual(token, t2)
639
def test_lock_with_buggy_rename(self):
640
# test that lock acquisition handles servers which pretend they
641
# renamed correctly but that actually fail
642
t = transport.get_transport('brokenrename+' + self.get_url())
643
ld1 = LockDir(t, 'test_lock')
646
ld2 = LockDir(t, 'test_lock')
647
# we should fail to lock
648
e = self.assertRaises(errors.LockContention, ld2.attempt_lock)
649
# now the original caller should succeed in unlocking
651
# and there should be nothing left over
652
self.assertEquals([], t.list_dir('test_lock'))
654
def test_failed_lock_leaves_no_trash(self):
655
# if we fail to acquire the lock, we don't leave pending directories
656
# behind -- https://bugs.launchpad.net/bzr/+bug/109169
657
ld1 = self.get_lock()
658
ld2 = self.get_lock()
659
# should be nothing before we start
661
t = self.get_transport().clone('test_lock')
663
self.assertEquals(a, t.list_dir('.'))
665
# when held, that's all we see
667
self.addCleanup(ld1.unlock)
669
# second guy should fail
670
self.assertRaises(errors.LockContention, ld2.attempt_lock)
675
class TestLockDirHooks(TestCaseWithTransport):
678
super(TestLockDirHooks, self).setUp()
682
return LockDir(self.get_transport(), 'test_lock')
684
def record_hook(self, result):
685
self._calls.append(result)
687
def test_LockDir_acquired_success(self):
688
# the LockDir.lock_acquired hook fires when a lock is acquired.
689
LockDir.hooks.install_named_hook('lock_acquired',
690
self.record_hook, 'record_hook')
693
self.assertEqual([], self._calls)
694
result = ld.attempt_lock()
695
lock_path = ld.transport.abspath(ld.path)
696
self.assertEqual([lock.LockResult(lock_path, result)], self._calls)
698
self.assertEqual([lock.LockResult(lock_path, result)], self._calls)
700
def test_LockDir_acquired_fail(self):
701
# the LockDir.lock_acquired hook does not fire on failure.
704
ld2 = self.get_lock()
706
# install a lock hook now, when the disk lock is locked
707
LockDir.hooks.install_named_hook('lock_acquired',
708
self.record_hook, 'record_hook')
709
self.assertRaises(errors.LockContention, ld.attempt_lock)
710
self.assertEqual([], self._calls)
712
self.assertEqual([], self._calls)
714
def test_LockDir_released_success(self):
715
# the LockDir.lock_released hook fires when a lock is acquired.
716
LockDir.hooks.install_named_hook('lock_released',
717
self.record_hook, 'record_hook')
720
self.assertEqual([], self._calls)
721
result = ld.attempt_lock()
722
self.assertEqual([], self._calls)
724
lock_path = ld.transport.abspath(ld.path)
725
self.assertEqual([lock.LockResult(lock_path, result)], self._calls)
727
def test_LockDir_released_fail(self):
728
# the LockDir.lock_released hook does not fire on failure.
731
ld2 = self.get_lock()
733
ld2.force_break(ld2.peek())
734
LockDir.hooks.install_named_hook('lock_released',
735
self.record_hook, 'record_hook')
736
self.assertRaises(LockBroken, ld.unlock)
737
self.assertEqual([], self._calls)
739
def test_LockDir_broken_success(self):
740
# the LockDir.lock_broken hook fires when a lock is broken.
743
ld2 = self.get_lock()
744
result = ld.attempt_lock()
745
LockDir.hooks.install_named_hook('lock_broken',
746
self.record_hook, 'record_hook')
747
ld2.force_break(ld2.peek())
748
lock_path = ld.transport.abspath(ld.path)
749
self.assertEqual([lock.LockResult(lock_path, result)], self._calls)
751
def test_LockDir_broken_failure(self):
752
# the LockDir.lock_broken hook does not fires when a lock is already
756
ld2 = self.get_lock()
757
result = ld.attempt_lock()
758
holder_info = ld2.peek()
760
LockDir.hooks.install_named_hook('lock_broken',
761
self.record_hook, 'record_hook')
762
ld2.force_break(holder_info)
763
lock_path = ld.transport.abspath(ld.path)
764
self.assertEqual([], self._calls)
added
removed
bzrlib/tests/test_lockdir.py
