1
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
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
17
17
"""Tests for LockDir"""
19
from cStringIO import StringIO
21
from threading import Thread, Lock
19
from threading import Thread
32
22
from bzrlib.errors import (
34
24
LockContention, LockError, UnlockableTransport,
172
143
lf1 = LockDir(t, 'test_lock')
174
145
lf2 = LockDir(t, 'test_lock')
175
self.setup_log_reporter(lf2)
176
146
lf1.attempt_lock()
178
148
before = time.time()
179
149
self.assertRaises(LockContention, lf2.wait_lock,
180
150
timeout=0.4, poll=0.1)
181
151
after = time.time()
182
# it should only take about 0.4 seconds, but we allow more time in
183
# case the machine is heavily loaded
184
self.assertTrue(after - before <= 8.0,
185
"took %f seconds to detect lock contention" % (after - before))
152
self.assertTrue(after - before <= 1.0)
188
lock_base = lf2.transport.abspath(lf2.path)
189
self.assertEqual(1, len(self._logged_reports))
190
self.assertEqual('%s %s\n'
192
'Will continue to try until %s\n',
193
self._logged_reports[0][0])
194
args = self._logged_reports[0][1]
195
self.assertEqual('Unable to obtain', args[0])
196
self.assertEqual('lock %s' % (lock_base,), args[1])
197
self.assertStartsWith(args[2], 'held by ')
198
self.assertStartsWith(args[3], 'locked ')
199
self.assertEndsWith(args[3], ' ago')
200
self.assertContainsRe(args[4], r'\d\d:\d\d:\d\d')
202
156
def test_31_lock_wait_easy(self):
203
157
"""Succeed when waiting on a lock with no contention.
255
# There should be only 1 report, even though it should have to
257
lock_base = lf2.transport.abspath(lf2.path)
258
self.assertEqual(1, len(self._logged_reports))
259
self.assertEqual('%s %s\n'
261
'Will continue to try until %s\n',
262
self._logged_reports[0][0])
263
args = self._logged_reports[0][1]
264
self.assertEqual('Unable to obtain', args[0])
265
self.assertEqual('lock %s' % (lock_base,), args[1])
266
self.assertStartsWith(args[2], 'held by ')
267
self.assertStartsWith(args[3], 'locked ')
268
self.assertEndsWith(args[3], ' ago')
269
self.assertContainsRe(args[4], r'\d\d:\d\d:\d\d')
196
def test_33_wait(self):
197
"""Succeed when waiting on a lock that gets released
271
def test_34_lock_write_waits(self):
272
"""LockDir.lock_write() will wait for the lock."""
273
# the test suite sets the default to 0 to make deadlocks fail fast.
274
# change it for this test, as we want to try a manual deadlock.
275
bzrlib.lockdir._DEFAULT_TIMEOUT_SECONDS = 300
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.
276
203
t = self.get_transport()
277
204
lf1 = LockDir(t, 'test_lock')
284
211
unlocker = Thread(target=wait_and_unlock)
287
lf2 = LockDir(t, 'test_lock')
288
self.setup_log_reporter(lf2)
214
lf2 = LockDir(self.get_readonly_transport(), 'test_lock')
289
215
before = time.time()
216
# wait but don't lock
217
lf2.wait(timeout=0.4, poll=0.1)
292
218
after = time.time()
296
# There should be only 1 report, even though it should have to
298
lock_base = lf2.transport.abspath(lf2.path)
299
self.assertEqual(1, len(self._logged_reports))
300
self.assertEqual('%s %s\n'
302
'Will continue to try until %s\n',
303
self._logged_reports[0][0])
304
args = self._logged_reports[0][1]
305
self.assertEqual('Unable to obtain', args[0])
306
self.assertEqual('lock %s' % (lock_base,), args[1])
307
self.assertStartsWith(args[2], 'held by ')
308
self.assertStartsWith(args[3], 'locked ')
309
self.assertEndsWith(args[3], ' ago')
310
self.assertContainsRe(args[4], r'\d\d:\d\d:\d\d')
312
def test_35_wait_lock_changing(self):
313
"""LockDir.wait_lock() will report if the lock changes underneath.
315
This is the stages we want to happen:
317
0) Synchronization locks are created and locked.
318
1) Lock1 obtains the lockdir, and releases the 'check' lock.
319
2) Lock2 grabs the 'check' lock, and checks the lockdir.
320
It sees the lockdir is already acquired, reports the fact,
321
and unsets the 'checked' lock.
322
3) Thread1 blocks on acquiring the 'checked' lock, and then tells
323
Lock1 to release and acquire the lockdir. This resets the 'check'
325
4) Lock2 acquires the 'check' lock, and checks again. It notices
326
that the holder of the lock has changed, and so reports a new
328
5) Thread1 blocks on the 'checked' lock, this time, it completely
329
unlocks the lockdir, allowing Lock2 to acquire the lock.
332
wait_to_check_lock = Lock()
333
wait_until_checked_lock = Lock()
335
wait_to_check_lock.acquire()
336
wait_until_checked_lock.acquire()
337
note('locked check and checked locks')
339
class LockDir1(LockDir):
340
"""Use the synchronization points for the first lock."""
342
def attempt_lock(self):
343
# Once we have acquired the lock, it is okay for
344
# the other lock to check it
346
return super(LockDir1, self).attempt_lock()
348
note('lock1: releasing check lock')
349
wait_to_check_lock.release()
351
class LockDir2(LockDir):
352
"""Use the synchronization points for the second lock."""
354
def attempt_lock(self):
355
note('lock2: waiting for check lock')
356
wait_to_check_lock.acquire()
357
note('lock2: acquired check lock')
359
return super(LockDir2, self).attempt_lock()
361
note('lock2: releasing checked lock')
362
wait_until_checked_lock.release()
364
t = self.get_transport()
365
lf1 = LockDir1(t, 'test_lock')
368
lf2 = LockDir2(t, 'test_lock')
369
self.setup_log_reporter(lf2)
371
def wait_and_switch():
373
# Block until lock2 has had a chance to check
374
note('lock1: waiting 1 for checked lock')
375
wait_until_checked_lock.acquire()
376
note('lock1: acquired for checked lock')
377
note('lock1: released lockdir')
379
note('lock1: acquiring lockdir')
380
# Create a new nonce, so the lock looks different.
381
lf1.nonce = osutils.rand_chars(20)
383
note('lock1: acquired lockdir')
385
# Block until lock2 has peeked again
386
note('lock1: waiting 2 for checked lock')
387
wait_until_checked_lock.acquire()
388
note('lock1: acquired for checked lock')
389
# Now unlock, and let lock 2 grab the lock
391
wait_to_check_lock.release()
393
unlocker = Thread(target=wait_and_switch)
396
# Wait and play against the other thread
397
lf2.wait_lock(timeout=1.0, poll=0.01)
402
# There should be 2 reports, because the lock changed
403
lock_base = lf2.transport.abspath(lf2.path)
404
self.assertEqual(2, len(self._logged_reports))
406
self.assertEqual('%s %s\n'
408
'Will continue to try until %s\n',
409
self._logged_reports[0][0])
410
args = self._logged_reports[0][1]
411
self.assertEqual('Unable to obtain', args[0])
412
self.assertEqual('lock %s' % (lock_base,), args[1])
413
self.assertStartsWith(args[2], 'held by ')
414
self.assertStartsWith(args[3], 'locked ')
415
self.assertEndsWith(args[3], ' ago')
416
self.assertContainsRe(args[4], r'\d\d:\d\d:\d\d')
418
self.assertEqual('%s %s\n'
420
'Will continue to try until %s\n',
421
self._logged_reports[1][0])
422
args = self._logged_reports[1][1]
423
self.assertEqual('Lock owner changed for', args[0])
424
self.assertEqual('lock %s' % (lock_base,), args[1])
425
self.assertStartsWith(args[2], 'held by ')
426
self.assertStartsWith(args[3], 'locked ')
427
self.assertEndsWith(args[3], ' ago')
428
self.assertContainsRe(args[4], r'\d\d:\d\d:\d\d')
219
self.assertTrue(after - before <= 1.0)
430
223
def test_40_confirm_easy(self):
431
224
"""Confirm a lock that's already held"""
525
318
self.assertTrue(t.has('test_lock/held/info'))
527
320
self.assertFalse(t.has('test_lock/held/info'))
529
def test_break_lock(self):
530
# the ui based break_lock routine should Just Work (tm)
531
ld1 = self.get_lock()
532
ld2 = self.get_lock()
535
# do this without IO redirection to ensure it doesn't prompt.
536
self.assertRaises(AssertionError, ld1.break_lock)
537
orig_factory = bzrlib.ui.ui_factory
538
# silent ui - no need for stdout
539
bzrlib.ui.ui_factory = bzrlib.ui.SilentUIFactory()
540
bzrlib.ui.ui_factory.stdin = StringIO("y\n")
543
self.assertRaises(LockBroken, ld1.unlock)
545
bzrlib.ui.ui_factory = orig_factory
547
def test_create_missing_base_directory(self):
548
"""If LockDir.path doesn't exist, it can be created
550
Some people manually remove the entire lock/ directory trying
551
to unlock a stuck repository/branch/etc. Rather than failing
552
after that, just create the lock directory when needed.
554
t = self.get_transport()
555
lf1 = LockDir(t, 'test_lock')
558
self.failUnless(t.has('test_lock'))
561
self.failIf(t.has('test_lock'))
563
# This will create 'test_lock' if it needs to
565
self.failUnless(t.has('test_lock'))
566
self.failUnless(t.has('test_lock/held/info'))
569
self.failIf(t.has('test_lock/held/info'))
571
def test__format_lock_info(self):
572
ld1 = self.get_lock()
576
info_list = ld1._format_lock_info(ld1.peek())
579
self.assertEqual('lock %s' % (ld1.transport.abspath(ld1.path),),
581
self.assertContainsRe(info_list[1],
582
r'^held by .* on host .* \[process #\d*\]$')
583
self.assertContainsRe(info_list[2], r'locked \d+ seconds? ago$')
585
def test_lock_without_email(self):
586
global_config = config.GlobalConfig()
587
# Intentionally has no email address
588
global_config.set_user_option('email', 'User Identity')
589
ld1 = self.get_lock()
594
def test_lock_permission(self):
595
if not osutils.supports_posix_readonly():
596
raise tests.TestSkipped('Cannot induce a permission failure')
597
ld1 = self.get_lock()
598
lock_path = ld1.transport.local_abspath('test_lock')
600
osutils.make_readonly(lock_path)
601
self.assertRaises(errors.PermissionDenied, ld1.attempt_lock)
603
def test_lock_by_token(self):
604
ld1 = self.get_lock()
605
token = ld1.lock_write()
606
self.assertNotEqual(None, token)
607
ld2 = self.get_lock()
608
t2 = ld2.lock_write(token)
609
self.assertEqual(token, t2)
611
def test_lock_with_buggy_rename(self):
612
# test that lock acquisition handles servers which pretend they
613
# renamed correctly but that actually fail
614
t = transport.get_transport('brokenrename+' + self.get_url())
615
ld1 = LockDir(t, 'test_lock')
618
ld2 = LockDir(t, 'test_lock')
619
# we should fail to lock
620
e = self.assertRaises(errors.LockContention, ld2.attempt_lock)
621
# now the original caller should succeed in unlocking
623
# and there should be nothing left over
624
self.assertEquals([], t.list_dir('test_lock'))
626
def test_failed_lock_leaves_no_trash(self):
627
# if we fail to acquire the lock, we don't leave pending directories
628
# behind -- https://bugs.launchpad.net/bzr/+bug/109169
629
ld1 = self.get_lock()
630
ld2 = self.get_lock()
631
# should be nothing before we start
633
t = self.get_transport().clone('test_lock')
635
self.assertEquals(a, t.list_dir('.'))
637
# when held, that's all we see
640
# second guy should fail
641
self.assertRaises(errors.LockContention, ld2.attempt_lock)
added
removed
bzrlib/tests/test_lockdir.py
