/brz/remove-bazaar

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar

« back to all changes in this revision

Viewing changes to bzrlib/lock.py

  • Committer: Alexander Belchenko
  • Date: 2007-03-15 23:27:43 UTC
  • mto: (2353.4.10 locking)
  • mto: This revision was merged to the branch mainline in revision 2367.
  • Revision ID: bialix@ukr.net-20070315232743-ol8q5vyqzpvdkrjy
forgotten import of TestSkipped

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
 
import sys
40
 
import warnings
41
38
 
42
39
from bzrlib import (
43
 
    debug,
44
40
    errors,
45
41
    osutils,
46
42
    trace,
47
43
    )
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
129
 
 
130
 
 
131
 
class _OSLock(object):
 
44
 
 
45
 
 
46
class _base_Lock(object):
132
47
 
133
48
    def __init__(self):
134
49
        self.f = None
141
56
            return self.f
142
57
        except IOError, e:
143
58
            if e.errno in (errno.EACCES, errno.EPERM):
144
 
                raise errors.LockFailed(self.filename, str(e))
 
59
                raise errors.ReadOnlyLockError(self.filename, str(e))
145
60
            if e.errno != errno.ENOENT:
146
61
                raise
147
62
 
167
82
        raise NotImplementedError()
168
83
 
169
84
 
 
85
try:
 
86
    import fcntl
 
87
    have_fcntl = True
 
88
except ImportError:
 
89
    have_fcntl = False
 
90
try:
 
91
    import win32con, win32file, pywintypes, winerror, msvcrt
 
92
    have_pywin32 = True
 
93
except ImportError:
 
94
    have_pywin32 = False
 
95
try:
 
96
    import ctypes, msvcrt
 
97
    have_ctypes = True
 
98
except ImportError:
 
99
    have_ctypes = False
 
100
 
 
101
 
170
102
_lock_classes = []
171
103
 
172
104
 
173
105
if have_fcntl:
174
 
 
175
 
    class _fcntl_FileLock(_OSLock):
 
106
    LOCK_SH = fcntl.LOCK_SH
 
107
    LOCK_NB = fcntl.LOCK_NB
 
108
    lock_EX = fcntl.LOCK_EX
 
109
 
 
110
 
 
111
    class _fcntl_FileLock(_base_Lock):
176
112
 
177
113
        def _unlock(self):
178
114
            fcntl.lockf(self.f, fcntl.LOCK_UN)
187
123
            super(_fcntl_WriteLock, self).__init__()
188
124
            # Check we can grab a lock before we actually open the file.
189
125
            self.filename = osutils.realpath(filename)
190
 
            if self.filename in _fcntl_WriteLock._open_locks:
 
126
            if (self.filename in _fcntl_WriteLock._open_locks
 
127
                or self.filename in _fcntl_ReadLock._open_locks):
191
128
                self._clear_f()
192
129
                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,))
200
130
 
201
131
            self._open(self.filename, 'rb+')
202
132
            # reserve a slot for this lock - even if the lockf call fails,
203
 
            # 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.
204
134
            # TODO: make this fully threadsafe, if we decide we care.
205
135
            _fcntl_WriteLock._open_locks.add(self.filename)
206
136
            try:
213
143
                    self.unlock()
214
144
                # we should be more precise about whats a locking
215
145
                # error and whats a random-other error
216
 
                raise errors.LockContention(self.filename, e)
 
146
                raise errors.LockError(e)
217
147
 
218
148
        def unlock(self):
219
149
            _fcntl_WriteLock._open_locks.remove(self.filename)
224
154
 
225
155
        _open_locks = {}
226
156
 
227
 
        def __init__(self, filename):
 
157
        def __init__(self, filename, _ignore_write_lock=False):
228
158
            super(_fcntl_ReadLock, self).__init__()
229
159
            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
            if not _ignore_write_lock and self.filename in _fcntl_WriteLock._open_locks:
 
161
                raise errors.LockContention(self.filename)
238
162
            _fcntl_ReadLock._open_locks.setdefault(self.filename, 0)
239
163
            _fcntl_ReadLock._open_locks[self.filename] += 1
240
164
            self._open(filename, 'rb')
245
169
            except IOError, e:
246
170
                # we should be more precise about whats a locking
247
171
                # error and whats a random-other error
248
 
                raise errors.LockContention(self.filename, e)
 
172
                raise errors.LockError(e)
249
173
 
250
174
        def unlock(self):
251
175
            count = _fcntl_ReadLock._open_locks[self.filename]
265
189
 
266
190
            :return: A token which can be used to switch back to a read lock.
267
191
            """
268
 
            if self.filename in _fcntl_WriteLock._open_locks:
269
 
                raise AssertionError('file already locked: %r'
270
 
                    % (self.filename,))
 
192
            assert self.filename not in _fcntl_WriteLock._open_locks
271
193
            try:
272
194
                wlock = _fcntl_TemporaryWriteLock(self)
273
195
            except errors.LockError:
276
198
            return True, wlock
277
199
 
278
200
 
279
 
    class _fcntl_TemporaryWriteLock(_OSLock):
 
201
    class _fcntl_TemporaryWriteLock(_base_Lock):
280
202
        """A token used when grabbing a temporary_write_lock.
281
203
 
282
204
        Call restore_read_lock() when you are done with the write lock.
293
215
                # write lock.
294
216
                raise errors.LockContention(self.filename)
295
217
 
296
 
            if self.filename in _fcntl_WriteLock._open_locks:
297
 
                raise AssertionError('file already locked: %r'
298
 
                    % (self.filename,))
 
218
            assert self.filename not in _fcntl_WriteLock._open_locks
299
219
 
300
220
            # See if we can open the file for writing. Another process might
301
221
            # have a read lock. We don't use self._open() because we don't want
305
225
                new_f = open(self.filename, 'rb+')
306
226
            except IOError, e:
307
227
                if e.errno in (errno.EACCES, errno.EPERM):
308
 
                    raise errors.LockFailed(self.filename, str(e))
 
228
                    raise errors.ReadOnlyLockError(self.filename, str(e))
309
229
                raise
310
230
            try:
311
231
                # LOCK_NB will cause IOError to be raised if we can't grab a
312
232
                # lock right away.
313
 
                fcntl.lockf(new_f, fcntl.LOCK_EX | fcntl.LOCK_NB)
 
233
                fcntl.lockf(new_f, fcntl.LOCK_SH | fcntl.LOCK_NB)
314
234
            except IOError, e:
315
235
                # TODO: Raise a more specific error based on the type of error
316
 
                raise errors.LockContention(self.filename, e)
 
236
                raise errors.LockError(e)
317
237
            _fcntl_WriteLock._open_locks.add(self.filename)
318
238
 
319
239
            self.f = new_f
334
254
    _lock_classes.append(('fcntl', _fcntl_WriteLock, _fcntl_ReadLock))
335
255
 
336
256
 
337
 
if have_pywin32 and sys.platform == 'win32':
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
344
 
 
345
 
    class _w32c_FileLock(_OSLock):
346
 
 
347
 
        def _open(self, filename, access, share, cflags, pymode):
348
 
            self.filename = osutils.realpath(filename)
 
257
if have_pywin32:
 
258
    LOCK_SH = 0 # the default
 
259
    LOCK_EX = win32con.LOCKFILE_EXCLUSIVE_LOCK
 
260
    LOCK_NB = win32con.LOCKFILE_FAIL_IMMEDIATELY
 
261
 
 
262
 
 
263
    class _w32c_FileLock(_base_Lock):
 
264
 
 
265
        def _lock(self, filename, openmode, lockmode):
 
266
            self._open(filename, openmode)
 
267
 
 
268
            self.hfile = msvcrt.get_osfhandle(self.f.fileno())
 
269
            overlapped = pywintypes.OVERLAPPED()
349
270
            try:
350
 
                self._handle = win32file_CreateFile(filename, access, share,
351
 
                    None, win32file.OPEN_ALWAYS,
352
 
                    win32file.FILE_ATTRIBUTE_NORMAL, None)
 
271
                win32file.LockFileEx(self.hfile, lockmode, 0, 0x7fff0000,
 
272
                                     overlapped)
353
273
            except pywintypes.error, e:
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)
 
274
                self._clear_f()
 
275
                if e.args[0] in (winerror.ERROR_LOCK_VIOLATION,):
 
276
                    raise errors.LockContention(filename)
 
277
                ## import pdb; pdb.set_trace()
358
278
                raise
359
 
            fd = win32file._open_osfhandle(self._handle, cflags)
360
 
            self.f = os.fdopen(fd, pymode)
361
 
            return self.f
 
279
            except Exception, e:
 
280
                self._clear_f()
 
281
                raise errors.LockError(e)
362
282
 
363
283
        def unlock(self):
364
 
            self._clear_f()
365
 
            self._handle = None
 
284
            overlapped = pywintypes.OVERLAPPED()
 
285
            try:
 
286
                win32file.UnlockFileEx(self.hfile, 0, 0x7fff0000, overlapped)
 
287
                self._clear_f()
 
288
            except Exception, e:
 
289
                raise errors.LockError(e)
366
290
 
367
291
 
368
292
    class _w32c_ReadLock(_w32c_FileLock):
369
293
        def __init__(self, filename):
370
294
            super(_w32c_ReadLock, self).__init__()
371
 
            self._open(filename, win32file.GENERIC_READ,
372
 
                win32file.FILE_SHARE_READ, os.O_RDONLY, "rb")
 
295
            self._lock(filename, 'rb', LOCK_SH + LOCK_NB)
373
296
 
374
297
        def temporary_write_lock(self):
375
298
            """Try to grab a write lock on the file.
394
317
    class _w32c_WriteLock(_w32c_FileLock):
395
318
        def __init__(self, filename):
396
319
            super(_w32c_WriteLock, self).__init__()
397
 
            self._open(filename,
398
 
                win32file.GENERIC_READ | win32file.GENERIC_WRITE, 0,
399
 
                os.O_RDWR, "rb+")
 
320
            self._lock(filename, 'rb+', LOCK_EX + LOCK_NB)
400
321
 
401
322
        def restore_read_lock(self):
402
323
            """Restore the original ReadLock."""
409
330
    _lock_classes.append(('pywin32', _w32c_WriteLock, _w32c_ReadLock))
410
331
 
411
332
 
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
447
 
 
448
 
    class _ctypes_FileLock(_OSLock):
449
 
 
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
 
333
if have_ctypes:
 
334
    # These constants were copied from the win32con.py module.
 
335
    LOCKFILE_FAIL_IMMEDIATELY = 1
 
336
    LOCKFILE_EXCLUSIVE_LOCK = 2
 
337
    # Constant taken from winerror.py module
 
338
    ERROR_LOCK_VIOLATION = 33
 
339
 
 
340
    LOCK_SH = 0
 
341
    LOCK_EX = LOCKFILE_EXCLUSIVE_LOCK
 
342
    LOCK_NB = LOCKFILE_FAIL_IMMEDIATELY
 
343
    _LockFileEx = ctypes.windll.kernel32.LockFileEx
 
344
    _UnlockFileEx = ctypes.windll.kernel32.UnlockFileEx
 
345
    _GetLastError = ctypes.windll.kernel32.GetLastError
 
346
 
 
347
    ### Define the OVERLAPPED structure.
 
348
    #   http://msdn2.microsoft.com/en-us/library/ms684342.aspx
 
349
    # typedef struct _OVERLAPPED {
 
350
    #   ULONG_PTR Internal;
 
351
    #   ULONG_PTR InternalHigh;
 
352
    #   union {
 
353
    #     struct {
 
354
    #       DWORD Offset;
 
355
    #       DWORD OffsetHigh;
 
356
    #     };
 
357
    #     PVOID Pointer;
 
358
    #   };
 
359
    #   HANDLE hEvent;
 
360
    # } OVERLAPPED,
 
361
 
 
362
    class _inner_struct(ctypes.Structure):
 
363
        _fields_ = [('Offset', ctypes.c_uint), # DWORD
 
364
                    ('OffsetHigh', ctypes.c_uint), # DWORD
 
365
                   ]
 
366
 
 
367
    class _inner_union(ctypes.Union):
 
368
        _fields_  = [('anon_struct', _inner_struct), # struct
 
369
                     ('Pointer', ctypes.c_void_p), # PVOID
 
370
                    ]
 
371
 
 
372
    class OVERLAPPED(ctypes.Structure):
 
373
        _fields_ = [('Internal', ctypes.c_void_p), # ULONG_PTR
 
374
                    ('InternalHigh', ctypes.c_void_p), # ULONG_PTR
 
375
                    ('_inner_union', _inner_union),
 
376
                    ('hEvent', ctypes.c_void_p), # HANDLE
 
377
                   ]
 
378
 
 
379
    class _ctypes_FileLock(_base_Lock):
 
380
 
 
381
        def _lock(self, filename, openmode, lockmode):
 
382
            self._open(filename, openmode)
 
383
 
 
384
            self.hfile = msvcrt.get_osfhandle(self.f.fileno())
 
385
            overlapped = OVERLAPPED()
 
386
            p_overlapped = ctypes.pointer(overlapped)
 
387
            result = _LockFileEx(self.hfile, # HANDLE hFile
 
388
                                 lockmode,   # DWORD dwFlags
 
389
                                 0,          # DWORD dwReserved
 
390
                                 0x7fffffff, # DWORD nNumberOfBytesToLockLow
 
391
                                 0x00000000, # DWORD nNumberOfBytesToLockHigh
 
392
                                 p_overlapped, # lpOverlapped
 
393
                                )
 
394
            if result == 0:
 
395
                self._clear_f()
 
396
                last_err = _GetLastError()
 
397
                if last_err in (ERROR_LOCK_VIOLATION,):
 
398
                    raise errors.LockContention(filename)
 
399
                raise errors.LockError('Unknown locking error: %s'
 
400
                                       % (last_err,))
464
401
 
465
402
        def unlock(self):
 
403
            overlapped = OVERLAPPED()
 
404
            p_overlapped = ctypes.pointer(overlapped)
 
405
            result = _UnlockFileEx(self.hfile, # HANDLE hFile
 
406
                                   0,          # DWORD dwReserved
 
407
                                   0x7fffffff, # DWORD nNumberOfBytesToLockLow
 
408
                                   0x00000000, # DWORD nNumberOfBytesToLockHigh
 
409
                                   p_overlapped, # lpOverlapped
 
410
                                  )
466
411
            self._clear_f()
 
412
            if result == 0:
 
413
                self._clear_f()
 
414
                last_err = _GetLastError()
 
415
                raise errors.LockError('Unknown unlocking error: %s'
 
416
                                       % (last_err,))
467
417
 
468
418
 
469
419
    class _ctypes_ReadLock(_ctypes_FileLock):
470
420
        def __init__(self, filename):
471
421
            super(_ctypes_ReadLock, self).__init__()
472
 
            self._open(filename, GENERIC_READ, FILE_SHARE_READ, os.O_RDONLY,
473
 
                "rb")
 
422
            self._lock(filename, 'rb', LOCK_SH + LOCK_NB)
474
423
 
475
424
        def temporary_write_lock(self):
476
425
            """Try to grab a write lock on the file.
494
443
    class _ctypes_WriteLock(_ctypes_FileLock):
495
444
        def __init__(self, filename):
496
445
            super(_ctypes_WriteLock, self).__init__()
497
 
            self._open(filename, GENERIC_READ | GENERIC_WRITE, 0, os.O_RDWR,
498
 
                "rb+")
 
446
            self._lock(filename, 'rb+', LOCK_EX + LOCK_NB)
499
447
 
500
448
        def restore_read_lock(self):
501
449
            """Restore the original ReadLock."""
518
466
# We default to using the first available lock class.
519
467
_lock_type, WriteLock, ReadLock = _lock_classes[0]
520
468
 
521
 
 
522
 
class _RelockDebugMixin(object):
523
 
    """Mixin support for -Drelock flag.
524
 
 
525
 
    Add this as a base class then call self._note_lock with 'r' or 'w' when
526
 
    acquiring a read- or write-lock.  If this object was previously locked (and
527
 
    locked the same way), and -Drelock is set, then this will trace.note a
528
 
    message about it.
529
 
    """
530
 
    
531
 
    _prev_lock = None
532
 
 
533
 
    def _note_lock(self, lock_type):
534
 
        if 'relock' in debug.debug_flags and self._prev_lock == lock_type:
535
 
            if lock_type == 'r':
536
 
                type_name = 'read'
537
 
            else:
538
 
                type_name = 'write'
539
 
            trace.note('%r was %s locked again', self, type_name)
540
 
        self._prev_lock = lock_type
541