215
218
self.assertEqual([], self._logged_reports)
217
def test_32_lock_wait_succeed(self):
218
"""Succeed when trying to acquire a lock that gets released
220
One thread holds on a lock and then releases it; another
223
t = self.get_transport()
224
lf1 = LockDir(t, 'test_lock')
228
def wait_and_unlock():
231
unlocker = Thread(target=wait_and_unlock)
234
lf2 = LockDir(t, 'test_lock')
235
self.setup_log_reporter(lf2)
238
lf2.wait_lock(timeout=0.4, poll=0.1)
240
self.assertTrue(after - before <= 1.0)
244
# There should be only 1 report, even though it should have to
246
lock_base = lf2.transport.abspath(lf2.path)
247
self.assertEqual(1, len(self._logged_reports))
248
self.assertEqual('%s %s\n'
250
'Will continue to try until %s\n',
251
self._logged_reports[0][0])
252
args = self._logged_reports[0][1]
253
self.assertEqual('Unable to obtain', args[0])
254
self.assertEqual('lock %s' % (lock_base,), args[1])
255
self.assertStartsWith(args[2], 'held by ')
256
self.assertStartsWith(args[3], 'locked ')
257
self.assertEndsWith(args[3], ' ago')
258
self.assertContainsRe(args[4], r'\d\d:\d\d:\d\d')
260
def test_33_wait(self):
261
"""Succeed when waiting on a lock that gets released
263
The difference from test_32_lock_wait_succeed is that the second
264
caller does not actually acquire the lock, but just waits for it
265
to be released. This is done over a readonly transport.
267
t = self.get_transport()
268
lf1 = LockDir(t, 'test_lock')
272
def wait_and_unlock():
275
unlocker = Thread(target=wait_and_unlock)
278
lf2 = LockDir(self.get_readonly_transport(), 'test_lock')
280
# wait but don't lock
281
lf2.wait(timeout=0.4, poll=0.1)
283
self.assertTrue(after - before <= 1.0)
287
def test_34_lock_write_waits(self):
288
"""LockDir.lock_write() will wait for the lock."""
289
# the test suite sets the default to 0 to make deadlocks fail fast.
290
# change it for this test, as we want to try a manual deadlock.
291
bzrlib.lockdir._DEFAULT_TIMEOUT_SECONDS = 300
292
t = self.get_transport()
293
lf1 = LockDir(t, 'test_lock')
297
def wait_and_unlock():
300
unlocker = Thread(target=wait_and_unlock)
303
lf2 = LockDir(t, 'test_lock')
304
self.setup_log_reporter(lf2)
312
# There should be only 1 report, even though it should have to
314
lock_base = lf2.transport.abspath(lf2.path)
315
self.assertEqual(1, len(self._logged_reports))
316
self.assertEqual('%s %s\n'
318
'Will continue to try until %s\n',
319
self._logged_reports[0][0])
320
args = self._logged_reports[0][1]
321
self.assertEqual('Unable to obtain', args[0])
322
self.assertEqual('lock %s' % (lock_base,), args[1])
323
self.assertStartsWith(args[2], 'held by ')
324
self.assertStartsWith(args[3], 'locked ')
325
self.assertEndsWith(args[3], ' ago')
326
self.assertContainsRe(args[4], r'\d\d:\d\d:\d\d')
328
def test_35_wait_lock_changing(self):
329
"""LockDir.wait_lock() will report if the lock changes underneath.
331
This is the stages we want to happen:
333
0) Synchronization locks are created and locked.
334
1) Lock1 obtains the lockdir, and releases the 'check' lock.
335
2) Lock2 grabs the 'check' lock, and checks the lockdir.
336
It sees the lockdir is already acquired, reports the fact,
337
and unsets the 'checked' lock.
338
3) Thread1 blocks on acquiring the 'checked' lock, and then tells
339
Lock1 to release and acquire the lockdir. This resets the 'check'
341
4) Lock2 acquires the 'check' lock, and checks again. It notices
342
that the holder of the lock has changed, and so reports a new
344
5) Thread1 blocks on the 'checked' lock, this time, it completely
345
unlocks the lockdir, allowing Lock2 to acquire the lock.
348
wait_to_check_lock = Lock()
349
wait_until_checked_lock = Lock()
351
wait_to_check_lock.acquire()
352
wait_until_checked_lock.acquire()
353
note('locked check and checked locks')
355
class LockDir1(LockDir):
356
"""Use the synchronization points for the first lock."""
358
def attempt_lock(self):
359
# Once we have acquired the lock, it is okay for
360
# the other lock to check it
362
return super(LockDir1, self).attempt_lock()
364
note('lock1: releasing check lock')
365
wait_to_check_lock.release()
367
class LockDir2(LockDir):
368
"""Use the synchronization points for the second lock."""
370
def attempt_lock(self):
371
note('lock2: waiting for check lock')
372
wait_to_check_lock.acquire()
373
note('lock2: acquired check lock')
375
return super(LockDir2, self).attempt_lock()
377
note('lock2: releasing checked lock')
378
wait_until_checked_lock.release()
380
t = self.get_transport()
381
lf1 = LockDir1(t, 'test_lock')
384
lf2 = LockDir2(t, 'test_lock')
385
self.setup_log_reporter(lf2)
387
def wait_and_switch():
389
# Block until lock2 has had a chance to check
390
note('lock1: waiting 1 for checked lock')
391
wait_until_checked_lock.acquire()
392
note('lock1: acquired for checked lock')
393
note('lock1: released lockdir')
395
note('lock1: acquiring lockdir')
396
# Create a new nonce, so the lock looks different.
397
lf1.nonce = osutils.rand_chars(20)
399
note('lock1: acquired lockdir')
401
# Block until lock2 has peeked again
402
note('lock1: waiting 2 for checked lock')
403
wait_until_checked_lock.acquire()
404
note('lock1: acquired for checked lock')
405
# Now unlock, and let lock 2 grab the lock
407
wait_to_check_lock.release()
409
unlocker = Thread(target=wait_and_switch)
412
# Wait and play against the other thread
413
lf2.wait_lock(timeout=1.0, poll=0.01)
418
# There should be 2 reports, because the lock changed
419
lock_base = lf2.transport.abspath(lf2.path)
420
self.assertEqual(2, len(self._logged_reports))
422
self.assertEqual('%s %s\n'
424
'Will continue to try until %s\n',
425
self._logged_reports[0][0])
426
args = self._logged_reports[0][1]
427
self.assertEqual('Unable to obtain', 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
self.assertEqual('%s %s\n'
436
'Will continue to try until %s\n',
437
self._logged_reports[1][0])
438
args = self._logged_reports[1][1]
439
self.assertEqual('Lock owner changed for', args[0])
440
self.assertEqual('lock %s' % (lock_base,), args[1])
441
self.assertStartsWith(args[2], 'held by ')
442
self.assertStartsWith(args[3], 'locked ')
443
self.assertEndsWith(args[3], ' ago')
444
self.assertContainsRe(args[4], r'\d\d:\d\d:\d\d')
446
220
def test_40_confirm_easy(self):
447
221
"""Confirm a lock that's already held"""
448
222
t = self.get_transport()
449
223
lf1 = LockDir(t, 'test_lock')
451
225
lf1.attempt_lock()
226
self.addCleanup(lf1.unlock)
454
229
def test_41_confirm_not_held(self):
571
407
lf1 = LockDir(t, 'test_lock')
574
self.failUnless(t.has('test_lock'))
410
self.assertTrue(t.has('test_lock'))
576
412
t.rmdir('test_lock')
577
self.failIf(t.has('test_lock'))
413
self.assertFalse(t.has('test_lock'))
579
415
# This will create 'test_lock' if it needs to
581
self.failUnless(t.has('test_lock'))
582
self.failUnless(t.has('test_lock/held/info'))
417
self.assertTrue(t.has('test_lock'))
418
self.assertTrue(t.has('test_lock/held/info'))
585
self.failIf(t.has('test_lock/held/info'))
421
self.assertFalse(t.has('test_lock/held/info'))
587
def test__format_lock_info(self):
423
def test_display_form(self):
588
424
ld1 = self.get_lock()
592
info_list = ld1._format_lock_info(ld1.peek())
428
info_list = ld1.peek().to_readable_dict()
595
self.assertEqual('lock %s' % (ld1.transport.abspath(ld1.path),),
597
self.assertContainsRe(info_list[1],
598
r'^held by .* on host .* \[process #\d*\]$')
599
self.assertContainsRe(info_list[2], r'locked \d+ seconds? ago$')
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$')
601
435
def test_lock_without_email(self):
602
global_config = config.GlobalConfig()
436
global_config = config.GlobalStack()
603
437
# Intentionally has no email address
604
global_config.set_user_option('email', 'User Identity')
438
global_config.set('email', 'User Identity')
605
439
ld1 = self.get_lock()
610
444
def test_lock_permission(self):
445
self.requireFeature(features.not_running_as_root)
611
446
if not osutils.supports_posix_readonly():
612
447
raise tests.TestSkipped('Cannot induce a permission failure')
613
448
ld1 = self.get_lock()
614
449
lock_path = ld1.transport.local_abspath('test_lock')
615
450
os.mkdir(lock_path)
616
451
osutils.make_readonly(lock_path)
617
self.assertRaises(errors.PermissionDenied, ld1.attempt_lock)
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
