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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 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
# lock is held, should get some info on it
147
self.assertEqual(set(info1.keys()),
148
set(['user', 'nonce', 'hostname', 'pid', 'start_time']))
149
# should get the same info if we look at it through a different
151
info2 = LockDir(t, 'test_lock').peek()
152
self.assertEqual(info1, info2)
153
# locks which are never used should be not-held
154
self.assertEqual(LockDir(t, 'other_lock').peek(), None)
156
def test_21_peek_readonly(self):
157
"""Peek over a readonly transport"""
158
t = self.get_transport()
159
lf1 = LockDir(t, 'test_lock')
161
lf2 = LockDir(self.get_readonly_transport(), 'test_lock')
162
self.assertEqual(lf2.peek(), None)
165
self.assertTrue(info2)
166
self.assertEqual(info2['nonce'], lf1.nonce)
168
def test_30_lock_wait_fail(self):
169
"""Wait on a lock, then fail
171
We ask to wait up to 400ms; this should fail within at most one
172
second. (Longer times are more realistic but we don't want the test
173
suite to take too long, and this should do for now.)
175
t = self.get_transport()
176
lf1 = LockDir(t, 'test_lock')
178
lf2 = LockDir(t, 'test_lock')
179
self.setup_log_reporter(lf2)
183
self.assertRaises(LockContention, lf2.wait_lock,
184
timeout=0.4, poll=0.1)
186
# it should only take about 0.4 seconds, but we allow more time in
187
# case the machine is heavily loaded
188
self.assertTrue(after - before <= 8.0,
189
"took %f seconds to detect lock contention" % (after - before))
192
lock_base = lf2.transport.abspath(lf2.path)
193
self.assertEqual(1, len(self._logged_reports))
194
self.assertEqual('%s %s\n'
196
'Will continue to try until %s\n',
197
self._logged_reports[0][0])
198
args = self._logged_reports[0][1]
199
self.assertEqual('Unable to obtain', args[0])
200
self.assertEqual('lock %s' % (lock_base,), args[1])
201
self.assertStartsWith(args[2], 'held by ')
202
self.assertStartsWith(args[3], 'locked ')
203
self.assertEndsWith(args[3], ' ago')
204
self.assertContainsRe(args[4], r'\d\d:\d\d:\d\d')
206
def test_31_lock_wait_easy(self):
207
"""Succeed when waiting on a lock with no contention.
209
t = self.get_transport()
210
lf1 = LockDir(t, 'test_lock')
212
self.setup_log_reporter(lf1)
215
lf1.wait_lock(timeout=0.4, poll=0.1)
217
self.assertTrue(after - before <= 1.0)
220
self.assertEqual([], self._logged_reports)
222
def test_32_lock_wait_succeed(self):
223
"""Succeed when trying to acquire a lock that gets released
225
One thread holds on a lock and then releases it; another
228
# This test sometimes fails like this:
229
# Traceback (most recent call last):
231
# File "/home/pqm/bzr-pqm-workdir/home/+trunk/bzrlib/tests/
232
# test_lockdir.py", line 247, in test_32_lock_wait_succeed
233
# self.assertEqual(1, len(self._logged_reports))
234
# AssertionError: not equal:
237
raise tests.TestSkipped("Test fails intermittently")
238
t = self.get_transport()
239
lf1 = LockDir(t, 'test_lock')
243
def wait_and_unlock():
246
unlocker = Thread(target=wait_and_unlock)
249
lf2 = LockDir(t, 'test_lock')
250
self.setup_log_reporter(lf2)
253
lf2.wait_lock(timeout=0.4, poll=0.1)
255
self.assertTrue(after - before <= 1.0)
259
# There should be only 1 report, even though it should have to
261
lock_base = lf2.transport.abspath(lf2.path)
262
self.assertEqual(1, len(self._logged_reports))
263
self.assertEqual('%s %s\n'
265
'Will continue to try until %s\n',
266
self._logged_reports[0][0])
267
args = self._logged_reports[0][1]
268
self.assertEqual('Unable to obtain', args[0])
269
self.assertEqual('lock %s' % (lock_base,), args[1])
270
self.assertStartsWith(args[2], 'held by ')
271
self.assertStartsWith(args[3], 'locked ')
272
self.assertEndsWith(args[3], ' ago')
273
self.assertContainsRe(args[4], r'\d\d:\d\d:\d\d')
275
def test_34_lock_write_waits(self):
276
"""LockDir.lock_write() will wait for the lock."""
277
# the test suite sets the default to 0 to make deadlocks fail fast.
278
# change it for this test, as we want to try a manual deadlock.
279
raise tests.TestSkipped('Timing-sensitive test')
280
bzrlib.lockdir._DEFAULT_TIMEOUT_SECONDS = 300
281
t = self.get_transport()
282
lf1 = LockDir(t, 'test_lock')
286
def wait_and_unlock():
289
unlocker = Thread(target=wait_and_unlock)
292
lf2 = LockDir(t, 'test_lock')
293
self.setup_log_reporter(lf2)
301
# There should be only 1 report, even though it should have to
303
lock_base = lf2.transport.abspath(lf2.path)
304
self.assertEqual(1, len(self._logged_reports))
305
self.assertEqual('%s %s\n'
307
'Will continue to try until %s\n',
308
self._logged_reports[0][0])
309
args = self._logged_reports[0][1]
310
self.assertEqual('Unable to obtain', args[0])
311
self.assertEqual('lock %s' % (lock_base,), args[1])
312
self.assertStartsWith(args[2], 'held by ')
313
self.assertStartsWith(args[3], 'locked ')
314
self.assertEndsWith(args[3], ' ago')
315
self.assertContainsRe(args[4], r'\d\d:\d\d:\d\d')
317
def test_35_wait_lock_changing(self):
318
"""LockDir.wait_lock() will report if the lock changes underneath.
320
This is the stages we want to happen:
322
0) Synchronization locks are created and locked.
323
1) Lock1 obtains the lockdir, and releases the 'check' lock.
324
2) Lock2 grabs the 'check' lock, and checks the lockdir.
325
It sees the lockdir is already acquired, reports the fact,
326
and unsets the 'checked' lock.
327
3) Thread1 blocks on acquiring the 'checked' lock, and then tells
328
Lock1 to release and acquire the lockdir. This resets the 'check'
330
4) Lock2 acquires the 'check' lock, and checks again. It notices
331
that the holder of the lock has changed, and so reports a new
333
5) Thread1 blocks on the 'checked' lock, this time, it completely
334
unlocks the lockdir, allowing Lock2 to acquire the lock.
337
wait_to_check_lock = Lock()
338
wait_until_checked_lock = Lock()
340
wait_to_check_lock.acquire()
341
wait_until_checked_lock.acquire()
342
note('locked check and checked locks')
344
class LockDir1(LockDir):
345
"""Use the synchronization points for the first lock."""
347
def attempt_lock(self):
348
# Once we have acquired the lock, it is okay for
349
# the other lock to check it
351
return super(LockDir1, self).attempt_lock()
353
note('lock1: releasing check lock')
354
wait_to_check_lock.release()
356
class LockDir2(LockDir):
357
"""Use the synchronization points for the second lock."""
359
def attempt_lock(self):
360
note('lock2: waiting for check lock')
361
wait_to_check_lock.acquire()
362
note('lock2: acquired check lock')
364
return super(LockDir2, self).attempt_lock()
366
note('lock2: releasing checked lock')
367
wait_until_checked_lock.release()
369
t = self.get_transport()
370
lf1 = LockDir1(t, 'test_lock')
373
lf2 = LockDir2(t, 'test_lock')
374
self.setup_log_reporter(lf2)
376
def wait_and_switch():
378
# Block until lock2 has had a chance to check
379
note('lock1: waiting 1 for checked lock')
380
wait_until_checked_lock.acquire()
381
note('lock1: acquired for checked lock')
382
note('lock1: released lockdir')
384
note('lock1: acquiring lockdir')
385
# Create a new nonce, so the lock looks different.
386
lf1.nonce = osutils.rand_chars(20)
388
note('lock1: acquired lockdir')
390
# Block until lock2 has peeked again
391
note('lock1: waiting 2 for checked lock')
392
wait_until_checked_lock.acquire()
393
note('lock1: acquired for checked lock')
394
# Now unlock, and let lock 2 grab the lock
396
wait_to_check_lock.release()
398
unlocker = Thread(target=wait_and_switch)
401
# Wait and play against the other thread
402
lf2.wait_lock(timeout=20.0, poll=0.01)
407
# There should be 2 reports, because the lock changed
408
lock_base = lf2.transport.abspath(lf2.path)
409
self.assertEqual(2, len(self._logged_reports))
411
self.assertEqual('%s %s\n'
413
'Will continue to try until %s\n',
414
self._logged_reports[0][0])
415
args = self._logged_reports[0][1]
416
self.assertEqual('Unable to obtain', args[0])
417
self.assertEqual('lock %s' % (lock_base,), args[1])
418
self.assertStartsWith(args[2], 'held by ')
419
self.assertStartsWith(args[3], 'locked ')
420
self.assertEndsWith(args[3], ' ago')
421
self.assertContainsRe(args[4], r'\d\d:\d\d:\d\d')
423
self.assertEqual('%s %s\n'
425
'Will continue to try until %s\n',
426
self._logged_reports[1][0])
427
args = self._logged_reports[1][1]
428
self.assertEqual('Lock owner changed for', 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
def test_40_confirm_easy(self):
436
"""Confirm a lock that's already held"""
437
t = self.get_transport()
438
lf1 = LockDir(t, 'test_lock')
443
def test_41_confirm_not_held(self):
444
"""Confirm a lock that's already held"""
445
t = self.get_transport()
446
lf1 = LockDir(t, 'test_lock')
448
self.assertRaises(LockNotHeld, lf1.confirm)
450
def test_42_confirm_broken_manually(self):
451
"""Confirm a lock broken by hand"""
452
t = self.get_transport()
453
lf1 = LockDir(t, 'test_lock')
456
t.move('test_lock', 'lock_gone_now')
457
self.assertRaises(LockBroken, lf1.confirm)
459
def test_43_break(self):
460
"""Break a lock whose caller has forgotten it"""
461
t = self.get_transport()
462
lf1 = LockDir(t, 'test_lock')
465
# we incorrectly discard the lock object without unlocking it
467
# someone else sees it's still locked
468
lf2 = LockDir(t, 'test_lock')
469
holder_info = lf2.peek()
470
self.assertTrue(holder_info)
471
lf2.force_break(holder_info)
472
# now we should be able to take it
476
def test_44_break_already_released(self):
477
"""Lock break races with regular release"""
478
t = self.get_transport()
479
lf1 = LockDir(t, 'test_lock')
482
# someone else sees it's still locked
483
lf2 = LockDir(t, 'test_lock')
484
holder_info = lf2.peek()
485
# in the interim the lock is released
487
# break should succeed
488
lf2.force_break(holder_info)
489
# now we should be able to take it
493
def test_45_break_mismatch(self):
494
"""Lock break races with someone else acquiring it"""
495
t = self.get_transport()
496
lf1 = LockDir(t, 'test_lock')
499
# someone else sees it's still locked
500
lf2 = LockDir(t, 'test_lock')
501
holder_info = lf2.peek()
502
# in the interim the lock is released
504
lf3 = LockDir(t, 'test_lock')
506
# break should now *fail*
507
self.assertRaises(LockBreakMismatch, lf2.force_break,
511
def test_46_fake_read_lock(self):
512
t = self.get_transport()
513
lf1 = LockDir(t, 'test_lock')
518
def test_50_lockdir_representation(self):
519
"""Check the on-disk representation of LockDirs is as expected.
521
There should always be a top-level directory named by the lock.
522
When the lock is held, there should be a lockname/held directory
523
containing an info file.
525
t = self.get_transport()
526
lf1 = LockDir(t, 'test_lock')
528
self.assertTrue(t.has('test_lock'))
530
self.assertTrue(t.has('test_lock/held/info'))
532
self.assertFalse(t.has('test_lock/held/info'))
534
def test_break_lock(self):
535
# the ui based break_lock routine should Just Work (tm)
536
ld1 = self.get_lock()
537
ld2 = self.get_lock()
540
# do this without IO redirection to ensure it doesn't prompt.
541
self.assertRaises(AssertionError, ld1.break_lock)
542
orig_factory = bzrlib.ui.ui_factory
543
# silent ui - no need for stdout
544
bzrlib.ui.ui_factory = bzrlib.ui.SilentUIFactory()
545
bzrlib.ui.ui_factory.stdin = StringIO("y\n")
548
self.assertRaises(LockBroken, ld1.unlock)
550
bzrlib.ui.ui_factory = orig_factory
552
def test_create_missing_base_directory(self):
553
"""If LockDir.path doesn't exist, it can be created
555
Some people manually remove the entire lock/ directory trying
556
to unlock a stuck repository/branch/etc. Rather than failing
557
after that, just create the lock directory when needed.
559
t = self.get_transport()
560
lf1 = LockDir(t, 'test_lock')
563
self.failUnless(t.has('test_lock'))
566
self.failIf(t.has('test_lock'))
568
# This will create 'test_lock' if it needs to
570
self.failUnless(t.has('test_lock'))
571
self.failUnless(t.has('test_lock/held/info'))
574
self.failIf(t.has('test_lock/held/info'))
576
def test__format_lock_info(self):
577
ld1 = self.get_lock()
581
info_list = ld1._format_lock_info(ld1.peek())
584
self.assertEqual('lock %s' % (ld1.transport.abspath(ld1.path),),
586
self.assertContainsRe(info_list[1],
587
r'^held by .* on host .* \[process #\d*\]$')
588
self.assertContainsRe(info_list[2], r'locked \d+ seconds? ago$')
590
def test_lock_without_email(self):
591
global_config = config.GlobalConfig()
592
# Intentionally has no email address
593
global_config.set_user_option('email', 'User Identity')
594
ld1 = self.get_lock()
599
def test_lock_permission(self):
600
if not osutils.supports_posix_readonly():
601
raise tests.TestSkipped('Cannot induce a permission failure')
602
ld1 = self.get_lock()
603
lock_path = ld1.transport.local_abspath('test_lock')
605
osutils.make_readonly(lock_path)
606
self.assertRaises(errors.LockFailed, ld1.attempt_lock)
608
def test_lock_by_token(self):
609
ld1 = self.get_lock()
610
token = ld1.lock_write()
611
self.assertNotEqual(None, token)
612
ld2 = self.get_lock()
613
t2 = ld2.lock_write(token)
614
self.assertEqual(token, t2)
616
def test_lock_with_buggy_rename(self):
617
# test that lock acquisition handles servers which pretend they
618
# renamed correctly but that actually fail
619
t = transport.get_transport('brokenrename+' + self.get_url())
620
ld1 = LockDir(t, 'test_lock')
623
ld2 = LockDir(t, 'test_lock')
624
# we should fail to lock
625
e = self.assertRaises(errors.LockContention, ld2.attempt_lock)
626
# now the original caller should succeed in unlocking
628
# and there should be nothing left over
629
self.assertEquals([], t.list_dir('test_lock'))
631
def test_failed_lock_leaves_no_trash(self):
632
# if we fail to acquire the lock, we don't leave pending directories
633
# behind -- https://bugs.launchpad.net/bzr/+bug/109169
634
ld1 = self.get_lock()
635
ld2 = self.get_lock()
636
# should be nothing before we start
638
t = self.get_transport().clone('test_lock')
640
self.assertEquals(a, t.list_dir('.'))
642
# when held, that's all we see
645
# second guy should fail
646
self.assertRaises(errors.LockContention, ld2.attempt_lock)
650
def record_hook(self, result):
651
self._calls.append(result)
653
def reset_hooks(self):
654
self._old_hooks = lock.PhysicalLock.hooks.clone()
655
self.addCleanup(self.restore_hooks)
656
lock.PhysicalLock.hooks.clear_hooks()
658
def restore_hooks(self):
659
lock.PhysicalLock.hooks = self._old_hooks
661
def test_PhysicalLock_acquired_success(self):
662
# the PhysicalLock.lock_acquired hook fires when a lock is acquired.
665
lock.PhysicalLock.hooks.install_hook('lock_acquired', self.record_hook)
668
self.assertEqual([], self._calls)
669
result = ld.attempt_lock()
670
lock_path = ld.transport.abspath(ld.path)
671
self.assertEqual([lock.LockResult(lock_path, result)], self._calls)
673
self.assertEqual([lock.LockResult(lock_path, result)], self._calls)
675
def test_PhysicalLock_acquired_fail(self):
676
# the PhysicalLock.lock_acquired hook does not fire on failure.
681
ld2 = self.get_lock()
683
# install a lock hook now, when the disk lock is locked
684
lock.PhysicalLock.hooks.install_hook('lock_acquired', self.record_hook)
685
self.assertRaises(errors.LockContention, ld.attempt_lock)
686
self.assertEqual([], self._calls)
688
self.assertEqual([], self._calls)
690
def test_PhysicalLock_released_success(self):
691
# the PhysicalLock.lock_released hook fires when a lock is acquired.
694
lock.PhysicalLock.hooks.install_hook('lock_released', self.record_hook)
697
self.assertEqual([], self._calls)
698
result = ld.attempt_lock()
699
self.assertEqual([], self._calls)
701
lock_path = ld.transport.abspath(ld.path)
702
self.assertEqual([lock.LockResult(lock_path, result)], self._calls)
704
def test_PhysicalLock_released_fail(self):
705
# the PhysicalLock.lock_released hook does not fire on failure.
710
ld2 = self.get_lock()
712
ld2.force_break(ld2.peek())
713
lock.PhysicalLock.hooks.install_hook('lock_released', self.record_hook)
714
self.assertRaises(LockBroken, ld.unlock)
715
self.assertEqual([], self._calls)
added
removed
bzrlib/tests/test_lockdir.py
