1
# Copyright (C) 2006 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
32
from bzrlib.errors import (
34
LockContention, LockError, UnlockableTransport,
35
LockNotHeld, LockBroken
37
from bzrlib.lockdir import LockDir
38
from bzrlib.tests import TestCaseWithTransport
39
from bzrlib.trace import note
41
# These tests sometimes use threads to test the behaviour of lock files with
42
# concurrent actors. This is not a typical (or necessarily supported) use;
43
# they're really meant for guarding between processes.
45
# These tests are run on the default transport provided by the test framework
46
# (typically a local disk transport). That can be changed by the --transport
47
# option to bzr selftest. The required properties of the transport
48
# implementation are tested separately. (The main requirement is just that
49
# they don't allow overwriting nonempty directories.)
51
class TestLockDir(TestCaseWithTransport):
52
"""Test LockDir operations"""
54
def logging_report_function(self, fmt, *args):
55
self._logged_reports.append((fmt, args))
57
def setup_log_reporter(self, lock_dir):
58
self._logged_reports = []
59
lock_dir._report_function = self.logging_report_function
61
def test_00_lock_creation(self):
62
"""Creation of lock file on a transport"""
63
t = self.get_transport()
64
lf = LockDir(t, 'test_lock')
65
self.assertFalse(lf.is_held)
67
def test_01_lock_repr(self):
68
"""Lock string representation"""
69
lf = LockDir(self.get_transport(), 'test_lock')
71
self.assertContainsRe(r, r'^LockDir\(.*/test_lock\)$')
73
def test_02_unlocked_peek(self):
74
lf = LockDir(self.get_transport(), 'test_lock')
75
self.assertEqual(lf.peek(), None)
78
return LockDir(self.get_transport(), 'test_lock')
80
def test_unlock_after_break_raises(self):
85
ld2.force_break(ld2.peek())
86
self.assertRaises(LockBroken, ld.unlock)
88
def test_03_readonly_peek(self):
89
lf = LockDir(self.get_readonly_transport(), 'test_lock')
90
self.assertEqual(lf.peek(), None)
92
def test_10_lock_uncontested(self):
93
"""Acquire and release a lock"""
94
t = self.get_transport()
95
lf = LockDir(t, 'test_lock')
99
self.assertTrue(lf.is_held)
102
self.assertFalse(lf.is_held)
104
def test_11_create_readonly_transport(self):
105
"""Fail to create lock on readonly transport"""
106
t = self.get_readonly_transport()
107
lf = LockDir(t, 'test_lock')
108
self.assertRaises(UnlockableTransport, lf.create)
110
def test_12_lock_readonly_transport(self):
111
"""Fail to lock on readonly transport"""
112
lf = LockDir(self.get_transport(), 'test_lock')
114
lf = LockDir(self.get_readonly_transport(), 'test_lock')
115
self.assertRaises(UnlockableTransport, lf.attempt_lock)
117
def test_20_lock_contested(self):
118
"""Contention to get a lock"""
119
t = self.get_transport()
120
lf1 = LockDir(t, 'test_lock')
123
lf2 = LockDir(t, 'test_lock')
125
# locking is between LockDir instances; aliases within
126
# a single process are not detected
128
self.fail('Failed to detect lock collision')
129
except LockContention, e:
130
self.assertEqual(e.lock, lf2)
131
self.assertContainsRe(str(e),
132
r'^Could not acquire.*test_lock.*$')
135
def test_20_lock_peek(self):
136
"""Peek at the state of a lock"""
137
t = self.get_transport()
138
lf1 = LockDir(t, 'test_lock')
141
# lock is held, should get some info on it
143
self.assertEqual(set(info1.keys()),
144
set(['user', 'nonce', 'hostname', 'pid', 'start_time']))
145
# should get the same info if we look at it through a different
147
info2 = LockDir(t, 'test_lock').peek()
148
self.assertEqual(info1, info2)
149
# locks which are never used should be not-held
150
self.assertEqual(LockDir(t, 'other_lock').peek(), None)
152
def test_21_peek_readonly(self):
153
"""Peek over a readonly transport"""
154
t = self.get_transport()
155
lf1 = LockDir(t, 'test_lock')
157
lf2 = LockDir(self.get_readonly_transport(), 'test_lock')
158
self.assertEqual(lf2.peek(), None)
161
self.assertTrue(info2)
162
self.assertEqual(info2['nonce'], lf1.nonce)
164
def test_30_lock_wait_fail(self):
165
"""Wait on a lock, then fail
167
We ask to wait up to 400ms; this should fail within at most one
168
second. (Longer times are more realistic but we don't want the test
169
suite to take too long, and this should do for now.)
171
t = self.get_transport()
172
lf1 = LockDir(t, 'test_lock')
174
lf2 = LockDir(t, 'test_lock')
175
self.setup_log_reporter(lf2)
179
self.assertRaises(LockContention, lf2.wait_lock,
180
timeout=0.4, poll=0.1)
182
# it should only take about 0.4 seconds, but we allow more time in
183
# case the machine is heavily loaded
184
self.assertTrue(after - before <= 8.0,
185
"took %f seconds to detect lock contention" % (after - before))
188
lock_base = lf2.transport.abspath(lf2.path)
189
self.assertEqual(1, len(self._logged_reports))
190
self.assertEqual('%s %s\n'
192
'Will continue to try until %s\n',
193
self._logged_reports[0][0])
194
args = self._logged_reports[0][1]
195
self.assertEqual('Unable to obtain', args[0])
196
self.assertEqual('lock %s' % (lock_base,), args[1])
197
self.assertStartsWith(args[2], 'held by ')
198
self.assertStartsWith(args[3], 'locked ')
199
self.assertEndsWith(args[3], ' ago')
200
self.assertContainsRe(args[4], r'\d\d:\d\d:\d\d')
202
def test_31_lock_wait_easy(self):
203
"""Succeed when waiting on a lock with no contention.
205
t = self.get_transport()
206
lf1 = LockDir(t, 'test_lock')
208
self.setup_log_reporter(lf1)
211
lf1.wait_lock(timeout=0.4, poll=0.1)
213
self.assertTrue(after - before <= 1.0)
216
self.assertEqual([], self._logged_reports)
218
def test_32_lock_wait_succeed(self):
219
"""Succeed when trying to acquire a lock that gets released
221
One thread holds on a lock and then releases it; another
224
# This test sometimes fails like this:
225
# Traceback (most recent call last):
227
# File "/home/pqm/bzr-pqm-workdir/home/+trunk/bzrlib/tests/
228
# test_lockdir.py", line 247, in test_32_lock_wait_succeed
229
# self.assertEqual(1, len(self._logged_reports))
230
# AssertionError: not equal:
233
raise tests.TestSkipped("Test fails intermittently")
234
t = self.get_transport()
235
lf1 = LockDir(t, 'test_lock')
239
def wait_and_unlock():
242
unlocker = Thread(target=wait_and_unlock)
245
lf2 = LockDir(t, 'test_lock')
246
self.setup_log_reporter(lf2)
249
lf2.wait_lock(timeout=0.4, poll=0.1)
251
self.assertTrue(after - before <= 1.0)
255
# There should be only 1 report, even though it should have to
257
lock_base = lf2.transport.abspath(lf2.path)
258
self.assertEqual(1, len(self._logged_reports))
259
self.assertEqual('%s %s\n'
261
'Will continue to try until %s\n',
262
self._logged_reports[0][0])
263
args = self._logged_reports[0][1]
264
self.assertEqual('Unable to obtain', args[0])
265
self.assertEqual('lock %s' % (lock_base,), args[1])
266
self.assertStartsWith(args[2], 'held by ')
267
self.assertStartsWith(args[3], 'locked ')
268
self.assertEndsWith(args[3], ' ago')
269
self.assertContainsRe(args[4], r'\d\d:\d\d:\d\d')
271
def test_34_lock_write_waits(self):
272
"""LockDir.lock_write() will wait for the lock."""
273
# the test suite sets the default to 0 to make deadlocks fail fast.
274
# change it for this test, as we want to try a manual deadlock.
275
raise tests.TestSkipped('Timing-sensitive test')
276
bzrlib.lockdir._DEFAULT_TIMEOUT_SECONDS = 300
277
t = self.get_transport()
278
lf1 = LockDir(t, 'test_lock')
282
def wait_and_unlock():
285
unlocker = Thread(target=wait_and_unlock)
288
lf2 = LockDir(t, 'test_lock')
289
self.setup_log_reporter(lf2)
297
# There should be only 1 report, even though it should have to
299
lock_base = lf2.transport.abspath(lf2.path)
300
self.assertEqual(1, len(self._logged_reports))
301
self.assertEqual('%s %s\n'
303
'Will continue to try until %s\n',
304
self._logged_reports[0][0])
305
args = self._logged_reports[0][1]
306
self.assertEqual('Unable to obtain', args[0])
307
self.assertEqual('lock %s' % (lock_base,), args[1])
308
self.assertStartsWith(args[2], 'held by ')
309
self.assertStartsWith(args[3], 'locked ')
310
self.assertEndsWith(args[3], ' ago')
311
self.assertContainsRe(args[4], r'\d\d:\d\d:\d\d')
313
def test_35_wait_lock_changing(self):
314
"""LockDir.wait_lock() will report if the lock changes underneath.
316
This is the stages we want to happen:
318
0) Synchronization locks are created and locked.
319
1) Lock1 obtains the lockdir, and releases the 'check' lock.
320
2) Lock2 grabs the 'check' lock, and checks the lockdir.
321
It sees the lockdir is already acquired, reports the fact,
322
and unsets the 'checked' lock.
323
3) Thread1 blocks on acquiring the 'checked' lock, and then tells
324
Lock1 to release and acquire the lockdir. This resets the 'check'
326
4) Lock2 acquires the 'check' lock, and checks again. It notices
327
that the holder of the lock has changed, and so reports a new
329
5) Thread1 blocks on the 'checked' lock, this time, it completely
330
unlocks the lockdir, allowing Lock2 to acquire the lock.
333
wait_to_check_lock = Lock()
334
wait_until_checked_lock = Lock()
336
wait_to_check_lock.acquire()
337
wait_until_checked_lock.acquire()
338
note('locked check and checked locks')
340
class LockDir1(LockDir):
341
"""Use the synchronization points for the first lock."""
343
def attempt_lock(self):
344
# Once we have acquired the lock, it is okay for
345
# the other lock to check it
347
return super(LockDir1, self).attempt_lock()
349
note('lock1: releasing check lock')
350
wait_to_check_lock.release()
352
class LockDir2(LockDir):
353
"""Use the synchronization points for the second lock."""
355
def attempt_lock(self):
356
note('lock2: waiting for check lock')
357
wait_to_check_lock.acquire()
358
note('lock2: acquired check lock')
360
return super(LockDir2, self).attempt_lock()
362
note('lock2: releasing checked lock')
363
wait_until_checked_lock.release()
365
t = self.get_transport()
366
lf1 = LockDir1(t, 'test_lock')
369
lf2 = LockDir2(t, 'test_lock')
370
self.setup_log_reporter(lf2)
372
def wait_and_switch():
374
# Block until lock2 has had a chance to check
375
note('lock1: waiting 1 for checked lock')
376
wait_until_checked_lock.acquire()
377
note('lock1: acquired for checked lock')
378
note('lock1: released lockdir')
380
note('lock1: acquiring lockdir')
381
# Create a new nonce, so the lock looks different.
382
lf1.nonce = osutils.rand_chars(20)
384
note('lock1: acquired lockdir')
386
# Block until lock2 has peeked again
387
note('lock1: waiting 2 for checked lock')
388
wait_until_checked_lock.acquire()
389
note('lock1: acquired for checked lock')
390
# Now unlock, and let lock 2 grab the lock
392
wait_to_check_lock.release()
394
unlocker = Thread(target=wait_and_switch)
397
# Wait and play against the other thread
398
lf2.wait_lock(timeout=20.0, poll=0.01)
403
# There should be 2 reports, because the lock changed
404
lock_base = lf2.transport.abspath(lf2.path)
405
self.assertEqual(2, len(self._logged_reports))
407
self.assertEqual('%s %s\n'
409
'Will continue to try until %s\n',
410
self._logged_reports[0][0])
411
args = self._logged_reports[0][1]
412
self.assertEqual('Unable to obtain', args[0])
413
self.assertEqual('lock %s' % (lock_base,), args[1])
414
self.assertStartsWith(args[2], 'held by ')
415
self.assertStartsWith(args[3], 'locked ')
416
self.assertEndsWith(args[3], ' ago')
417
self.assertContainsRe(args[4], r'\d\d:\d\d:\d\d')
419
self.assertEqual('%s %s\n'
421
'Will continue to try until %s\n',
422
self._logged_reports[1][0])
423
args = self._logged_reports[1][1]
424
self.assertEqual('Lock owner changed for', args[0])
425
self.assertEqual('lock %s' % (lock_base,), args[1])
426
self.assertStartsWith(args[2], 'held by ')
427
self.assertStartsWith(args[3], 'locked ')
428
self.assertEndsWith(args[3], ' ago')
429
self.assertContainsRe(args[4], r'\d\d:\d\d:\d\d')
431
def test_40_confirm_easy(self):
432
"""Confirm a lock that's already held"""
433
t = self.get_transport()
434
lf1 = LockDir(t, 'test_lock')
439
def test_41_confirm_not_held(self):
440
"""Confirm a lock that's already held"""
441
t = self.get_transport()
442
lf1 = LockDir(t, 'test_lock')
444
self.assertRaises(LockNotHeld, lf1.confirm)
446
def test_42_confirm_broken_manually(self):
447
"""Confirm a lock broken by hand"""
448
t = self.get_transport()
449
lf1 = LockDir(t, 'test_lock')
452
t.move('test_lock', 'lock_gone_now')
453
self.assertRaises(LockBroken, lf1.confirm)
455
def test_43_break(self):
456
"""Break a lock whose caller has forgotten it"""
457
t = self.get_transport()
458
lf1 = LockDir(t, 'test_lock')
461
# we incorrectly discard the lock object without unlocking it
463
# someone else sees it's still locked
464
lf2 = LockDir(t, 'test_lock')
465
holder_info = lf2.peek()
466
self.assertTrue(holder_info)
467
lf2.force_break(holder_info)
468
# now we should be able to take it
472
def test_44_break_already_released(self):
473
"""Lock break races with regular release"""
474
t = self.get_transport()
475
lf1 = LockDir(t, 'test_lock')
478
# someone else sees it's still locked
479
lf2 = LockDir(t, 'test_lock')
480
holder_info = lf2.peek()
481
# in the interim the lock is released
483
# break should succeed
484
lf2.force_break(holder_info)
485
# now we should be able to take it
489
def test_45_break_mismatch(self):
490
"""Lock break races with someone else acquiring it"""
491
t = self.get_transport()
492
lf1 = LockDir(t, 'test_lock')
495
# someone else sees it's still locked
496
lf2 = LockDir(t, 'test_lock')
497
holder_info = lf2.peek()
498
# in the interim the lock is released
500
lf3 = LockDir(t, 'test_lock')
502
# break should now *fail*
503
self.assertRaises(LockBreakMismatch, lf2.force_break,
507
def test_46_fake_read_lock(self):
508
t = self.get_transport()
509
lf1 = LockDir(t, 'test_lock')
514
def test_50_lockdir_representation(self):
515
"""Check the on-disk representation of LockDirs is as expected.
517
There should always be a top-level directory named by the lock.
518
When the lock is held, there should be a lockname/held directory
519
containing an info file.
521
t = self.get_transport()
522
lf1 = LockDir(t, 'test_lock')
524
self.assertTrue(t.has('test_lock'))
526
self.assertTrue(t.has('test_lock/held/info'))
528
self.assertFalse(t.has('test_lock/held/info'))
530
def test_break_lock(self):
531
# the ui based break_lock routine should Just Work (tm)
532
ld1 = self.get_lock()
533
ld2 = self.get_lock()
536
# do this without IO redirection to ensure it doesn't prompt.
537
self.assertRaises(AssertionError, ld1.break_lock)
538
orig_factory = bzrlib.ui.ui_factory
539
# silent ui - no need for stdout
540
bzrlib.ui.ui_factory = bzrlib.ui.SilentUIFactory()
541
bzrlib.ui.ui_factory.stdin = StringIO("y\n")
544
self.assertRaises(LockBroken, ld1.unlock)
546
bzrlib.ui.ui_factory = orig_factory
548
def test_create_missing_base_directory(self):
549
"""If LockDir.path doesn't exist, it can be created
551
Some people manually remove the entire lock/ directory trying
552
to unlock a stuck repository/branch/etc. Rather than failing
553
after that, just create the lock directory when needed.
555
t = self.get_transport()
556
lf1 = LockDir(t, 'test_lock')
559
self.failUnless(t.has('test_lock'))
562
self.failIf(t.has('test_lock'))
564
# This will create 'test_lock' if it needs to
566
self.failUnless(t.has('test_lock'))
567
self.failUnless(t.has('test_lock/held/info'))
570
self.failIf(t.has('test_lock/held/info'))
572
def test__format_lock_info(self):
573
ld1 = self.get_lock()
577
info_list = ld1._format_lock_info(ld1.peek())
580
self.assertEqual('lock %s' % (ld1.transport.abspath(ld1.path),),
582
self.assertContainsRe(info_list[1],
583
r'^held by .* on host .* \[process #\d*\]$')
584
self.assertContainsRe(info_list[2], r'locked \d+ seconds? ago$')
586
def test_lock_without_email(self):
587
global_config = config.GlobalConfig()
588
# Intentionally has no email address
589
global_config.set_user_option('email', 'User Identity')
590
ld1 = self.get_lock()
595
def test_lock_permission(self):
596
if not osutils.supports_posix_readonly():
597
raise tests.TestSkipped('Cannot induce a permission failure')
598
ld1 = self.get_lock()
599
lock_path = ld1.transport.local_abspath('test_lock')
601
osutils.make_readonly(lock_path)
602
self.assertRaises(errors.PermissionDenied, ld1.attempt_lock)
604
def test_lock_by_token(self):
605
ld1 = self.get_lock()
606
token = ld1.lock_write()
607
self.assertNotEqual(None, token)
608
ld2 = self.get_lock()
609
t2 = ld2.lock_write(token)
610
self.assertEqual(token, t2)
612
def test_lock_with_buggy_rename(self):
613
# test that lock acquisition handles servers which pretend they
614
# renamed correctly but that actually fail
615
t = transport.get_transport('brokenrename+' + self.get_url())
616
ld1 = LockDir(t, 'test_lock')
619
ld2 = LockDir(t, 'test_lock')
620
# we should fail to lock
621
e = self.assertRaises(errors.LockContention, ld2.attempt_lock)
622
# now the original caller should succeed in unlocking
624
# and there should be nothing left over
625
self.assertEquals([], t.list_dir('test_lock'))
627
def test_failed_lock_leaves_no_trash(self):
628
# if we fail to acquire the lock, we don't leave pending directories
629
# behind -- https://bugs.launchpad.net/bzr/+bug/109169
630
ld1 = self.get_lock()
631
ld2 = self.get_lock()
632
# should be nothing before we start
634
t = self.get_transport().clone('test_lock')
636
self.assertEquals(a, t.list_dir('.'))
638
# when held, that's all we see
641
# second guy should fail
642
self.assertRaises(errors.LockContention, ld2.attempt_lock)
added
removed
bzrlib/tests/test_lockdir.py
