223
217
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
219
def test_40_confirm_easy(self):
448
220
"""Confirm a lock that's already held"""
449
221
t = self.get_transport()
450
222
lf1 = LockDir(t, 'test_lock')
452
224
lf1.attempt_lock()
225
self.addCleanup(lf1.unlock)
455
228
def test_41_confirm_not_held(self):
552
330
# do this without IO redirection to ensure it doesn't prompt.
553
331
self.assertRaises(AssertionError, ld1.break_lock)
554
332
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")
333
bzrlib.ui.ui_factory = bzrlib.ui.CannedInputUIFactory([True])
560
336
self.assertRaises(LockBroken, ld1.unlock)
562
338
bzrlib.ui.ui_factory = orig_factory
340
def test_break_lock_corrupt_info(self):
341
"""break_lock works even if the info file is corrupt (and tells the UI
345
ld2 = self.get_lock()
348
ld.transport.put_bytes_non_atomic('test_lock/held/info', '\0')
350
class LoggingUIFactory(bzrlib.ui.SilentUIFactory):
354
def get_boolean(self, prompt):
355
self.prompts.append(('boolean', prompt))
358
ui = LoggingUIFactory()
359
self.overrideAttr(bzrlib.ui, 'ui_factory', ui)
361
self.assertLength(1, ui.prompts)
362
self.assertEqual('boolean', ui.prompts[0][0])
363
self.assertStartsWith(ui.prompts[0][1], 'Break (corrupt LockDir')
364
self.assertRaises(LockBroken, ld.unlock)
366
def test_break_lock_missing_info(self):
367
"""break_lock works even if the info file is missing (and tells the UI
371
ld2 = self.get_lock()
374
ld.transport.delete('test_lock/held/info')
376
class LoggingUIFactory(bzrlib.ui.SilentUIFactory):
380
def get_boolean(self, prompt):
381
self.prompts.append(('boolean', prompt))
384
ui = LoggingUIFactory()
385
orig_factory = bzrlib.ui.ui_factory
386
bzrlib.ui.ui_factory = ui
389
self.assertRaises(LockBroken, ld.unlock)
390
self.assertLength(0, ui.prompts)
392
bzrlib.ui.ui_factory = orig_factory
393
# Suppress warnings due to ld not being unlocked
394
# XXX: if lock_broken hook was invoked in this case, this hack would
395
# not be necessary. - Andrew Bennetts, 2010-09-06.
396
del self._lock_actions[:]
564
398
def test_create_missing_base_directory(self):
565
399
"""If LockDir.path doesn't exist, it can be created
648
483
# should be nothing before we start
650
485
t = self.get_transport().clone('test_lock')
651
487
def check_dir(a):
652
488
self.assertEquals(a, t.list_dir('.'))
654
491
# when held, that's all we see
655
492
ld1.attempt_lock()
493
self.addCleanup(ld1.unlock)
656
494
check_dir(['held'])
657
495
# second guy should fail
658
496
self.assertRaises(errors.LockContention, ld2.attempt_lock)
660
498
check_dir(['held'])
500
def test_no_lockdir_info(self):
501
"""We can cope with empty info files."""
502
# This seems like a fairly common failure case - see
503
# <https://bugs.launchpad.net/bzr/+bug/185103> and all its dupes.
504
# Processes are often interrupted after opening the file
505
# before the actual contents are committed.
506
t = self.get_transport()
508
t.mkdir('test_lock/held')
509
t.put_bytes('test_lock/held/info', '')
510
lf = LockDir(t, 'test_lock')
512
formatted_info = info.to_readable_dict()
514
dict(user='<unknown>', hostname='<unknown>', pid='<unknown>',
515
time_ago='(unknown)'),
518
def test_corrupt_lockdir_info(self):
519
"""We can cope with corrupt (and thus unparseable) info files."""
520
# This seems like a fairly common failure case too - see
521
# <https://bugs.launchpad.net/bzr/+bug/619872> for instance.
522
# In particular some systems tend to fill recently created files with
523
# nul bytes after recovering from a system crash.
524
t = self.get_transport()
526
t.mkdir('test_lock/held')
527
t.put_bytes('test_lock/held/info', '\0')
528
lf = LockDir(t, 'test_lock')
529
self.assertRaises(errors.LockCorrupt, lf.peek)
530
# Currently attempt_lock gives LockContention, but LockCorrupt would be
531
# a reasonable result too.
533
(errors.LockCorrupt, errors.LockContention), lf.attempt_lock)
534
self.assertRaises(errors.LockCorrupt, lf.validate_token, 'fake token')
536
def test_missing_lockdir_info(self):
537
"""We can cope with absent info files."""
538
t = self.get_transport()
540
t.mkdir('test_lock/held')
541
lf = LockDir(t, 'test_lock')
542
# In this case we expect the 'not held' result from peek, because peek
543
# cannot be expected to notice that there is a 'held' directory with no
545
self.assertEqual(None, lf.peek())
546
# And lock/unlock may work or give LockContention (but not any other
550
except LockContention:
551
# LockContention is ok, and expected on Windows
554
# no error is ok, and expected on POSIX (because POSIX allows
555
# os.rename over an empty directory).
557
# Currently raises TokenMismatch, but LockCorrupt would be reasonable
560
(errors.TokenMismatch, errors.LockCorrupt),
561
lf.validate_token, 'fake token')
564
class TestLockDirHooks(TestCaseWithTransport):
567
super(TestLockDirHooks, self).setUp()
571
return LockDir(self.get_transport(), 'test_lock')
573
def record_hook(self, result):
574
self._calls.append(result)
576
def test_LockDir_acquired_success(self):
577
# the LockDir.lock_acquired hook fires when a lock is acquired.
578
LockDir.hooks.install_named_hook('lock_acquired',
579
self.record_hook, 'record_hook')
582
self.assertEqual([], self._calls)
583
result = ld.attempt_lock()
584
lock_path = ld.transport.abspath(ld.path)
585
self.assertEqual([lock.LockResult(lock_path, result)], self._calls)
587
self.assertEqual([lock.LockResult(lock_path, result)], self._calls)
589
def test_LockDir_acquired_fail(self):
590
# the LockDir.lock_acquired hook does not fire on failure.
593
ld2 = self.get_lock()
595
# install a lock hook now, when the disk lock is locked
596
LockDir.hooks.install_named_hook('lock_acquired',
597
self.record_hook, 'record_hook')
598
self.assertRaises(errors.LockContention, ld.attempt_lock)
599
self.assertEqual([], self._calls)
601
self.assertEqual([], self._calls)
603
def test_LockDir_released_success(self):
604
# the LockDir.lock_released hook fires when a lock is acquired.
605
LockDir.hooks.install_named_hook('lock_released',
606
self.record_hook, 'record_hook')
609
self.assertEqual([], self._calls)
610
result = ld.attempt_lock()
611
self.assertEqual([], self._calls)
613
lock_path = ld.transport.abspath(ld.path)
614
self.assertEqual([lock.LockResult(lock_path, result)], self._calls)
616
def test_LockDir_released_fail(self):
617
# the LockDir.lock_released hook does not fire on failure.
620
ld2 = self.get_lock()
622
ld2.force_break(ld2.peek())
623
LockDir.hooks.install_named_hook('lock_released',
624
self.record_hook, 'record_hook')
625
self.assertRaises(LockBroken, ld.unlock)
626
self.assertEqual([], self._calls)
628
def test_LockDir_broken_success(self):
629
# the LockDir.lock_broken hook fires when a lock is broken.
632
ld2 = self.get_lock()
633
result = ld.attempt_lock()
634
LockDir.hooks.install_named_hook('lock_broken',
635
self.record_hook, 'record_hook')
636
ld2.force_break(ld2.peek())
637
lock_path = ld.transport.abspath(ld.path)
638
self.assertEqual([lock.LockResult(lock_path, result)], self._calls)
640
def test_LockDir_broken_failure(self):
641
# the LockDir.lock_broken hook does not fires when a lock is already
645
ld2 = self.get_lock()
646
result = ld.attempt_lock()
647
holder_info = ld2.peek()
649
LockDir.hooks.install_named_hook('lock_broken',
650
self.record_hook, 'record_hook')
651
ld2.force_break(holder_info)
652
lock_path = ld.transport.abspath(ld.path)
653
self.assertEqual([], self._calls)
656
class TestLockHeldInfo(TestCase):
657
"""Can get information about the lock holder, and detect whether they're
661
info = LockHeldInfo.for_this_process(None)
662
self.assertContainsRe(repr(info), r"LockHeldInfo\(.*\)")
664
def test_unicode(self):
665
info = LockHeldInfo.for_this_process(None)
666
self.assertContainsRe(unicode(info),
667
r'held by .* on .* \(process #\d+\), acquired .* ago')
669
def test_is_locked_by_this_process(self):
670
info = LockHeldInfo.for_this_process(None)
671
self.assertTrue(info.is_locked_by_this_process())
673
def test_is_not_locked_by_this_process(self):
674
info = LockHeldInfo.for_this_process(None)
675
info.info_dict['pid'] = '123123123123123'
676
self.assertFalse(info.is_locked_by_this_process())
678
def test_lock_holder_live_process(self):
679
"""Detect that the holder (this process) is still running."""
680
info = LockHeldInfo.for_this_process(None)
681
self.assertFalse(info.is_lock_holder_known_dead())
683
def test_lock_holder_dead_process(self):
684
"""Detect that the holder (this process) is still running."""
685
self.overrideAttr(lockdir, 'get_host_name',
686
lambda: 'aproperhostname')
687
info = LockHeldInfo.for_this_process(None)
688
info.info_dict['pid'] = '123123123'
689
self.assertTrue(info.is_lock_holder_known_dead())
691
def test_lock_holder_other_machine(self):
692
"""The lock holder isn't here so we don't know if they're alive."""
693
info = LockHeldInfo.for_this_process(None)
694
info.info_dict['hostname'] = 'egg.example.com'
695
info.info_dict['pid'] = '123123123'
696
self.assertFalse(info.is_lock_holder_known_dead())
698
def test_lock_holder_other_user(self):
699
"""Only auto-break locks held by this user."""
700
info = LockHeldInfo.for_this_process(None)
701
info.info_dict['user'] = 'notme@example.com'
702
info.info_dict['pid'] = '123123123'
703
self.assertFalse(info.is_lock_holder_known_dead())
705
def test_no_good_hostname(self):
706
"""Correctly handle ambiguous hostnames.
708
If the lock's recorded with just 'localhost' we can't really trust
709
it's the same 'localhost'. (There are quite a few of them. :-)
710
So even if the process is known not to be alive, we can't say that's
713
self.overrideAttr(lockdir, 'get_host_name',
715
info = LockHeldInfo.for_this_process(None)
716
info.info_dict['pid'] = '123123123'
717
self.assertFalse(info.is_lock_holder_known_dead())
720
class TestStaleLockDir(TestCaseWithTransport):
721
"""Can automatically break stale locks.
723
:see: https://bugs.launchpad.net/bzr/+bug/220464
726
def test_auto_break_stale_lock(self):
727
"""Locks safely known to be stale are just cleaned up.
729
This generates a warning but no other user interaction.
731
self.overrideAttr(lockdir, 'get_host_name',
732
lambda: 'aproperhostname')
733
# This is off by default at present; see the discussion in the bug.
734
# If you change the default, don't forget to update the docs.
735
config.GlobalConfig().set_user_option('locks.steal_dead', True)
736
# Create a lock pretending to come from a different nonexistent
737
# process on the same machine.
738
l1 = LockDir(self.get_transport(), 'a',
739
extra_holder_info={'pid': '12312313'})
740
token_1 = l1.attempt_lock()
741
l2 = LockDir(self.get_transport(), 'a')
742
token_2 = l2.attempt_lock()
743
# l1 will notice its lock was stolen.
744
self.assertRaises(errors.LockBroken,
748
def test_auto_break_stale_lock_configured_off(self):
749
"""Automatic breaking can be turned off"""
750
l1 = LockDir(self.get_transport(), 'a',
751
extra_holder_info={'pid': '12312313'})
752
token_1 = l1.attempt_lock()
753
self.addCleanup(l1.unlock)
754
l2 = LockDir(self.get_transport(), 'a')
755
# This fails now, because dead lock breaking is off by default.
756
self.assertRaises(LockContention,
758
# and it's in fact not broken
added
removed
bzrlib/tests/test_lockdir.py
