187
164
after = time.time()
188
165
# it should only take about 0.4 seconds, but we allow more time in
189
166
# case the machine is heavily loaded
190
self.assertTrue(after - before <= 8.0,
167
self.assertTrue(after - before <= 8.0,
191
168
"took %f seconds to detect lock contention" % (after - before))
194
self.assertEqual(1, len(self._logged_reports))
195
self.assertEqual(self._logged_reports[0][0],
196
'%s lock %s held by %s\n'
197
'at %s [process #%s], acquired %s.\n'
198
'Will continue to try until %s, unless '
199
'you press Ctrl-C.\n'
200
'See "bzr help break-lock" for more.')
201
start, lock_url, user, hostname, pid, time_ago, deadline_str = \
202
self._logged_reports[0][1]
203
self.assertEqual(start, u'Unable to obtain')
204
self.assertEqual(user, u'jrandom@example.com')
206
self.assertContainsRe(pid, r'\d+')
207
self.assertContainsRe(time_ago, r'.* ago')
208
self.assertContainsRe(deadline_str, r'\d{2}:\d{2}:\d{2}')
210
172
def test_31_lock_wait_easy(self):
211
173
"""Succeed when waiting on a lock with no contention.
263
# There should be only 1 report, even though it should have to
265
lock_base = lf2.transport.abspath(lf2.path)
266
self.assertEqual(1, len(self._logged_reports))
267
self.assertEqual('%s %s\n'
269
'Will continue to try until %s\n',
270
self._logged_reports[0][0])
271
args = self._logged_reports[0][1]
272
self.assertEqual('Unable to obtain', args[0])
273
self.assertEqual('lock %s' % (lock_base,), args[1])
274
self.assertStartsWith(args[2], 'held by ')
275
self.assertStartsWith(args[3], 'locked ')
276
self.assertEndsWith(args[3], ' ago')
277
self.assertContainsRe(args[4], r'\d\d:\d\d:\d\d')
212
def test_33_wait(self):
213
"""Succeed when waiting on a lock that gets released
279
def test_34_lock_write_waits(self):
280
"""LockDir.lock_write() will wait for the lock."""
281
# the test suite sets the default to 0 to make deadlocks fail fast.
282
# change it for this test, as we want to try a manual deadlock.
283
raise tests.TestSkipped('Timing-sensitive test')
284
bzrlib.lockdir._DEFAULT_TIMEOUT_SECONDS = 300
215
The difference from test_32_lock_wait_succeed is that the second
216
caller does not actually acquire the lock, but just waits for it
217
to be released. This is done over a readonly transport.
285
219
t = self.get_transport()
286
220
lf1 = LockDir(t, 'test_lock')
293
227
unlocker = Thread(target=wait_and_unlock)
296
lf2 = LockDir(t, 'test_lock')
297
self.setup_log_reporter(lf2)
230
lf2 = LockDir(self.get_readonly_transport(), 'test_lock')
298
231
before = time.time()
232
# wait but don't lock
233
lf2.wait(timeout=0.4, poll=0.1)
301
234
after = time.time()
305
# There should be only 1 report, even though it should have to
307
lock_base = lf2.transport.abspath(lf2.path)
308
self.assertEqual(1, len(self._logged_reports))
309
self.assertEqual('%s %s\n'
311
'Will continue to try until %s\n',
312
self._logged_reports[0][0])
313
args = self._logged_reports[0][1]
314
self.assertEqual('Unable to obtain', args[0])
315
self.assertEqual('lock %s' % (lock_base,), args[1])
316
self.assertStartsWith(args[2], 'held by ')
317
self.assertStartsWith(args[3], 'locked ')
318
self.assertEndsWith(args[3], ' ago')
319
self.assertContainsRe(args[4], r'\d\d:\d\d:\d\d')
321
def test_35_wait_lock_changing(self):
322
"""LockDir.wait_lock() will report if the lock changes underneath.
324
This is the stages we want to happen:
326
0) Synchronization locks are created and locked.
327
1) Lock1 obtains the lockdir, and releases the 'check' lock.
328
2) Lock2 grabs the 'check' lock, and checks the lockdir.
329
It sees the lockdir is already acquired, reports the fact,
330
and unsets the 'checked' lock.
331
3) Thread1 blocks on acquiring the 'checked' lock, and then tells
332
Lock1 to release and acquire the lockdir. This resets the 'check'
334
4) Lock2 acquires the 'check' lock, and checks again. It notices
335
that the holder of the lock has changed, and so reports a new
337
5) Thread1 blocks on the 'checked' lock, this time, it completely
338
unlocks the lockdir, allowing Lock2 to acquire the lock.
341
raise tests.KnownFailure(
342
"timing dependency in lock tests (#213182)")
344
wait_to_check_lock = Lock()
345
wait_until_checked_lock = Lock()
347
wait_to_check_lock.acquire()
348
wait_until_checked_lock.acquire()
349
note('locked check and checked locks')
351
class LockDir1(LockDir):
352
"""Use the synchronization points for the first lock."""
354
def attempt_lock(self):
355
# Once we have acquired the lock, it is okay for
356
# the other lock to check it
358
return super(LockDir1, self).attempt_lock()
360
note('lock1: releasing check lock')
361
wait_to_check_lock.release()
363
class LockDir2(LockDir):
364
"""Use the synchronization points for the second lock."""
366
def attempt_lock(self):
367
note('lock2: waiting for check lock')
368
wait_to_check_lock.acquire()
369
note('lock2: acquired check lock')
371
return super(LockDir2, self).attempt_lock()
373
note('lock2: releasing checked lock')
374
wait_until_checked_lock.release()
376
t = self.get_transport()
377
lf1 = LockDir1(t, 'test_lock')
380
lf2 = LockDir2(t, 'test_lock')
381
self.setup_log_reporter(lf2)
383
def wait_and_switch():
385
# Block until lock2 has had a chance to check
386
note('lock1: waiting 1 for checked lock')
387
wait_until_checked_lock.acquire()
388
note('lock1: acquired for checked lock')
389
note('lock1: released lockdir')
391
note('lock1: acquiring lockdir')
392
# Create a new nonce, so the lock looks different.
393
lf1.nonce = osutils.rand_chars(20)
395
note('lock1: acquired lockdir')
397
# Block until lock2 has peeked again
398
note('lock1: waiting 2 for checked lock')
399
wait_until_checked_lock.acquire()
400
note('lock1: acquired for checked lock')
401
# Now unlock, and let lock 2 grab the lock
403
wait_to_check_lock.release()
405
unlocker = Thread(target=wait_and_switch)
408
# Wait and play against the other thread
409
lf2.wait_lock(timeout=20.0, poll=0.01)
414
# There should be 2 reports, because the lock changed
415
lock_base = lf2.transport.abspath(lf2.path)
416
self.assertEqual(2, len(self._logged_reports))
417
lock_url = lf2.transport.abspath(lf2.path)
418
self.assertEqual('%s %s\n'
420
'Will continue to try until %s, unless '
421
'you press Ctrl-C.\n'
422
'See "bzr help break-lock" for more.',
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 '
435
'you press Ctrl-C.\n'
436
'See "bzr help break-lock" for more.',
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')
235
self.assertTrue(after - before <= 1.0)
446
239
def test_40_confirm_easy(self):
447
240
"""Confirm a lock that's already held"""
557
344
# do this without IO redirection to ensure it doesn't prompt.
558
345
self.assertRaises(AssertionError, ld1.break_lock)
559
346
orig_factory = bzrlib.ui.ui_factory
560
bzrlib.ui.ui_factory = bzrlib.ui.CannedInputUIFactory([True])
347
# silent ui - no need for stdout
348
bzrlib.ui.ui_factory = bzrlib.ui.SilentUIFactory()
349
bzrlib.ui.ui_factory.stdin = StringIO("y\n")
563
352
self.assertRaises(LockBroken, ld1.unlock)
565
354
bzrlib.ui.ui_factory = orig_factory
567
def test_create_missing_base_directory(self):
568
"""If LockDir.path doesn't exist, it can be created
570
Some people manually remove the entire lock/ directory trying
571
to unlock a stuck repository/branch/etc. Rather than failing
572
after that, just create the lock directory when needed.
574
t = self.get_transport()
575
lf1 = LockDir(t, 'test_lock')
578
self.failUnless(t.has('test_lock'))
581
self.failIf(t.has('test_lock'))
583
# This will create 'test_lock' if it needs to
585
self.failUnless(t.has('test_lock'))
586
self.failUnless(t.has('test_lock/held/info'))
589
self.failIf(t.has('test_lock/held/info'))
591
def test__format_lock_info(self):
592
ld1 = self.get_lock()
596
info_list = ld1._format_lock_info(ld1.peek())
599
self.assertEqual(info_list[0], u'jrandom@example.com')
600
# info_list[1] is hostname. we skip this.
601
self.assertContainsRe(info_list[2], '^\d+$') # pid
602
self.assertContainsRe(info_list[3], r'^\d+ seconds? ago$') # time_ago
604
def test_lock_without_email(self):
605
global_config = config.GlobalConfig()
606
# Intentionally has no email address
607
global_config.set_user_option('email', 'User Identity')
608
ld1 = self.get_lock()
613
def test_lock_permission(self):
614
if not osutils.supports_posix_readonly():
615
raise tests.TestSkipped('Cannot induce a permission failure')
616
ld1 = self.get_lock()
617
lock_path = ld1.transport.local_abspath('test_lock')
619
osutils.make_readonly(lock_path)
620
self.assertRaises(errors.LockFailed, ld1.attempt_lock)
622
def test_lock_by_token(self):
623
ld1 = self.get_lock()
624
token = ld1.lock_write()
625
self.addCleanup(ld1.unlock)
626
self.assertNotEqual(None, token)
627
ld2 = self.get_lock()
628
t2 = ld2.lock_write(token)
629
self.addCleanup(ld2.unlock)
630
self.assertEqual(token, t2)
632
def test_lock_with_buggy_rename(self):
633
# test that lock acquisition handles servers which pretend they
634
# renamed correctly but that actually fail
635
t = transport.get_transport('brokenrename+' + self.get_url())
636
ld1 = LockDir(t, 'test_lock')
639
ld2 = LockDir(t, 'test_lock')
640
# we should fail to lock
641
e = self.assertRaises(errors.LockContention, ld2.attempt_lock)
642
# now the original caller should succeed in unlocking
644
# and there should be nothing left over
645
self.assertEquals([], t.list_dir('test_lock'))
647
def test_failed_lock_leaves_no_trash(self):
648
# if we fail to acquire the lock, we don't leave pending directories
649
# behind -- https://bugs.launchpad.net/bzr/+bug/109169
650
ld1 = self.get_lock()
651
ld2 = self.get_lock()
652
# should be nothing before we start
654
t = self.get_transport().clone('test_lock')
656
self.assertEquals(a, t.list_dir('.'))
658
# when held, that's all we see
660
self.addCleanup(ld1.unlock)
662
# second guy should fail
663
self.assertRaises(errors.LockContention, ld2.attempt_lock)
667
def test_no_lockdir_info(self):
668
"""We can cope with empty info files."""
669
# This seems like a fairly common failure case - see
670
# <https://bugs.launchpad.net/bzr/+bug/185103> and all its dupes.
671
# Processes are often interrupted after opening the file
672
# before the actual contents are committed.
673
t = self.get_transport()
675
t.mkdir('test_lock/held')
676
t.put_bytes('test_lock/held/info', '')
677
lf = LockDir(t, 'test_lock')
679
formatted_info = lf._format_lock_info(info)
681
['<unknown>', '<unknown>', '<unknown>', '(unknown)'],
685
class TestLockDirHooks(TestCaseWithTransport):
688
super(TestLockDirHooks, self).setUp()
692
return LockDir(self.get_transport(), 'test_lock')
694
def record_hook(self, result):
695
self._calls.append(result)
697
def test_LockDir_acquired_success(self):
698
# the LockDir.lock_acquired hook fires when a lock is acquired.
699
LockDir.hooks.install_named_hook('lock_acquired',
700
self.record_hook, 'record_hook')
703
self.assertEqual([], self._calls)
704
result = ld.attempt_lock()
705
lock_path = ld.transport.abspath(ld.path)
706
self.assertEqual([lock.LockResult(lock_path, result)], self._calls)
708
self.assertEqual([lock.LockResult(lock_path, result)], self._calls)
710
def test_LockDir_acquired_fail(self):
711
# the LockDir.lock_acquired hook does not fire on failure.
714
ld2 = self.get_lock()
716
# install a lock hook now, when the disk lock is locked
717
LockDir.hooks.install_named_hook('lock_acquired',
718
self.record_hook, 'record_hook')
719
self.assertRaises(errors.LockContention, ld.attempt_lock)
720
self.assertEqual([], self._calls)
722
self.assertEqual([], self._calls)
724
def test_LockDir_released_success(self):
725
# the LockDir.lock_released hook fires when a lock is acquired.
726
LockDir.hooks.install_named_hook('lock_released',
727
self.record_hook, 'record_hook')
730
self.assertEqual([], self._calls)
731
result = ld.attempt_lock()
732
self.assertEqual([], self._calls)
734
lock_path = ld.transport.abspath(ld.path)
735
self.assertEqual([lock.LockResult(lock_path, result)], self._calls)
737
def test_LockDir_released_fail(self):
738
# the LockDir.lock_released hook does not fire on failure.
741
ld2 = self.get_lock()
743
ld2.force_break(ld2.peek())
744
LockDir.hooks.install_named_hook('lock_released',
745
self.record_hook, 'record_hook')
746
self.assertRaises(LockBroken, ld.unlock)
747
self.assertEqual([], self._calls)
749
def test_LockDir_broken_success(self):
750
# the LockDir.lock_broken hook fires when a lock is broken.
753
ld2 = self.get_lock()
754
result = ld.attempt_lock()
755
LockDir.hooks.install_named_hook('lock_broken',
756
self.record_hook, 'record_hook')
757
ld2.force_break(ld2.peek())
758
lock_path = ld.transport.abspath(ld.path)
759
self.assertEqual([lock.LockResult(lock_path, result)], self._calls)
761
def test_LockDir_broken_failure(self):
762
# the LockDir.lock_broken hook does not fires when a lock is already
766
ld2 = self.get_lock()
767
result = ld.attempt_lock()
768
holder_info = ld2.peek()
770
LockDir.hooks.install_named_hook('lock_broken',
771
self.record_hook, 'record_hook')
772
ld2.force_break(holder_info)
773
lock_path = ld.transport.abspath(ld.path)
774
self.assertEqual([], self._calls)
added
removed
bzrlib/tests/test_lockdir.py
