← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/lock.py

  • Committer: Danny van Heumen
  • Date: 2010-03-09 21:42:11 UTC
  • mto: (4634.139.5 2.0)
  • mto: This revision was merged to the branch mainline in revision 5160.
  • Revision ID: danny@dannyvanheumen.nl-20100309214211-iqh42x6qcikgd9p3
Reverted now-useless TODO list.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/lock.py
1
 
# Copyright (C) 2005, 2006, 2007 Canonical Ltd
 
1
# Copyright (C) 2005, 2006, 2007, 2008, 2009 Canonical Ltd
2
2
#
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
12
12
#
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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
16
16
 
17
17
 
18
18
"""Locking using OS file locks or file existence.
35
35
"""
36
36
 
37
37
import errno
 
38
import os
38
39
import sys
 
40
import warnings
39
41
 
40
42
from bzrlib import (
 
43
    debug,
41
44
    errors,
42
45
    osutils,
43
46
    trace,
44
47
    )
 
48
from bzrlib.hooks import HookPoint, Hooks
 
49
 
 
50
 
 
51
class LockHooks(Hooks):
 
52
 
 
53
    def __init__(self):
 
54
        Hooks.__init__(self)
 
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))
 
64
 
 
65
 
 
66
class Lock(object):
 
67
    """Base class for locks.
 
68
 
 
69
    :cvar hooks: Hook dictionary for operations on locks.
 
70
    """
 
71
 
 
72
    hooks = LockHooks()
 
73
 
 
74
 
 
75
class LockResult(object):
 
76
    """Result of an operation on a lock; passed to a hook"""
 
77
 
 
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
 
82
 
 
83
    def __eq__(self, other):
 
84
        return self.lock_url == other.lock_url and self.details == other.details
 
85
 
 
86
    def __repr__(self):
 
87
        return '%s(%s%s)' % (self.__class__.__name__,
 
88
                             self.lock_url, self.details)
 
89
 
 
90
 
 
91
def cant_unlock_not_held(locked_object):
 
92
    """An attempt to unlock failed because the object was not locked.
 
93
 
 
94
    This provides a policy point from which we can generate either a warning 
 
95
    or an exception.
 
96
    """
 
97
    # This is typically masking some other error and called from a finally
 
98
    # block, so it's useful to have the option not to generate a new error
 
99
    # here.  You can use -Werror to make it fatal.  It should possibly also
 
100
    # raise LockNotHeld.
 
101
    if 'unlock' in debug.debug_flags:
 
102
        warnings.warn("%r is already unlocked" % (locked_object,),
 
103
            stacklevel=3)
 
104
    else:
 
105
        raise errors.LockNotHeld(locked_object)
 
106
 
 
107
 
 
108
try:
 
109
    import fcntl
 
110
    have_fcntl = True
 
111
except ImportError:
 
112
    have_fcntl = False
 
113
 
 
114
have_pywin32 = False
 
115
have_ctypes_win32 = False
 
116
if sys.platform == 'win32':
 
117
    import msvcrt
 
118
    try:
 
119
        import win32file, pywintypes, winerror
 
120
        have_pywin32 = True
 
121
    except ImportError:
 
122
        pass
 
123
 
 
124
    try:
 
125
        import ctypes
 
126
        have_ctypes_win32 = True
 
127
    except ImportError:
 
128
        pass
45
129
 
46
130
 
47
131
class _OSLock(object):
57
141
            return self.f
58
142
        except IOError, e:
59
143
            if e.errno in (errno.EACCES, errno.EPERM):
60
 
                raise errors.ReadOnlyLockError(self.filename, str(e))
 
144
                raise errors.LockFailed(self.filename, str(e))
61
145
            if e.errno != errno.ENOENT:
62
146
                raise
63
147
 
83
167
        raise NotImplementedError()
84
168
 
85
169
 
86
 
try:
87
 
    import fcntl
88
 
    have_fcntl = True
89
 
except ImportError:
90
 
    have_fcntl = False
91
 
try:
92
 
    import win32con, win32file, pywintypes, winerror, msvcrt
93
 
    have_pywin32 = True
94
 
except ImportError:
95
 
    have_pywin32 = False
96
 
try:
97
 
    import ctypes, msvcrt
98
 
    have_ctypes = True
99
 
except ImportError:
100
 
    have_ctypes = False
101
 
 
102
 
 
103
170
_lock_classes = []
104
171
 
105
172
 
106
173
if have_fcntl:
107
 
    LOCK_SH = fcntl.LOCK_SH
108
 
    LOCK_NB = fcntl.LOCK_NB
109
 
    lock_EX = fcntl.LOCK_EX
110
 
 
111
174
 
112
175
    class _fcntl_FileLock(_OSLock):
113
176
 
127
190
            if self.filename in _fcntl_WriteLock._open_locks:
128
191
                self._clear_f()
129
192
                raise errors.LockContention(self.filename)
 
193
            if self.filename in _fcntl_ReadLock._open_locks:
 
194
                if 'strict_locks' in debug.debug_flags:
 
195
                    self._clear_f()
 
196
                    raise errors.LockContention(self.filename)
 
197
                else:
 
198
                    trace.mutter('Write lock taken w/ an open read lock on: %s'
 
199
                                 % (self.filename,))
130
200
 
131
201
            self._open(self.filename, 'rb+')
132
202
            # reserve a slot for this lock - even if the lockf call fails,
143
213
                    self.unlock()
144
214
                # we should be more precise about whats a locking
145
215
                # error and whats a random-other error
146
 
                raise errors.LockContention(e)
 
216
                raise errors.LockContention(self.filename, e)
147
217
 
148
218
        def unlock(self):
149
219
            _fcntl_WriteLock._open_locks.remove(self.filename)
157
227
        def __init__(self, filename):
158
228
            super(_fcntl_ReadLock, self).__init__()
159
229
            self.filename = osutils.realpath(filename)
 
230
            if self.filename in _fcntl_WriteLock._open_locks:
 
231
                if 'strict_locks' in debug.debug_flags:
 
232
                    # We raise before calling _open so we don't need to
 
233
                    # _clear_f
 
234
                    raise errors.LockContention(self.filename)
 
235
                else:
 
236
                    trace.mutter('Read lock taken w/ an open write lock on: %s'
 
237
                                 % (self.filename,))
160
238
            _fcntl_ReadLock._open_locks.setdefault(self.filename, 0)
161
239
            _fcntl_ReadLock._open_locks[self.filename] += 1
162
240
            self._open(filename, 'rb')
167
245
            except IOError, e:
168
246
                # we should be more precise about whats a locking
169
247
                # error and whats a random-other error
170
 
                raise errors.LockContention(e)
 
248
                raise errors.LockContention(self.filename, e)
171
249
 
172
250
        def unlock(self):
173
251
            count = _fcntl_ReadLock._open_locks[self.filename]
187
265
 
188
266
            :return: A token which can be used to switch back to a read lock.
189
267
            """
190
 
            assert self.filename not in _fcntl_WriteLock._open_locks
 
268
            if self.filename in _fcntl_WriteLock._open_locks:
 
269
                raise AssertionError('file already locked: %r'
 
270
                    % (self.filename,))
191
271
            try:
192
272
                wlock = _fcntl_TemporaryWriteLock(self)
193
273
            except errors.LockError:
213
293
                # write lock.
214
294
                raise errors.LockContention(self.filename)
215
295
 
216
 
            assert self.filename not in _fcntl_WriteLock._open_locks
 
296
            if self.filename in _fcntl_WriteLock._open_locks:
 
297
                raise AssertionError('file already locked: %r'
 
298
                    % (self.filename,))
217
299
 
218
300
            # See if we can open the file for writing. Another process might
219
301
            # have a read lock. We don't use self._open() because we don't want
223
305
                new_f = open(self.filename, 'rb+')
224
306
            except IOError, e:
225
307
                if e.errno in (errno.EACCES, errno.EPERM):
226
 
                    raise errors.ReadOnlyLockError(self.filename, str(e))
 
308
                    raise errors.LockFailed(self.filename, str(e))
227
309
                raise
228
310
            try:
229
311
                # LOCK_NB will cause IOError to be raised if we can't grab a
231
313
                fcntl.lockf(new_f, fcntl.LOCK_EX | fcntl.LOCK_NB)
232
314
            except IOError, e:
233
315
                # TODO: Raise a more specific error based on the type of error
234
 
                raise errors.LockContention(e)
 
316
                raise errors.LockContention(self.filename, e)
235
317
            _fcntl_WriteLock._open_locks.add(self.filename)
236
318
 
237
319
            self.f = new_f
253
335
 
254
336
 
255
337
if have_pywin32 and sys.platform == 'win32':
256
 
    LOCK_SH = 0 # the default
257
 
    LOCK_EX = win32con.LOCKFILE_EXCLUSIVE_LOCK
258
 
    LOCK_NB = win32con.LOCKFILE_FAIL_IMMEDIATELY
259
 
 
 
338
    if os.path.supports_unicode_filenames:
 
339
        # for Windows NT/2K/XP/etc
 
340
        win32file_CreateFile = win32file.CreateFileW
 
341
    else:
 
342
        # for Windows 98
 
343
        win32file_CreateFile = win32file.CreateFile
260
344
 
261
345
    class _w32c_FileLock(_OSLock):
262
346
 
263
 
        def _lock(self, filename, openmode, lockmode):
264
 
            self._open(filename, openmode)
265
 
 
266
 
            self.hfile = msvcrt.get_osfhandle(self.f.fileno())
267
 
            overlapped = pywintypes.OVERLAPPED()
 
347
        def _open(self, filename, access, share, cflags, pymode):
 
348
            self.filename = osutils.realpath(filename)
268
349
            try:
269
 
                win32file.LockFileEx(self.hfile, lockmode, 0, 0x7fff0000,
270
 
                                     overlapped)
 
350
                self._handle = win32file_CreateFile(filename, access, share,
 
351
                    None, win32file.OPEN_ALWAYS,
 
352
                    win32file.FILE_ATTRIBUTE_NORMAL, None)
271
353
            except pywintypes.error, e:
272
 
                self._clear_f()
273
 
                if e.args[0] in (winerror.ERROR_LOCK_VIOLATION,):
274
 
                    raise errors.LockContention(filename)
275
 
                ## import pdb; pdb.set_trace()
 
354
                if e.args[0] == winerror.ERROR_ACCESS_DENIED:
 
355
                    raise errors.LockFailed(filename, e)
 
356
                if e.args[0] == winerror.ERROR_SHARING_VIOLATION:
 
357
                    raise errors.LockContention(filename, e)
276
358
                raise
277
 
            except Exception, e:
278
 
                self._clear_f()
279
 
                raise errors.LockContention(e)
 
359
            fd = win32file._open_osfhandle(self._handle, cflags)
 
360
            self.f = os.fdopen(fd, pymode)
 
361
            return self.f
280
362
 
281
363
        def unlock(self):
282
 
            overlapped = pywintypes.OVERLAPPED()
283
 
            try:
284
 
                win32file.UnlockFileEx(self.hfile, 0, 0x7fff0000, overlapped)
285
 
                self._clear_f()
286
 
            except Exception, e:
287
 
                raise errors.LockContention(e)
 
364
            self._clear_f()
 
365
            self._handle = None
288
366
 
289
367
 
290
368
    class _w32c_ReadLock(_w32c_FileLock):
291
369
        def __init__(self, filename):
292
370
            super(_w32c_ReadLock, self).__init__()
293
 
            self._lock(filename, 'rb', LOCK_SH + LOCK_NB)
 
371
            self._open(filename, win32file.GENERIC_READ,
 
372
                win32file.FILE_SHARE_READ, os.O_RDONLY, "rb")
294
373
 
295
374
        def temporary_write_lock(self):
296
375
            """Try to grab a write lock on the file.
315
394
    class _w32c_WriteLock(_w32c_FileLock):
316
395
        def __init__(self, filename):
317
396
            super(_w32c_WriteLock, self).__init__()
318
 
            self._lock(filename, 'rb+', LOCK_EX + LOCK_NB)
 
397
            self._open(filename,
 
398
                win32file.GENERIC_READ | win32file.GENERIC_WRITE, 0,
 
399
                os.O_RDWR, "rb+")
319
400
 
320
401
        def restore_read_lock(self):
321
402
            """Restore the original ReadLock."""
328
409
    _lock_classes.append(('pywin32', _w32c_WriteLock, _w32c_ReadLock))
329
410
 
330
411
 
331
 
if have_ctypes and sys.platform == 'win32':
332
 
    # These constants were copied from the win32con.py module.
333
 
    LOCKFILE_FAIL_IMMEDIATELY = 1
334
 
    LOCKFILE_EXCLUSIVE_LOCK = 2
335
 
    # Constant taken from winerror.py module
336
 
    ERROR_LOCK_VIOLATION = 33
337
 
 
338
 
    LOCK_SH = 0
339
 
    LOCK_EX = LOCKFILE_EXCLUSIVE_LOCK
340
 
    LOCK_NB = LOCKFILE_FAIL_IMMEDIATELY
341
 
    _LockFileEx = ctypes.windll.kernel32.LockFileEx
342
 
    _UnlockFileEx = ctypes.windll.kernel32.UnlockFileEx
343
 
    _GetLastError = ctypes.windll.kernel32.GetLastError
344
 
 
345
 
    ### Define the OVERLAPPED structure.
346
 
    #   http://msdn2.microsoft.com/en-us/library/ms684342.aspx
347
 
    # typedef struct _OVERLAPPED {
348
 
    #   ULONG_PTR Internal;
349
 
    #   ULONG_PTR InternalHigh;
350
 
    #   union {
351
 
    #     struct {
352
 
    #       DWORD Offset;
353
 
    #       DWORD OffsetHigh;
354
 
    #     };
355
 
    #     PVOID Pointer;
356
 
    #   };
357
 
    #   HANDLE hEvent;
358
 
    # } OVERLAPPED,
359
 
 
360
 
    class _inner_struct(ctypes.Structure):
361
 
        _fields_ = [('Offset', ctypes.c_uint), # DWORD
362
 
                    ('OffsetHigh', ctypes.c_uint), # DWORD
363
 
                   ]
364
 
 
365
 
    class _inner_union(ctypes.Union):
366
 
        _fields_  = [('anon_struct', _inner_struct), # struct
367
 
                     ('Pointer', ctypes.c_void_p), # PVOID
368
 
                    ]
369
 
 
370
 
    class OVERLAPPED(ctypes.Structure):
371
 
        _fields_ = [('Internal', ctypes.c_void_p), # ULONG_PTR
372
 
                    ('InternalHigh', ctypes.c_void_p), # ULONG_PTR
373
 
                    ('_inner_union', _inner_union),
374
 
                    ('hEvent', ctypes.c_void_p), # HANDLE
375
 
                   ]
 
412
if have_ctypes_win32:
 
413
    from ctypes.wintypes import DWORD, LPCSTR, LPCWSTR
 
414
    LPSECURITY_ATTRIBUTES = ctypes.c_void_p # used as NULL no need to declare
 
415
    HANDLE = ctypes.c_int # rather than unsigned as in ctypes.wintypes
 
416
    if os.path.supports_unicode_filenames:
 
417
        _function_name = "CreateFileW"
 
418
        LPTSTR = LPCWSTR
 
419
    else:
 
420
        _function_name = "CreateFileA"
 
421
        class LPTSTR(LPCSTR):
 
422
            def __new__(cls, obj):
 
423
                return LPCSTR.__new__(cls, obj.encode("mbcs"))
 
424
 
 
425
    # CreateFile <http://msdn.microsoft.com/en-us/library/aa363858.aspx>
 
426
    _CreateFile = ctypes.WINFUNCTYPE(
 
427
            HANDLE,                # return value
 
428
            LPTSTR,                # lpFileName
 
429
            DWORD,                 # dwDesiredAccess
 
430
            DWORD,                 # dwShareMode
 
431
            LPSECURITY_ATTRIBUTES, # lpSecurityAttributes
 
432
            DWORD,                 # dwCreationDisposition
 
433
            DWORD,                 # dwFlagsAndAttributes
 
434
            HANDLE                 # hTemplateFile
 
435
        )((_function_name, ctypes.windll.kernel32))
 
436
 
 
437
    INVALID_HANDLE_VALUE = -1
 
438
 
 
439
    GENERIC_READ = 0x80000000
 
440
    GENERIC_WRITE = 0x40000000
 
441
    FILE_SHARE_READ = 1
 
442
    OPEN_ALWAYS = 4
 
443
    FILE_ATTRIBUTE_NORMAL = 128
 
444
 
 
445
    ERROR_ACCESS_DENIED = 5
 
446
    ERROR_SHARING_VIOLATION = 32
376
447
 
377
448
    class _ctypes_FileLock(_OSLock):
378
449
 
379
 
        def _lock(self, filename, openmode, lockmode):
380
 
            self._open(filename, openmode)
381
 
 
382
 
            self.hfile = msvcrt.get_osfhandle(self.f.fileno())
383
 
            overlapped = OVERLAPPED()
384
 
            result = _LockFileEx(self.hfile, # HANDLE hFile
385
 
                                 lockmode,   # DWORD dwFlags
386
 
                                 0,          # DWORD dwReserved
387
 
                                 0x7fffffff, # DWORD nNumberOfBytesToLockLow
388
 
                                 0x00000000, # DWORD nNumberOfBytesToLockHigh
389
 
                                 ctypes.byref(overlapped), # lpOverlapped
390
 
                                )
391
 
            if result == 0:
392
 
                self._clear_f()
393
 
                last_err = _GetLastError()
394
 
                if last_err in (ERROR_LOCK_VIOLATION,):
395
 
                    raise errors.LockContention(filename)
396
 
                raise errors.LockContention('Unknown locking error: %s'
397
 
                                            % (last_err,))
 
450
        def _open(self, filename, access, share, cflags, pymode):
 
451
            self.filename = osutils.realpath(filename)
 
452
            handle = _CreateFile(filename, access, share, None, OPEN_ALWAYS,
 
453
                FILE_ATTRIBUTE_NORMAL, 0)
 
454
            if handle in (INVALID_HANDLE_VALUE, 0):
 
455
                e = ctypes.WinError()
 
456
                if e.args[0] == ERROR_ACCESS_DENIED:
 
457
                    raise errors.LockFailed(filename, e)
 
458
                if e.args[0] == ERROR_SHARING_VIOLATION:
 
459
                    raise errors.LockContention(filename, e)
 
460
                raise e
 
461
            fd = msvcrt.open_osfhandle(handle, cflags)
 
462
            self.f = os.fdopen(fd, pymode)
 
463
            return self.f
398
464
 
399
465
        def unlock(self):
400
 
            overlapped = OVERLAPPED()
401
 
            result = _UnlockFileEx(self.hfile, # HANDLE hFile
402
 
                                   0,          # DWORD dwReserved
403
 
                                   0x7fffffff, # DWORD nNumberOfBytesToLockLow
404
 
                                   0x00000000, # DWORD nNumberOfBytesToLockHigh
405
 
                                   ctypes.byref(overlapped), # lpOverlapped
406
 
                                  )
407
466
            self._clear_f()
408
 
            if result == 0:
409
 
                self._clear_f()
410
 
                last_err = _GetLastError()
411
 
                raise errors.LockContention('Unknown unlocking error: %s'
412
 
                                            % (last_err,))
413
467
 
414
468
 
415
469
    class _ctypes_ReadLock(_ctypes_FileLock):
416
470
        def __init__(self, filename):
417
471
            super(_ctypes_ReadLock, self).__init__()
418
 
            self._lock(filename, 'rb', LOCK_SH + LOCK_NB)
 
472
            self._open(filename, GENERIC_READ, FILE_SHARE_READ, os.O_RDONLY,
 
473
                "rb")
419
474
 
420
475
        def temporary_write_lock(self):
421
476
            """Try to grab a write lock on the file.
439
494
    class _ctypes_WriteLock(_ctypes_FileLock):
440
495
        def __init__(self, filename):
441
496
            super(_ctypes_WriteLock, self).__init__()
442
 
            self._lock(filename, 'rb+', LOCK_EX + LOCK_NB)
 
497
            self._open(filename, GENERIC_READ | GENERIC_WRITE, 0, os.O_RDWR,
 
498
                "rb+")
443
499
 
444
500
        def restore_read_lock(self):
445
501
            """Restore the original ReadLock."""