1
# Copyright (C) 2006 Canonical Ltd
3
# This program is free software; you can redistribute it and/or modify
4
# it under the terms of the GNU General Public License as published by
5
# the Free Software Foundation; either version 2 of the License, or
6
# (at your option) any later version.
8
# This program is distributed in the hope that it will be useful,
9
# but WITHOUT ANY WARRANTY; without even the implied warranty of
10
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
11
# GNU General Public License for more details.
13
# You should have received a copy of the GNU General Public License
14
# along with this program; if not, write to the Free Software
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
17
"""Tests for LockDir"""
19
from cStringIO import StringIO
20
from threading import Thread
24
from bzrlib.errors import (
26
LockContention, LockError, UnlockableTransport,
27
LockNotHeld, LockBroken
29
from bzrlib.lockdir import LockDir
30
from bzrlib.tests import TestCaseWithTransport
32
# These tests sometimes use threads to test the behaviour of lock files with
33
# concurrent actors. This is not a typical (or necessarily supported) use;
34
# they're really meant for guarding between processes.
36
# These tests are run on the default transport provided by the test framework
37
# (typically a local disk transport). That can be changed by the --transport
38
# option to bzr selftest. The required properties of the transport
39
# implementation are tested separately. (The main requirement is just that
40
# they don't allow overwriting nonempty directories.)
42
class TestLockDir(TestCaseWithTransport):
43
"""Test LockDir operations"""
45
def test_00_lock_creation(self):
46
"""Creation of lock file on a transport"""
47
t = self.get_transport()
48
lf = LockDir(t, 'test_lock')
49
self.assertFalse(lf.is_held)
51
def test_01_lock_repr(self):
52
"""Lock string representation"""
53
lf = LockDir(self.get_transport(), 'test_lock')
55
self.assertContainsRe(r, r'^LockDir\(.*/test_lock\)$')
57
def test_02_unlocked_peek(self):
58
lf = LockDir(self.get_transport(), 'test_lock')
59
self.assertEqual(lf.peek(), None)
62
return LockDir(self.get_transport(), 'test_lock')
64
def test_unlock_after_break_raises(self):
69
ld2.force_break(ld2.peek())
70
self.assertRaises(LockBroken, ld.unlock)
72
def test_03_readonly_peek(self):
73
lf = LockDir(self.get_readonly_transport(), 'test_lock')
74
self.assertEqual(lf.peek(), None)
76
def test_10_lock_uncontested(self):
77
"""Acquire and release a lock"""
78
t = self.get_transport()
79
lf = LockDir(t, 'test_lock')
83
self.assertTrue(lf.is_held)
86
self.assertFalse(lf.is_held)
88
def test_11_create_readonly_transport(self):
89
"""Fail to create lock on readonly transport"""
90
t = self.get_readonly_transport()
91
lf = LockDir(t, 'test_lock')
92
self.assertRaises(UnlockableTransport, lf.create)
94
def test_12_lock_readonly_transport(self):
95
"""Fail to lock on readonly transport"""
96
lf = LockDir(self.get_transport(), 'test_lock')
98
lf = LockDir(self.get_readonly_transport(), 'test_lock')
99
self.assertRaises(UnlockableTransport, lf.attempt_lock)
101
def test_20_lock_contested(self):
102
"""Contention to get a lock"""
103
t = self.get_transport()
104
lf1 = LockDir(t, 'test_lock')
107
lf2 = LockDir(t, 'test_lock')
109
# locking is between LockDir instances; aliases within
110
# a single process are not detected
112
self.fail('Failed to detect lock collision')
113
except LockContention, e:
114
self.assertEqual(e.lock, lf2)
115
self.assertContainsRe(str(e),
116
r'^Could not acquire.*test_lock.*$')
119
def test_20_lock_peek(self):
120
"""Peek at the state of a lock"""
121
t = self.get_transport()
122
lf1 = LockDir(t, 'test_lock')
125
# lock is held, should get some info on it
127
self.assertEqual(set(info1.keys()),
128
set(['user', 'nonce', 'hostname', 'pid', 'start_time']))
129
# should get the same info if we look at it through a different
131
info2 = LockDir(t, 'test_lock').peek()
132
self.assertEqual(info1, info2)
133
# locks which are never used should be not-held
134
self.assertEqual(LockDir(t, 'other_lock').peek(), None)
136
def test_21_peek_readonly(self):
137
"""Peek over a readonly transport"""
138
t = self.get_transport()
139
lf1 = LockDir(t, 'test_lock')
141
lf2 = LockDir(self.get_readonly_transport(), 'test_lock')
142
self.assertEqual(lf2.peek(), None)
145
self.assertTrue(info2)
146
self.assertEqual(info2['nonce'], lf1.nonce)
148
def test_30_lock_wait_fail(self):
149
"""Wait on a lock, then fail
151
We ask to wait up to 400ms; this should fail within at most one
152
second. (Longer times are more realistic but we don't want the test
153
suite to take too long, and this should do for now.)
155
t = self.get_transport()
156
lf1 = LockDir(t, 'test_lock')
158
lf2 = LockDir(t, 'test_lock')
162
self.assertRaises(LockContention, lf2.wait_lock,
163
timeout=0.4, poll=0.1)
165
self.assertTrue(after - before <= 1.0)
169
def test_31_lock_wait_easy(self):
170
"""Succeed when waiting on a lock with no contention.
172
t = self.get_transport()
173
lf1 = LockDir(t, 'test_lock')
177
lf1.wait_lock(timeout=0.4, poll=0.1)
179
self.assertTrue(after - before <= 1.0)
183
def test_32_lock_wait_succeed(self):
184
"""Succeed when trying to acquire a lock that gets released
186
One thread holds on a lock and then releases it; another
189
t = self.get_transport()
190
lf1 = LockDir(t, 'test_lock')
194
def wait_and_unlock():
197
unlocker = Thread(target=wait_and_unlock)
200
lf2 = LockDir(t, 'test_lock')
203
lf2.wait_lock(timeout=0.4, poll=0.1)
205
self.assertTrue(after - before <= 1.0)
209
def test_33_wait(self):
210
"""Succeed when waiting on a lock that gets released
212
The difference from test_32_lock_wait_succeed is that the second
213
caller does not actually acquire the lock, but just waits for it
214
to be released. This is done over a readonly transport.
216
t = self.get_transport()
217
lf1 = LockDir(t, 'test_lock')
221
def wait_and_unlock():
224
unlocker = Thread(target=wait_and_unlock)
227
lf2 = LockDir(self.get_readonly_transport(), 'test_lock')
229
# wait but don't lock
230
lf2.wait(timeout=0.4, poll=0.1)
232
self.assertTrue(after - before <= 1.0)
236
def test_40_confirm_easy(self):
237
"""Confirm a lock that's already held"""
238
t = self.get_transport()
239
lf1 = LockDir(t, 'test_lock')
244
def test_41_confirm_not_held(self):
245
"""Confirm a lock that's already held"""
246
t = self.get_transport()
247
lf1 = LockDir(t, 'test_lock')
249
self.assertRaises(LockNotHeld, lf1.confirm)
251
def test_42_confirm_broken_manually(self):
252
"""Confirm a lock broken by hand"""
253
t = self.get_transport()
254
lf1 = LockDir(t, 'test_lock')
257
t.move('test_lock', 'lock_gone_now')
258
self.assertRaises(LockBroken, lf1.confirm)
260
def test_43_break(self):
261
"""Break a lock whose caller has forgotten it"""
262
t = self.get_transport()
263
lf1 = LockDir(t, 'test_lock')
266
# we incorrectly discard the lock object without unlocking it
268
# someone else sees it's still locked
269
lf2 = LockDir(t, 'test_lock')
270
holder_info = lf2.peek()
271
self.assertTrue(holder_info)
272
lf2.force_break(holder_info)
273
# now we should be able to take it
277
def test_44_break_already_released(self):
278
"""Lock break races with regular release"""
279
t = self.get_transport()
280
lf1 = LockDir(t, 'test_lock')
283
# someone else sees it's still locked
284
lf2 = LockDir(t, 'test_lock')
285
holder_info = lf2.peek()
286
# in the interim the lock is released
288
# break should succeed
289
lf2.force_break(holder_info)
290
# now we should be able to take it
294
def test_45_break_mismatch(self):
295
"""Lock break races with someone else acquiring it"""
296
t = self.get_transport()
297
lf1 = LockDir(t, 'test_lock')
300
# someone else sees it's still locked
301
lf2 = LockDir(t, 'test_lock')
302
holder_info = lf2.peek()
303
# in the interim the lock is released
305
lf3 = LockDir(t, 'test_lock')
307
# break should now *fail*
308
self.assertRaises(LockBreakMismatch, lf2.force_break,
312
def test_46_fake_read_lock(self):
313
t = self.get_transport()
314
lf1 = LockDir(t, 'test_lock')
319
def test_50_lockdir_representation(self):
320
"""Check the on-disk representation of LockDirs is as expected.
322
There should always be a top-level directory named by the lock.
323
When the lock is held, there should be a lockname/held directory
324
containing an info file.
326
t = self.get_transport()
327
lf1 = LockDir(t, 'test_lock')
329
self.assertTrue(t.has('test_lock'))
331
self.assertTrue(t.has('test_lock/held/info'))
333
self.assertFalse(t.has('test_lock/held/info'))
335
def test_break_lock(self):
336
# the ui based break_lock routine should Just Work (tm)
337
ld1 = self.get_lock()
338
ld2 = self.get_lock()
341
# do this without IO redirection to ensure it doesn't prompt.
342
self.assertRaises(AssertionError, ld1.break_lock)
343
orig_factory = bzrlib.ui.ui_factory
344
# silent ui - no need for stdout
345
bzrlib.ui.ui_factory = bzrlib.ui.SilentUIFactory()
346
bzrlib.ui.ui_factory.stdin = StringIO("y\n")
349
self.assertRaises(LockBroken, ld1.unlock)
351
bzrlib.ui.ui_factory = orig_factory
added
removed
bzrlib/tests/test_lockdir.py
