1
# Copyright (C) 2006, 2007, 2008 Canonical Ltd
1
# Copyright (C) 2006 Canonical Ltd
3
3
# This program is free software; you can redistribute it and/or modify
4
4
# it under the terms of the GNU General Public License as published by
5
5
# the Free Software Foundation; either version 2 of the License, or
6
6
# (at your option) any later version.
8
8
# This program is distributed in the hope that it will be useful,
9
9
# but WITHOUT ANY WARRANTY; without even the implied warranty of
10
10
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
11
11
# GNU General Public License for more details.
13
13
# You should have received a copy of the GNU General Public License
14
14
# along with this program; if not, write to the Free Software
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
17
17
"""Tests for LockDir"""
19
19
from cStringIO import StringIO
21
from threading import Thread, Lock
20
from threading import Thread
33
24
from bzrlib.errors import (
26
LockContention, LockError, UnlockableTransport,
27
LockNotHeld, LockBroken
41
29
from bzrlib.lockdir import LockDir
42
30
from bzrlib.tests import TestCaseWithTransport
43
from bzrlib.trace import note
45
32
# These tests sometimes use threads to test the behaviour of lock files with
46
33
# concurrent actors. This is not a typical (or necessarily supported) use;
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
lock_base = lf2.transport.abspath(lf2.path)
195
self.assertEqual(1, len(self._logged_reports))
196
lock_url = lf2.transport.abspath(lf2.path)
197
self.assertEqual('%s %s\n'
199
'Will continue to try until %s, unless '
201
'If you\'re sure that it\'s not being '
202
'modified, use bzr break-lock %s',
203
self._logged_reports[0][0])
204
args = self._logged_reports[0][1]
205
self.assertEqual('Unable to obtain', args[0])
206
self.assertEqual('lock %s' % (lock_base,), args[1])
207
self.assertStartsWith(args[2], 'held by ')
208
self.assertStartsWith(args[3], 'locked ')
209
self.assertEndsWith(args[3], ' ago')
210
self.assertContainsRe(args[4], r'\d\d:\d\d:\d\d')
212
172
def test_31_lock_wait_easy(self):
213
173
"""Succeed when waiting on a lock with no contention.
265
# There should be only 1 report, even though it should have to
267
lock_base = lf2.transport.abspath(lf2.path)
268
self.assertEqual(1, len(self._logged_reports))
269
self.assertEqual('%s %s\n'
271
'Will continue to try until %s\n',
272
self._logged_reports[0][0])
273
args = self._logged_reports[0][1]
274
self.assertEqual('Unable to obtain', args[0])
275
self.assertEqual('lock %s' % (lock_base,), args[1])
276
self.assertStartsWith(args[2], 'held by ')
277
self.assertStartsWith(args[3], 'locked ')
278
self.assertEndsWith(args[3], ' ago')
279
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
281
def test_34_lock_write_waits(self):
282
"""LockDir.lock_write() will wait for the lock."""
283
# the test suite sets the default to 0 to make deadlocks fail fast.
284
# change it for this test, as we want to try a manual deadlock.
285
raise tests.TestSkipped('Timing-sensitive test')
286
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.
287
219
t = self.get_transport()
288
220
lf1 = LockDir(t, 'test_lock')
295
227
unlocker = Thread(target=wait_and_unlock)
298
lf2 = LockDir(t, 'test_lock')
299
self.setup_log_reporter(lf2)
230
lf2 = LockDir(self.get_readonly_transport(), 'test_lock')
300
231
before = time.time()
232
# wait but don't lock
233
lf2.wait(timeout=0.4, poll=0.1)
303
234
after = time.time()
307
# There should be only 1 report, even though it should have to
309
lock_base = lf2.transport.abspath(lf2.path)
310
self.assertEqual(1, len(self._logged_reports))
311
self.assertEqual('%s %s\n'
313
'Will continue to try until %s\n',
314
self._logged_reports[0][0])
315
args = self._logged_reports[0][1]
316
self.assertEqual('Unable to obtain', args[0])
317
self.assertEqual('lock %s' % (lock_base,), args[1])
318
self.assertStartsWith(args[2], 'held by ')
319
self.assertStartsWith(args[3], 'locked ')
320
self.assertEndsWith(args[3], ' ago')
321
self.assertContainsRe(args[4], r'\d\d:\d\d:\d\d')
323
def test_35_wait_lock_changing(self):
324
"""LockDir.wait_lock() will report if the lock changes underneath.
326
This is the stages we want to happen:
328
0) Synchronization locks are created and locked.
329
1) Lock1 obtains the lockdir, and releases the 'check' lock.
330
2) Lock2 grabs the 'check' lock, and checks the lockdir.
331
It sees the lockdir is already acquired, reports the fact,
332
and unsets the 'checked' lock.
333
3) Thread1 blocks on acquiring the 'checked' lock, and then tells
334
Lock1 to release and acquire the lockdir. This resets the 'check'
336
4) Lock2 acquires the 'check' lock, and checks again. It notices
337
that the holder of the lock has changed, and so reports a new
339
5) Thread1 blocks on the 'checked' lock, this time, it completely
340
unlocks the lockdir, allowing Lock2 to acquire the lock.
343
raise tests.KnownFailure(
344
"timing dependency in lock tests (#213182)")
346
wait_to_check_lock = Lock()
347
wait_until_checked_lock = Lock()
349
wait_to_check_lock.acquire()
350
wait_until_checked_lock.acquire()
351
note('locked check and checked locks')
353
class LockDir1(LockDir):
354
"""Use the synchronization points for the first lock."""
356
def attempt_lock(self):
357
# Once we have acquired the lock, it is okay for
358
# the other lock to check it
360
return super(LockDir1, self).attempt_lock()
362
note('lock1: releasing check lock')
363
wait_to_check_lock.release()
365
class LockDir2(LockDir):
366
"""Use the synchronization points for the second lock."""
368
def attempt_lock(self):
369
note('lock2: waiting for check lock')
370
wait_to_check_lock.acquire()
371
note('lock2: acquired check lock')
373
return super(LockDir2, self).attempt_lock()
375
note('lock2: releasing checked lock')
376
wait_until_checked_lock.release()
378
t = self.get_transport()
379
lf1 = LockDir1(t, 'test_lock')
382
lf2 = LockDir2(t, 'test_lock')
383
self.setup_log_reporter(lf2)
385
def wait_and_switch():
387
# Block until lock2 has had a chance to check
388
note('lock1: waiting 1 for checked lock')
389
wait_until_checked_lock.acquire()
390
note('lock1: acquired for checked lock')
391
note('lock1: released lockdir')
393
note('lock1: acquiring lockdir')
394
# Create a new nonce, so the lock looks different.
395
lf1.nonce = osutils.rand_chars(20)
397
note('lock1: acquired lockdir')
399
# Block until lock2 has peeked again
400
note('lock1: waiting 2 for checked lock')
401
wait_until_checked_lock.acquire()
402
note('lock1: acquired for checked lock')
403
# Now unlock, and let lock 2 grab the lock
405
wait_to_check_lock.release()
407
unlocker = Thread(target=wait_and_switch)
410
# Wait and play against the other thread
411
lf2.wait_lock(timeout=20.0, poll=0.01)
416
# There should be 2 reports, because the lock changed
417
lock_base = lf2.transport.abspath(lf2.path)
418
self.assertEqual(2, len(self._logged_reports))
419
lock_url = lf2.transport.abspath(lf2.path)
420
self.assertEqual('%s %s\n'
422
'Will continue to try until %s, unless '
424
'If you\'re sure that it\'s not being '
425
'modified, use bzr break-lock %s',
426
self._logged_reports[0][0])
427
args = self._logged_reports[0][1]
428
self.assertEqual('Unable to obtain', args[0])
429
self.assertEqual('lock %s' % (lock_base,), args[1])
430
self.assertStartsWith(args[2], 'held by ')
431
self.assertStartsWith(args[3], 'locked ')
432
self.assertEndsWith(args[3], ' ago')
433
self.assertContainsRe(args[4], r'\d\d:\d\d:\d\d')
435
self.assertEqual('%s %s\n'
437
'Will continue to try until %s, unless '
439
'If you\'re sure that it\'s not being '
440
'modified, use bzr break-lock %s',
441
self._logged_reports[1][0])
442
args = self._logged_reports[1][1]
443
self.assertEqual('Lock owner changed for', args[0])
444
self.assertEqual('lock %s' % (lock_base,), args[1])
445
self.assertStartsWith(args[2], 'held by ')
446
self.assertStartsWith(args[3], 'locked ')
447
self.assertEndsWith(args[3], ' ago')
448
self.assertContainsRe(args[4], r'\d\d:\d\d:\d\d')
235
self.assertTrue(after - before <= 1.0)
450
239
def test_40_confirm_easy(self):
451
240
"""Confirm a lock that's already held"""
561
344
# do this without IO redirection to ensure it doesn't prompt.
562
345
self.assertRaises(AssertionError, ld1.break_lock)
563
346
orig_factory = bzrlib.ui.ui_factory
564
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")
567
352
self.assertRaises(LockBroken, ld1.unlock)
569
354
bzrlib.ui.ui_factory = orig_factory
571
def test_create_missing_base_directory(self):
572
"""If LockDir.path doesn't exist, it can be created
574
Some people manually remove the entire lock/ directory trying
575
to unlock a stuck repository/branch/etc. Rather than failing
576
after that, just create the lock directory when needed.
578
t = self.get_transport()
579
lf1 = LockDir(t, 'test_lock')
582
self.failUnless(t.has('test_lock'))
585
self.failIf(t.has('test_lock'))
587
# This will create 'test_lock' if it needs to
589
self.failUnless(t.has('test_lock'))
590
self.failUnless(t.has('test_lock/held/info'))
593
self.failIf(t.has('test_lock/held/info'))
595
def test__format_lock_info(self):
596
ld1 = self.get_lock()
600
info_list = ld1._format_lock_info(ld1.peek())
603
self.assertEqual('lock %s' % (ld1.transport.abspath(ld1.path),),
605
self.assertContainsRe(info_list[1],
606
r'^held by .* on host .* \[process #\d*\]$')
607
self.assertContainsRe(info_list[2], r'locked \d+ seconds? ago$')
609
def test_lock_without_email(self):
610
global_config = config.GlobalConfig()
611
# Intentionally has no email address
612
global_config.set_user_option('email', 'User Identity')
613
ld1 = self.get_lock()
618
def test_lock_permission(self):
619
if not osutils.supports_posix_readonly():
620
raise tests.TestSkipped('Cannot induce a permission failure')
621
ld1 = self.get_lock()
622
lock_path = ld1.transport.local_abspath('test_lock')
624
osutils.make_readonly(lock_path)
625
self.assertRaises(errors.LockFailed, ld1.attempt_lock)
627
def test_lock_by_token(self):
628
ld1 = self.get_lock()
629
token = ld1.lock_write()
630
self.addCleanup(ld1.unlock)
631
self.assertNotEqual(None, token)
632
ld2 = self.get_lock()
633
t2 = ld2.lock_write(token)
634
self.addCleanup(ld2.unlock)
635
self.assertEqual(token, t2)
637
def test_lock_with_buggy_rename(self):
638
# test that lock acquisition handles servers which pretend they
639
# renamed correctly but that actually fail
640
t = transport.get_transport('brokenrename+' + self.get_url())
641
ld1 = LockDir(t, 'test_lock')
644
ld2 = LockDir(t, 'test_lock')
645
# we should fail to lock
646
e = self.assertRaises(errors.LockContention, ld2.attempt_lock)
647
# now the original caller should succeed in unlocking
649
# and there should be nothing left over
650
self.assertEquals([], t.list_dir('test_lock'))
652
def test_failed_lock_leaves_no_trash(self):
653
# if we fail to acquire the lock, we don't leave pending directories
654
# behind -- https://bugs.launchpad.net/bzr/+bug/109169
655
ld1 = self.get_lock()
656
ld2 = self.get_lock()
657
# should be nothing before we start
659
t = self.get_transport().clone('test_lock')
661
self.assertEquals(a, t.list_dir('.'))
663
# when held, that's all we see
665
self.addCleanup(ld1.unlock)
667
# second guy should fail
668
self.assertRaises(errors.LockContention, ld2.attempt_lock)
673
class TestLockDirHooks(TestCaseWithTransport):
676
super(TestLockDirHooks, self).setUp()
680
return LockDir(self.get_transport(), 'test_lock')
682
def record_hook(self, result):
683
self._calls.append(result)
685
def test_LockDir_acquired_success(self):
686
# the LockDir.lock_acquired hook fires when a lock is acquired.
687
LockDir.hooks.install_named_hook('lock_acquired',
688
self.record_hook, 'record_hook')
691
self.assertEqual([], self._calls)
692
result = ld.attempt_lock()
693
lock_path = ld.transport.abspath(ld.path)
694
self.assertEqual([lock.LockResult(lock_path, result)], self._calls)
696
self.assertEqual([lock.LockResult(lock_path, result)], self._calls)
698
def test_LockDir_acquired_fail(self):
699
# the LockDir.lock_acquired hook does not fire on failure.
702
ld2 = self.get_lock()
704
# install a lock hook now, when the disk lock is locked
705
LockDir.hooks.install_named_hook('lock_acquired',
706
self.record_hook, 'record_hook')
707
self.assertRaises(errors.LockContention, ld.attempt_lock)
708
self.assertEqual([], self._calls)
710
self.assertEqual([], self._calls)
712
def test_LockDir_released_success(self):
713
# the LockDir.lock_released hook fires when a lock is acquired.
714
LockDir.hooks.install_named_hook('lock_released',
715
self.record_hook, 'record_hook')
718
self.assertEqual([], self._calls)
719
result = ld.attempt_lock()
720
self.assertEqual([], self._calls)
722
lock_path = ld.transport.abspath(ld.path)
723
self.assertEqual([lock.LockResult(lock_path, result)], self._calls)
725
def test_LockDir_released_fail(self):
726
# the LockDir.lock_released hook does not fire on failure.
729
ld2 = self.get_lock()
731
ld2.force_break(ld2.peek())
732
LockDir.hooks.install_named_hook('lock_released',
733
self.record_hook, 'record_hook')
734
self.assertRaises(LockBroken, ld.unlock)
735
self.assertEqual([], self._calls)
737
def test_LockDir_broken_success(self):
738
# the LockDir.lock_broken hook fires when a lock is broken.
741
ld2 = self.get_lock()
742
result = ld.attempt_lock()
743
LockDir.hooks.install_named_hook('lock_broken',
744
self.record_hook, 'record_hook')
745
ld2.force_break(ld2.peek())
746
lock_path = ld.transport.abspath(ld.path)
747
self.assertEqual([lock.LockResult(lock_path, result)], self._calls)
749
def test_LockDir_broken_failure(self):
750
# the LockDir.lock_broken hook does not fires when a lock is already
754
ld2 = self.get_lock()
755
result = ld.attempt_lock()
756
holder_info = ld2.peek()
758
LockDir.hooks.install_named_hook('lock_broken',
759
self.record_hook, 'record_hook')
760
ld2.force_break(holder_info)
761
lock_path = ld.transport.abspath(ld.path)
762
self.assertEqual([], self._calls)
added
removed
bzrlib/tests/test_lockdir.py
