← 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: 2010-09-01 08:02:42 UTC
  • mfrom: (5390.3.3 faster-revert-593560)
  • Revision ID: pqm@pqm.ubuntu.com-20100901080242-esg62ody4frwmy66
(spiv) Avoid repeatedly calling self.target.all_file_ids() in
 InterTree.iter_changes. (Andrew Bennetts)

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/lock.py
1
 
# Copyright (C) 2005, 2006, 2007, 2008, 2009 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
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,
55
58
        self.create_hook(HookPoint('lock_released',
56
59
            "Called with a bzrlib.lock.LockResult when a physical lock is "
57
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))
58
64
 
59
65
 
60
66
class Lock(object):
77
83
    def __eq__(self, other):
78
84
        return self.lock_url == other.lock_url and self.details == other.details
79
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
 
80
121
 
81
122
try:
82
123
    import fcntl
89
130
if sys.platform == 'win32':
90
131
    import msvcrt
91
132
    try:
92
 
        import win32con, win32file, pywintypes, winerror
 
133
        import win32file, pywintypes, winerror
93
134
        have_pywin32 = True
94
135
    except ImportError:
95
136
        pass
144
185
 
145
186
 
146
187
if have_fcntl:
147
 
    LOCK_SH = fcntl.LOCK_SH
148
 
    LOCK_NB = fcntl.LOCK_NB
149
 
    lock_EX = fcntl.LOCK_EX
150
 
 
151
188
 
152
189
    class _fcntl_FileLock(_OSLock):
153
190
 
167
204
            if self.filename in _fcntl_WriteLock._open_locks:
168
205
                self._clear_f()
169
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,))
170
214
 
171
215
            self._open(self.filename, 'rb+')
172
216
            # reserve a slot for this lock - even if the lockf call fails,
173
 
            # 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.
174
218
            # TODO: make this fully threadsafe, if we decide we care.
175
219
            _fcntl_WriteLock._open_locks.add(self.filename)
176
220
            try:
197
241
        def __init__(self, filename):
198
242
            super(_fcntl_ReadLock, self).__init__()
199
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,))
200
252
            _fcntl_ReadLock._open_locks.setdefault(self.filename, 0)
201
253
            _fcntl_ReadLock._open_locks[self.filename] += 1
202
254
            self._open(filename, 'rb')
297
349
 
298
350
 
299
351
if have_pywin32 and sys.platform == 'win32':
300
 
    LOCK_SH = 0 # the default
301
 
    LOCK_EX = win32con.LOCKFILE_EXCLUSIVE_LOCK
302
 
    LOCK_NB = win32con.LOCKFILE_FAIL_IMMEDIATELY
303
 
 
 
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
304
358
 
305
359
    class _w32c_FileLock(_OSLock):
306
360
 
307
 
        def _lock(self, filename, openmode, lockmode):
308
 
            self._open(filename, openmode)
309
 
 
310
 
            self.hfile = msvcrt.get_osfhandle(self.f.fileno())
311
 
            overlapped = pywintypes.OVERLAPPED()
 
361
        def _open(self, filename, access, share, cflags, pymode):
 
362
            self.filename = osutils.realpath(filename)
312
363
            try:
313
 
                win32file.LockFileEx(self.hfile, lockmode, 0, 0x7fff0000,
314
 
                                     overlapped)
 
364
                self._handle = win32file_CreateFile(filename, access, share,
 
365
                    None, win32file.OPEN_ALWAYS,
 
366
                    win32file.FILE_ATTRIBUTE_NORMAL, None)
315
367
            except pywintypes.error, e:
316
 
                self._clear_f()
317
 
                if e.args[0] in (winerror.ERROR_LOCK_VIOLATION,):
318
 
                    raise errors.LockContention(filename)
319
 
                ## 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)
320
372
                raise
321
 
            except Exception, e:
322
 
                self._clear_f()
323
 
                raise errors.LockContention(filename, e)
 
373
            fd = win32file._open_osfhandle(self._handle, cflags)
 
374
            self.f = os.fdopen(fd, pymode)
 
375
            return self.f
324
376
 
325
377
        def unlock(self):
326
 
            overlapped = pywintypes.OVERLAPPED()
327
 
            try:
328
 
                win32file.UnlockFileEx(self.hfile, 0, 0x7fff0000, overlapped)
329
 
                self._clear_f()
330
 
            except Exception, e:
331
 
                raise errors.LockContention(self.filename, e)
 
378
            self._clear_f()
 
379
            self._handle = None
332
380
 
333
381
 
334
382
    class _w32c_ReadLock(_w32c_FileLock):
335
383
        def __init__(self, filename):
336
384
            super(_w32c_ReadLock, self).__init__()
337
 
            self._lock(filename, 'rb', LOCK_SH + LOCK_NB)
 
385
            self._open(filename, win32file.GENERIC_READ,
 
386
                win32file.FILE_SHARE_READ, os.O_RDONLY, "rb")
338
387
 
339
388
        def temporary_write_lock(self):
340
389
            """Try to grab a write lock on the file.
359
408
    class _w32c_WriteLock(_w32c_FileLock):
360
409
        def __init__(self, filename):
361
410
            super(_w32c_WriteLock, self).__init__()
362
 
            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+")
363
414
 
364
415
        def restore_read_lock(self):
365
416
            """Restore the original ReadLock."""
373
424
 
374
425
 
375
426
if have_ctypes_win32:
376
 
    # These constants were copied from the win32con.py module.
377
 
    LOCKFILE_FAIL_IMMEDIATELY = 1
378
 
    LOCKFILE_EXCLUSIVE_LOCK = 2
379
 
    # Constant taken from winerror.py module
380
 
    ERROR_LOCK_VIOLATION = 33
381
 
 
382
 
    LOCK_SH = 0
383
 
    LOCK_EX = LOCKFILE_EXCLUSIVE_LOCK
384
 
    LOCK_NB = LOCKFILE_FAIL_IMMEDIATELY
385
 
    _LockFileEx = ctypes.windll.kernel32.LockFileEx
386
 
    _UnlockFileEx = ctypes.windll.kernel32.UnlockFileEx
387
 
    _GetLastError = ctypes.windll.kernel32.GetLastError
388
 
 
389
 
    ### Define the OVERLAPPED structure.
390
 
    #   http://msdn2.microsoft.com/en-us/library/ms684342.aspx
391
 
    # typedef struct _OVERLAPPED {
392
 
    #   ULONG_PTR Internal;
393
 
    #   ULONG_PTR InternalHigh;
394
 
    #   union {
395
 
    #     struct {
396
 
    #       DWORD Offset;
397
 
    #       DWORD OffsetHigh;
398
 
    #     };
399
 
    #     PVOID Pointer;
400
 
    #   };
401
 
    #   HANDLE hEvent;
402
 
    # } OVERLAPPED,
403
 
 
404
 
    class _inner_struct(ctypes.Structure):
405
 
        _fields_ = [('Offset', ctypes.c_uint), # DWORD
406
 
                    ('OffsetHigh', ctypes.c_uint), # DWORD
407
 
                   ]
408
 
 
409
 
    class _inner_union(ctypes.Union):
410
 
        _fields_  = [('anon_struct', _inner_struct), # struct
411
 
                     ('Pointer', ctypes.c_void_p), # PVOID
412
 
                    ]
413
 
 
414
 
    class OVERLAPPED(ctypes.Structure):
415
 
        _fields_ = [('Internal', ctypes.c_void_p), # ULONG_PTR
416
 
                    ('InternalHigh', ctypes.c_void_p), # ULONG_PTR
417
 
                    ('_inner_union', _inner_union),
418
 
                    ('hEvent', ctypes.c_void_p), # HANDLE
419
 
                   ]
 
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
420
461
 
421
462
    class _ctypes_FileLock(_OSLock):
422
463
 
423
 
        def _lock(self, filename, openmode, lockmode):
424
 
            self._open(filename, openmode)
425
 
 
426
 
            self.hfile = msvcrt.get_osfhandle(self.f.fileno())
427
 
            overlapped = OVERLAPPED()
428
 
            result = _LockFileEx(self.hfile, # HANDLE hFile
429
 
                                 lockmode,   # DWORD dwFlags
430
 
                                 0,          # DWORD dwReserved
431
 
                                 0x7fffffff, # DWORD nNumberOfBytesToLockLow
432
 
                                 0x00000000, # DWORD nNumberOfBytesToLockHigh
433
 
                                 ctypes.byref(overlapped), # lpOverlapped
434
 
                                )
435
 
            if result == 0:
436
 
                self._clear_f()
437
 
                last_err = _GetLastError()
438
 
                if last_err in (ERROR_LOCK_VIOLATION,):
439
 
                    raise errors.LockContention(filename)
440
 
                raise errors.LockContention(filename,
441
 
                    'Unknown locking error: %s' % (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
442
478
 
443
479
        def unlock(self):
444
 
            overlapped = OVERLAPPED()
445
 
            result = _UnlockFileEx(self.hfile, # HANDLE hFile
446
 
                                   0,          # DWORD dwReserved
447
 
                                   0x7fffffff, # DWORD nNumberOfBytesToLockLow
448
 
                                   0x00000000, # DWORD nNumberOfBytesToLockHigh
449
 
                                   ctypes.byref(overlapped), # lpOverlapped
450
 
                                  )
451
480
            self._clear_f()
452
 
            if result == 0:
453
 
                self._clear_f()
454
 
                last_err = _GetLastError()
455
 
                raise errors.LockContention(self.filename,
456
 
                    'Unknown unlocking error: %s' % (last_err,))
457
481
 
458
482
 
459
483
    class _ctypes_ReadLock(_ctypes_FileLock):
460
484
        def __init__(self, filename):
461
485
            super(_ctypes_ReadLock, self).__init__()
462
 
            self._lock(filename, 'rb', LOCK_SH + LOCK_NB)
 
486
            self._open(filename, GENERIC_READ, FILE_SHARE_READ, os.O_RDONLY,
 
487
                "rb")
463
488
 
464
489
        def temporary_write_lock(self):
465
490
            """Try to grab a write lock on the file.
483
508
    class _ctypes_WriteLock(_ctypes_FileLock):
484
509
        def __init__(self, filename):
485
510
            super(_ctypes_WriteLock, self).__init__()
486
 
            self._lock(filename, 'rb+', LOCK_EX + LOCK_NB)
 
511
            self._open(filename, GENERIC_READ | GENERIC_WRITE, 0, os.O_RDWR,
 
512
                "rb+")
487
513
 
488
514
        def restore_read_lock(self):
489
515
            """Restore the original ReadLock."""
506
532
# We default to using the first available lock class.
507
533
_lock_type, WriteLock, ReadLock = _lock_classes[0]
508
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