219
218
self.assertEqual([], self._logged_reports)
221
def test_32_lock_wait_succeed(self):
222
"""Succeed when trying to acquire a lock that gets released
224
One thread holds on a lock and then releases it; another
227
# This test sometimes fails like this:
228
# Traceback (most recent call last):
230
# File "/home/pqm/bzr-pqm-workdir/home/+trunk/bzrlib/tests/
231
# test_lockdir.py", line 247, in test_32_lock_wait_succeed
232
# self.assertEqual(1, len(self._logged_reports))
233
# AssertionError: not equal:
236
raise tests.TestSkipped("Test fails intermittently")
237
t = self.get_transport()
238
lf1 = LockDir(t, 'test_lock')
242
def wait_and_unlock():
245
unlocker = Thread(target=wait_and_unlock)
248
lf2 = LockDir(t, 'test_lock')
249
self.setup_log_reporter(lf2)
252
lf2.wait_lock(timeout=0.4, poll=0.1)
254
self.assertTrue(after - before <= 1.0)
258
# There should be only 1 report, even though it should have to
260
lock_base = lf2.transport.abspath(lf2.path)
261
self.assertEqual(1, len(self._logged_reports))
262
self.assertEqual('%s %s\n'
264
'Will continue to try until %s\n',
265
self._logged_reports[0][0])
266
args = self._logged_reports[0][1]
267
self.assertEqual('Unable to obtain', args[0])
268
self.assertEqual('lock %s' % (lock_base,), args[1])
269
self.assertStartsWith(args[2], 'held by ')
270
self.assertStartsWith(args[3], 'locked ')
271
self.assertEndsWith(args[3], ' ago')
272
self.assertContainsRe(args[4], r'\d\d:\d\d:\d\d')
274
def test_34_lock_write_waits(self):
275
"""LockDir.lock_write() will wait for the lock."""
276
# the test suite sets the default to 0 to make deadlocks fail fast.
277
# change it for this test, as we want to try a manual deadlock.
278
raise tests.TestSkipped('Timing-sensitive test')
279
bzrlib.lockdir._DEFAULT_TIMEOUT_SECONDS = 300
280
t = self.get_transport()
281
lf1 = LockDir(t, 'test_lock')
285
def wait_and_unlock():
288
unlocker = Thread(target=wait_and_unlock)
291
lf2 = LockDir(t, 'test_lock')
292
self.setup_log_reporter(lf2)
300
# There should be only 1 report, even though it should have to
302
lock_base = lf2.transport.abspath(lf2.path)
303
self.assertEqual(1, len(self._logged_reports))
304
self.assertEqual('%s %s\n'
306
'Will continue to try until %s\n',
307
self._logged_reports[0][0])
308
args = self._logged_reports[0][1]
309
self.assertEqual('Unable to obtain', args[0])
310
self.assertEqual('lock %s' % (lock_base,), args[1])
311
self.assertStartsWith(args[2], 'held by ')
312
self.assertStartsWith(args[3], 'locked ')
313
self.assertEndsWith(args[3], ' ago')
314
self.assertContainsRe(args[4], r'\d\d:\d\d:\d\d')
316
def test_35_wait_lock_changing(self):
317
"""LockDir.wait_lock() will report if the lock changes underneath.
319
This is the stages we want to happen:
321
0) Synchronization locks are created and locked.
322
1) Lock1 obtains the lockdir, and releases the 'check' lock.
323
2) Lock2 grabs the 'check' lock, and checks the lockdir.
324
It sees the lockdir is already acquired, reports the fact,
325
and unsets the 'checked' lock.
326
3) Thread1 blocks on acquiring the 'checked' lock, and then tells
327
Lock1 to release and acquire the lockdir. This resets the 'check'
329
4) Lock2 acquires the 'check' lock, and checks again. It notices
330
that the holder of the lock has changed, and so reports a new
332
5) Thread1 blocks on the 'checked' lock, this time, it completely
333
unlocks the lockdir, allowing Lock2 to acquire the lock.
336
wait_to_check_lock = Lock()
337
wait_until_checked_lock = Lock()
339
wait_to_check_lock.acquire()
340
wait_until_checked_lock.acquire()
341
note('locked check and checked locks')
343
class LockDir1(LockDir):
344
"""Use the synchronization points for the first lock."""
346
def attempt_lock(self):
347
# Once we have acquired the lock, it is okay for
348
# the other lock to check it
350
return super(LockDir1, self).attempt_lock()
352
note('lock1: releasing check lock')
353
wait_to_check_lock.release()
355
class LockDir2(LockDir):
356
"""Use the synchronization points for the second lock."""
358
def attempt_lock(self):
359
note('lock2: waiting for check lock')
360
wait_to_check_lock.acquire()
361
note('lock2: acquired check lock')
363
return super(LockDir2, self).attempt_lock()
365
note('lock2: releasing checked lock')
366
wait_until_checked_lock.release()
368
t = self.get_transport()
369
lf1 = LockDir1(t, 'test_lock')
372
lf2 = LockDir2(t, 'test_lock')
373
self.setup_log_reporter(lf2)
375
def wait_and_switch():
377
# Block until lock2 has had a chance to check
378
note('lock1: waiting 1 for checked lock')
379
wait_until_checked_lock.acquire()
380
note('lock1: acquired for checked lock')
381
note('lock1: released lockdir')
383
note('lock1: acquiring lockdir')
384
# Create a new nonce, so the lock looks different.
385
lf1.nonce = osutils.rand_chars(20)
387
note('lock1: acquired lockdir')
389
# Block until lock2 has peeked again
390
note('lock1: waiting 2 for checked lock')
391
wait_until_checked_lock.acquire()
392
note('lock1: acquired for checked lock')
393
# Now unlock, and let lock 2 grab the lock
395
wait_to_check_lock.release()
397
unlocker = Thread(target=wait_and_switch)
400
# Wait and play against the other thread
401
lf2.wait_lock(timeout=20.0, poll=0.01)
406
# There should be 2 reports, because the lock changed
407
lock_base = lf2.transport.abspath(lf2.path)
408
self.assertEqual(2, len(self._logged_reports))
410
self.assertEqual('%s %s\n'
412
'Will continue to try until %s\n',
413
self._logged_reports[0][0])
414
args = self._logged_reports[0][1]
415
self.assertEqual('Unable to obtain', args[0])
416
self.assertEqual('lock %s' % (lock_base,), args[1])
417
self.assertStartsWith(args[2], 'held by ')
418
self.assertStartsWith(args[3], 'locked ')
419
self.assertEndsWith(args[3], ' ago')
420
self.assertContainsRe(args[4], r'\d\d:\d\d:\d\d')
422
self.assertEqual('%s %s\n'
424
'Will continue to try until %s\n',
425
self._logged_reports[1][0])
426
args = self._logged_reports[1][1]
427
self.assertEqual('Lock owner changed for', args[0])
428
self.assertEqual('lock %s' % (lock_base,), args[1])
429
self.assertStartsWith(args[2], 'held by ')
430
self.assertStartsWith(args[3], 'locked ')
431
self.assertEndsWith(args[3], ' ago')
432
self.assertContainsRe(args[4], r'\d\d:\d\d:\d\d')
434
220
def test_40_confirm_easy(self):
435
221
"""Confirm a lock that's already held"""
436
222
t = self.get_transport()
437
223
lf1 = LockDir(t, 'test_lock')
439
225
lf1.attempt_lock()
226
self.addCleanup(lf1.unlock)
442
229
def test_41_confirm_not_held(self):
539
331
# do this without IO redirection to ensure it doesn't prompt.
540
332
self.assertRaises(AssertionError, ld1.break_lock)
541
333
orig_factory = bzrlib.ui.ui_factory
542
# silent ui - no need for stdout
543
bzrlib.ui.ui_factory = bzrlib.ui.SilentUIFactory()
544
bzrlib.ui.ui_factory.stdin = StringIO("y\n")
334
bzrlib.ui.ui_factory = bzrlib.ui.CannedInputUIFactory([True])
547
337
self.assertRaises(LockBroken, ld1.unlock)
549
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[:]
551
399
def test_create_missing_base_directory(self):
552
400
"""If LockDir.path doesn't exist, it can be created
635
485
# should be nothing before we start
637
487
t = self.get_transport().clone('test_lock')
638
489
def check_dir(a):
639
self.assertEquals(a, t.list_dir('.'))
490
self.assertEqual(a, t.list_dir('.'))
641
493
# when held, that's all we see
642
494
ld1.attempt_lock()
495
self.addCleanup(ld1.unlock)
643
496
check_dir(['held'])
644
497
# second guy should fail
645
498
self.assertRaises(errors.LockContention, ld2.attempt_lock)
647
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
