168
189
"took %f seconds to detect lock contention" % (after - before))
192
lock_base = lf2.transport.abspath(lf2.path)
193
self.assertEqual(1, len(self._logged_reports))
194
lock_url = lf2.transport.abspath(lf2.path)
195
self.assertEqual('%s %s\n'
197
'Will continue to try until %s, unless '
199
'If you\'re sure that it\'s not being '
200
'modified, use bzr break-lock %s',
201
self._logged_reports[0][0])
202
args = self._logged_reports[0][1]
203
self.assertEqual('Unable to obtain', args[0])
204
self.assertEqual('lock %s' % (lock_base,), args[1])
205
self.assertStartsWith(args[2], 'held by ')
206
self.assertStartsWith(args[3], 'locked ')
207
self.assertEndsWith(args[3], ' ago')
208
self.assertContainsRe(args[4], r'\d\d:\d\d:\d\d')
172
210
def test_31_lock_wait_easy(self):
173
211
"""Succeed when waiting on a lock with no contention.
212
def test_33_wait(self):
213
"""Succeed when waiting on a lock that gets released
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')
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.
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
219
285
t = self.get_transport()
220
286
lf1 = LockDir(t, 'test_lock')
227
293
unlocker = Thread(target=wait_and_unlock)
230
lf2 = LockDir(self.get_readonly_transport(), 'test_lock')
296
lf2 = LockDir(t, 'test_lock')
297
self.setup_log_reporter(lf2)
231
298
before = time.time()
232
# wait but don't lock
233
lf2.wait(timeout=0.4, poll=0.1)
234
301
after = time.time()
235
self.assertTrue(after - before <= 1.0)
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 '
422
'If you\'re sure that it\'s not being '
423
'modified, use bzr break-lock %s',
424
self._logged_reports[0][0])
425
args = self._logged_reports[0][1]
426
self.assertEqual('Unable to obtain', args[0])
427
self.assertEqual('lock %s' % (lock_base,), args[1])
428
self.assertStartsWith(args[2], 'held by ')
429
self.assertStartsWith(args[3], 'locked ')
430
self.assertEndsWith(args[3], ' ago')
431
self.assertContainsRe(args[4], r'\d\d:\d\d:\d\d')
433
self.assertEqual('%s %s\n'
435
'Will continue to try until %s, unless '
437
'If you\'re sure that it\'s not being '
438
'modified, use bzr break-lock %s',
439
self._logged_reports[1][0])
440
args = self._logged_reports[1][1]
441
self.assertEqual('Lock owner changed for', args[0])
442
self.assertEqual('lock %s' % (lock_base,), args[1])
443
self.assertStartsWith(args[2], 'held by ')
444
self.assertStartsWith(args[3], 'locked ')
445
self.assertEndsWith(args[3], ' ago')
446
self.assertContainsRe(args[4], r'\d\d:\d\d:\d\d')
239
448
def test_40_confirm_easy(self):
240
449
"""Confirm a lock that's already held"""
352
561
self.assertRaises(LockBroken, ld1.unlock)
354
563
bzrlib.ui.ui_factory = orig_factory
565
def test_create_missing_base_directory(self):
566
"""If LockDir.path doesn't exist, it can be created
568
Some people manually remove the entire lock/ directory trying
569
to unlock a stuck repository/branch/etc. Rather than failing
570
after that, just create the lock directory when needed.
572
t = self.get_transport()
573
lf1 = LockDir(t, 'test_lock')
576
self.failUnless(t.has('test_lock'))
579
self.failIf(t.has('test_lock'))
581
# This will create 'test_lock' if it needs to
583
self.failUnless(t.has('test_lock'))
584
self.failUnless(t.has('test_lock/held/info'))
587
self.failIf(t.has('test_lock/held/info'))
589
def test__format_lock_info(self):
590
ld1 = self.get_lock()
594
info_list = ld1._format_lock_info(ld1.peek())
597
self.assertEqual('lock %s' % (ld1.transport.abspath(ld1.path),),
599
self.assertContainsRe(info_list[1],
600
r'^held by .* on host .* \[process #\d*\]$')
601
self.assertContainsRe(info_list[2], r'locked \d+ seconds? ago$')
603
def test_lock_without_email(self):
604
global_config = config.GlobalConfig()
605
# Intentionally has no email address
606
global_config.set_user_option('email', 'User Identity')
607
ld1 = self.get_lock()
612
def test_lock_permission(self):
613
if not osutils.supports_posix_readonly():
614
raise tests.TestSkipped('Cannot induce a permission failure')
615
ld1 = self.get_lock()
616
lock_path = ld1.transport.local_abspath('test_lock')
618
osutils.make_readonly(lock_path)
619
self.assertRaises(errors.LockFailed, ld1.attempt_lock)
621
def test_lock_by_token(self):
622
ld1 = self.get_lock()
623
token = ld1.lock_write()
624
self.assertNotEqual(None, token)
625
ld2 = self.get_lock()
626
t2 = ld2.lock_write(token)
627
self.assertEqual(token, t2)
629
def test_lock_with_buggy_rename(self):
630
# test that lock acquisition handles servers which pretend they
631
# renamed correctly but that actually fail
632
t = transport.get_transport('brokenrename+' + self.get_url())
633
ld1 = LockDir(t, 'test_lock')
636
ld2 = LockDir(t, 'test_lock')
637
# we should fail to lock
638
e = self.assertRaises(errors.LockContention, ld2.attempt_lock)
639
# now the original caller should succeed in unlocking
641
# and there should be nothing left over
642
self.assertEquals([], t.list_dir('test_lock'))
644
def test_failed_lock_leaves_no_trash(self):
645
# if we fail to acquire the lock, we don't leave pending directories
646
# behind -- https://bugs.launchpad.net/bzr/+bug/109169
647
ld1 = self.get_lock()
648
ld2 = self.get_lock()
649
# should be nothing before we start
651
t = self.get_transport().clone('test_lock')
653
self.assertEquals(a, t.list_dir('.'))
655
# when held, that's all we see
658
# second guy should fail
659
self.assertRaises(errors.LockContention, ld2.attempt_lock)
663
def record_hook(self, result):
664
self._calls.append(result)
666
def reset_hooks(self):
667
self._old_hooks = lock.Lock.hooks
668
self.addCleanup(self.restore_hooks)
669
lock.Lock.hooks = lock.LockHooks()
671
def restore_hooks(self):
672
lock.Lock.hooks = self._old_hooks
674
def test_LockDir_acquired_success(self):
675
# the LockDir.lock_acquired hook fires when a lock is acquired.
678
LockDir.hooks.install_named_hook('lock_acquired',
679
self.record_hook, 'record_hook')
682
self.assertEqual([], self._calls)
683
result = ld.attempt_lock()
684
lock_path = ld.transport.abspath(ld.path)
685
self.assertEqual([lock.LockResult(lock_path, result)], self._calls)
687
self.assertEqual([lock.LockResult(lock_path, result)], self._calls)
689
def test_LockDir_acquired_fail(self):
690
# the LockDir.lock_acquired hook does not fire on failure.
695
ld2 = self.get_lock()
697
# install a lock hook now, when the disk lock is locked
698
LockDir.hooks.install_named_hook('lock_acquired',
699
self.record_hook, 'record_hook')
700
self.assertRaises(errors.LockContention, ld.attempt_lock)
701
self.assertEqual([], self._calls)
703
self.assertEqual([], self._calls)
705
def test_LockDir_released_success(self):
706
# the LockDir.lock_released hook fires when a lock is acquired.
709
LockDir.hooks.install_named_hook('lock_released',
710
self.record_hook, 'record_hook')
713
self.assertEqual([], self._calls)
714
result = ld.attempt_lock()
715
self.assertEqual([], self._calls)
717
lock_path = ld.transport.abspath(ld.path)
718
self.assertEqual([lock.LockResult(lock_path, result)], self._calls)
720
def test_LockDir_released_fail(self):
721
# the LockDir.lock_released hook does not fire on failure.
726
ld2 = self.get_lock()
728
ld2.force_break(ld2.peek())
729
LockDir.hooks.install_named_hook('lock_released',
730
self.record_hook, 'record_hook')
731
self.assertRaises(LockBroken, ld.unlock)
732
self.assertEqual([], self._calls)