← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/lock.py

  • Committer: Canonical.com Patch Queue Manager
  • Date: 2008-09-11 06:10:59 UTC
  • mfrom: (3702.1.1 trivial)
  • Revision ID: pqm@pqm.ubuntu.com-20080911061059-svzqfejar17ui4zw
(mbp) KnitVersionedFiles repr

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/lock.py
1
 
# Copyright (C) 2005-2010 Canonical Ltd
 
1
# Copyright (C) 2005, 2006, 2007 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  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
39
38
import sys
40
 
import warnings
41
39
 
42
40
from bzrlib import (
43
 
    debug,
44
41
    errors,
45
42
    osutils,
46
43
    trace,
47
44
    )
48
 
from bzrlib.hooks import Hooks
49
 
 
50
 
 
51
 
class LockHooks(Hooks):
52
 
 
53
 
    def __init__(self):
54
 
        Hooks.__init__(self, "bzrlib.lock", "Lock.hooks")
55
 
        self.add_hook('lock_acquired',
56
 
            "Called with a bzrlib.lock.LockResult when a physical lock is "
57
 
            "acquired.", (1, 8))
58
 
        self.add_hook('lock_released',
59
 
            "Called with a bzrlib.lock.LockResult when a physical lock is "
60
 
            "released.", (1, 8))
61
 
        self.add_hook('lock_broken',
62
 
            "Called with a bzrlib.lock.LockResult when a physical lock is "
63
 
            "broken.", (1, 15))
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
143
45
 
144
46
 
145
47
class _OSLock(object):
171
73
            self.f.close()
172
74
            self.f = None
173
75
 
 
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
 
174
82
    def unlock(self):
175
83
        raise NotImplementedError()
176
84
 
177
85
 
 
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
 
178
103
_lock_classes = []
179
104
 
180
105
 
181
106
if have_fcntl:
 
107
    LOCK_SH = fcntl.LOCK_SH
 
108
    LOCK_NB = fcntl.LOCK_NB
 
109
    lock_EX = fcntl.LOCK_EX
 
110
 
182
111
 
183
112
    class _fcntl_FileLock(_OSLock):
184
113
 
198
127
            if self.filename in _fcntl_WriteLock._open_locks:
199
128
                self._clear_f()
200
129
                raise errors.LockContention(self.filename)
201
 
            if self.filename in _fcntl_ReadLock._open_locks:
202
 
                if 'strict_locks' in debug.debug_flags:
203
 
                    self._clear_f()
204
 
                    raise errors.LockContention(self.filename)
205
 
                else:
206
 
                    trace.mutter('Write lock taken w/ an open read lock on: %s'
207
 
                                 % (self.filename,))
208
130
 
209
131
            self._open(self.filename, 'rb+')
210
132
            # reserve a slot for this lock - even if the lockf call fails,
211
 
            # at this point unlock() will be called, because self.f is set.
 
133
            # at thisi point unlock() will be called, because self.f is set.
212
134
            # TODO: make this fully threadsafe, if we decide we care.
213
135
            _fcntl_WriteLock._open_locks.add(self.filename)
214
136
            try:
221
143
                    self.unlock()
222
144
                # we should be more precise about whats a locking
223
145
                # error and whats a random-other error
224
 
                raise errors.LockContention(self.filename, e)
 
146
                raise errors.LockContention(e)
225
147
 
226
148
        def unlock(self):
227
149
            _fcntl_WriteLock._open_locks.remove(self.filename)
235
157
        def __init__(self, filename):
236
158
            super(_fcntl_ReadLock, self).__init__()
237
159
            self.filename = osutils.realpath(filename)
238
 
            if self.filename in _fcntl_WriteLock._open_locks:
239
 
                if 'strict_locks' in debug.debug_flags:
240
 
                    # We raise before calling _open so we don't need to
241
 
                    # _clear_f
242
 
                    raise errors.LockContention(self.filename)
243
 
                else:
244
 
                    trace.mutter('Read lock taken w/ an open write lock on: %s'
245
 
                                 % (self.filename,))
246
160
            _fcntl_ReadLock._open_locks.setdefault(self.filename, 0)
247
161
            _fcntl_ReadLock._open_locks[self.filename] += 1
248
162
            self._open(filename, 'rb')
253
167
            except IOError, e:
254
168
                # we should be more precise about whats a locking
255
169
                # error and whats a random-other error
256
 
                raise errors.LockContention(self.filename, e)
 
170
                raise errors.LockContention(e)
257
171
 
258
172
        def unlock(self):
259
173
            count = _fcntl_ReadLock._open_locks[self.filename]
321
235
                fcntl.lockf(new_f, fcntl.LOCK_EX | fcntl.LOCK_NB)
322
236
            except IOError, e:
323
237
                # TODO: Raise a more specific error based on the type of error
324
 
                raise errors.LockContention(self.filename, e)
 
238
                raise errors.LockContention(e)
325
239
            _fcntl_WriteLock._open_locks.add(self.filename)
326
240
 
327
241
            self.f = new_f
343
257
 
344
258
 
345
259
if have_pywin32 and sys.platform == 'win32':
346
 
    if os.path.supports_unicode_filenames:
347
 
        # for Windows NT/2K/XP/etc
348
 
        win32file_CreateFile = win32file.CreateFileW
349
 
    else:
350
 
        # for Windows 98
351
 
        win32file_CreateFile = win32file.CreateFile
 
260
    LOCK_SH = 0 # the default
 
261
    LOCK_EX = win32con.LOCKFILE_EXCLUSIVE_LOCK
 
262
    LOCK_NB = win32con.LOCKFILE_FAIL_IMMEDIATELY
 
263
 
352
264
 
353
265
    class _w32c_FileLock(_OSLock):
354
266
 
355
 
        def _open(self, filename, access, share, cflags, pymode):
356
 
            self.filename = osutils.realpath(filename)
 
267
        def _lock(self, filename, openmode, lockmode):
 
268
            self._open(filename, openmode)
 
269
 
 
270
            self.hfile = msvcrt.get_osfhandle(self.f.fileno())
 
271
            overlapped = pywintypes.OVERLAPPED()
357
272
            try:
358
 
                self._handle = win32file_CreateFile(filename, access, share,
359
 
                    None, win32file.OPEN_ALWAYS,
360
 
                    win32file.FILE_ATTRIBUTE_NORMAL, None)
 
273
                win32file.LockFileEx(self.hfile, lockmode, 0, 0x7fff0000,
 
274
                                     overlapped)
361
275
            except pywintypes.error, e:
362
 
                if e.args[0] == winerror.ERROR_ACCESS_DENIED:
363
 
                    raise errors.LockFailed(filename, e)
364
 
                if e.args[0] == winerror.ERROR_SHARING_VIOLATION:
365
 
                    raise errors.LockContention(filename, e)
 
276
                self._clear_f()
 
277
                if e.args[0] in (winerror.ERROR_LOCK_VIOLATION,):
 
278
                    raise errors.LockContention(filename)
 
279
                ## import pdb; pdb.set_trace()
366
280
                raise
367
 
            fd = win32file._open_osfhandle(self._handle, cflags)
368
 
            self.f = os.fdopen(fd, pymode)
369
 
            return self.f
 
281
            except Exception, e:
 
282
                self._clear_f()
 
283
                raise errors.LockContention(e)
370
284
 
371
285
        def unlock(self):
372
 
            self._clear_f()
373
 
            self._handle = None
 
286
            overlapped = pywintypes.OVERLAPPED()
 
287
            try:
 
288
                win32file.UnlockFileEx(self.hfile, 0, 0x7fff0000, overlapped)
 
289
                self._clear_f()
 
290
            except Exception, e:
 
291
                raise errors.LockContention(e)
374
292
 
375
293
 
376
294
    class _w32c_ReadLock(_w32c_FileLock):
377
295
        def __init__(self, filename):
378
296
            super(_w32c_ReadLock, self).__init__()
379
 
            self._open(filename, win32file.GENERIC_READ,
380
 
                win32file.FILE_SHARE_READ, os.O_RDONLY, "rb")
 
297
            self._lock(filename, 'rb', LOCK_SH + LOCK_NB)
381
298
 
382
299
        def temporary_write_lock(self):
383
300
            """Try to grab a write lock on the file.
402
319
    class _w32c_WriteLock(_w32c_FileLock):
403
320
        def __init__(self, filename):
404
321
            super(_w32c_WriteLock, self).__init__()
405
 
            self._open(filename,
406
 
                win32file.GENERIC_READ | win32file.GENERIC_WRITE, 0,
407
 
                os.O_RDWR, "rb+")
 
322
            self._lock(filename, 'rb+', LOCK_EX + LOCK_NB)
408
323
 
409
324
        def restore_read_lock(self):
410
325
            """Restore the original ReadLock."""
417
332
    _lock_classes.append(('pywin32', _w32c_WriteLock, _w32c_ReadLock))
418
333
 
419
334
 
420
 
if have_ctypes_win32:
421
 
    from ctypes.wintypes import DWORD, LPCSTR, LPCWSTR
422
 
    LPSECURITY_ATTRIBUTES = ctypes.c_void_p # used as NULL no need to declare
423
 
    HANDLE = ctypes.c_int # rather than unsigned as in ctypes.wintypes
424
 
    if os.path.supports_unicode_filenames:
425
 
        _function_name = "CreateFileW"
426
 
        LPTSTR = LPCWSTR
427
 
    else:
428
 
        _function_name = "CreateFileA"
429
 
        class LPTSTR(LPCSTR):
430
 
            def __new__(cls, obj):
431
 
                return LPCSTR.__new__(cls, obj.encode("mbcs"))
432
 
 
433
 
    # CreateFile <http://msdn.microsoft.com/en-us/library/aa363858.aspx>
434
 
    _CreateFile = ctypes.WINFUNCTYPE(
435
 
            HANDLE,                # return value
436
 
            LPTSTR,                # lpFileName
437
 
            DWORD,                 # dwDesiredAccess
438
 
            DWORD,                 # dwShareMode
439
 
            LPSECURITY_ATTRIBUTES, # lpSecurityAttributes
440
 
            DWORD,                 # dwCreationDisposition
441
 
            DWORD,                 # dwFlagsAndAttributes
442
 
            HANDLE                 # hTemplateFile
443
 
        )((_function_name, ctypes.windll.kernel32))
444
 
 
445
 
    INVALID_HANDLE_VALUE = -1
446
 
 
447
 
    GENERIC_READ = 0x80000000
448
 
    GENERIC_WRITE = 0x40000000
449
 
    FILE_SHARE_READ = 1
450
 
    OPEN_ALWAYS = 4
451
 
    FILE_ATTRIBUTE_NORMAL = 128
452
 
 
453
 
    ERROR_ACCESS_DENIED = 5
454
 
    ERROR_SHARING_VIOLATION = 32
 
335
if have_ctypes and sys.platform == 'win32':
 
336
    # These constants were copied from the win32con.py module.
 
337
    LOCKFILE_FAIL_IMMEDIATELY = 1
 
338
    LOCKFILE_EXCLUSIVE_LOCK = 2
 
339
    # Constant taken from winerror.py module
 
340
    ERROR_LOCK_VIOLATION = 33
 
341
 
 
342
    LOCK_SH = 0
 
343
    LOCK_EX = LOCKFILE_EXCLUSIVE_LOCK
 
344
    LOCK_NB = LOCKFILE_FAIL_IMMEDIATELY
 
345
    _LockFileEx = ctypes.windll.kernel32.LockFileEx
 
346
    _UnlockFileEx = ctypes.windll.kernel32.UnlockFileEx
 
347
    _GetLastError = ctypes.windll.kernel32.GetLastError
 
348
 
 
349
    ### Define the OVERLAPPED structure.
 
350
    #   http://msdn2.microsoft.com/en-us/library/ms684342.aspx
 
351
    # typedef struct _OVERLAPPED {
 
352
    #   ULONG_PTR Internal;
 
353
    #   ULONG_PTR InternalHigh;
 
354
    #   union {
 
355
    #     struct {
 
356
    #       DWORD Offset;
 
357
    #       DWORD OffsetHigh;
 
358
    #     };
 
359
    #     PVOID Pointer;
 
360
    #   };
 
361
    #   HANDLE hEvent;
 
362
    # } OVERLAPPED,
 
363
 
 
364
    class _inner_struct(ctypes.Structure):
 
365
        _fields_ = [('Offset', ctypes.c_uint), # DWORD
 
366
                    ('OffsetHigh', ctypes.c_uint), # DWORD
 
367
                   ]
 
368
 
 
369
    class _inner_union(ctypes.Union):
 
370
        _fields_  = [('anon_struct', _inner_struct), # struct
 
371
                     ('Pointer', ctypes.c_void_p), # PVOID
 
372
                    ]
 
373
 
 
374
    class OVERLAPPED(ctypes.Structure):
 
375
        _fields_ = [('Internal', ctypes.c_void_p), # ULONG_PTR
 
376
                    ('InternalHigh', ctypes.c_void_p), # ULONG_PTR
 
377
                    ('_inner_union', _inner_union),
 
378
                    ('hEvent', ctypes.c_void_p), # HANDLE
 
379
                   ]
455
380
 
456
381
    class _ctypes_FileLock(_OSLock):
457
382
 
458
 
        def _open(self, filename, access, share, cflags, pymode):
459
 
            self.filename = osutils.realpath(filename)
460
 
            handle = _CreateFile(filename, access, share, None, OPEN_ALWAYS,
461
 
                FILE_ATTRIBUTE_NORMAL, 0)
462
 
            if handle in (INVALID_HANDLE_VALUE, 0):
463
 
                e = ctypes.WinError()
464
 
                if e.args[0] == ERROR_ACCESS_DENIED:
465
 
                    raise errors.LockFailed(filename, e)
466
 
                if e.args[0] == ERROR_SHARING_VIOLATION:
467
 
                    raise errors.LockContention(filename, e)
468
 
                raise e
469
 
            fd = msvcrt.open_osfhandle(handle, cflags)
470
 
            self.f = os.fdopen(fd, pymode)
471
 
            return self.f
 
383
        def _lock(self, filename, openmode, lockmode):
 
384
            self._open(filename, openmode)
 
385
 
 
386
            self.hfile = msvcrt.get_osfhandle(self.f.fileno())
 
387
            overlapped = OVERLAPPED()
 
388
            result = _LockFileEx(self.hfile, # HANDLE hFile
 
389
                                 lockmode,   # DWORD dwFlags
 
390
                                 0,          # DWORD dwReserved
 
391
                                 0x7fffffff, # DWORD nNumberOfBytesToLockLow
 
392
                                 0x00000000, # DWORD nNumberOfBytesToLockHigh
 
393
                                 ctypes.byref(overlapped), # lpOverlapped
 
394
                                )
 
395
            if result == 0:
 
396
                self._clear_f()
 
397
                last_err = _GetLastError()
 
398
                if last_err in (ERROR_LOCK_VIOLATION,):
 
399
                    raise errors.LockContention(filename)
 
400
                raise errors.LockContention('Unknown locking error: %s'
 
401
                                            % (last_err,))
472
402
 
473
403
        def unlock(self):
 
404
            overlapped = OVERLAPPED()
 
405
            result = _UnlockFileEx(self.hfile, # HANDLE hFile
 
406
                                   0,          # DWORD dwReserved
 
407
                                   0x7fffffff, # DWORD nNumberOfBytesToLockLow
 
408
                                   0x00000000, # DWORD nNumberOfBytesToLockHigh
 
409
                                   ctypes.byref(overlapped), # lpOverlapped
 
410
                                  )
474
411
            self._clear_f()
 
412
            if result == 0:
 
413
                self._clear_f()
 
414
                last_err = _GetLastError()
 
415
                raise errors.LockContention('Unknown unlocking error: %s'
 
416
                                            % (last_err,))
475
417
 
476
418
 
477
419
    class _ctypes_ReadLock(_ctypes_FileLock):
478
420
        def __init__(self, filename):
479
421
            super(_ctypes_ReadLock, self).__init__()
480
 
            self._open(filename, GENERIC_READ, FILE_SHARE_READ, os.O_RDONLY,
481
 
                "rb")
 
422
            self._lock(filename, 'rb', LOCK_SH + LOCK_NB)
482
423
 
483
424
        def temporary_write_lock(self):
484
425
            """Try to grab a write lock on the file.
502
443
    class _ctypes_WriteLock(_ctypes_FileLock):
503
444
        def __init__(self, filename):
504
445
            super(_ctypes_WriteLock, self).__init__()
505
 
            self._open(filename, GENERIC_READ | GENERIC_WRITE, 0, os.O_RDWR,
506
 
                "rb+")
 
446
            self._lock(filename, 'rb+', LOCK_EX + LOCK_NB)
507
447
 
508
448
        def restore_read_lock(self):
509
449
            """Restore the original ReadLock."""
526
466
# We default to using the first available lock class.
527
467
_lock_type, WriteLock, ReadLock = _lock_classes[0]
528
468
 
529
 
 
530
 
class _RelockDebugMixin(object):
531
 
    """Mixin support for -Drelock flag.
532
 
 
533
 
    Add this as a base class then call self._note_lock with 'r' or 'w' when
534
 
    acquiring a read- or write-lock.  If this object was previously locked (and
535
 
    locked the same way), and -Drelock is set, then this will trace.note a
536
 
    message about it.
537
 
    """
538
 
    
539
 
    _prev_lock = None
540
 
 
541
 
    def _note_lock(self, lock_type):
542
 
        if 'relock' in debug.debug_flags and self._prev_lock == lock_type:
543
 
            if lock_type == 'r':
544
 
                type_name = 'read'
545
 
            else:
546
 
                type_name = 'write'
547
 
            trace.note('%r was %s locked again', self, type_name)
548
 
        self._prev_lock = lock_type
549