← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/lock.py

  • Committer: Martin Pool
  • Date: 2009-06-19 09:06:56 UTC
  • mfrom: (4463 +trunk)
  • mto: This revision was merged to the branch mainline in revision 4464.
  • Revision ID: mbp@sourcefrog.net-20090619090656-d5weqeecyscv8kqp
merge news

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,
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
 
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
88
try:
109
89
    import fcntl
110
90
    have_fcntl = True
116
96
if sys.platform == 'win32':
117
97
    import msvcrt
118
98
    try:
119
 
        import win32file, pywintypes, winerror
 
99
        import win32con, win32file, pywintypes, winerror
120
100
        have_pywin32 = True
121
101
    except ImportError:
122
102
        pass
171
151
 
172
152
 
173
153
if have_fcntl:
 
154
    LOCK_SH = fcntl.LOCK_SH
 
155
    LOCK_NB = fcntl.LOCK_NB
 
156
    lock_EX = fcntl.LOCK_EX
 
157
 
174
158
 
175
159
    class _fcntl_FileLock(_OSLock):
176
160
 
190
174
            if self.filename in _fcntl_WriteLock._open_locks:
191
175
                self._clear_f()
192
176
                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
177
 
201
178
            self._open(self.filename, 'rb+')
202
179
            # 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.
 
180
            # at thisi point unlock() will be called, because self.f is set.
204
181
            # TODO: make this fully threadsafe, if we decide we care.
205
182
            _fcntl_WriteLock._open_locks.add(self.filename)
206
183
            try:
227
204
        def __init__(self, filename):
228
205
            super(_fcntl_ReadLock, self).__init__()
229
206
            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,))
238
207
            _fcntl_ReadLock._open_locks.setdefault(self.filename, 0)
239
208
            _fcntl_ReadLock._open_locks[self.filename] += 1
240
209
            self._open(filename, 'rb')
335
304
 
336
305
 
337
306
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
 
307
    LOCK_SH = 0 # the default
 
308
    LOCK_EX = win32con.LOCKFILE_EXCLUSIVE_LOCK
 
309
    LOCK_NB = win32con.LOCKFILE_FAIL_IMMEDIATELY
 
310
 
344
311
 
345
312
    class _w32c_FileLock(_OSLock):
346
313
 
347
 
        def _open(self, filename, access, share, cflags, pymode):
348
 
            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()
349
319
            try:
350
 
                self._handle = win32file_CreateFile(filename, access, share,
351
 
                    None, win32file.OPEN_ALWAYS,
352
 
                    win32file.FILE_ATTRIBUTE_NORMAL, None)
 
320
                win32file.LockFileEx(self.hfile, lockmode, 0, 0x7fff0000,
 
321
                                     overlapped)
353
322
            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)
 
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()
358
327
                raise
359
 
            fd = win32file._open_osfhandle(self._handle, cflags)
360
 
            self.f = os.fdopen(fd, pymode)
361
 
            return self.f
 
328
            except Exception, e:
 
329
                self._clear_f()
 
330
                raise errors.LockContention(filename, e)
362
331
 
363
332
        def unlock(self):
364
 
            self._clear_f()
365
 
            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)
366
339
 
367
340
 
368
341
    class _w32c_ReadLock(_w32c_FileLock):
369
342
        def __init__(self, filename):
370
343
            super(_w32c_ReadLock, self).__init__()
371
 
            self._open(filename, win32file.GENERIC_READ,
372
 
                win32file.FILE_SHARE_READ, os.O_RDONLY, "rb")
 
344
            self._lock(filename, 'rb', LOCK_SH + LOCK_NB)
373
345
 
374
346
        def temporary_write_lock(self):
375
347
            """Try to grab a write lock on the file.
394
366
    class _w32c_WriteLock(_w32c_FileLock):
395
367
        def __init__(self, filename):
396
368
            super(_w32c_WriteLock, self).__init__()
397
 
            self._open(filename,
398
 
                win32file.GENERIC_READ | win32file.GENERIC_WRITE, 0,
399
 
                os.O_RDWR, "rb+")
 
369
            self._lock(filename, 'rb+', LOCK_EX + LOCK_NB)
400
370
 
401
371
        def restore_read_lock(self):
402
372
            """Restore the original ReadLock."""
410
380
 
411
381
 
412
382
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
 
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
 
 
395
    ### Define the OVERLAPPED structure.
 
396
    #   http://msdn2.microsoft.com/en-us/library/ms684342.aspx
 
397
    # typedef struct _OVERLAPPED {
 
398
    #   ULONG_PTR Internal;
 
399
    #   ULONG_PTR InternalHigh;
 
400
    #   union {
 
401
    #     struct {
 
402
    #       DWORD Offset;
 
403
    #       DWORD OffsetHigh;
 
404
    #     };
 
405
    #     PVOID Pointer;
 
406
    #   };
 
407
    #   HANDLE hEvent;
 
408
    # } OVERLAPPED,
 
409
 
 
410
    class _inner_struct(ctypes.Structure):
 
411
        _fields_ = [('Offset', ctypes.c_uint), # DWORD
 
412
                    ('OffsetHigh', ctypes.c_uint), # DWORD
 
413
                   ]
 
414
 
 
415
    class _inner_union(ctypes.Union):
 
416
        _fields_  = [('anon_struct', _inner_struct), # struct
 
417
                     ('Pointer', ctypes.c_void_p), # PVOID
 
418
                    ]
 
419
 
 
420
    class OVERLAPPED(ctypes.Structure):
 
421
        _fields_ = [('Internal', ctypes.c_void_p), # ULONG_PTR
 
422
                    ('InternalHigh', ctypes.c_void_p), # ULONG_PTR
 
423
                    ('_inner_union', _inner_union),
 
424
                    ('hEvent', ctypes.c_void_p), # HANDLE
 
425
                   ]
447
426
 
448
427
    class _ctypes_FileLock(_OSLock):
449
428
 
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
 
429
        def _lock(self, filename, openmode, lockmode):
 
430
            self._open(filename, openmode)
 
431
 
 
432
            self.hfile = msvcrt.get_osfhandle(self.f.fileno())
 
433
            overlapped = OVERLAPPED()
 
434
            result = _LockFileEx(self.hfile, # HANDLE hFile
 
435
                                 lockmode,   # DWORD dwFlags
 
436
                                 0,          # DWORD dwReserved
 
437
                                 0x7fffffff, # DWORD nNumberOfBytesToLockLow
 
438
                                 0x00000000, # DWORD nNumberOfBytesToLockHigh
 
439
                                 ctypes.byref(overlapped), # lpOverlapped
 
440
                                )
 
441
            if result == 0:
 
442
                last_err = ctypes.GetLastError()
 
443
                self._clear_f()
 
444
                if last_err in (ERROR_LOCK_VIOLATION,):
 
445
                    raise errors.LockContention(filename)
 
446
                raise errors.LockContention(filename,
 
447
                    'Unknown locking error: %s' % (last_err,))
464
448
 
465
449
        def unlock(self):
 
450
            overlapped = OVERLAPPED()
 
451
            result = _UnlockFileEx(self.hfile, # HANDLE hFile
 
452
                                   0,          # DWORD dwReserved
 
453
                                   0x7fffffff, # DWORD nNumberOfBytesToLockLow
 
454
                                   0x00000000, # DWORD nNumberOfBytesToLockHigh
 
455
                                   ctypes.byref(overlapped), # lpOverlapped
 
456
                                  )
 
457
            if result == 0:
 
458
                last_err = ctypes.GetLastError()
 
459
                self._clear_f()
 
460
                raise errors.LockContention(self.filename,
 
461
                    'Unknown unlocking error: %s' % (last_err,))
466
462
            self._clear_f()
467
463
 
468
464
 
469
465
    class _ctypes_ReadLock(_ctypes_FileLock):
470
466
        def __init__(self, filename):
471
467
            super(_ctypes_ReadLock, self).__init__()
472
 
            self._open(filename, GENERIC_READ, FILE_SHARE_READ, os.O_RDONLY,
473
 
                "rb")
 
468
            self._lock(filename, 'rb', LOCK_SH + LOCK_NB)
474
469
 
475
470
        def temporary_write_lock(self):
476
471
            """Try to grab a write lock on the file.
494
489
    class _ctypes_WriteLock(_ctypes_FileLock):
495
490
        def __init__(self, filename):
496
491
            super(_ctypes_WriteLock, self).__init__()
497
 
            self._open(filename, GENERIC_READ | GENERIC_WRITE, 0, os.O_RDWR,
498
 
                "rb+")
 
492
            self._lock(filename, 'rb+', LOCK_EX + LOCK_NB)
499
493
 
500
494
        def restore_read_lock(self):
501
495
            """Restore the original ReadLock."""
518
512
# We default to using the first available lock class.
519
513
_lock_type, WriteLock, ReadLock = _lock_classes[0]
520
514
 
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