223
218
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
220
def test_40_confirm_easy(self):
448
221
"""Confirm a lock that's already held"""
449
222
t = self.get_transport()
450
223
lf1 = LockDir(t, 'test_lock')
452
225
lf1.attempt_lock()
226
self.addCleanup(lf1.unlock)
455
229
def test_41_confirm_not_held(self):
552
331
# do this without IO redirection to ensure it doesn't prompt.
553
332
self.assertRaises(AssertionError, ld1.break_lock)
554
333
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")
334
bzrlib.ui.ui_factory = bzrlib.ui.CannedInputUIFactory([True])
560
337
self.assertRaises(LockBroken, ld1.unlock)
562
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[:]
564
399
def test_create_missing_base_directory(self):
565
400
"""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(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
