223
219
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
221
def test_40_confirm_easy(self):
448
222
"""Confirm a lock that's already held"""
449
223
t = self.get_transport()
450
224
lf1 = LockDir(t, 'test_lock')
452
226
lf1.attempt_lock()
227
self.addCleanup(lf1.unlock)
455
230
def test_41_confirm_not_held(self):
552
332
# do this without IO redirection to ensure it doesn't prompt.
553
333
self.assertRaises(AssertionError, ld1.break_lock)
554
334
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")
335
bzrlib.ui.ui_factory = bzrlib.ui.CannedInputUIFactory([True])
560
338
self.assertRaises(LockBroken, ld1.unlock)
562
340
bzrlib.ui.ui_factory = orig_factory
342
def test_break_lock_corrupt_info(self):
343
"""break_lock works even if the info file is corrupt (and tells the UI
347
ld2 = self.get_lock()
350
ld.transport.put_bytes_non_atomic('test_lock/held/info', '\0')
352
class LoggingUIFactory(bzrlib.ui.SilentUIFactory):
356
def get_boolean(self, prompt):
357
self.prompts.append(('boolean', prompt))
360
ui = LoggingUIFactory()
361
self.overrideAttr(bzrlib.ui, 'ui_factory', ui)
363
self.assertLength(1, ui.prompts)
364
self.assertEqual('boolean', ui.prompts[0][0])
365
self.assertStartsWith(ui.prompts[0][1], 'Break (corrupt LockDir')
366
self.assertRaises(LockBroken, ld.unlock)
368
def test_break_lock_missing_info(self):
369
"""break_lock works even if the info file is missing (and tells the UI
373
ld2 = self.get_lock()
376
ld.transport.delete('test_lock/held/info')
378
class LoggingUIFactory(bzrlib.ui.SilentUIFactory):
382
def get_boolean(self, prompt):
383
self.prompts.append(('boolean', prompt))
386
ui = LoggingUIFactory()
387
orig_factory = bzrlib.ui.ui_factory
388
bzrlib.ui.ui_factory = ui
391
self.assertRaises(LockBroken, ld.unlock)
392
self.assertLength(0, ui.prompts)
394
bzrlib.ui.ui_factory = orig_factory
395
# Suppress warnings due to ld not being unlocked
396
# XXX: if lock_broken hook was invoked in this case, this hack would
397
# not be necessary. - Andrew Bennetts, 2010-09-06.
398
del self._lock_actions[:]
564
400
def test_create_missing_base_directory(self):
565
401
"""If LockDir.path doesn't exist, it can be created
648
485
# should be nothing before we start
650
487
t = self.get_transport().clone('test_lock')
651
489
def check_dir(a):
652
490
self.assertEquals(a, t.list_dir('.'))
654
493
# when held, that's all we see
655
494
ld1.attempt_lock()
495
self.addCleanup(ld1.unlock)
656
496
check_dir(['held'])
657
497
# second guy should fail
658
498
self.assertRaises(errors.LockContention, ld2.attempt_lock)
660
500
check_dir(['held'])
502
def test_no_lockdir_info(self):
503
"""We can cope with empty info files."""
504
# This seems like a fairly common failure case - see
505
# <https://bugs.launchpad.net/bzr/+bug/185103> and all its dupes.
506
# Processes are often interrupted after opening the file
507
# before the actual contents are committed.
508
t = self.get_transport()
510
t.mkdir('test_lock/held')
511
t.put_bytes('test_lock/held/info', '')
512
lf = LockDir(t, 'test_lock')
514
formatted_info = info.to_readable_dict()
516
dict(user='<unknown>', hostname='<unknown>', pid='<unknown>',
517
time_ago='(unknown)'),
520
def test_corrupt_lockdir_info(self):
521
"""We can cope with corrupt (and thus unparseable) info files."""
522
# This seems like a fairly common failure case too - see
523
# <https://bugs.launchpad.net/bzr/+bug/619872> for instance.
524
# In particular some systems tend to fill recently created files with
525
# nul bytes after recovering from a system crash.
526
t = self.get_transport()
528
t.mkdir('test_lock/held')
529
t.put_bytes('test_lock/held/info', '\0')
530
lf = LockDir(t, 'test_lock')
531
self.assertRaises(errors.LockCorrupt, lf.peek)
532
# Currently attempt_lock gives LockContention, but LockCorrupt would be
533
# a reasonable result too.
535
(errors.LockCorrupt, errors.LockContention), lf.attempt_lock)
536
self.assertRaises(errors.LockCorrupt, lf.validate_token, 'fake token')
538
def test_missing_lockdir_info(self):
539
"""We can cope with absent info files."""
540
t = self.get_transport()
542
t.mkdir('test_lock/held')
543
lf = LockDir(t, 'test_lock')
544
# In this case we expect the 'not held' result from peek, because peek
545
# cannot be expected to notice that there is a 'held' directory with no
547
self.assertEqual(None, lf.peek())
548
# And lock/unlock may work or give LockContention (but not any other
552
except LockContention:
553
# LockContention is ok, and expected on Windows
556
# no error is ok, and expected on POSIX (because POSIX allows
557
# os.rename over an empty directory).
559
# Currently raises TokenMismatch, but LockCorrupt would be reasonable
562
(errors.TokenMismatch, errors.LockCorrupt),
563
lf.validate_token, 'fake token')
566
class TestLockDirHooks(TestCaseWithTransport):
569
super(TestLockDirHooks, self).setUp()
573
return LockDir(self.get_transport(), 'test_lock')
575
def record_hook(self, result):
576
self._calls.append(result)
578
def test_LockDir_acquired_success(self):
579
# the LockDir.lock_acquired hook fires when a lock is acquired.
580
LockDir.hooks.install_named_hook('lock_acquired',
581
self.record_hook, 'record_hook')
584
self.assertEqual([], self._calls)
585
result = ld.attempt_lock()
586
lock_path = ld.transport.abspath(ld.path)
587
self.assertEqual([lock.LockResult(lock_path, result)], self._calls)
589
self.assertEqual([lock.LockResult(lock_path, result)], self._calls)
591
def test_LockDir_acquired_fail(self):
592
# the LockDir.lock_acquired hook does not fire on failure.
595
ld2 = self.get_lock()
597
# install a lock hook now, when the disk lock is locked
598
LockDir.hooks.install_named_hook('lock_acquired',
599
self.record_hook, 'record_hook')
600
self.assertRaises(errors.LockContention, ld.attempt_lock)
601
self.assertEqual([], self._calls)
603
self.assertEqual([], self._calls)
605
def test_LockDir_released_success(self):
606
# the LockDir.lock_released hook fires when a lock is acquired.
607
LockDir.hooks.install_named_hook('lock_released',
608
self.record_hook, 'record_hook')
611
self.assertEqual([], self._calls)
612
result = ld.attempt_lock()
613
self.assertEqual([], self._calls)
615
lock_path = ld.transport.abspath(ld.path)
616
self.assertEqual([lock.LockResult(lock_path, result)], self._calls)
618
def test_LockDir_released_fail(self):
619
# the LockDir.lock_released hook does not fire on failure.
622
ld2 = self.get_lock()
624
ld2.force_break(ld2.peek())
625
LockDir.hooks.install_named_hook('lock_released',
626
self.record_hook, 'record_hook')
627
self.assertRaises(LockBroken, ld.unlock)
628
self.assertEqual([], self._calls)
630
def test_LockDir_broken_success(self):
631
# the LockDir.lock_broken hook fires when a lock is broken.
634
ld2 = self.get_lock()
635
result = ld.attempt_lock()
636
LockDir.hooks.install_named_hook('lock_broken',
637
self.record_hook, 'record_hook')
638
ld2.force_break(ld2.peek())
639
lock_path = ld.transport.abspath(ld.path)
640
self.assertEqual([lock.LockResult(lock_path, result)], self._calls)
642
def test_LockDir_broken_failure(self):
643
# the LockDir.lock_broken hook does not fires when a lock is already
647
ld2 = self.get_lock()
648
result = ld.attempt_lock()
649
holder_info = ld2.peek()
651
LockDir.hooks.install_named_hook('lock_broken',
652
self.record_hook, 'record_hook')
653
ld2.force_break(holder_info)
654
lock_path = ld.transport.abspath(ld.path)
655
self.assertEqual([], self._calls)
658
class TestLockHeldInfo(TestCase):
659
"""Can get information about the lock holder, and detect whether they're
663
info = LockHeldInfo.for_this_process(None)
664
self.assertContainsRe(repr(info), r"LockHeldInfo\(.*\)")
666
def test_unicode(self):
667
info = LockHeldInfo.for_this_process(None)
668
self.assertContainsRe(unicode(info),
669
r'held by .* on .* \(process #\d+\), acquired .* ago')
671
def test_is_locked_by_this_process(self):
672
info = LockHeldInfo.for_this_process(None)
673
self.assertTrue(info.is_locked_by_this_process())
675
def test_is_not_locked_by_this_process(self):
676
info = LockHeldInfo.for_this_process(None)
677
info.info_dict['pid'] = '123123123123123'
678
self.assertFalse(info.is_locked_by_this_process())
680
def test_lock_holder_live_process(self):
681
"""Detect that the holder (this process) is still running."""
682
info = LockHeldInfo.for_this_process(None)
683
self.assertFalse(info.is_lock_holder_known_dead())
685
def test_lock_holder_dead_process(self):
686
"""Detect that the holder (this process) is still running."""
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
# This is off by default at present; see the discussion in the bug.
732
# If you change the default, don't forget to update the docs.
733
config.GlobalConfig().set_user_option('locks.steal_dead', True)
734
# Create a lock pretending to come from a different nonexistent
735
# process on the same machine.
736
l1 = LockDir(self.get_transport(), 'a',
737
extra_holder_info={'pid': '12312313'})
738
token_1 = l1.attempt_lock()
739
l2 = LockDir(self.get_transport(), 'a')
740
token_2 = l2.attempt_lock()
741
# l1 will notice its lock was stolen.
742
self.assertRaises(errors.LockBroken,
746
def test_auto_break_stale_lock_configured_off(self):
747
"""Automatic breaking can be turned off"""
748
l1 = LockDir(self.get_transport(), 'a',
749
extra_holder_info={'pid': '12312313'})
750
token_1 = l1.attempt_lock()
751
self.addCleanup(l1.unlock)
752
l2 = LockDir(self.get_transport(), 'a')
753
# This fails now, because dead lock breaking is off by default.
754
self.assertRaises(LockContention,
756
# and it's in fact not broken
added
removed
bzrlib/tests/test_lockdir.py
