1
# Copyright (C) 2006, 2007 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 (
40
from bzrlib.lockdir import LockDir
41
from bzrlib.tests import TestCaseWithTransport
42
from bzrlib.trace import note
44
# These tests sometimes use threads to test the behaviour of lock files with
45
# concurrent actors. This is not a typical (or necessarily supported) use;
46
# they're really meant for guarding between processes.
48
# These tests are run on the default transport provided by the test framework
49
# (typically a local disk transport). That can be changed by the --transport
50
# option to bzr selftest. The required properties of the transport
51
# implementation are tested separately. (The main requirement is just that
52
# they don't allow overwriting nonempty directories.)
54
class TestLockDir(TestCaseWithTransport):
55
"""Test LockDir operations"""
57
def logging_report_function(self, fmt, *args):
58
self._logged_reports.append((fmt, args))
60
def setup_log_reporter(self, lock_dir):
61
self._logged_reports = []
62
lock_dir._report_function = self.logging_report_function
64
def test_00_lock_creation(self):
65
"""Creation of lock file on a transport"""
66
t = self.get_transport()
67
lf = LockDir(t, 'test_lock')
68
self.assertFalse(lf.is_held)
70
def test_01_lock_repr(self):
71
"""Lock string representation"""
72
lf = LockDir(self.get_transport(), 'test_lock')
74
self.assertContainsRe(r, r'^LockDir\(.*/test_lock\)$')
76
def test_02_unlocked_peek(self):
77
lf = LockDir(self.get_transport(), 'test_lock')
78
self.assertEqual(lf.peek(), None)
81
return LockDir(self.get_transport(), 'test_lock')
83
def test_unlock_after_break_raises(self):
88
ld2.force_break(ld2.peek())
89
self.assertRaises(LockBroken, ld.unlock)
91
def test_03_readonly_peek(self):
92
lf = LockDir(self.get_readonly_transport(), 'test_lock')
93
self.assertEqual(lf.peek(), None)
95
def test_10_lock_uncontested(self):
96
"""Acquire and release a lock"""
97
t = self.get_transport()
98
lf = LockDir(t, 'test_lock')
102
self.assertTrue(lf.is_held)
105
self.assertFalse(lf.is_held)
107
def test_11_create_readonly_transport(self):
108
"""Fail to create lock on readonly transport"""
109
t = self.get_readonly_transport()
110
lf = LockDir(t, 'test_lock')
111
self.assertRaises(LockFailed, lf.create)
113
def test_12_lock_readonly_transport(self):
114
"""Fail to lock on readonly transport"""
115
lf = LockDir(self.get_transport(), 'test_lock')
117
lf = LockDir(self.get_readonly_transport(), 'test_lock')
118
self.assertRaises(LockFailed, lf.attempt_lock)
120
def test_20_lock_contested(self):
121
"""Contention to get a lock"""
122
t = self.get_transport()
123
lf1 = LockDir(t, 'test_lock')
126
lf2 = LockDir(t, 'test_lock')
128
# locking is between LockDir instances; aliases within
129
# a single process are not detected
131
self.fail('Failed to detect lock collision')
132
except LockContention, e:
133
self.assertEqual(e.lock, lf2)
134
self.assertContainsRe(str(e),
135
r'^Could not acquire.*test_lock.*$')
138
def test_20_lock_peek(self):
139
"""Peek at the state of a lock"""
140
t = self.get_transport()
141
lf1 = LockDir(t, 'test_lock')
144
# lock is held, should get some info on it
146
self.assertEqual(set(info1.keys()),
147
set(['user', 'nonce', 'hostname', 'pid', 'start_time']))
148
# should get the same info if we look at it through a different
150
info2 = LockDir(t, 'test_lock').peek()
151
self.assertEqual(info1, info2)
152
# locks which are never used should be not-held
153
self.assertEqual(LockDir(t, 'other_lock').peek(), None)
155
def test_21_peek_readonly(self):
156
"""Peek over a readonly transport"""
157
t = self.get_transport()
158
lf1 = LockDir(t, 'test_lock')
160
lf2 = LockDir(self.get_readonly_transport(), 'test_lock')
161
self.assertEqual(lf2.peek(), None)
164
self.assertTrue(info2)
165
self.assertEqual(info2['nonce'], lf1.nonce)
167
def test_30_lock_wait_fail(self):
168
"""Wait on a lock, then fail
170
We ask to wait up to 400ms; this should fail within at most one
171
second. (Longer times are more realistic but we don't want the test
172
suite to take too long, and this should do for now.)
174
t = self.get_transport()
175
lf1 = LockDir(t, 'test_lock')
177
lf2 = LockDir(t, 'test_lock')
178
self.setup_log_reporter(lf2)
182
self.assertRaises(LockContention, lf2.wait_lock,
183
timeout=0.4, poll=0.1)
185
# it should only take about 0.4 seconds, but we allow more time in
186
# case the machine is heavily loaded
187
self.assertTrue(after - before <= 8.0,
188
"took %f seconds to detect lock contention" % (after - before))
191
lock_base = lf2.transport.abspath(lf2.path)
192
self.assertEqual(1, len(self._logged_reports))
193
lock_url = lf2.transport.abspath(lf2.path)
194
self.assertEqual('%s %s\n'
196
'Will continue to try until %s, unless '
198
'If you\'re sure that it\'s not being '
199
'modified, use bzr break-lock %s',
200
self._logged_reports[0][0])
201
args = self._logged_reports[0][1]
202
self.assertEqual('Unable to obtain', args[0])
203
self.assertEqual('lock %s' % (lock_base,), args[1])
204
self.assertStartsWith(args[2], 'held by ')
205
self.assertStartsWith(args[3], 'locked ')
206
self.assertEndsWith(args[3], ' ago')
207
self.assertContainsRe(args[4], r'\d\d:\d\d:\d\d')
209
def test_31_lock_wait_easy(self):
210
"""Succeed when waiting on a lock with no contention.
212
t = self.get_transport()
213
lf1 = LockDir(t, 'test_lock')
215
self.setup_log_reporter(lf1)
218
lf1.wait_lock(timeout=0.4, poll=0.1)
220
self.assertTrue(after - before <= 1.0)
223
self.assertEqual([], self._logged_reports)
225
def test_32_lock_wait_succeed(self):
226
"""Succeed when trying to acquire a lock that gets released
228
One thread holds on a lock and then releases it; another
231
# This test sometimes fails like this:
232
# Traceback (most recent call last):
234
# File "/home/pqm/bzr-pqm-workdir/home/+trunk/bzrlib/tests/
235
# test_lockdir.py", line 247, in test_32_lock_wait_succeed
236
# self.assertEqual(1, len(self._logged_reports))
237
# AssertionError: not equal:
240
raise tests.TestSkipped("Test fails intermittently")
241
t = self.get_transport()
242
lf1 = LockDir(t, 'test_lock')
246
def wait_and_unlock():
249
unlocker = Thread(target=wait_and_unlock)
252
lf2 = LockDir(t, 'test_lock')
253
self.setup_log_reporter(lf2)
256
lf2.wait_lock(timeout=0.4, poll=0.1)
258
self.assertTrue(after - before <= 1.0)
262
# There should be only 1 report, even though it should have to
264
lock_base = lf2.transport.abspath(lf2.path)
265
self.assertEqual(1, len(self._logged_reports))
266
self.assertEqual('%s %s\n'
268
'Will continue to try until %s\n',
269
self._logged_reports[0][0])
270
args = self._logged_reports[0][1]
271
self.assertEqual('Unable to obtain', args[0])
272
self.assertEqual('lock %s' % (lock_base,), args[1])
273
self.assertStartsWith(args[2], 'held by ')
274
self.assertStartsWith(args[3], 'locked ')
275
self.assertEndsWith(args[3], ' ago')
276
self.assertContainsRe(args[4], r'\d\d:\d\d:\d\d')
278
def test_34_lock_write_waits(self):
279
"""LockDir.lock_write() will wait for the lock."""
280
# the test suite sets the default to 0 to make deadlocks fail fast.
281
# change it for this test, as we want to try a manual deadlock.
282
raise tests.TestSkipped('Timing-sensitive test')
283
bzrlib.lockdir._DEFAULT_TIMEOUT_SECONDS = 300
284
t = self.get_transport()
285
lf1 = LockDir(t, 'test_lock')
289
def wait_and_unlock():
292
unlocker = Thread(target=wait_and_unlock)
295
lf2 = LockDir(t, 'test_lock')
296
self.setup_log_reporter(lf2)
304
# There should be only 1 report, even though it should have to
306
lock_base = lf2.transport.abspath(lf2.path)
307
self.assertEqual(1, len(self._logged_reports))
308
self.assertEqual('%s %s\n'
310
'Will continue to try until %s\n',
311
self._logged_reports[0][0])
312
args = self._logged_reports[0][1]
313
self.assertEqual('Unable to obtain', args[0])
314
self.assertEqual('lock %s' % (lock_base,), args[1])
315
self.assertStartsWith(args[2], 'held by ')
316
self.assertStartsWith(args[3], 'locked ')
317
self.assertEndsWith(args[3], ' ago')
318
self.assertContainsRe(args[4], r'\d\d:\d\d:\d\d')
320
def test_35_wait_lock_changing(self):
321
"""LockDir.wait_lock() will report if the lock changes underneath.
323
This is the stages we want to happen:
325
0) Synchronization locks are created and locked.
326
1) Lock1 obtains the lockdir, and releases the 'check' lock.
327
2) Lock2 grabs the 'check' lock, and checks the lockdir.
328
It sees the lockdir is already acquired, reports the fact,
329
and unsets the 'checked' lock.
330
3) Thread1 blocks on acquiring the 'checked' lock, and then tells
331
Lock1 to release and acquire the lockdir. This resets the 'check'
333
4) Lock2 acquires the 'check' lock, and checks again. It notices
334
that the holder of the lock has changed, and so reports a new
336
5) Thread1 blocks on the 'checked' lock, this time, it completely
337
unlocks the lockdir, allowing Lock2 to acquire the lock.
340
raise tests.KnownFailure(
341
"timing dependency in lock tests (#213182)")
343
wait_to_check_lock = Lock()
344
wait_until_checked_lock = Lock()
346
wait_to_check_lock.acquire()
347
wait_until_checked_lock.acquire()
348
note('locked check and checked locks')
350
class LockDir1(LockDir):
351
"""Use the synchronization points for the first lock."""
353
def attempt_lock(self):
354
# Once we have acquired the lock, it is okay for
355
# the other lock to check it
357
return super(LockDir1, self).attempt_lock()
359
note('lock1: releasing check lock')
360
wait_to_check_lock.release()
362
class LockDir2(LockDir):
363
"""Use the synchronization points for the second lock."""
365
def attempt_lock(self):
366
note('lock2: waiting for check lock')
367
wait_to_check_lock.acquire()
368
note('lock2: acquired check lock')
370
return super(LockDir2, self).attempt_lock()
372
note('lock2: releasing checked lock')
373
wait_until_checked_lock.release()
375
t = self.get_transport()
376
lf1 = LockDir1(t, 'test_lock')
379
lf2 = LockDir2(t, 'test_lock')
380
self.setup_log_reporter(lf2)
382
def wait_and_switch():
384
# Block until lock2 has had a chance to check
385
note('lock1: waiting 1 for checked lock')
386
wait_until_checked_lock.acquire()
387
note('lock1: acquired for checked lock')
388
note('lock1: released lockdir')
390
note('lock1: acquiring lockdir')
391
# Create a new nonce, so the lock looks different.
392
lf1.nonce = osutils.rand_chars(20)
394
note('lock1: acquired lockdir')
396
# Block until lock2 has peeked again
397
note('lock1: waiting 2 for checked lock')
398
wait_until_checked_lock.acquire()
399
note('lock1: acquired for checked lock')
400
# Now unlock, and let lock 2 grab the lock
402
wait_to_check_lock.release()
404
unlocker = Thread(target=wait_and_switch)
407
# Wait and play against the other thread
408
lf2.wait_lock(timeout=20.0, poll=0.01)
413
# There should be 2 reports, because the lock changed
414
lock_base = lf2.transport.abspath(lf2.path)
415
self.assertEqual(2, len(self._logged_reports))
416
lock_url = lf2.transport.abspath(lf2.path)
417
self.assertEqual('%s %s\n'
419
'Will continue to try until %s, unless '
421
'If you\'re sure that it\'s not being '
422
'modified, use bzr break-lock %s',
423
self._logged_reports[0][0])
424
args = self._logged_reports[0][1]
425
self.assertEqual('Unable to obtain', args[0])
426
self.assertEqual('lock %s' % (lock_base,), args[1])
427
self.assertStartsWith(args[2], 'held by ')
428
self.assertStartsWith(args[3], 'locked ')
429
self.assertEndsWith(args[3], ' ago')
430
self.assertContainsRe(args[4], r'\d\d:\d\d:\d\d')
432
self.assertEqual('%s %s\n'
434
'Will continue to try until %s, unless '
436
'If you\'re sure that it\'s not being '
437
'modified, use bzr break-lock %s',
438
self._logged_reports[1][0])
439
args = self._logged_reports[1][1]
440
self.assertEqual('Lock owner changed for', args[0])
441
self.assertEqual('lock %s' % (lock_base,), args[1])
442
self.assertStartsWith(args[2], 'held by ')
443
self.assertStartsWith(args[3], 'locked ')
444
self.assertEndsWith(args[3], ' ago')
445
self.assertContainsRe(args[4], r'\d\d:\d\d:\d\d')
447
def test_40_confirm_easy(self):
448
"""Confirm a lock that's already held"""
449
t = self.get_transport()
450
lf1 = LockDir(t, 'test_lock')
455
def test_41_confirm_not_held(self):
456
"""Confirm a lock that's already held"""
457
t = self.get_transport()
458
lf1 = LockDir(t, 'test_lock')
460
self.assertRaises(LockNotHeld, lf1.confirm)
462
def test_42_confirm_broken_manually(self):
463
"""Confirm a lock broken by hand"""
464
t = self.get_transport()
465
lf1 = LockDir(t, 'test_lock')
468
t.move('test_lock', 'lock_gone_now')
469
self.assertRaises(LockBroken, lf1.confirm)
471
def test_43_break(self):
472
"""Break a lock whose caller has forgotten it"""
473
t = self.get_transport()
474
lf1 = LockDir(t, 'test_lock')
477
# we incorrectly discard the lock object without unlocking it
479
# someone else sees it's still locked
480
lf2 = LockDir(t, 'test_lock')
481
holder_info = lf2.peek()
482
self.assertTrue(holder_info)
483
lf2.force_break(holder_info)
484
# now we should be able to take it
488
def test_44_break_already_released(self):
489
"""Lock break races with regular release"""
490
t = self.get_transport()
491
lf1 = LockDir(t, 'test_lock')
494
# someone else sees it's still locked
495
lf2 = LockDir(t, 'test_lock')
496
holder_info = lf2.peek()
497
# in the interim the lock is released
499
# break should succeed
500
lf2.force_break(holder_info)
501
# now we should be able to take it
505
def test_45_break_mismatch(self):
506
"""Lock break races with someone else acquiring it"""
507
t = self.get_transport()
508
lf1 = LockDir(t, 'test_lock')
511
# someone else sees it's still locked
512
lf2 = LockDir(t, 'test_lock')
513
holder_info = lf2.peek()
514
# in the interim the lock is released
516
lf3 = LockDir(t, 'test_lock')
518
# break should now *fail*
519
self.assertRaises(LockBreakMismatch, lf2.force_break,
523
def test_46_fake_read_lock(self):
524
t = self.get_transport()
525
lf1 = LockDir(t, 'test_lock')
530
def test_50_lockdir_representation(self):
531
"""Check the on-disk representation of LockDirs is as expected.
533
There should always be a top-level directory named by the lock.
534
When the lock is held, there should be a lockname/held directory
535
containing an info file.
537
t = self.get_transport()
538
lf1 = LockDir(t, 'test_lock')
540
self.assertTrue(t.has('test_lock'))
542
self.assertTrue(t.has('test_lock/held/info'))
544
self.assertFalse(t.has('test_lock/held/info'))
546
def test_break_lock(self):
547
# the ui based break_lock routine should Just Work (tm)
548
ld1 = self.get_lock()
549
ld2 = self.get_lock()
552
# do this without IO redirection to ensure it doesn't prompt.
553
self.assertRaises(AssertionError, ld1.break_lock)
554
orig_factory = bzrlib.ui.ui_factory
555
# silent ui - no need for stdout
556
bzrlib.ui.ui_factory = bzrlib.ui.SilentUIFactory()
557
bzrlib.ui.ui_factory.stdin = StringIO("y\n")
560
self.assertRaises(LockBroken, ld1.unlock)
562
bzrlib.ui.ui_factory = orig_factory
564
def test_create_missing_base_directory(self):
565
"""If LockDir.path doesn't exist, it can be created
567
Some people manually remove the entire lock/ directory trying
568
to unlock a stuck repository/branch/etc. Rather than failing
569
after that, just create the lock directory when needed.
571
t = self.get_transport()
572
lf1 = LockDir(t, 'test_lock')
575
self.failUnless(t.has('test_lock'))
578
self.failIf(t.has('test_lock'))
580
# This will create 'test_lock' if it needs to
582
self.failUnless(t.has('test_lock'))
583
self.failUnless(t.has('test_lock/held/info'))
586
self.failIf(t.has('test_lock/held/info'))
588
def test__format_lock_info(self):
589
ld1 = self.get_lock()
593
info_list = ld1._format_lock_info(ld1.peek())
596
self.assertEqual('lock %s' % (ld1.transport.abspath(ld1.path),),
598
self.assertContainsRe(info_list[1],
599
r'^held by .* on host .* \[process #\d*\]$')
600
self.assertContainsRe(info_list[2], r'locked \d+ seconds? ago$')
602
def test_lock_without_email(self):
603
global_config = config.GlobalConfig()
604
# Intentionally has no email address
605
global_config.set_user_option('email', 'User Identity')
606
ld1 = self.get_lock()
611
def test_lock_permission(self):
612
if not osutils.supports_posix_readonly():
613
raise tests.TestSkipped('Cannot induce a permission failure')
614
ld1 = self.get_lock()
615
lock_path = ld1.transport.local_abspath('test_lock')
617
osutils.make_readonly(lock_path)
618
self.assertRaises(errors.LockFailed, ld1.attempt_lock)
620
def test_lock_by_token(self):
621
ld1 = self.get_lock()
622
token = ld1.lock_write()
623
self.assertNotEqual(None, token)
624
ld2 = self.get_lock()
625
t2 = ld2.lock_write(token)
626
self.assertEqual(token, t2)
628
def test_lock_with_buggy_rename(self):
629
# test that lock acquisition handles servers which pretend they
630
# renamed correctly but that actually fail
631
t = transport.get_transport('brokenrename+' + self.get_url())
632
ld1 = LockDir(t, 'test_lock')
635
ld2 = LockDir(t, 'test_lock')
636
# we should fail to lock
637
e = self.assertRaises(errors.LockContention, ld2.attempt_lock)
638
# now the original caller should succeed in unlocking
640
# and there should be nothing left over
641
self.assertEquals([], t.list_dir('test_lock'))
643
def test_failed_lock_leaves_no_trash(self):
644
# if we fail to acquire the lock, we don't leave pending directories
645
# behind -- https://bugs.launchpad.net/bzr/+bug/109169
646
ld1 = self.get_lock()
647
ld2 = self.get_lock()
648
# should be nothing before we start
650
t = self.get_transport().clone('test_lock')
652
self.assertEquals(a, t.list_dir('.'))
654
# when held, that's all we see
657
# second guy should fail
658
self.assertRaises(errors.LockContention, ld2.attempt_lock)
added
removed
bzrlib/tests/test_lockdir.py
