48
from bzrlib.hooks import HookPoint, Hooks
51
class LockHooks(Hooks):
55
self.create_hook(HookPoint('lock_acquired',
56
"Called with a bzrlib.lock.LockResult when a physical lock is "
57
"acquired.", (1, 8), None))
58
self.create_hook(HookPoint('lock_released',
59
"Called with a bzrlib.lock.LockResult when a physical lock is "
60
"released.", (1, 8), None))
61
self.create_hook(HookPoint('lock_broken',
62
"Called with a bzrlib.lock.LockResult when a physical lock is "
63
"broken.", (1, 15), None))
67
"""Base class for locks.
69
:cvar hooks: Hook dictionary for operations on locks.
75
class LockResult(object):
76
"""Result of an operation on a lock; passed to a hook"""
78
def __init__(self, lock_url, details=None):
79
"""Create a lock result for lock with optional details about the lock."""
80
self.lock_url = lock_url
81
self.details = details
83
def __eq__(self, other):
84
return self.lock_url == other.lock_url and self.details == other.details
87
return '%s(%s, %s)' % (self.__class__.__name__,
88
self.lock_url, self.details)
91
class LogicalLockResult(object):
92
"""The result of a lock_read/lock_write/lock_tree_write call on lockables.
94
:ivar unlock: A callable which will unlock the lock.
97
def __init__(self, unlock):
101
return "LogicalLockResult(%s)" % (self.unlock)
105
def cant_unlock_not_held(locked_object):
106
"""An attempt to unlock failed because the object was not locked.
108
This provides a policy point from which we can generate either a warning
111
# This is typically masking some other error and called from a finally
112
# block, so it's useful to have the option not to generate a new error
113
# here. You can use -Werror to make it fatal. It should possibly also
115
if 'unlock' in debug.debug_flags:
116
warnings.warn("%r is already unlocked" % (locked_object,),
119
raise errors.LockNotHeld(locked_object)
129
have_ctypes_win32 = False
130
if sys.platform == 'win32':
133
import win32file, pywintypes, winerror
140
have_ctypes_win32 = True
145
class _OSLock(object):
41
from bzrlib import errors
42
from bzrlib.errors import LockError, LockContention
43
from bzrlib.osutils import realpath
44
from bzrlib.trace import mutter
47
class _base_Lock(object):
147
49
def __init__(self):
151
52
def _open(self, filename, filemode):
152
self.filename = osutils.realpath(filename)
154
self.f = open(self.filename, filemode)
54
self.f = open(filename, filemode)
156
56
except IOError, e:
157
57
if e.errno in (errno.EACCES, errno.EPERM):
158
raise errors.LockFailed(self.filename, str(e))
58
raise errors.ReadOnlyLockError(e)
159
59
if e.errno != errno.ENOENT:
162
62
# maybe this is an old branch (before may 2005)
163
trace.mutter("trying to create missing lock %r", self.filename)
63
mutter("trying to create missing branch lock %r", filename)
165
self.f = open(self.filename, 'wb+')
65
self.f = open(filename, 'wb+')
168
68
def _clear_f(self):
259
162
except IOError, e:
260
163
# we should be more precise about whats a locking
261
164
# error and whats a random-other error
262
raise errors.LockContention(self.filename, e)
264
167
def unlock(self):
265
count = _fcntl_ReadLock._open_locks[self.filename]
267
del _fcntl_ReadLock._open_locks[self.filename]
269
_fcntl_ReadLock._open_locks[self.filename] = count - 1
272
def temporary_write_lock(self):
273
"""Try to grab a write lock on the file.
275
On platforms that support it, this will upgrade to a write lock
276
without unlocking the file.
277
Otherwise, this will release the read lock, and try to acquire a
280
:return: A token which can be used to switch back to a read lock.
282
if self.filename in _fcntl_WriteLock._open_locks:
283
raise AssertionError('file already locked: %r'
286
wlock = _fcntl_TemporaryWriteLock(self)
287
except errors.LockError:
288
# We didn't unlock, so we can just return 'self'
293
class _fcntl_TemporaryWriteLock(_OSLock):
294
"""A token used when grabbing a temporary_write_lock.
296
Call restore_read_lock() when you are done with the write lock.
299
def __init__(self, read_lock):
300
super(_fcntl_TemporaryWriteLock, self).__init__()
301
self._read_lock = read_lock
302
self.filename = read_lock.filename
304
count = _fcntl_ReadLock._open_locks[self.filename]
306
# Something else also has a read-lock, so we cannot grab a
308
raise errors.LockContention(self.filename)
310
if self.filename in _fcntl_WriteLock._open_locks:
311
raise AssertionError('file already locked: %r'
314
# See if we can open the file for writing. Another process might
315
# have a read lock. We don't use self._open() because we don't want
316
# to create the file if it exists. That would have already been
317
# done by _fcntl_ReadLock
319
new_f = open(self.filename, 'rb+')
321
if e.errno in (errno.EACCES, errno.EPERM):
322
raise errors.LockFailed(self.filename, str(e))
325
# LOCK_NB will cause IOError to be raised if we can't grab a
327
fcntl.lockf(new_f, fcntl.LOCK_EX | fcntl.LOCK_NB)
329
# TODO: Raise a more specific error based on the type of error
330
raise errors.LockContention(self.filename, e)
331
_fcntl_WriteLock._open_locks.add(self.filename)
335
def restore_read_lock(self):
336
"""Restore the original ReadLock."""
337
# For fcntl, since we never released the read lock, just release the
338
# write lock, and return the original lock.
339
fcntl.lockf(self.f, fcntl.LOCK_UN)
341
_fcntl_WriteLock._open_locks.remove(self.filename)
342
# Avoid reference cycles
343
read_lock = self._read_lock
344
self._read_lock = None
348
171
_lock_classes.append(('fcntl', _fcntl_WriteLock, _fcntl_ReadLock))
351
if have_pywin32 and sys.platform == 'win32':
352
if os.path.supports_unicode_filenames:
353
# for Windows NT/2K/XP/etc
354
win32file_CreateFile = win32file.CreateFileW
357
win32file_CreateFile = win32file.CreateFile
359
class _w32c_FileLock(_OSLock):
361
def _open(self, filename, access, share, cflags, pymode):
362
self.filename = osutils.realpath(filename)
174
LOCK_SH = 0 # the default
175
LOCK_EX = win32con.LOCKFILE_EXCLUSIVE_LOCK
176
LOCK_NB = win32con.LOCKFILE_FAIL_IMMEDIATELY
179
class _w32c_FileLock(_base_Lock):
181
def _lock(self, filename, openmode, lockmode):
182
self._open(filename, openmode)
184
self.hfile = msvcrt.get_osfhandle(self.f.fileno())
185
overlapped = pywintypes.OVERLAPPED()
364
self._handle = win32file_CreateFile(filename, access, share,
365
None, win32file.OPEN_ALWAYS,
366
win32file.FILE_ATTRIBUTE_NORMAL, None)
187
win32file.LockFileEx(self.hfile, lockmode, 0, 0x7fff0000,
367
189
except pywintypes.error, e:
368
if e.args[0] == winerror.ERROR_ACCESS_DENIED:
369
raise errors.LockFailed(filename, e)
370
if e.args[0] == winerror.ERROR_SHARING_VIOLATION:
371
raise errors.LockContention(filename, e)
191
if e.args[0] in (winerror.ERROR_LOCK_VIOLATION,):
192
raise errors.LockContention(filename)
193
## import pdb; pdb.set_trace()
373
fd = win32file._open_osfhandle(self._handle, cflags)
374
self.f = os.fdopen(fd, pymode)
377
199
def unlock(self):
200
overlapped = pywintypes.OVERLAPPED()
202
win32file.UnlockFileEx(self.hfile, 0, 0x7fff0000, overlapped)
382
208
class _w32c_ReadLock(_w32c_FileLock):
383
209
def __init__(self, filename):
384
210
super(_w32c_ReadLock, self).__init__()
385
self._open(filename, win32file.GENERIC_READ,
386
win32file.FILE_SHARE_READ, os.O_RDONLY, "rb")
388
def temporary_write_lock(self):
389
"""Try to grab a write lock on the file.
391
On platforms that support it, this will upgrade to a write lock
392
without unlocking the file.
393
Otherwise, this will release the read lock, and try to acquire a
396
:return: A token which can be used to switch back to a read lock.
398
# I can't find a way to upgrade a read lock to a write lock without
399
# unlocking first. So here, we do just that.
402
wlock = _w32c_WriteLock(self.filename)
403
except errors.LockError:
404
return False, _w32c_ReadLock(self.filename)
211
self._lock(filename, 'rb', LOCK_SH + LOCK_NB)
408
213
class _w32c_WriteLock(_w32c_FileLock):
409
214
def __init__(self, filename):
410
215
super(_w32c_WriteLock, self).__init__()
412
win32file.GENERIC_READ | win32file.GENERIC_WRITE, 0,
415
def restore_read_lock(self):
416
"""Restore the original ReadLock."""
417
# For win32 we had to completely let go of the original lock, so we
418
# just unlock and create a new read lock.
420
return _w32c_ReadLock(self.filename)
216
self._lock(filename, 'rb+', LOCK_EX + LOCK_NB)
423
218
_lock_classes.append(('pywin32', _w32c_WriteLock, _w32c_ReadLock))
426
if have_ctypes_win32:
427
from ctypes.wintypes import DWORD, LPCSTR, LPCWSTR
428
LPSECURITY_ATTRIBUTES = ctypes.c_void_p # used as NULL no need to declare
429
HANDLE = ctypes.c_int # rather than unsigned as in ctypes.wintypes
430
if os.path.supports_unicode_filenames:
431
_function_name = "CreateFileW"
434
_function_name = "CreateFileA"
435
class LPTSTR(LPCSTR):
436
def __new__(cls, obj):
437
return LPCSTR.__new__(cls, obj.encode("mbcs"))
439
# CreateFile <http://msdn.microsoft.com/en-us/library/aa363858.aspx>
440
_CreateFile = ctypes.WINFUNCTYPE(
441
HANDLE, # return value
443
DWORD, # dwDesiredAccess
445
LPSECURITY_ATTRIBUTES, # lpSecurityAttributes
446
DWORD, # dwCreationDisposition
447
DWORD, # dwFlagsAndAttributes
448
HANDLE # hTemplateFile
449
)((_function_name, ctypes.windll.kernel32))
451
INVALID_HANDLE_VALUE = -1
453
GENERIC_READ = 0x80000000
454
GENERIC_WRITE = 0x40000000
457
FILE_ATTRIBUTE_NORMAL = 128
459
ERROR_ACCESS_DENIED = 5
460
ERROR_SHARING_VIOLATION = 32
462
class _ctypes_FileLock(_OSLock):
464
def _open(self, filename, access, share, cflags, pymode):
465
self.filename = osutils.realpath(filename)
466
handle = _CreateFile(filename, access, share, None, OPEN_ALWAYS,
467
FILE_ATTRIBUTE_NORMAL, 0)
468
if handle in (INVALID_HANDLE_VALUE, 0):
469
e = ctypes.WinError()
470
if e.args[0] == ERROR_ACCESS_DENIED:
471
raise errors.LockFailed(filename, e)
472
if e.args[0] == ERROR_SHARING_VIOLATION:
473
raise errors.LockContention(filename, e)
475
fd = msvcrt.open_osfhandle(handle, cflags)
476
self.f = os.fdopen(fd, pymode)
221
# These constants were copied from the win32con.py module.
222
LOCKFILE_FAIL_IMMEDIATELY = 1
223
LOCKFILE_EXCLUSIVE_LOCK = 2
224
# Constant taken from winerror.py module
225
ERROR_LOCK_VIOLATION = 33
228
LOCK_EX = LOCKFILE_EXCLUSIVE_LOCK
229
LOCK_NB = LOCKFILE_FAIL_IMMEDIATELY
230
_LockFileEx = ctypes.windll.kernel32.LockFileEx
231
_UnlockFileEx = ctypes.windll.kernel32.UnlockFileEx
232
_GetLastError = ctypes.windll.kernel32.GetLastError
234
### Define the OVERLAPPED structure.
235
# http://msdn2.microsoft.com/en-us/library/ms684342.aspx
236
# typedef struct _OVERLAPPED {
237
# ULONG_PTR Internal;
238
# ULONG_PTR InternalHigh;
249
class _inner_struct(ctypes.Structure):
250
_fields_ = [('Offset', ctypes.c_uint), # DWORD
251
('OffsetHigh', ctypes.c_uint), # DWORD
254
class _inner_union(ctypes.Union):
255
_fields_ = [('anon_struct', _inner_struct), # struct
256
('Pointer', ctypes.c_void_p), # PVOID
259
class OVERLAPPED(ctypes.Structure):
260
_fields_ = [('Internal', ctypes.c_void_p), # ULONG_PTR
261
('InternalHigh', ctypes.c_void_p), # ULONG_PTR
262
('_inner_union', _inner_union),
263
('hEvent', ctypes.c_void_p), # HANDLE
266
class _ctypes_FileLock(_base_Lock):
268
def _lock(self, filename, openmode, lockmode):
269
self._open(filename, openmode)
271
self.hfile = msvcrt.get_osfhandle(self.f.fileno())
272
overlapped = OVERLAPPED()
273
p_overlapped = ctypes.pointer(overlapped)
274
result = _LockFileEx(self.hfile, # HANDLE hFile
275
lockmode, # DWORD dwFlags
276
0, # DWORD dwReserved
277
0x7fffffff, # DWORD nNumberOfBytesToLockLow
278
0x00000000, # DWORD nNumberOfBytesToLockHigh
279
p_overlapped, # lpOverlapped
283
last_err = _GetLastError()
284
if last_err in (ERROR_LOCK_VIOLATION,):
285
raise errors.LockContention(filename)
286
raise errors.LockError('Unknown locking error: %s'
479
289
def unlock(self):
290
overlapped = OVERLAPPED()
291
p_overlapped = ctypes.pointer(overlapped)
292
result = _UnlockFileEx(self.hfile, # HANDLE hFile
293
0, # DWORD dwReserved
294
0x7fffffff, # DWORD nNumberOfBytesToLockLow
295
0x00000000, # DWORD nNumberOfBytesToLockHigh
296
p_overlapped, # lpOverlapped
301
last_err = _GetLastError()
302
raise errors.LockError('Unknown unlocking error: %s'
483
306
class _ctypes_ReadLock(_ctypes_FileLock):
484
307
def __init__(self, filename):
485
308
super(_ctypes_ReadLock, self).__init__()
486
self._open(filename, GENERIC_READ, FILE_SHARE_READ, os.O_RDONLY,
489
def temporary_write_lock(self):
490
"""Try to grab a write lock on the file.
492
On platforms that support it, this will upgrade to a write lock
493
without unlocking the file.
494
Otherwise, this will release the read lock, and try to acquire a
497
:return: A token which can be used to switch back to a read lock.
499
# I can't find a way to upgrade a read lock to a write lock without
500
# unlocking first. So here, we do just that.
503
wlock = _ctypes_WriteLock(self.filename)
504
except errors.LockError:
505
return False, _ctypes_ReadLock(self.filename)
309
self._lock(filename, 'rb', LOCK_SH + LOCK_NB)
508
311
class _ctypes_WriteLock(_ctypes_FileLock):
509
312
def __init__(self, filename):
510
313
super(_ctypes_WriteLock, self).__init__()
511
self._open(filename, GENERIC_READ | GENERIC_WRITE, 0, os.O_RDWR,
514
def restore_read_lock(self):
515
"""Restore the original ReadLock."""
516
# For win32 we had to completely let go of the original lock, so we
517
# just unlock and create a new read lock.
519
return _ctypes_ReadLock(self.filename)
314
self._lock(filename, 'rb+', LOCK_EX + LOCK_NB)
522
316
_lock_classes.append(('ctypes', _ctypes_WriteLock, _ctypes_ReadLock))
525
319
if len(_lock_classes) == 0:
526
raise NotImplementedError(
527
"We must have one of fcntl, pywin32, or ctypes available"
528
" to support OS locking."
320
raise NotImplementedError("We only have support for"
321
" fcntl, pywin32 or ctypes locking."
322
" If your platform (windows) does not"
323
" support fcntl locks, you must have"
324
" either pywin32 or ctypes installed.")
532
326
# We default to using the first available lock class.
533
327
_lock_type, WriteLock, ReadLock = _lock_classes[0]
536
class _RelockDebugMixin(object):
537
"""Mixin support for -Drelock flag.
330
class LockTreeTestProviderAdapter(object):
331
"""A tool to generate a suite testing multiple lock formats at once.
539
Add this as a base class then call self._note_lock with 'r' or 'w' when
540
acquiring a read- or write-lock. If this object was previously locked (and
541
locked the same way), and -Drelock is set, then this will trace.note a
333
This is done by copying the test once for each lock and injecting the
334
read_lock and write_lock classes.
335
They are also given a new test id.
547
def _note_lock(self, lock_type):
548
if 'relock' in debug.debug_flags and self._prev_lock == lock_type:
553
trace.note('%r was %s locked again', self, type_name)
554
self._prev_lock = lock_type
338
def __init__(self, lock_classes):
339
self._lock_classes = lock_classes
341
def _clone_test(self, test, write_lock, read_lock, variation):
342
"""Clone test for adaption."""
343
new_test = deepcopy(test)
344
new_test.write_lock = write_lock
345
new_test.read_lock = read_lock
346
def make_new_test_id():
347
new_id = "%s(%s)" % (test.id(), variation)
348
return lambda: new_id
349
new_test.id = make_new_test_id()
352
def adapt(self, test):
353
from bzrlib.tests import TestSuite
355
for name, write_lock, read_lock in self._lock_classes:
356
new_test = self._clone_test(test, write_lock, read_lock, name)
357
result.addTest(new_test)
added
removed
bzrlib/lock.py
