← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/lock.py

(vila) Revise legal option names to be less drastic. (Vincent Ladeuil)

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
16
 
 
 
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
17
16
 
18
17
"""Locking using OS file locks or file existence.
19
18
 
34
33
unlock() method.
35
34
"""
36
35
 
 
36
from __future__ import absolute_import
 
37
 
 
38
import contextlib
37
39
import errno
 
40
import os
38
41
import sys
 
42
import warnings
39
43
 
40
44
from bzrlib import (
 
45
    debug,
41
46
    errors,
42
47
    osutils,
43
48
    trace,
44
49
    )
 
50
from bzrlib.hooks import Hooks
 
51
from bzrlib.i18n import gettext
 
52
 
 
53
class LockHooks(Hooks):
 
54
 
 
55
    def __init__(self):
 
56
        Hooks.__init__(self, "bzrlib.lock", "Lock.hooks")
 
57
        self.add_hook('lock_acquired',
 
58
            "Called with a bzrlib.lock.LockResult when a physical lock is "
 
59
            "acquired.", (1, 8))
 
60
        self.add_hook('lock_released',
 
61
            "Called with a bzrlib.lock.LockResult when a physical lock is "
 
62
            "released.", (1, 8))
 
63
        self.add_hook('lock_broken',
 
64
            "Called with a bzrlib.lock.LockResult when a physical lock is "
 
65
            "broken.", (1, 15))
 
66
 
 
67
 
 
68
class Lock(object):
 
69
    """Base class for locks.
 
70
 
 
71
    :cvar hooks: Hook dictionary for operations on locks.
 
72
    """
 
73
 
 
74
    hooks = LockHooks()
 
75
 
 
76
 
 
77
class LockResult(object):
 
78
    """Result of an operation on a lock; passed to a hook"""
 
79
 
 
80
    def __init__(self, lock_url, details=None):
 
81
        """Create a lock result for lock with optional details about the lock."""
 
82
        self.lock_url = lock_url
 
83
        self.details = details
 
84
 
 
85
    def __eq__(self, other):
 
86
        return self.lock_url == other.lock_url and self.details == other.details
 
87
 
 
88
    def __repr__(self):
 
89
        return '%s(%s, %s)' % (self.__class__.__name__,
 
90
                             self.lock_url, self.details)
 
91
 
 
92
 
 
93
class LogicalLockResult(object):
 
94
    """The result of a lock_read/lock_write/lock_tree_write call on lockables.
 
95
 
 
96
    :ivar unlock: A callable which will unlock the lock.
 
97
    """
 
98
 
 
99
    def __init__(self, unlock):
 
100
        self.unlock = unlock
 
101
 
 
102
    def __repr__(self):
 
103
        return "LogicalLockResult(%s)" % (self.unlock)
 
104
 
 
105
 
 
106
 
 
107
def cant_unlock_not_held(locked_object):
 
108
    """An attempt to unlock failed because the object was not locked.
 
109
 
 
110
    This provides a policy point from which we can generate either a warning 
 
111
    or an exception.
 
112
    """
 
113
    # This is typically masking some other error and called from a finally
 
114
    # block, so it's useful to have the option not to generate a new error
 
115
    # here.  You can use -Werror to make it fatal.  It should possibly also
 
116
    # raise LockNotHeld.
 
117
    if 'unlock' in debug.debug_flags:
 
118
        warnings.warn("%r is already unlocked" % (locked_object,),
 
119
            stacklevel=3)
 
120
    else:
 
121
        raise errors.LockNotHeld(locked_object)
 
122
 
 
123
 
 
124
try:
 
125
    import fcntl
 
126
    have_fcntl = True
 
127
except ImportError:
 
128
    have_fcntl = False
 
129
 
 
130
have_pywin32 = False
 
131
have_ctypes_win32 = False
 
132
if sys.platform == 'win32':
 
133
    import msvcrt
 
134
    try:
 
135
        import win32file, pywintypes, winerror
 
136
        have_pywin32 = True
 
137
    except ImportError:
 
138
        pass
 
139
 
 
140
    try:
 
141
        import ctypes
 
142
        have_ctypes_win32 = True
 
143
    except ImportError:
 
144
        pass
45
145
 
46
146
 
47
147
class _OSLock(object):
57
157
            return self.f
58
158
        except IOError, e:
59
159
            if e.errno in (errno.EACCES, errno.EPERM):
60
 
                raise errors.ReadOnlyLockError(self.filename, str(e))
 
160
                raise errors.LockFailed(self.filename, str(e))
61
161
            if e.errno != errno.ENOENT:
62
162
                raise
63
163
 
73
173
            self.f.close()
74
174
            self.f = None
75
175
 
76
 
    def __del__(self):
77
 
        if self.f:
78
 
            from warnings import warn
79
 
            warn("lock on %r not released" % self.f)
80
 
            self.unlock()
81
 
 
82
176
    def unlock(self):
83
177
        raise NotImplementedError()
84
178
 
85
179
 
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
180
_lock_classes = []
104
181
 
105
182
 
106
183
if have_fcntl:
107
 
    LOCK_SH = fcntl.LOCK_SH
108
 
    LOCK_NB = fcntl.LOCK_NB
109
 
    lock_EX = fcntl.LOCK_EX
110
 
 
111
184
 
112
185
    class _fcntl_FileLock(_OSLock):
113
186
 
127
200
            if self.filename in _fcntl_WriteLock._open_locks:
128
201
                self._clear_f()
129
202
                raise errors.LockContention(self.filename)
 
203
            if self.filename in _fcntl_ReadLock._open_locks:
 
204
                if 'strict_locks' in debug.debug_flags:
 
205
                    self._clear_f()
 
206
                    raise errors.LockContention(self.filename)
 
207
                else:
 
208
                    trace.mutter('Write lock taken w/ an open read lock on: %s'
 
209
                                 % (self.filename,))
130
210
 
131
211
            self._open(self.filename, 'rb+')
132
212
            # 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.
 
213
            # at this point unlock() will be called, because self.f is set.
134
214
            # TODO: make this fully threadsafe, if we decide we care.
135
215
            _fcntl_WriteLock._open_locks.add(self.filename)
136
216
            try:
143
223
                    self.unlock()
144
224
                # we should be more precise about whats a locking
145
225
                # error and whats a random-other error
146
 
                raise errors.LockContention(e)
 
226
                raise errors.LockContention(self.filename, e)
147
227
 
148
228
        def unlock(self):
149
229
            _fcntl_WriteLock._open_locks.remove(self.filename)
157
237
        def __init__(self, filename):
158
238
            super(_fcntl_ReadLock, self).__init__()
159
239
            self.filename = osutils.realpath(filename)
 
240
            if self.filename in _fcntl_WriteLock._open_locks:
 
241
                if 'strict_locks' in debug.debug_flags:
 
242
                    # We raise before calling _open so we don't need to
 
243
                    # _clear_f
 
244
                    raise errors.LockContention(self.filename)
 
245
                else:
 
246
                    trace.mutter('Read lock taken w/ an open write lock on: %s'
 
247
                                 % (self.filename,))
160
248
            _fcntl_ReadLock._open_locks.setdefault(self.filename, 0)
161
249
            _fcntl_ReadLock._open_locks[self.filename] += 1
162
250
            self._open(filename, 'rb')
167
255
            except IOError, e:
168
256
                # we should be more precise about whats a locking
169
257
                # error and whats a random-other error
170
 
                raise errors.LockContention(e)
 
258
                raise errors.LockContention(self.filename, e)
171
259
 
172
260
        def unlock(self):
173
261
            count = _fcntl_ReadLock._open_locks[self.filename]
187
275
 
188
276
            :return: A token which can be used to switch back to a read lock.
189
277
            """
190
 
            assert self.filename not in _fcntl_WriteLock._open_locks
 
278
            if self.filename in _fcntl_WriteLock._open_locks:
 
279
                raise AssertionError('file already locked: %r'
 
280
                    % (self.filename,))
191
281
            try:
192
282
                wlock = _fcntl_TemporaryWriteLock(self)
193
283
            except errors.LockError:
213
303
                # write lock.
214
304
                raise errors.LockContention(self.filename)
215
305
 
216
 
            assert self.filename not in _fcntl_WriteLock._open_locks
 
306
            if self.filename in _fcntl_WriteLock._open_locks:
 
307
                raise AssertionError('file already locked: %r'
 
308
                    % (self.filename,))
217
309
 
218
310
            # See if we can open the file for writing. Another process might
219
311
            # have a read lock. We don't use self._open() because we don't want
223
315
                new_f = open(self.filename, 'rb+')
224
316
            except IOError, e:
225
317
                if e.errno in (errno.EACCES, errno.EPERM):
226
 
                    raise errors.ReadOnlyLockError(self.filename, str(e))
 
318
                    raise errors.LockFailed(self.filename, str(e))
227
319
                raise
228
320
            try:
229
321
                # LOCK_NB will cause IOError to be raised if we can't grab a
231
323
                fcntl.lockf(new_f, fcntl.LOCK_EX | fcntl.LOCK_NB)
232
324
            except IOError, e:
233
325
                # TODO: Raise a more specific error based on the type of error
234
 
                raise errors.LockContention(e)
 
326
                raise errors.LockContention(self.filename, e)
235
327
            _fcntl_WriteLock._open_locks.add(self.filename)
236
328
 
237
329
            self.f = new_f
253
345
 
254
346
 
255
347
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
 
 
 
348
    if os.path.supports_unicode_filenames:
 
349
        # for Windows NT/2K/XP/etc
 
350
        win32file_CreateFile = win32file.CreateFileW
 
351
    else:
 
352
        # for Windows 98
 
353
        win32file_CreateFile = win32file.CreateFile
260
354
 
261
355
    class _w32c_FileLock(_OSLock):
262
356
 
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()
 
357
        def _open(self, filename, access, share, cflags, pymode):
 
358
            self.filename = osutils.realpath(filename)
268
359
            try:
269
 
                win32file.LockFileEx(self.hfile, lockmode, 0, 0x7fff0000,
270
 
                                     overlapped)
 
360
                self._handle = win32file_CreateFile(filename, access, share,
 
361
                    None, win32file.OPEN_ALWAYS,
 
362
                    win32file.FILE_ATTRIBUTE_NORMAL, None)
271
363
            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()
 
364
                if e.args[0] == winerror.ERROR_ACCESS_DENIED:
 
365
                    raise errors.LockFailed(filename, e)
 
366
                if e.args[0] == winerror.ERROR_SHARING_VIOLATION:
 
367
                    raise errors.LockContention(filename, e)
276
368
                raise
277
 
            except Exception, e:
278
 
                self._clear_f()
279
 
                raise errors.LockContention(e)
 
369
            fd = win32file._open_osfhandle(self._handle, cflags)
 
370
            self.f = os.fdopen(fd, pymode)
 
371
            return self.f
280
372
 
281
373
        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)
 
374
            self._clear_f()
 
375
            self._handle = None
288
376
 
289
377
 
290
378
    class _w32c_ReadLock(_w32c_FileLock):
291
379
        def __init__(self, filename):
292
380
            super(_w32c_ReadLock, self).__init__()
293
 
            self._lock(filename, 'rb', LOCK_SH + LOCK_NB)
 
381
            self._open(filename, win32file.GENERIC_READ,
 
382
                win32file.FILE_SHARE_READ, os.O_RDONLY, "rb")
294
383
 
295
384
        def temporary_write_lock(self):
296
385
            """Try to grab a write lock on the file.
315
404
    class _w32c_WriteLock(_w32c_FileLock):
316
405
        def __init__(self, filename):
317
406
            super(_w32c_WriteLock, self).__init__()
318
 
            self._lock(filename, 'rb+', LOCK_EX + LOCK_NB)
 
407
            self._open(filename,
 
408
                win32file.GENERIC_READ | win32file.GENERIC_WRITE, 0,
 
409
                os.O_RDWR, "rb+")
319
410
 
320
411
        def restore_read_lock(self):
321
412
            """Restore the original ReadLock."""
328
419
    _lock_classes.append(('pywin32', _w32c_WriteLock, _w32c_ReadLock))
329
420
 
330
421
 
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
 
                   ]
 
422
if have_ctypes_win32:
 
423
    from ctypes.wintypes import DWORD, LPCSTR, LPCWSTR
 
424
    LPSECURITY_ATTRIBUTES = ctypes.c_void_p # used as NULL no need to declare
 
425
    HANDLE = ctypes.c_int # rather than unsigned as in ctypes.wintypes
 
426
    if os.path.supports_unicode_filenames:
 
427
        _function_name = "CreateFileW"
 
428
        LPTSTR = LPCWSTR
 
429
    else:
 
430
        _function_name = "CreateFileA"
 
431
        class LPTSTR(LPCSTR):
 
432
            def __new__(cls, obj):
 
433
                return LPCSTR.__new__(cls, obj.encode("mbcs"))
 
434
 
 
435
    # CreateFile <http://msdn.microsoft.com/en-us/library/aa363858.aspx>
 
436
    _CreateFile = ctypes.WINFUNCTYPE(
 
437
            HANDLE,                # return value
 
438
            LPTSTR,                # lpFileName
 
439
            DWORD,                 # dwDesiredAccess
 
440
            DWORD,                 # dwShareMode
 
441
            LPSECURITY_ATTRIBUTES, # lpSecurityAttributes
 
442
            DWORD,                 # dwCreationDisposition
 
443
            DWORD,                 # dwFlagsAndAttributes
 
444
            HANDLE                 # hTemplateFile
 
445
        )((_function_name, ctypes.windll.kernel32))
 
446
 
 
447
    INVALID_HANDLE_VALUE = -1
 
448
 
 
449
    GENERIC_READ = 0x80000000
 
450
    GENERIC_WRITE = 0x40000000
 
451
    FILE_SHARE_READ = 1
 
452
    OPEN_ALWAYS = 4
 
453
    FILE_ATTRIBUTE_NORMAL = 128
 
454
 
 
455
    ERROR_ACCESS_DENIED = 5
 
456
    ERROR_SHARING_VIOLATION = 32
376
457
 
377
458
    class _ctypes_FileLock(_OSLock):
378
459
 
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,))
 
460
        def _open(self, filename, access, share, cflags, pymode):
 
461
            self.filename = osutils.realpath(filename)
 
462
            handle = _CreateFile(filename, access, share, None, OPEN_ALWAYS,
 
463
                FILE_ATTRIBUTE_NORMAL, 0)
 
464
            if handle in (INVALID_HANDLE_VALUE, 0):
 
465
                e = ctypes.WinError()
 
466
                if e.args[0] == ERROR_ACCESS_DENIED:
 
467
                    raise errors.LockFailed(filename, e)
 
468
                if e.args[0] == ERROR_SHARING_VIOLATION:
 
469
                    raise errors.LockContention(filename, e)
 
470
                raise e
 
471
            fd = msvcrt.open_osfhandle(handle, cflags)
 
472
            self.f = os.fdopen(fd, pymode)
 
473
            return self.f
398
474
 
399
475
        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
476
            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
477
 
414
478
 
415
479
    class _ctypes_ReadLock(_ctypes_FileLock):
416
480
        def __init__(self, filename):
417
481
            super(_ctypes_ReadLock, self).__init__()
418
 
            self._lock(filename, 'rb', LOCK_SH + LOCK_NB)
 
482
            self._open(filename, GENERIC_READ, FILE_SHARE_READ, os.O_RDONLY,
 
483
                "rb")
419
484
 
420
485
        def temporary_write_lock(self):
421
486
            """Try to grab a write lock on the file.
439
504
    class _ctypes_WriteLock(_ctypes_FileLock):
440
505
        def __init__(self, filename):
441
506
            super(_ctypes_WriteLock, self).__init__()
442
 
            self._lock(filename, 'rb+', LOCK_EX + LOCK_NB)
 
507
            self._open(filename, GENERIC_READ | GENERIC_WRITE, 0, os.O_RDWR,
 
508
                "rb+")
443
509
 
444
510
        def restore_read_lock(self):
445
511
            """Restore the original ReadLock."""
462
528
# We default to using the first available lock class.
463
529
_lock_type, WriteLock, ReadLock = _lock_classes[0]
464
530
 
 
531
 
 
532
class _RelockDebugMixin(object):
 
533
    """Mixin support for -Drelock flag.
 
534
 
 
535
    Add this as a base class then call self._note_lock with 'r' or 'w' when
 
536
    acquiring a read- or write-lock.  If this object was previously locked (and
 
537
    locked the same way), and -Drelock is set, then this will trace.note a
 
538
    message about it.
 
539
    """
 
540
 
 
541
    _prev_lock = None
 
542
 
 
543
    def _note_lock(self, lock_type):
 
544
        if 'relock' in debug.debug_flags and self._prev_lock == lock_type:
 
545
            if lock_type == 'r':
 
546
                type_name = 'read'
 
547
            else:
 
548
                type_name = 'write'
 
549
            trace.note(gettext('{0!r} was {1} locked again'), self, type_name)
 
550
        self._prev_lock = lock_type
 
551
 
 
552
@contextlib.contextmanager
 
553
def write_locked(lockable):
 
554
    lockable.lock_write()
 
555
    try:
 
556
        yield lockable
 
557
    finally:
 
558
        lockable.unlock()