344
331
# do this without IO redirection to ensure it doesn't prompt.
345
332
self.assertRaises(AssertionError, ld1.break_lock)
346
333
orig_factory = bzrlib.ui.ui_factory
347
# silent ui - no need for stdout
348
bzrlib.ui.ui_factory = bzrlib.ui.SilentUIFactory()
349
bzrlib.ui.ui_factory.stdin = StringIO("y\n")
334
bzrlib.ui.ui_factory = bzrlib.ui.CannedInputUIFactory([True])
352
337
self.assertRaises(LockBroken, ld1.unlock)
354
339
bzrlib.ui.ui_factory = orig_factory
341
def test_break_lock_corrupt_info(self):
342
"""break_lock works even if the info file is corrupt (and tells the UI
346
ld2 = self.get_lock()
349
ld.transport.put_bytes_non_atomic('test_lock/held/info', '\0')
351
class LoggingUIFactory(bzrlib.ui.SilentUIFactory):
355
def get_boolean(self, prompt):
356
self.prompts.append(('boolean', prompt))
359
ui = LoggingUIFactory()
360
self.overrideAttr(bzrlib.ui, 'ui_factory', ui)
362
self.assertLength(1, ui.prompts)
363
self.assertEqual('boolean', ui.prompts[0][0])
364
self.assertStartsWith(ui.prompts[0][1], 'Break (corrupt LockDir')
365
self.assertRaises(LockBroken, ld.unlock)
367
def test_break_lock_missing_info(self):
368
"""break_lock works even if the info file is missing (and tells the UI
372
ld2 = self.get_lock()
375
ld.transport.delete('test_lock/held/info')
377
class LoggingUIFactory(bzrlib.ui.SilentUIFactory):
381
def get_boolean(self, prompt):
382
self.prompts.append(('boolean', prompt))
385
ui = LoggingUIFactory()
386
orig_factory = bzrlib.ui.ui_factory
387
bzrlib.ui.ui_factory = ui
390
self.assertRaises(LockBroken, ld.unlock)
391
self.assertLength(0, ui.prompts)
393
bzrlib.ui.ui_factory = orig_factory
394
# Suppress warnings due to ld not being unlocked
395
# XXX: if lock_broken hook was invoked in this case, this hack would
396
# not be necessary. - Andrew Bennetts, 2010-09-06.
397
del self._lock_actions[:]
399
def test_create_missing_base_directory(self):
400
"""If LockDir.path doesn't exist, it can be created
402
Some people manually remove the entire lock/ directory trying
403
to unlock a stuck repository/branch/etc. Rather than failing
404
after that, just create the lock directory when needed.
406
t = self.get_transport()
407
lf1 = LockDir(t, 'test_lock')
410
self.assertTrue(t.has('test_lock'))
413
self.assertFalse(t.has('test_lock'))
415
# This will create 'test_lock' if it needs to
417
self.assertTrue(t.has('test_lock'))
418
self.assertTrue(t.has('test_lock/held/info'))
421
self.assertFalse(t.has('test_lock/held/info'))
423
def test_display_form(self):
424
ld1 = self.get_lock()
428
info_list = ld1.peek().to_readable_dict()
431
self.assertEqual(info_list['user'], u'jrandom@example.com')
432
self.assertContainsRe(info_list['pid'], '^\d+$')
433
self.assertContainsRe(info_list['time_ago'], r'^\d+ seconds? ago$')
435
def test_lock_without_email(self):
436
global_config = config.GlobalStack()
437
# Intentionally has no email address
438
global_config.set('email', 'User Identity')
439
ld1 = self.get_lock()
444
def test_lock_permission(self):
445
self.requireFeature(features.not_running_as_root)
446
if not osutils.supports_posix_readonly():
447
raise tests.TestSkipped('Cannot induce a permission failure')
448
ld1 = self.get_lock()
449
lock_path = ld1.transport.local_abspath('test_lock')
451
osutils.make_readonly(lock_path)
452
self.assertRaises(errors.LockFailed, ld1.attempt_lock)
454
def test_lock_by_token(self):
455
ld1 = self.get_lock()
456
token = ld1.lock_write()
457
self.addCleanup(ld1.unlock)
458
self.assertNotEqual(None, token)
459
ld2 = self.get_lock()
460
t2 = ld2.lock_write(token)
461
self.addCleanup(ld2.unlock)
462
self.assertEqual(token, t2)
464
def test_lock_with_buggy_rename(self):
465
# test that lock acquisition handles servers which pretend they
466
# renamed correctly but that actually fail
467
t = transport.get_transport_from_url(
468
'brokenrename+' + self.get_url())
469
ld1 = LockDir(t, 'test_lock')
472
ld2 = LockDir(t, 'test_lock')
473
# we should fail to lock
474
e = self.assertRaises(errors.LockContention, ld2.attempt_lock)
475
# now the original caller should succeed in unlocking
477
# and there should be nothing left over
478
self.assertEquals([], t.list_dir('test_lock'))
480
def test_failed_lock_leaves_no_trash(self):
481
# if we fail to acquire the lock, we don't leave pending directories
482
# behind -- https://bugs.launchpad.net/bzr/+bug/109169
483
ld1 = self.get_lock()
484
ld2 = self.get_lock()
485
# should be nothing before we start
487
t = self.get_transport().clone('test_lock')
490
self.assertEquals(a, t.list_dir('.'))
493
# when held, that's all we see
495
self.addCleanup(ld1.unlock)
497
# second guy should fail
498
self.assertRaises(errors.LockContention, ld2.attempt_lock)
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(TestCaseInTempDir):
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
self.overrideAttr(lockdir, 'get_host_name',
688
lambda: 'aproperhostname')
689
info = LockHeldInfo.for_this_process(None)
690
info.info_dict['pid'] = '123123123'
691
self.assertTrue(info.is_lock_holder_known_dead())
693
def test_lock_holder_other_machine(self):
694
"""The lock holder isn't here so we don't know if they're alive."""
695
info = LockHeldInfo.for_this_process(None)
696
info.info_dict['hostname'] = 'egg.example.com'
697
info.info_dict['pid'] = '123123123'
698
self.assertFalse(info.is_lock_holder_known_dead())
700
def test_lock_holder_other_user(self):
701
"""Only auto-break locks held by this user."""
702
info = LockHeldInfo.for_this_process(None)
703
info.info_dict['user'] = 'notme@example.com'
704
info.info_dict['pid'] = '123123123'
705
self.assertFalse(info.is_lock_holder_known_dead())
707
def test_no_good_hostname(self):
708
"""Correctly handle ambiguous hostnames.
710
If the lock's recorded with just 'localhost' we can't really trust
711
it's the same 'localhost'. (There are quite a few of them. :-)
712
So even if the process is known not to be alive, we can't say that's
715
self.overrideAttr(lockdir, 'get_host_name',
717
info = LockHeldInfo.for_this_process(None)
718
info.info_dict['pid'] = '123123123'
719
self.assertFalse(info.is_lock_holder_known_dead())
722
class TestStaleLockDir(TestCaseWithTransport):
723
"""Can automatically break stale locks.
725
:see: https://bugs.launchpad.net/bzr/+bug/220464
728
def test_auto_break_stale_lock(self):
729
"""Locks safely known to be stale are just cleaned up.
731
This generates a warning but no other user interaction.
733
self.overrideAttr(lockdir, 'get_host_name',
734
lambda: 'aproperhostname')
735
# This is off by default at present; see the discussion in the bug.
736
# If you change the default, don't forget to update the docs.
737
config.GlobalStack().set('locks.steal_dead', True)
738
# Create a lock pretending to come from a different nonexistent
739
# process on the same machine.
740
l1 = LockDir(self.get_transport(), 'a',
741
extra_holder_info={'pid': '12312313'})
742
token_1 = l1.attempt_lock()
743
l2 = LockDir(self.get_transport(), 'a')
744
token_2 = l2.attempt_lock()
745
# l1 will notice its lock was stolen.
746
self.assertRaises(errors.LockBroken,
750
def test_auto_break_stale_lock_configured_off(self):
751
"""Automatic breaking can be turned off"""
752
l1 = LockDir(self.get_transport(), 'a',
753
extra_holder_info={'pid': '12312313'})
754
token_1 = l1.attempt_lock()
755
self.addCleanup(l1.unlock)
756
l2 = LockDir(self.get_transport(), 'a')
757
# This fails now, because dead lock breaking is off by default.
758
self.assertRaises(LockContention,
760
# and it's in fact not broken
added
removed
bzrlib/tests/test_lockdir.py
