1
# Copyright (C) 2006 Canonical Ltd
1
# Copyright (C) 2006, 2007 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
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
17
17
"""Tests for LockDir"""
19
from threading import Thread
19
from cStringIO import StringIO
21
from threading import Thread, Lock
22
32
from bzrlib.errors import (
24
LockContention, LockError, UnlockableTransport,
25
LockNotHeld, LockBroken
27
40
from bzrlib.lockdir import LockDir
28
41
from bzrlib.tests import TestCaseWithTransport
42
from bzrlib.trace import note
30
44
# These tests sometimes use threads to test the behaviour of lock files with
31
45
# concurrent actors. This is not a typical (or necessarily supported) use;
143
175
lf1 = LockDir(t, 'test_lock')
145
177
lf2 = LockDir(t, 'test_lock')
178
self.setup_log_reporter(lf2)
146
179
lf1.attempt_lock()
148
181
before = time.time()
149
182
self.assertRaises(LockContention, lf2.wait_lock,
150
183
timeout=0.4, poll=0.1)
151
184
after = time.time()
152
self.assertTrue(after - before <= 1.0)
185
# it should only take about 0.4 seconds, but we allow more time in
186
# case the machine is heavily loaded
187
self.assertTrue(after - before <= 8.0,
188
"took %f seconds to detect lock contention" % (after - before))
191
lock_base = lf2.transport.abspath(lf2.path)
192
self.assertEqual(1, len(self._logged_reports))
193
self.assertEqual('%s %s\n'
195
'Will continue to try until %s\n',
196
self._logged_reports[0][0])
197
args = self._logged_reports[0][1]
198
self.assertEqual('Unable to obtain', args[0])
199
self.assertEqual('lock %s' % (lock_base,), args[1])
200
self.assertStartsWith(args[2], 'held by ')
201
self.assertStartsWith(args[3], 'locked ')
202
self.assertEndsWith(args[3], ' ago')
203
self.assertContainsRe(args[4], r'\d\d:\d\d:\d\d')
156
205
def test_31_lock_wait_easy(self):
157
206
"""Succeed when waiting on a lock with no contention.
196
def test_33_wait(self):
197
"""Succeed when waiting on a lock that gets released
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')
199
The difference from test_32_lock_wait_succeed is that the second
200
caller does not actually acquire the lock, but just waits for it
201
to be released. This is done over a readonly transport.
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
203
280
t = self.get_transport()
204
281
lf1 = LockDir(t, 'test_lock')
211
288
unlocker = Thread(target=wait_and_unlock)
214
lf2 = LockDir(self.get_readonly_transport(), 'test_lock')
291
lf2 = LockDir(t, 'test_lock')
292
self.setup_log_reporter(lf2)
215
293
before = time.time()
216
# wait but don't lock
217
lf2.wait(timeout=0.4, poll=0.1)
218
296
after = time.time()
219
self.assertTrue(after - before <= 1.0)
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')
223
434
def test_40_confirm_easy(self):
224
435
"""Confirm a lock that's already held"""
318
529
self.assertTrue(t.has('test_lock/held/info'))
320
531
self.assertFalse(t.has('test_lock/held/info'))
533
def test_break_lock(self):
534
# the ui based break_lock routine should Just Work (tm)
535
ld1 = self.get_lock()
536
ld2 = self.get_lock()
539
# do this without IO redirection to ensure it doesn't prompt.
540
self.assertRaises(AssertionError, ld1.break_lock)
541
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")
547
self.assertRaises(LockBroken, ld1.unlock)
549
bzrlib.ui.ui_factory = orig_factory
551
def test_create_missing_base_directory(self):
552
"""If LockDir.path doesn't exist, it can be created
554
Some people manually remove the entire lock/ directory trying
555
to unlock a stuck repository/branch/etc. Rather than failing
556
after that, just create the lock directory when needed.
558
t = self.get_transport()
559
lf1 = LockDir(t, 'test_lock')
562
self.failUnless(t.has('test_lock'))
565
self.failIf(t.has('test_lock'))
567
# This will create 'test_lock' if it needs to
569
self.failUnless(t.has('test_lock'))
570
self.failUnless(t.has('test_lock/held/info'))
573
self.failIf(t.has('test_lock/held/info'))
575
def test__format_lock_info(self):
576
ld1 = self.get_lock()
580
info_list = ld1._format_lock_info(ld1.peek())
583
self.assertEqual('lock %s' % (ld1.transport.abspath(ld1.path),),
585
self.assertContainsRe(info_list[1],
586
r'^held by .* on host .* \[process #\d*\]$')
587
self.assertContainsRe(info_list[2], r'locked \d+ seconds? ago$')
589
def test_lock_without_email(self):
590
global_config = config.GlobalConfig()
591
# Intentionally has no email address
592
global_config.set_user_option('email', 'User Identity')
593
ld1 = self.get_lock()
598
def test_lock_permission(self):
599
if not osutils.supports_posix_readonly():
600
raise tests.TestSkipped('Cannot induce a permission failure')
601
ld1 = self.get_lock()
602
lock_path = ld1.transport.local_abspath('test_lock')
604
osutils.make_readonly(lock_path)
605
self.assertRaises(errors.LockFailed, ld1.attempt_lock)
607
def test_lock_by_token(self):
608
ld1 = self.get_lock()
609
token = ld1.lock_write()
610
self.assertNotEqual(None, token)
611
ld2 = self.get_lock()
612
t2 = ld2.lock_write(token)
613
self.assertEqual(token, t2)
615
def test_lock_with_buggy_rename(self):
616
# test that lock acquisition handles servers which pretend they
617
# renamed correctly but that actually fail
618
t = transport.get_transport('brokenrename+' + self.get_url())
619
ld1 = LockDir(t, 'test_lock')
622
ld2 = LockDir(t, 'test_lock')
623
# we should fail to lock
624
e = self.assertRaises(errors.LockContention, ld2.attempt_lock)
625
# now the original caller should succeed in unlocking
627
# and there should be nothing left over
628
self.assertEquals([], t.list_dir('test_lock'))
630
def test_failed_lock_leaves_no_trash(self):
631
# if we fail to acquire the lock, we don't leave pending directories
632
# behind -- https://bugs.launchpad.net/bzr/+bug/109169
633
ld1 = self.get_lock()
634
ld2 = self.get_lock()
635
# should be nothing before we start
637
t = self.get_transport().clone('test_lock')
639
self.assertEquals(a, t.list_dir('.'))
641
# when held, that's all we see
644
# second guy should fail
645
self.assertRaises(errors.LockContention, ld2.attempt_lock)
added
removed
bzrlib/tests/test_lockdir.py
