← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/lock.py

  • Committer: Jelmer Vernooij
  • Date: 2009-06-09 00:59:51 UTC
  • mto: (4443.1.1 bzr.dev)
  • mto: This revision was merged to the branch mainline in revision 4444.
  • Revision ID: jelmer@samba.org-20090609005951-apv900cdk35o2ygh
Move squashing of XML-invalid characters to XMLSerializer.

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, 2009 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
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
 
45
from bzrlib.hooks import HookPoint, Hooks
49
46
 
50
47
 
51
48
class LockHooks(Hooks):
52
49
 
53
50
    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))
 
51
        Hooks.__init__(self)
 
52
        self.create_hook(HookPoint('lock_acquired',
 
53
            "Called with a bzrlib.lock.LockResult when a physical lock is "
 
54
            "acquired.", (1, 8), None))
 
55
        self.create_hook(HookPoint('lock_released',
 
56
            "Called with a bzrlib.lock.LockResult when a physical lock is "
 
57
            "released.", (1, 8), None))
 
58
        self.create_hook(HookPoint('lock_broken',
 
59
            "Called with a bzrlib.lock.LockResult when a physical lock is "
 
60
            "broken.", (1, 15), None))
64
61
 
65
62
 
66
63
class Lock(object):
84
81
        return self.lock_url == other.lock_url and self.details == other.details
85
82
 
86
83
    def __repr__(self):
87
 
        return '%s(%s, %s)' % (self.__class__.__name__,
 
84
        return '%s(%s%s)' % (self.__class__.__name__,
88
85
                             self.lock_url, self.details)
89
86
 
90
87
 
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
88
try:
123
89
    import fcntl
124
90
    have_fcntl = True
130
96
if sys.platform == 'win32':
131
97
    import msvcrt
132
98
    try:
133
 
        import win32file, pywintypes, winerror
 
99
        import win32con, win32file, pywintypes, winerror
134
100
        have_pywin32 = True
135
101
    except ImportError:
136
102
        pass
171
137
            self.f.close()
172
138
            self.f = None
173
139
 
 
140
    def __del__(self):
 
141
        if self.f:
 
142
            from warnings import warn
 
143
            warn("lock on %r not released" % self.f)
 
144
            self.unlock()
 
145
 
174
146
    def unlock(self):
175
147
        raise NotImplementedError()
176
148
 
179
151
 
180
152
 
181
153
if have_fcntl:
 
154
    LOCK_SH = fcntl.LOCK_SH
 
155
    LOCK_NB = fcntl.LOCK_NB
 
156
    lock_EX = fcntl.LOCK_EX
 
157
 
182
158
 
183
159
    class _fcntl_FileLock(_OSLock):
184
160
 
198
174
            if self.filename in _fcntl_WriteLock._open_locks:
199
175
                self._clear_f()
200
176
                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
177
 
209
178
            self._open(self.filename, 'rb+')
210
179
            # 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.
 
180
            # at thisi point unlock() will be called, because self.f is set.
212
181
            # TODO: make this fully threadsafe, if we decide we care.
213
182
            _fcntl_WriteLock._open_locks.add(self.filename)
214
183
            try:
235
204
        def __init__(self, filename):
236
205
            super(_fcntl_ReadLock, self).__init__()
237
206
            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
207
            _fcntl_ReadLock._open_locks.setdefault(self.filename, 0)
247
208
            _fcntl_ReadLock._open_locks[self.filename] += 1
248
209
            self._open(filename, 'rb')
343
304
 
344
305
 
345
306
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
 
307
    LOCK_SH = 0 # the default
 
308
    LOCK_EX = win32con.LOCKFILE_EXCLUSIVE_LOCK
 
309
    LOCK_NB = win32con.LOCKFILE_FAIL_IMMEDIATELY
 
310
 
352
311
 
353
312
    class _w32c_FileLock(_OSLock):
354
313
 
355
 
        def _open(self, filename, access, share, cflags, pymode):
356
 
            self.filename = osutils.realpath(filename)
 
314
        def _lock(self, filename, openmode, lockmode):
 
315
            self._open(filename, openmode)
 
316
 
 
317
            self.hfile = msvcrt.get_osfhandle(self.f.fileno())
 
318
            overlapped = pywintypes.OVERLAPPED()
357
319
            try:
358
 
                self._handle = win32file_CreateFile(filename, access, share,
359
 
                    None, win32file.OPEN_ALWAYS,
360
 
                    win32file.FILE_ATTRIBUTE_NORMAL, None)
 
320
                win32file.LockFileEx(self.hfile, lockmode, 0, 0x7fff0000,
 
321
                                     overlapped)
361
322
            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)
 
323
                self._clear_f()
 
324
                if e.args[0] in (winerror.ERROR_LOCK_VIOLATION,):
 
325
                    raise errors.LockContention(filename)
 
326
                ## import pdb; pdb.set_trace()
366
327
                raise
367
 
            fd = win32file._open_osfhandle(self._handle, cflags)
368
 
            self.f = os.fdopen(fd, pymode)
369
 
            return self.f
 
328
            except Exception, e:
 
329
                self._clear_f()
 
330
                raise errors.LockContention(filename, e)
370
331
 
371
332
        def unlock(self):
372
 
            self._clear_f()
373
 
            self._handle = None
 
333
            overlapped = pywintypes.OVERLAPPED()
 
334
            try:
 
335
                win32file.UnlockFileEx(self.hfile, 0, 0x7fff0000, overlapped)
 
336
                self._clear_f()
 
337
            except Exception, e:
 
338
                raise errors.LockContention(self.filename, e)
374
339
 
375
340
 
376
341
    class _w32c_ReadLock(_w32c_FileLock):
377
342
        def __init__(self, filename):
378
343
            super(_w32c_ReadLock, self).__init__()
379
 
            self._open(filename, win32file.GENERIC_READ,
380
 
                win32file.FILE_SHARE_READ, os.O_RDONLY, "rb")
 
344
            self._lock(filename, 'rb', LOCK_SH + LOCK_NB)
381
345
 
382
346
        def temporary_write_lock(self):
383
347
            """Try to grab a write lock on the file.
402
366
    class _w32c_WriteLock(_w32c_FileLock):
403
367
        def __init__(self, filename):
404
368
            super(_w32c_WriteLock, self).__init__()
405
 
            self._open(filename,
406
 
                win32file.GENERIC_READ | win32file.GENERIC_WRITE, 0,
407
 
                os.O_RDWR, "rb+")
 
369
            self._lock(filename, 'rb+', LOCK_EX + LOCK_NB)
408
370
 
409
371
        def restore_read_lock(self):
410
372
            """Restore the original ReadLock."""
418
380
 
419
381
 
420
382
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
 
383
    # These constants were copied from the win32con.py module.
 
384
    LOCKFILE_FAIL_IMMEDIATELY = 1
 
385
    LOCKFILE_EXCLUSIVE_LOCK = 2
 
386
    # Constant taken from winerror.py module
 
387
    ERROR_LOCK_VIOLATION = 33
 
388
 
 
389
    LOCK_SH = 0
 
390
    LOCK_EX = LOCKFILE_EXCLUSIVE_LOCK
 
391
    LOCK_NB = LOCKFILE_FAIL_IMMEDIATELY
 
392
    _LockFileEx = ctypes.windll.kernel32.LockFileEx
 
393
    _UnlockFileEx = ctypes.windll.kernel32.UnlockFileEx
 
394
    _GetLastError = ctypes.windll.kernel32.GetLastError
 
395
 
 
396
    ### Define the OVERLAPPED structure.
 
397
    #   http://msdn2.microsoft.com/en-us/library/ms684342.aspx
 
398
    # typedef struct _OVERLAPPED {
 
399
    #   ULONG_PTR Internal;
 
400
    #   ULONG_PTR InternalHigh;
 
401
    #   union {
 
402
    #     struct {
 
403
    #       DWORD Offset;
 
404
    #       DWORD OffsetHigh;
 
405
    #     };
 
406
    #     PVOID Pointer;
 
407
    #   };
 
408
    #   HANDLE hEvent;
 
409
    # } OVERLAPPED,
 
410
 
 
411
    class _inner_struct(ctypes.Structure):
 
412
        _fields_ = [('Offset', ctypes.c_uint), # DWORD
 
413
                    ('OffsetHigh', ctypes.c_uint), # DWORD
 
414
                   ]
 
415
 
 
416
    class _inner_union(ctypes.Union):
 
417
        _fields_  = [('anon_struct', _inner_struct), # struct
 
418
                     ('Pointer', ctypes.c_void_p), # PVOID
 
419
                    ]
 
420
 
 
421
    class OVERLAPPED(ctypes.Structure):
 
422
        _fields_ = [('Internal', ctypes.c_void_p), # ULONG_PTR
 
423
                    ('InternalHigh', ctypes.c_void_p), # ULONG_PTR
 
424
                    ('_inner_union', _inner_union),
 
425
                    ('hEvent', ctypes.c_void_p), # HANDLE
 
426
                   ]
455
427
 
456
428
    class _ctypes_FileLock(_OSLock):
457
429
 
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
 
430
        def _lock(self, filename, openmode, lockmode):
 
431
            self._open(filename, openmode)
 
432
 
 
433
            self.hfile = msvcrt.get_osfhandle(self.f.fileno())
 
434
            overlapped = OVERLAPPED()
 
435
            result = _LockFileEx(self.hfile, # HANDLE hFile
 
436
                                 lockmode,   # DWORD dwFlags
 
437
                                 0,          # DWORD dwReserved
 
438
                                 0x7fffffff, # DWORD nNumberOfBytesToLockLow
 
439
                                 0x00000000, # DWORD nNumberOfBytesToLockHigh
 
440
                                 ctypes.byref(overlapped), # lpOverlapped
 
441
                                )
 
442
            if result == 0:
 
443
                self._clear_f()
 
444
                last_err = _GetLastError()
 
445
                if last_err in (ERROR_LOCK_VIOLATION,):
 
446
                    raise errors.LockContention(filename)
 
447
                raise errors.LockContention(filename,
 
448
                    'Unknown locking error: %s' % (last_err,))
472
449
 
473
450
        def unlock(self):
 
451
            overlapped = OVERLAPPED()
 
452
            result = _UnlockFileEx(self.hfile, # HANDLE hFile
 
453
                                   0,          # DWORD dwReserved
 
454
                                   0x7fffffff, # DWORD nNumberOfBytesToLockLow
 
455
                                   0x00000000, # DWORD nNumberOfBytesToLockHigh
 
456
                                   ctypes.byref(overlapped), # lpOverlapped
 
457
                                  )
474
458
            self._clear_f()
 
459
            if result == 0:
 
460
                self._clear_f()
 
461
                last_err = _GetLastError()
 
462
                raise errors.LockContention(self.filename,
 
463
                    'Unknown unlocking error: %s' % (last_err,))
475
464
 
476
465
 
477
466
    class _ctypes_ReadLock(_ctypes_FileLock):
478
467
        def __init__(self, filename):
479
468
            super(_ctypes_ReadLock, self).__init__()
480
 
            self._open(filename, GENERIC_READ, FILE_SHARE_READ, os.O_RDONLY,
481
 
                "rb")
 
469
            self._lock(filename, 'rb', LOCK_SH + LOCK_NB)
482
470
 
483
471
        def temporary_write_lock(self):
484
472
            """Try to grab a write lock on the file.
502
490
    class _ctypes_WriteLock(_ctypes_FileLock):
503
491
        def __init__(self, filename):
504
492
            super(_ctypes_WriteLock, self).__init__()
505
 
            self._open(filename, GENERIC_READ | GENERIC_WRITE, 0, os.O_RDWR,
506
 
                "rb+")
 
493
            self._lock(filename, 'rb+', LOCK_EX + LOCK_NB)
507
494
 
508
495
        def restore_read_lock(self):
509
496
            """Restore the original ReadLock."""
526
513
# We default to using the first available lock class.
527
514
_lock_type, WriteLock, ReadLock = _lock_classes[0]
528
515
 
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