← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/lock.py

  • Committer: Andrew Bennetts
  • Date: 2010-10-08 08:15:14 UTC
  • mto: This revision was merged to the branch mainline in revision 5498.
  • Revision ID: andrew.bennetts@canonical.com-20101008081514-dviqzrdfwyzsqbz2
Split NEWS into per-release doc/en/release-notes/bzr-*.txt

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-2010 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
class LogicalLockResult(object):
 
92
    """The result of a lock_read/lock_write/lock_tree_write call on lockables.
 
93
 
 
94
    :ivar unlock: A callable which will unlock the lock.
 
95
    """
 
96
 
 
97
    def __init__(self, unlock):
 
98
        self.unlock = unlock
 
99
 
 
100
    def __repr__(self):
 
101
        return "LogicalLockResult(%s)" % (self.unlock)
 
102
 
 
103
 
 
104
 
 
105
def cant_unlock_not_held(locked_object):
 
106
    """An attempt to unlock failed because the object was not locked.
 
107
 
 
108
    This provides a policy point from which we can generate either a warning 
 
109
    or an exception.
 
110
    """
 
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
 
114
    # raise LockNotHeld.
 
115
    if 'unlock' in debug.debug_flags:
 
116
        warnings.warn("%r is already unlocked" % (locked_object,),
 
117
            stacklevel=3)
 
118
    else:
 
119
        raise errors.LockNotHeld(locked_object)
 
120
 
 
121
 
 
122
try:
 
123
    import fcntl
 
124
    have_fcntl = True
 
125
except ImportError:
 
126
    have_fcntl = False
 
127
 
 
128
have_pywin32 = False
 
129
have_ctypes_win32 = False
 
130
if sys.platform == 'win32':
 
131
    import msvcrt
 
132
    try:
 
133
        import win32file, pywintypes, winerror
 
134
        have_pywin32 = True
 
135
    except ImportError:
 
136
        pass
 
137
 
 
138
    try:
 
139
        import ctypes
 
140
        have_ctypes_win32 = True
 
141
    except ImportError:
 
142
        pass
45
143
 
46
144
 
47
145
class _OSLock(object):
57
155
            return self.f
58
156
        except IOError, e:
59
157
            if e.errno in (errno.EACCES, errno.EPERM):
60
 
                raise errors.ReadOnlyLockError(self.filename, str(e))
 
158
                raise errors.LockFailed(self.filename, str(e))
61
159
            if e.errno != errno.ENOENT:
62
160
                raise
63
161
 
83
181
        raise NotImplementedError()
84
182
 
85
183
 
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
184
_lock_classes = []
104
185
 
105
186
 
106
187
if have_fcntl:
107
 
    LOCK_SH = fcntl.LOCK_SH
108
 
    LOCK_NB = fcntl.LOCK_NB
109
 
    lock_EX = fcntl.LOCK_EX
110
 
 
111
188
 
112
189
    class _fcntl_FileLock(_OSLock):
113
190
 
127
204
            if self.filename in _fcntl_WriteLock._open_locks:
128
205
                self._clear_f()
129
206
                raise errors.LockContention(self.filename)
 
207
            if self.filename in _fcntl_ReadLock._open_locks:
 
208
                if 'strict_locks' in debug.debug_flags:
 
209
                    self._clear_f()
 
210
                    raise errors.LockContention(self.filename)
 
211
                else:
 
212
                    trace.mutter('Write lock taken w/ an open read lock on: %s'
 
213
                                 % (self.filename,))
130
214
 
131
215
            self._open(self.filename, 'rb+')
132
216
            # reserve a slot for this lock - even if the lockf call fails,
133
 
            # at thisi point unlock() will be called, because self.f is set.
 
217
            # at this point unlock() will be called, because self.f is set.
134
218
            # TODO: make this fully threadsafe, if we decide we care.
135
219
            _fcntl_WriteLock._open_locks.add(self.filename)
136
220
            try:
143
227
                    self.unlock()
144
228
                # we should be more precise about whats a locking
145
229
                # error and whats a random-other error
146
 
                raise errors.LockContention(e)
 
230
                raise errors.LockContention(self.filename, e)
147
231
 
148
232
        def unlock(self):
149
233
            _fcntl_WriteLock._open_locks.remove(self.filename)
157
241
        def __init__(self, filename):
158
242
            super(_fcntl_ReadLock, self).__init__()
159
243
            self.filename = osutils.realpath(filename)
 
244
            if self.filename in _fcntl_WriteLock._open_locks:
 
245
                if 'strict_locks' in debug.debug_flags:
 
246
                    # We raise before calling _open so we don't need to
 
247
                    # _clear_f
 
248
                    raise errors.LockContention(self.filename)
 
249
                else:
 
250
                    trace.mutter('Read lock taken w/ an open write lock on: %s'
 
251
                                 % (self.filename,))
160
252
            _fcntl_ReadLock._open_locks.setdefault(self.filename, 0)
161
253
            _fcntl_ReadLock._open_locks[self.filename] += 1
162
254
            self._open(filename, 'rb')
167
259
            except IOError, e:
168
260
                # we should be more precise about whats a locking
169
261
                # error and whats a random-other error
170
 
                raise errors.LockContention(e)
 
262
                raise errors.LockContention(self.filename, e)
171
263
 
172
264
        def unlock(self):
173
265
            count = _fcntl_ReadLock._open_locks[self.filename]
187
279
 
188
280
            :return: A token which can be used to switch back to a read lock.
189
281
            """
190
 
            assert self.filename not in _fcntl_WriteLock._open_locks
 
282
            if self.filename in _fcntl_WriteLock._open_locks:
 
283
                raise AssertionError('file already locked: %r'
 
284
                    % (self.filename,))
191
285
            try:
192
286
                wlock = _fcntl_TemporaryWriteLock(self)
193
287
            except errors.LockError:
213
307
                # write lock.
214
308
                raise errors.LockContention(self.filename)
215
309
 
216
 
            assert self.filename not in _fcntl_WriteLock._open_locks
 
310
            if self.filename in _fcntl_WriteLock._open_locks:
 
311
                raise AssertionError('file already locked: %r'
 
312
                    % (self.filename,))
217
313
 
218
314
            # See if we can open the file for writing. Another process might
219
315
            # have a read lock. We don't use self._open() because we don't want
223
319
                new_f = open(self.filename, 'rb+')
224
320
            except IOError, e:
225
321
                if e.errno in (errno.EACCES, errno.EPERM):
226
 
                    raise errors.ReadOnlyLockError(self.filename, str(e))
 
322
                    raise errors.LockFailed(self.filename, str(e))
227
323
                raise
228
324
            try:
229
325
                # LOCK_NB will cause IOError to be raised if we can't grab a
231
327
                fcntl.lockf(new_f, fcntl.LOCK_EX | fcntl.LOCK_NB)
232
328
            except IOError, e:
233
329
                # TODO: Raise a more specific error based on the type of error
234
 
                raise errors.LockContention(e)
 
330
                raise errors.LockContention(self.filename, e)
235
331
            _fcntl_WriteLock._open_locks.add(self.filename)
236
332
 
237
333
            self.f = new_f
253
349
 
254
350
 
255
351
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
 
 
 
352
    if os.path.supports_unicode_filenames:
 
353
        # for Windows NT/2K/XP/etc
 
354
        win32file_CreateFile = win32file.CreateFileW
 
355
    else:
 
356
        # for Windows 98
 
357
        win32file_CreateFile = win32file.CreateFile
260
358
 
261
359
    class _w32c_FileLock(_OSLock):
262
360
 
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()
 
361
        def _open(self, filename, access, share, cflags, pymode):
 
362
            self.filename = osutils.realpath(filename)
268
363
            try:
269
 
                win32file.LockFileEx(self.hfile, lockmode, 0, 0x7fff0000,
270
 
                                     overlapped)
 
364
                self._handle = win32file_CreateFile(filename, access, share,
 
365
                    None, win32file.OPEN_ALWAYS,
 
366
                    win32file.FILE_ATTRIBUTE_NORMAL, None)
271
367
            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()
 
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)
276
372
                raise
277
 
            except Exception, e:
278
 
                self._clear_f()
279
 
                raise errors.LockContention(e)
 
373
            fd = win32file._open_osfhandle(self._handle, cflags)
 
374
            self.f = os.fdopen(fd, pymode)
 
375
            return self.f
280
376
 
281
377
        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)
 
378
            self._clear_f()
 
379
            self._handle = None
288
380
 
289
381
 
290
382
    class _w32c_ReadLock(_w32c_FileLock):
291
383
        def __init__(self, filename):
292
384
            super(_w32c_ReadLock, self).__init__()
293
 
            self._lock(filename, 'rb', LOCK_SH + LOCK_NB)
 
385
            self._open(filename, win32file.GENERIC_READ,
 
386
                win32file.FILE_SHARE_READ, os.O_RDONLY, "rb")
294
387
 
295
388
        def temporary_write_lock(self):
296
389
            """Try to grab a write lock on the file.
315
408
    class _w32c_WriteLock(_w32c_FileLock):
316
409
        def __init__(self, filename):
317
410
            super(_w32c_WriteLock, self).__init__()
318
 
            self._lock(filename, 'rb+', LOCK_EX + LOCK_NB)
 
411
            self._open(filename,
 
412
                win32file.GENERIC_READ | win32file.GENERIC_WRITE, 0,
 
413
                os.O_RDWR, "rb+")
319
414
 
320
415
        def restore_read_lock(self):
321
416
            """Restore the original ReadLock."""
328
423
    _lock_classes.append(('pywin32', _w32c_WriteLock, _w32c_ReadLock))
329
424
 
330
425
 
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
 
                   ]
 
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"
 
432
        LPTSTR = LPCWSTR
 
433
    else:
 
434
        _function_name = "CreateFileA"
 
435
        class LPTSTR(LPCSTR):
 
436
            def __new__(cls, obj):
 
437
                return LPCSTR.__new__(cls, obj.encode("mbcs"))
 
438
 
 
439
    # CreateFile <http://msdn.microsoft.com/en-us/library/aa363858.aspx>
 
440
    _CreateFile = ctypes.WINFUNCTYPE(
 
441
            HANDLE,                # return value
 
442
            LPTSTR,                # lpFileName
 
443
            DWORD,                 # dwDesiredAccess
 
444
            DWORD,                 # dwShareMode
 
445
            LPSECURITY_ATTRIBUTES, # lpSecurityAttributes
 
446
            DWORD,                 # dwCreationDisposition
 
447
            DWORD,                 # dwFlagsAndAttributes
 
448
            HANDLE                 # hTemplateFile
 
449
        )((_function_name, ctypes.windll.kernel32))
 
450
 
 
451
    INVALID_HANDLE_VALUE = -1
 
452
 
 
453
    GENERIC_READ = 0x80000000
 
454
    GENERIC_WRITE = 0x40000000
 
455
    FILE_SHARE_READ = 1
 
456
    OPEN_ALWAYS = 4
 
457
    FILE_ATTRIBUTE_NORMAL = 128
 
458
 
 
459
    ERROR_ACCESS_DENIED = 5
 
460
    ERROR_SHARING_VIOLATION = 32
376
461
 
377
462
    class _ctypes_FileLock(_OSLock):
378
463
 
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,))
 
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)
 
474
                raise e
 
475
            fd = msvcrt.open_osfhandle(handle, cflags)
 
476
            self.f = os.fdopen(fd, pymode)
 
477
            return self.f
398
478
 
399
479
        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
480
            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
481
 
414
482
 
415
483
    class _ctypes_ReadLock(_ctypes_FileLock):
416
484
        def __init__(self, filename):
417
485
            super(_ctypes_ReadLock, self).__init__()
418
 
            self._lock(filename, 'rb', LOCK_SH + LOCK_NB)
 
486
            self._open(filename, GENERIC_READ, FILE_SHARE_READ, os.O_RDONLY,
 
487
                "rb")
419
488
 
420
489
        def temporary_write_lock(self):
421
490
            """Try to grab a write lock on the file.
439
508
    class _ctypes_WriteLock(_ctypes_FileLock):
440
509
        def __init__(self, filename):
441
510
            super(_ctypes_WriteLock, self).__init__()
442
 
            self._lock(filename, 'rb+', LOCK_EX + LOCK_NB)
 
511
            self._open(filename, GENERIC_READ | GENERIC_WRITE, 0, os.O_RDWR,
 
512
                "rb+")
443
513
 
444
514
        def restore_read_lock(self):
445
515
            """Restore the original ReadLock."""
462
532
# We default to using the first available lock class.
463
533
_lock_type, WriteLock, ReadLock = _lock_classes[0]
464
534
 
 
535
 
 
536
class _RelockDebugMixin(object):
 
537
    """Mixin support for -Drelock flag.
 
538
 
 
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
 
542
    message about it.
 
543
    """
 
544
    
 
545
    _prev_lock = None
 
546
 
 
547
    def _note_lock(self, lock_type):
 
548
        if 'relock' in debug.debug_flags and self._prev_lock == lock_type:
 
549
            if lock_type == 'r':
 
550
                type_name = 'read'
 
551
            else:
 
552
                type_name = 'write'
 
553
            trace.note('%r was %s locked again', self, type_name)
 
554
        self._prev_lock = lock_type
 
555