/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: Canonical.com Patch Queue Manager
  • Date: 2008-09-26 05:14:51 UTC
  • mfrom: (3737.1.3 trivial_python_compat)
  • Revision ID: pqm@pqm.ubuntu.com-20080926051451-dvc1qg5inn7msjvr
(jam) Some win32 tweaks for the faster iter_changes code.

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, 2008 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 HookPoint, Hooks
 
45
from bzrlib.hooks import Hooks
49
46
 
50
47
 
51
48
class LockHooks(Hooks):
52
49
 
53
50
    def __init__(self):
54
51
        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))
 
52
 
 
53
        # added in 1.8; called with a LockResult when a physical lock is
 
54
        # acquired
 
55
        self['lock_acquired'] = []
 
56
 
 
57
        # added in 1.8; called with a LockResult when a physical lock is
 
58
        # acquired
 
59
        self['lock_released'] = []
64
60
 
65
61
 
66
62
class Lock(object):
83
79
    def __eq__(self, other):
84
80
        return self.lock_url == other.lock_url and self.details == other.details
85
81
 
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
 
 
144
82
 
145
83
class _OSLock(object):
146
84
 
181
119
        raise NotImplementedError()
182
120
 
183
121
 
 
122
try:
 
123
    import fcntl
 
124
    have_fcntl = True
 
125
except ImportError:
 
126
    have_fcntl = False
 
127
try:
 
128
    import win32con, win32file, pywintypes, winerror, msvcrt
 
129
    have_pywin32 = True
 
130
except ImportError:
 
131
    have_pywin32 = False
 
132
try:
 
133
    import ctypes, msvcrt
 
134
    have_ctypes = True
 
135
except ImportError:
 
136
    have_ctypes = False
 
137
 
 
138
 
184
139
_lock_classes = []
185
140
 
186
141
 
187
142
if have_fcntl:
 
143
    LOCK_SH = fcntl.LOCK_SH
 
144
    LOCK_NB = fcntl.LOCK_NB
 
145
    lock_EX = fcntl.LOCK_EX
 
146
 
188
147
 
189
148
    class _fcntl_FileLock(_OSLock):
190
149
 
204
163
            if self.filename in _fcntl_WriteLock._open_locks:
205
164
                self._clear_f()
206
165
                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,))
214
166
 
215
167
            self._open(self.filename, 'rb+')
216
168
            # reserve a slot for this lock - even if the lockf call fails,
217
 
            # at this point unlock() will be called, because self.f is set.
 
169
            # at thisi point unlock() will be called, because self.f is set.
218
170
            # TODO: make this fully threadsafe, if we decide we care.
219
171
            _fcntl_WriteLock._open_locks.add(self.filename)
220
172
            try:
227
179
                    self.unlock()
228
180
                # we should be more precise about whats a locking
229
181
                # error and whats a random-other error
230
 
                raise errors.LockContention(self.filename, e)
 
182
                raise errors.LockContention(e)
231
183
 
232
184
        def unlock(self):
233
185
            _fcntl_WriteLock._open_locks.remove(self.filename)
241
193
        def __init__(self, filename):
242
194
            super(_fcntl_ReadLock, self).__init__()
243
195
            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,))
252
196
            _fcntl_ReadLock._open_locks.setdefault(self.filename, 0)
253
197
            _fcntl_ReadLock._open_locks[self.filename] += 1
254
198
            self._open(filename, 'rb')
259
203
            except IOError, e:
260
204
                # we should be more precise about whats a locking
261
205
                # error and whats a random-other error
262
 
                raise errors.LockContention(self.filename, e)
 
206
                raise errors.LockContention(e)
263
207
 
264
208
        def unlock(self):
265
209
            count = _fcntl_ReadLock._open_locks[self.filename]
327
271
                fcntl.lockf(new_f, fcntl.LOCK_EX | fcntl.LOCK_NB)
328
272
            except IOError, e:
329
273
                # TODO: Raise a more specific error based on the type of error
330
 
                raise errors.LockContention(self.filename, e)
 
274
                raise errors.LockContention(e)
331
275
            _fcntl_WriteLock._open_locks.add(self.filename)
332
276
 
333
277
            self.f = new_f
349
293
 
350
294
 
351
295
if have_pywin32 and sys.platform == 'win32':
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
 
296
    LOCK_SH = 0 # the default
 
297
    LOCK_EX = win32con.LOCKFILE_EXCLUSIVE_LOCK
 
298
    LOCK_NB = win32con.LOCKFILE_FAIL_IMMEDIATELY
 
299
 
358
300
 
359
301
    class _w32c_FileLock(_OSLock):
360
302
 
361
 
        def _open(self, filename, access, share, cflags, pymode):
362
 
            self.filename = osutils.realpath(filename)
 
303
        def _lock(self, filename, openmode, lockmode):
 
304
            self._open(filename, openmode)
 
305
 
 
306
            self.hfile = msvcrt.get_osfhandle(self.f.fileno())
 
307
            overlapped = pywintypes.OVERLAPPED()
363
308
            try:
364
 
                self._handle = win32file_CreateFile(filename, access, share,
365
 
                    None, win32file.OPEN_ALWAYS,
366
 
                    win32file.FILE_ATTRIBUTE_NORMAL, None)
 
309
                win32file.LockFileEx(self.hfile, lockmode, 0, 0x7fff0000,
 
310
                                     overlapped)
367
311
            except pywintypes.error, e:
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)
 
312
                self._clear_f()
 
313
                if e.args[0] in (winerror.ERROR_LOCK_VIOLATION,):
 
314
                    raise errors.LockContention(filename)
 
315
                ## import pdb; pdb.set_trace()
372
316
                raise
373
 
            fd = win32file._open_osfhandle(self._handle, cflags)
374
 
            self.f = os.fdopen(fd, pymode)
375
 
            return self.f
 
317
            except Exception, e:
 
318
                self._clear_f()
 
319
                raise errors.LockContention(e)
376
320
 
377
321
        def unlock(self):
378
 
            self._clear_f()
379
 
            self._handle = None
 
322
            overlapped = pywintypes.OVERLAPPED()
 
323
            try:
 
324
                win32file.UnlockFileEx(self.hfile, 0, 0x7fff0000, overlapped)
 
325
                self._clear_f()
 
326
            except Exception, e:
 
327
                raise errors.LockContention(e)
380
328
 
381
329
 
382
330
    class _w32c_ReadLock(_w32c_FileLock):
383
331
        def __init__(self, filename):
384
332
            super(_w32c_ReadLock, self).__init__()
385
 
            self._open(filename, win32file.GENERIC_READ,
386
 
                win32file.FILE_SHARE_READ, os.O_RDONLY, "rb")
 
333
            self._lock(filename, 'rb', LOCK_SH + LOCK_NB)
387
334
 
388
335
        def temporary_write_lock(self):
389
336
            """Try to grab a write lock on the file.
408
355
    class _w32c_WriteLock(_w32c_FileLock):
409
356
        def __init__(self, filename):
410
357
            super(_w32c_WriteLock, self).__init__()
411
 
            self._open(filename,
412
 
                win32file.GENERIC_READ | win32file.GENERIC_WRITE, 0,
413
 
                os.O_RDWR, "rb+")
 
358
            self._lock(filename, 'rb+', LOCK_EX + LOCK_NB)
414
359
 
415
360
        def restore_read_lock(self):
416
361
            """Restore the original ReadLock."""
423
368
    _lock_classes.append(('pywin32', _w32c_WriteLock, _w32c_ReadLock))
424
369
 
425
370
 
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
 
371
if have_ctypes and sys.platform == 'win32':
 
372
    # These constants were copied from the win32con.py module.
 
373
    LOCKFILE_FAIL_IMMEDIATELY = 1
 
374
    LOCKFILE_EXCLUSIVE_LOCK = 2
 
375
    # Constant taken from winerror.py module
 
376
    ERROR_LOCK_VIOLATION = 33
 
377
 
 
378
    LOCK_SH = 0
 
379
    LOCK_EX = LOCKFILE_EXCLUSIVE_LOCK
 
380
    LOCK_NB = LOCKFILE_FAIL_IMMEDIATELY
 
381
    _LockFileEx = ctypes.windll.kernel32.LockFileEx
 
382
    _UnlockFileEx = ctypes.windll.kernel32.UnlockFileEx
 
383
    _GetLastError = ctypes.windll.kernel32.GetLastError
 
384
 
 
385
    ### Define the OVERLAPPED structure.
 
386
    #   http://msdn2.microsoft.com/en-us/library/ms684342.aspx
 
387
    # typedef struct _OVERLAPPED {
 
388
    #   ULONG_PTR Internal;
 
389
    #   ULONG_PTR InternalHigh;
 
390
    #   union {
 
391
    #     struct {
 
392
    #       DWORD Offset;
 
393
    #       DWORD OffsetHigh;
 
394
    #     };
 
395
    #     PVOID Pointer;
 
396
    #   };
 
397
    #   HANDLE hEvent;
 
398
    # } OVERLAPPED,
 
399
 
 
400
    class _inner_struct(ctypes.Structure):
 
401
        _fields_ = [('Offset', ctypes.c_uint), # DWORD
 
402
                    ('OffsetHigh', ctypes.c_uint), # DWORD
 
403
                   ]
 
404
 
 
405
    class _inner_union(ctypes.Union):
 
406
        _fields_  = [('anon_struct', _inner_struct), # struct
 
407
                     ('Pointer', ctypes.c_void_p), # PVOID
 
408
                    ]
 
409
 
 
410
    class OVERLAPPED(ctypes.Structure):
 
411
        _fields_ = [('Internal', ctypes.c_void_p), # ULONG_PTR
 
412
                    ('InternalHigh', ctypes.c_void_p), # ULONG_PTR
 
413
                    ('_inner_union', _inner_union),
 
414
                    ('hEvent', ctypes.c_void_p), # HANDLE
 
415
                   ]
461
416
 
462
417
    class _ctypes_FileLock(_OSLock):
463
418
 
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
 
419
        def _lock(self, filename, openmode, lockmode):
 
420
            self._open(filename, openmode)
 
421
 
 
422
            self.hfile = msvcrt.get_osfhandle(self.f.fileno())
 
423
            overlapped = OVERLAPPED()
 
424
            result = _LockFileEx(self.hfile, # HANDLE hFile
 
425
                                 lockmode,   # DWORD dwFlags
 
426
                                 0,          # DWORD dwReserved
 
427
                                 0x7fffffff, # DWORD nNumberOfBytesToLockLow
 
428
                                 0x00000000, # DWORD nNumberOfBytesToLockHigh
 
429
                                 ctypes.byref(overlapped), # lpOverlapped
 
430
                                )
 
431
            if result == 0:
 
432
                self._clear_f()
 
433
                last_err = _GetLastError()
 
434
                if last_err in (ERROR_LOCK_VIOLATION,):
 
435
                    raise errors.LockContention(filename)
 
436
                raise errors.LockContention('Unknown locking error: %s'
 
437
                                            % (last_err,))
478
438
 
479
439
        def unlock(self):
 
440
            overlapped = OVERLAPPED()
 
441
            result = _UnlockFileEx(self.hfile, # HANDLE hFile
 
442
                                   0,          # DWORD dwReserved
 
443
                                   0x7fffffff, # DWORD nNumberOfBytesToLockLow
 
444
                                   0x00000000, # DWORD nNumberOfBytesToLockHigh
 
445
                                   ctypes.byref(overlapped), # lpOverlapped
 
446
                                  )
480
447
            self._clear_f()
 
448
            if result == 0:
 
449
                self._clear_f()
 
450
                last_err = _GetLastError()
 
451
                raise errors.LockContention('Unknown unlocking error: %s'
 
452
                                            % (last_err,))
481
453
 
482
454
 
483
455
    class _ctypes_ReadLock(_ctypes_FileLock):
484
456
        def __init__(self, filename):
485
457
            super(_ctypes_ReadLock, self).__init__()
486
 
            self._open(filename, GENERIC_READ, FILE_SHARE_READ, os.O_RDONLY,
487
 
                "rb")
 
458
            self._lock(filename, 'rb', LOCK_SH + LOCK_NB)
488
459
 
489
460
        def temporary_write_lock(self):
490
461
            """Try to grab a write lock on the file.
508
479
    class _ctypes_WriteLock(_ctypes_FileLock):
509
480
        def __init__(self, filename):
510
481
            super(_ctypes_WriteLock, self).__init__()
511
 
            self._open(filename, GENERIC_READ | GENERIC_WRITE, 0, os.O_RDWR,
512
 
                "rb+")
 
482
            self._lock(filename, 'rb+', LOCK_EX + LOCK_NB)
513
483
 
514
484
        def restore_read_lock(self):
515
485
            """Restore the original ReadLock."""
532
502
# We default to using the first available lock class.
533
503
_lock_type, WriteLock, ReadLock = _lock_classes[0]
534
504
 
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