1
# Copyright (C) 2006-2010 Canonical Ltd
1
# Copyright (C) 2006 Canonical Ltd
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
5
5
# the Free Software Foundation; either version 2 of the License, or
6
6
# (at your option) any later version.
8
8
# This program is distributed in the hope that it will be useful,
9
9
# but WITHOUT ANY WARRANTY; without even the implied warranty of
10
10
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
11
11
# GNU General Public License for more details.
13
13
# You should have received a copy of the GNU General Public License
14
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
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
17
17
"""Tests for LockDir"""
19
from cStringIO import StringIO
21
from threading import Thread, Lock
19
from threading import Thread
33
22
from bzrlib.errors import (
24
LockContention, LockError, UnlockableTransport,
25
LockNotHeld, LockBroken
41
27
from bzrlib.lockdir import LockDir
42
28
from bzrlib.tests import TestCaseWithTransport
43
from bzrlib.trace import note
45
30
# These tests sometimes use threads to test the behaviour of lock files with
46
31
# concurrent actors. This is not a typical (or necessarily supported) use;
47
32
# 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
34
class TestLockDir(TestCaseWithTransport):
56
35
"""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
37
def test_00_lock_creation(self):
66
38
"""Creation of lock file on a transport"""
67
39
t = self.get_transport()
158
108
"""Peek over a readonly transport"""
159
109
t = self.get_transport()
160
110
lf1 = LockDir(t, 'test_lock')
162
111
lf2 = LockDir(self.get_readonly_transport(), 'test_lock')
163
112
self.assertEqual(lf2.peek(), None)
164
113
lf1.attempt_lock()
165
self.addCleanup(lf1.unlock)
166
114
info2 = lf2.peek()
167
115
self.assertTrue(info2)
168
116
self.assertEqual(info2['nonce'], lf1.nonce)
170
118
def test_30_lock_wait_fail(self):
171
119
"""Wait on a lock, then fail
173
121
We ask to wait up to 400ms; this should fail within at most one
174
122
second. (Longer times are more realistic but we don't want the test
175
123
suite to take too long, and this should do for now.)
177
125
t = self.get_transport()
178
126
lf1 = LockDir(t, 'test_lock')
180
127
lf2 = LockDir(t, 'test_lock')
181
self.setup_log_reporter(lf2)
182
128
lf1.attempt_lock()
184
130
before = time.time()
185
131
self.assertRaises(LockContention, lf2.wait_lock,
186
132
timeout=0.4, poll=0.1)
187
133
after = time.time()
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))
134
self.assertTrue(after - before <= 1.0)
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 '
200
'you press Ctrl-C.\n'
201
'See "bzr help break-lock" for more.',
202
self._logged_reports[0][0])
203
args = self._logged_reports[0][1]
204
self.assertEqual('Unable to obtain', args[0])
205
self.assertEqual('lock %s' % (lock_base,), args[1])
206
self.assertStartsWith(args[2], 'held by ')
207
self.assertStartsWith(args[3], 'locked ')
208
self.assertEndsWith(args[3], ' ago')
209
self.assertContainsRe(args[4], r'\d\d:\d\d:\d\d')
211
138
def test_31_lock_wait_easy(self):
212
139
"""Succeed when waiting on a lock with no contention.
214
141
t = self.get_transport()
215
lf1 = LockDir(t, 'test_lock')
217
self.setup_log_reporter(lf1)
142
lf2 = LockDir(t, 'test_lock')
219
144
before = time.time()
220
lf1.wait_lock(timeout=0.4, poll=0.1)
145
lf2.wait_lock(timeout=0.4, poll=0.1)
221
146
after = time.time()
222
147
self.assertTrue(after - before <= 1.0)
225
self.assertEqual([], self._logged_reports)
227
151
def test_32_lock_wait_succeed(self):
228
152
"""Succeed when trying to acquire a lock that gets released
230
One thread holds on a lock and then releases it; another
154
One thread holds on a lock and then releases it; another tries to lock it.
233
# This test sometimes fails like this:
234
# Traceback (most recent call last):
236
# File "/home/pqm/bzr-pqm-workdir/home/+trunk/bzrlib/tests/
237
# test_lockdir.py", line 247, in test_32_lock_wait_succeed
238
# self.assertEqual(1, len(self._logged_reports))
239
# AssertionError: not equal:
242
raise tests.TestSkipped("Test fails intermittently")
243
156
t = self.get_transport()
244
157
lf1 = LockDir(t, 'test_lock')
246
158
lf1.attempt_lock()
248
160
def wait_and_unlock():
264
# There should be only 1 report, even though it should have to
266
lock_base = lf2.transport.abspath(lf2.path)
267
self.assertEqual(1, len(self._logged_reports))
268
self.assertEqual('%s %s\n'
270
'Will continue to try until %s\n',
271
self._logged_reports[0][0])
272
args = self._logged_reports[0][1]
273
self.assertEqual('Unable to obtain', args[0])
274
self.assertEqual('lock %s' % (lock_base,), args[1])
275
self.assertStartsWith(args[2], 'held by ')
276
self.assertStartsWith(args[3], 'locked ')
277
self.assertEndsWith(args[3], ' ago')
278
self.assertContainsRe(args[4], r'\d\d:\d\d:\d\d')
175
def test_33_wait(self):
176
"""Succeed when waiting on a lock that gets released
280
def test_34_lock_write_waits(self):
281
"""LockDir.lock_write() will wait for the lock."""
282
# the test suite sets the default to 0 to make deadlocks fail fast.
283
# change it for this test, as we want to try a manual deadlock.
284
raise tests.TestSkipped('Timing-sensitive test')
285
bzrlib.lockdir._DEFAULT_TIMEOUT_SECONDS = 300
178
The difference from test_32_lock_wait_succeed is that the second
179
caller does not actually acquire the lock, but just waits for it
180
to be released. This is done over a readonly transport.
286
182
t = self.get_transport()
287
183
lf1 = LockDir(t, 'test_lock')
289
184
lf1.attempt_lock()
291
186
def wait_and_unlock():
294
189
unlocker = Thread(target=wait_and_unlock)
297
lf2 = LockDir(t, 'test_lock')
298
self.setup_log_reporter(lf2)
192
lf2 = LockDir(self.get_readonly_transport(), 'test_lock')
299
193
before = time.time()
194
# wait but don't lock
195
lf2.wait(timeout=0.4, poll=0.1)
302
196
after = time.time()
306
# There should be only 1 report, even though it should have to
308
lock_base = lf2.transport.abspath(lf2.path)
309
self.assertEqual(1, len(self._logged_reports))
310
self.assertEqual('%s %s\n'
312
'Will continue to try until %s\n',
313
self._logged_reports[0][0])
314
args = self._logged_reports[0][1]
315
self.assertEqual('Unable to obtain', args[0])
316
self.assertEqual('lock %s' % (lock_base,), args[1])
317
self.assertStartsWith(args[2], 'held by ')
318
self.assertStartsWith(args[3], 'locked ')
319
self.assertEndsWith(args[3], ' ago')
320
self.assertContainsRe(args[4], r'\d\d:\d\d:\d\d')
322
def test_35_wait_lock_changing(self):
323
"""LockDir.wait_lock() will report if the lock changes underneath.
325
This is the stages we want to happen:
327
0) Synchronization locks are created and locked.
328
1) Lock1 obtains the lockdir, and releases the 'check' lock.
329
2) Lock2 grabs the 'check' lock, and checks the lockdir.
330
It sees the lockdir is already acquired, reports the fact,
331
and unsets the 'checked' lock.
332
3) Thread1 blocks on acquiring the 'checked' lock, and then tells
333
Lock1 to release and acquire the lockdir. This resets the 'check'
335
4) Lock2 acquires the 'check' lock, and checks again. It notices
336
that the holder of the lock has changed, and so reports a new
338
5) Thread1 blocks on the 'checked' lock, this time, it completely
339
unlocks the lockdir, allowing Lock2 to acquire the lock.
342
raise tests.KnownFailure(
343
"timing dependency in lock tests (#213182)")
345
wait_to_check_lock = Lock()
346
wait_until_checked_lock = Lock()
348
wait_to_check_lock.acquire()
349
wait_until_checked_lock.acquire()
350
note('locked check and checked locks')
352
class LockDir1(LockDir):
353
"""Use the synchronization points for the first lock."""
355
def attempt_lock(self):
356
# Once we have acquired the lock, it is okay for
357
# the other lock to check it
359
return super(LockDir1, self).attempt_lock()
361
note('lock1: releasing check lock')
362
wait_to_check_lock.release()
364
class LockDir2(LockDir):
365
"""Use the synchronization points for the second lock."""
367
def attempt_lock(self):
368
note('lock2: waiting for check lock')
369
wait_to_check_lock.acquire()
370
note('lock2: acquired check lock')
372
return super(LockDir2, self).attempt_lock()
374
note('lock2: releasing checked lock')
375
wait_until_checked_lock.release()
377
t = self.get_transport()
378
lf1 = LockDir1(t, 'test_lock')
381
lf2 = LockDir2(t, 'test_lock')
382
self.setup_log_reporter(lf2)
384
def wait_and_switch():
386
# Block until lock2 has had a chance to check
387
note('lock1: waiting 1 for checked lock')
388
wait_until_checked_lock.acquire()
389
note('lock1: acquired for checked lock')
390
note('lock1: released lockdir')
392
note('lock1: acquiring lockdir')
393
# Create a new nonce, so the lock looks different.
394
lf1.nonce = osutils.rand_chars(20)
396
note('lock1: acquired lockdir')
398
# Block until lock2 has peeked again
399
note('lock1: waiting 2 for checked lock')
400
wait_until_checked_lock.acquire()
401
note('lock1: acquired for checked lock')
402
# Now unlock, and let lock 2 grab the lock
404
wait_to_check_lock.release()
406
unlocker = Thread(target=wait_and_switch)
409
# Wait and play against the other thread
410
lf2.wait_lock(timeout=20.0, poll=0.01)
415
# There should be 2 reports, because the lock changed
416
lock_base = lf2.transport.abspath(lf2.path)
417
self.assertEqual(2, len(self._logged_reports))
418
lock_url = lf2.transport.abspath(lf2.path)
419
self.assertEqual('%s %s\n'
421
'Will continue to try until %s, unless '
422
'you press Ctrl-C.\n'
423
'See "bzr help break-lock" for more.',
424
self._logged_reports[0][0])
425
args = self._logged_reports[0][1]
426
self.assertEqual('Unable to obtain', args[0])
427
self.assertEqual('lock %s' % (lock_base,), args[1])
428
self.assertStartsWith(args[2], 'held by ')
429
self.assertStartsWith(args[3], 'locked ')
430
self.assertEndsWith(args[3], ' ago')
431
self.assertContainsRe(args[4], r'\d\d:\d\d:\d\d')
433
self.assertEqual('%s %s\n'
435
'Will continue to try until %s, unless '
436
'you press Ctrl-C.\n'
437
'See "bzr help break-lock" for more.',
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')
197
self.assertTrue(after - before <= 1.0)
447
201
def test_40_confirm_easy(self):
448
202
"""Confirm a lock that's already held"""
449
203
t = self.get_transport()
450
204
lf1 = LockDir(t, 'test_lock')
452
205
lf1.attempt_lock()
453
self.addCleanup(lf1.unlock)
456
208
def test_41_confirm_not_held(self):
457
209
"""Confirm a lock that's already held"""
458
210
t = self.get_transport()
459
211
lf1 = LockDir(t, 'test_lock')
461
212
self.assertRaises(LockNotHeld, lf1.confirm)
463
214
def test_42_confirm_broken_manually(self):
464
215
"""Confirm a lock broken by hand"""
465
216
t = self.get_transport()
466
217
lf1 = LockDir(t, 'test_lock')
468
218
lf1.attempt_lock()
469
219
t.move('test_lock', 'lock_gone_now')
470
220
self.assertRaises(LockBroken, lf1.confirm)
472
t.move('lock_gone_now', 'test_lock')
475
222
def test_43_break(self):
476
223
"""Break a lock whose caller has forgotten it"""
477
224
t = self.get_transport()
478
225
lf1 = LockDir(t, 'test_lock')
480
226
lf1.attempt_lock()
481
227
# we incorrectly discard the lock object without unlocking it
525
267
self.assertRaises(LockBreakMismatch, lf2.force_break,
529
def test_46_fake_read_lock(self):
530
t = self.get_transport()
531
lf1 = LockDir(t, 'test_lock')
536
def test_50_lockdir_representation(self):
537
"""Check the on-disk representation of LockDirs is as expected.
539
There should always be a top-level directory named by the lock.
540
When the lock is held, there should be a lockname/held directory
541
containing an info file.
543
t = self.get_transport()
544
lf1 = LockDir(t, 'test_lock')
546
self.assertTrue(t.has('test_lock'))
548
self.assertTrue(t.has('test_lock/held/info'))
550
self.assertFalse(t.has('test_lock/held/info'))
552
def test_break_lock(self):
553
# the ui based break_lock routine should Just Work (tm)
554
ld1 = self.get_lock()
555
ld2 = self.get_lock()
558
# do this without IO redirection to ensure it doesn't prompt.
559
self.assertRaises(AssertionError, ld1.break_lock)
560
orig_factory = bzrlib.ui.ui_factory
561
bzrlib.ui.ui_factory = bzrlib.ui.CannedInputUIFactory([True])
564
self.assertRaises(LockBroken, ld1.unlock)
566
bzrlib.ui.ui_factory = orig_factory
568
def test_create_missing_base_directory(self):
569
"""If LockDir.path doesn't exist, it can be created
571
Some people manually remove the entire lock/ directory trying
572
to unlock a stuck repository/branch/etc. Rather than failing
573
after that, just create the lock directory when needed.
575
t = self.get_transport()
576
lf1 = LockDir(t, 'test_lock')
579
self.failUnless(t.has('test_lock'))
582
self.failIf(t.has('test_lock'))
584
# This will create 'test_lock' if it needs to
586
self.failUnless(t.has('test_lock'))
587
self.failUnless(t.has('test_lock/held/info'))
590
self.failIf(t.has('test_lock/held/info'))
592
def test__format_lock_info(self):
593
ld1 = self.get_lock()
597
info_list = ld1._format_lock_info(ld1.peek())
600
self.assertEqual('lock %s' % (ld1.transport.abspath(ld1.path),),
602
self.assertContainsRe(info_list[1],
603
r'^held by .* on host .* \[process #\d*\]$')
604
self.assertContainsRe(info_list[2], r'locked \d+ seconds? ago$')
606
def test_lock_without_email(self):
607
global_config = config.GlobalConfig()
608
# Intentionally has no email address
609
global_config.set_user_option('email', 'User Identity')
610
ld1 = self.get_lock()
615
def test_lock_permission(self):
616
if not osutils.supports_posix_readonly():
617
raise tests.TestSkipped('Cannot induce a permission failure')
618
ld1 = self.get_lock()
619
lock_path = ld1.transport.local_abspath('test_lock')
621
osutils.make_readonly(lock_path)
622
self.assertRaises(errors.LockFailed, ld1.attempt_lock)
624
def test_lock_by_token(self):
625
ld1 = self.get_lock()
626
token = ld1.lock_write()
627
self.addCleanup(ld1.unlock)
628
self.assertNotEqual(None, token)
629
ld2 = self.get_lock()
630
t2 = ld2.lock_write(token)
631
self.addCleanup(ld2.unlock)
632
self.assertEqual(token, t2)
634
def test_lock_with_buggy_rename(self):
635
# test that lock acquisition handles servers which pretend they
636
# renamed correctly but that actually fail
637
t = transport.get_transport('brokenrename+' + self.get_url())
638
ld1 = LockDir(t, 'test_lock')
641
ld2 = LockDir(t, 'test_lock')
642
# we should fail to lock
643
e = self.assertRaises(errors.LockContention, ld2.attempt_lock)
644
# now the original caller should succeed in unlocking
646
# and there should be nothing left over
647
self.assertEquals([], t.list_dir('test_lock'))
649
def test_failed_lock_leaves_no_trash(self):
650
# if we fail to acquire the lock, we don't leave pending directories
651
# behind -- https://bugs.launchpad.net/bzr/+bug/109169
652
ld1 = self.get_lock()
653
ld2 = self.get_lock()
654
# should be nothing before we start
656
t = self.get_transport().clone('test_lock')
658
self.assertEquals(a, t.list_dir('.'))
660
# when held, that's all we see
662
self.addCleanup(ld1.unlock)
664
# second guy should fail
665
self.assertRaises(errors.LockContention, ld2.attempt_lock)
669
def test_no_lockdir_info(self):
670
"""We can cope with empty info files."""
671
# This seems like a fairly common failure case - see
672
# <https://bugs.edge.launchpad.net/bzr/+bug/185103> and all its dupes.
673
# Processes are often interrupted after opening the file
674
# before the actual contents are committed.
675
t = self.get_transport()
677
t.mkdir('test_lock/held')
678
t.put_bytes('test_lock/held/info', '')
679
lf = LockDir(t, 'test_lock')
681
formatted_info = lf._format_lock_info(info)
683
['lock %s' % t.abspath('test_lock'),
684
'held by <unknown> on host <unknown> [process #<unknown>]',
689
class TestLockDirHooks(TestCaseWithTransport):
692
super(TestLockDirHooks, self).setUp()
696
return LockDir(self.get_transport(), 'test_lock')
698
def record_hook(self, result):
699
self._calls.append(result)
701
def test_LockDir_acquired_success(self):
702
# the LockDir.lock_acquired hook fires when a lock is acquired.
703
LockDir.hooks.install_named_hook('lock_acquired',
704
self.record_hook, 'record_hook')
707
self.assertEqual([], self._calls)
708
result = ld.attempt_lock()
709
lock_path = ld.transport.abspath(ld.path)
710
self.assertEqual([lock.LockResult(lock_path, result)], self._calls)
712
self.assertEqual([lock.LockResult(lock_path, result)], self._calls)
714
def test_LockDir_acquired_fail(self):
715
# the LockDir.lock_acquired hook does not fire on failure.
718
ld2 = self.get_lock()
720
# install a lock hook now, when the disk lock is locked
721
LockDir.hooks.install_named_hook('lock_acquired',
722
self.record_hook, 'record_hook')
723
self.assertRaises(errors.LockContention, ld.attempt_lock)
724
self.assertEqual([], self._calls)
726
self.assertEqual([], self._calls)
728
def test_LockDir_released_success(self):
729
# the LockDir.lock_released hook fires when a lock is acquired.
730
LockDir.hooks.install_named_hook('lock_released',
731
self.record_hook, 'record_hook')
734
self.assertEqual([], self._calls)
735
result = ld.attempt_lock()
736
self.assertEqual([], self._calls)
738
lock_path = ld.transport.abspath(ld.path)
739
self.assertEqual([lock.LockResult(lock_path, result)], self._calls)
741
def test_LockDir_released_fail(self):
742
# the LockDir.lock_released hook does not fire on failure.
745
ld2 = self.get_lock()
747
ld2.force_break(ld2.peek())
748
LockDir.hooks.install_named_hook('lock_released',
749
self.record_hook, 'record_hook')
750
self.assertRaises(LockBroken, ld.unlock)
751
self.assertEqual([], self._calls)
753
def test_LockDir_broken_success(self):
754
# the LockDir.lock_broken hook fires when a lock is broken.
757
ld2 = self.get_lock()
758
result = ld.attempt_lock()
759
LockDir.hooks.install_named_hook('lock_broken',
760
self.record_hook, 'record_hook')
761
ld2.force_break(ld2.peek())
762
lock_path = ld.transport.abspath(ld.path)
763
self.assertEqual([lock.LockResult(lock_path, result)], self._calls)
765
def test_LockDir_broken_failure(self):
766
# the LockDir.lock_broken hook does not fires when a lock is already
770
ld2 = self.get_lock()
771
result = ld.attempt_lock()
772
holder_info = ld2.peek()
774
LockDir.hooks.install_named_hook('lock_broken',
775
self.record_hook, 'record_hook')
776
ld2.force_break(holder_info)
777
lock_path = ld.transport.abspath(ld.path)
778
self.assertEqual([], self._calls)
added
removed
bzrlib/tests/test_lockdir.py
