/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

Update DirState to use the new 'temporary_write_lock', and add tests that it works.

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,))
271
 
            try:
272
 
                wlock = _fcntl_TemporaryWriteLock(self)
273
 
            except errors.LockError:
274
 
                # We didn't unlock, so we can just return 'self'
275
 
                return False, self
276
 
            return True, wlock
277
 
 
278
 
 
279
 
    class _fcntl_TemporaryWriteLock(_OSLock):
 
192
            assert self.filename not in _fcntl_WriteLock._open_locks
 
193
            return _fcntl_TemporaryWriteLock(self)
 
194
 
 
195
 
 
196
    class _fcntl_TemporaryWriteLock(_base_Lock):
280
197
        """A token used when grabbing a temporary_write_lock.
281
198
 
282
199
        Call restore_read_lock() when you are done with the write lock.
293
210
                # write lock.
294
211
                raise errors.LockContention(self.filename)
295
212
 
296
 
            if self.filename in _fcntl_WriteLock._open_locks:
297
 
                raise AssertionError('file already locked: %r'
298
 
                    % (self.filename,))
 
213
            assert self.filename not in _fcntl_WriteLock._open_locks
299
214
 
300
215
            # See if we can open the file for writing. Another process might
301
216
            # have a read lock. We don't use self._open() because we don't want
305
220
                new_f = open(self.filename, 'rb+')
306
221
            except IOError, e:
307
222
                if e.errno in (errno.EACCES, errno.EPERM):
308
 
                    raise errors.LockFailed(self.filename, str(e))
 
223
                    raise errors.ReadOnlyLockError(self.filename, str(e))
309
224
                raise
310
225
            try:
311
226
                # LOCK_NB will cause IOError to be raised if we can't grab a
312
227
                # lock right away.
313
 
                fcntl.lockf(new_f, fcntl.LOCK_EX | fcntl.LOCK_NB)
 
228
                fcntl.lockf(new_f, fcntl.LOCK_SH | fcntl.LOCK_NB)
314
229
            except IOError, e:
315
230
                # TODO: Raise a more specific error based on the type of error
316
 
                raise errors.LockContention(self.filename, e)
 
231
                raise errors.LockError(e)
317
232
            _fcntl_WriteLock._open_locks.add(self.filename)
318
233
 
319
234
            self.f = new_f
334
249
    _lock_classes.append(('fcntl', _fcntl_WriteLock, _fcntl_ReadLock))
335
250
 
336
251
 
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)
 
252
if have_pywin32:
 
253
    LOCK_SH = 0 # the default
 
254
    LOCK_EX = win32con.LOCKFILE_EXCLUSIVE_LOCK
 
255
    LOCK_NB = win32con.LOCKFILE_FAIL_IMMEDIATELY
 
256
 
 
257
 
 
258
    class _w32c_FileLock(_base_Lock):
 
259
 
 
260
        def _lock(self, filename, openmode, lockmode):
 
261
            self._open(filename, openmode)
 
262
 
 
263
            self.hfile = msvcrt.get_osfhandle(self.f.fileno())
 
264
            overlapped = pywintypes.OVERLAPPED()
349
265
            try:
350
 
                self._handle = win32file_CreateFile(filename, access, share,
351
 
                    None, win32file.OPEN_ALWAYS,
352
 
                    win32file.FILE_ATTRIBUTE_NORMAL, None)
 
266
                win32file.LockFileEx(self.hfile, lockmode, 0, 0x7fff0000,
 
267
                                     overlapped)
353
268
            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)
 
269
                self._clear_f()
 
270
                if e.args[0] in (winerror.ERROR_LOCK_VIOLATION,):
 
271
                    raise errors.LockContention(filename)
 
272
                ## import pdb; pdb.set_trace()
358
273
                raise
359
 
            fd = win32file._open_osfhandle(self._handle, cflags)
360
 
            self.f = os.fdopen(fd, pymode)
361
 
            return self.f
 
274
            except Exception, e:
 
275
                self._clear_f()
 
276
                raise errors.LockError(e)
362
277
 
363
278
        def unlock(self):
364
 
            self._clear_f()
365
 
            self._handle = None
 
279
            overlapped = pywintypes.OVERLAPPED()
 
280
            try:
 
281
                win32file.UnlockFileEx(self.hfile, 0, 0x7fff0000, overlapped)
 
282
                self._clear_f()
 
283
            except Exception, e:
 
284
                raise errors.LockError(e)
366
285
 
367
286
 
368
287
    class _w32c_ReadLock(_w32c_FileLock):
369
288
        def __init__(self, filename):
370
289
            super(_w32c_ReadLock, self).__init__()
371
 
            self._open(filename, win32file.GENERIC_READ,
372
 
                win32file.FILE_SHARE_READ, os.O_RDONLY, "rb")
 
290
            self._lock(filename, 'rb', LOCK_SH + LOCK_NB)
373
291
 
374
292
        def temporary_write_lock(self):
375
293
            """Try to grab a write lock on the file.
384
302
            # I can't find a way to upgrade a read lock to a write lock without
385
303
            # unlocking first. So here, we do just that.
386
304
            self.unlock()
387
 
            try:
388
 
                wlock = _w32c_WriteLock(self.filename)
389
 
            except errors.LockError:
390
 
                return False, _w32c_ReadLock(self.filename)
391
 
            return True, wlock
 
305
            return _w32c_WriteLock(self.filename)
392
306
 
393
307
 
394
308
    class _w32c_WriteLock(_w32c_FileLock):
395
309
        def __init__(self, filename):
396
310
            super(_w32c_WriteLock, self).__init__()
397
 
            self._open(filename,
398
 
                win32file.GENERIC_READ | win32file.GENERIC_WRITE, 0,
399
 
                os.O_RDWR, "rb+")
 
311
            self._lock(filename, 'rb+', LOCK_EX + LOCK_NB)
400
312
 
401
313
        def restore_read_lock(self):
402
314
            """Restore the original ReadLock."""
409
321
    _lock_classes.append(('pywin32', _w32c_WriteLock, _w32c_ReadLock))
410
322
 
411
323
 
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
 
324
if have_ctypes:
 
325
    # These constants were copied from the win32con.py module.
 
326
    LOCKFILE_FAIL_IMMEDIATELY = 1
 
327
    LOCKFILE_EXCLUSIVE_LOCK = 2
 
328
    # Constant taken from winerror.py module
 
329
    ERROR_LOCK_VIOLATION = 33
 
330
 
 
331
    LOCK_SH = 0
 
332
    LOCK_EX = LOCKFILE_EXCLUSIVE_LOCK
 
333
    LOCK_NB = LOCKFILE_FAIL_IMMEDIATELY
 
334
    _LockFileEx = ctypes.windll.kernel32.LockFileEx
 
335
    _UnlockFileEx = ctypes.windll.kernel32.UnlockFileEx
 
336
    _GetLastError = ctypes.windll.kernel32.GetLastError
 
337
 
 
338
    ### Define the OVERLAPPED structure.
 
339
    #   http://msdn2.microsoft.com/en-us/library/ms684342.aspx
 
340
    # typedef struct _OVERLAPPED {
 
341
    #   ULONG_PTR Internal;
 
342
    #   ULONG_PTR InternalHigh;
 
343
    #   union {
 
344
    #     struct {
 
345
    #       DWORD Offset;
 
346
    #       DWORD OffsetHigh;
 
347
    #     };
 
348
    #     PVOID Pointer;
 
349
    #   };
 
350
    #   HANDLE hEvent;
 
351
    # } OVERLAPPED,
 
352
 
 
353
    class _inner_struct(ctypes.Structure):
 
354
        _fields_ = [('Offset', ctypes.c_uint), # DWORD
 
355
                    ('OffsetHigh', ctypes.c_uint), # DWORD
 
356
                   ]
 
357
 
 
358
    class _inner_union(ctypes.Union):
 
359
        _fields_  = [('anon_struct', _inner_struct), # struct
 
360
                     ('Pointer', ctypes.c_void_p), # PVOID
 
361
                    ]
 
362
 
 
363
    class OVERLAPPED(ctypes.Structure):
 
364
        _fields_ = [('Internal', ctypes.c_void_p), # ULONG_PTR
 
365
                    ('InternalHigh', ctypes.c_void_p), # ULONG_PTR
 
366
                    ('_inner_union', _inner_union),
 
367
                    ('hEvent', ctypes.c_void_p), # HANDLE
 
368
                   ]
 
369
 
 
370
    class _ctypes_FileLock(_base_Lock):
 
371
 
 
372
        def _lock(self, filename, openmode, lockmode):
 
373
            self._open(filename, openmode)
 
374
 
 
375
            self.hfile = msvcrt.get_osfhandle(self.f.fileno())
 
376
            overlapped = OVERLAPPED()
 
377
            p_overlapped = ctypes.pointer(overlapped)
 
378
            result = _LockFileEx(self.hfile, # HANDLE hFile
 
379
                                 lockmode,   # DWORD dwFlags
 
380
                                 0,          # DWORD dwReserved
 
381
                                 0x7fffffff, # DWORD nNumberOfBytesToLockLow
 
382
                                 0x00000000, # DWORD nNumberOfBytesToLockHigh
 
383
                                 p_overlapped, # lpOverlapped
 
384
                                )
 
385
            if result == 0:
 
386
                self._clear_f()
 
387
                last_err = _GetLastError()
 
388
                if last_err in (ERROR_LOCK_VIOLATION,):
 
389
                    raise errors.LockContention(filename)
 
390
                raise errors.LockError('Unknown locking error: %s'
 
391
                                       % (last_err,))
464
392
 
465
393
        def unlock(self):
 
394
            overlapped = OVERLAPPED()
 
395
            p_overlapped = ctypes.pointer(overlapped)
 
396
            result = _UnlockFileEx(self.hfile, # HANDLE hFile
 
397
                                   0,          # DWORD dwReserved
 
398
                                   0x7fffffff, # DWORD nNumberOfBytesToLockLow
 
399
                                   0x00000000, # DWORD nNumberOfBytesToLockHigh
 
400
                                   p_overlapped, # lpOverlapped
 
401
                                  )
466
402
            self._clear_f()
 
403
            if result == 0:
 
404
                self._clear_f()
 
405
                last_err = _GetLastError()
 
406
                raise errors.LockError('Unknown unlocking error: %s'
 
407
                                       % (last_err,))
467
408
 
468
409
 
469
410
    class _ctypes_ReadLock(_ctypes_FileLock):
470
411
        def __init__(self, filename):
471
412
            super(_ctypes_ReadLock, self).__init__()
472
 
            self._open(filename, GENERIC_READ, FILE_SHARE_READ, os.O_RDONLY,
473
 
                "rb")
 
413
            self._lock(filename, 'rb', LOCK_SH + LOCK_NB)
474
414
 
475
415
        def temporary_write_lock(self):
476
416
            """Try to grab a write lock on the file.
485
425
            # I can't find a way to upgrade a read lock to a write lock without
486
426
            # unlocking first. So here, we do just that.
487
427
            self.unlock()
488
 
            try:
489
 
                wlock = _ctypes_WriteLock(self.filename)
490
 
            except errors.LockError:
491
 
                return False, _ctypes_ReadLock(self.filename)
492
 
            return True, wlock
 
428
            return _w32c_WriteLock(self.filename)
493
429
 
494
430
    class _ctypes_WriteLock(_ctypes_FileLock):
495
431
        def __init__(self, filename):
496
432
            super(_ctypes_WriteLock, self).__init__()
497
 
            self._open(filename, GENERIC_READ | GENERIC_WRITE, 0, os.O_RDWR,
498
 
                "rb+")
 
433
            self._lock(filename, 'rb+', LOCK_EX + LOCK_NB)
499
434
 
500
435
        def restore_read_lock(self):
501
436
            """Restore the original ReadLock."""
502
437
            # For win32 we had to completely let go of the original lock, so we
503
438
            # just unlock and create a new read lock.
504
439
            self.unlock()
505
 
            return _ctypes_ReadLock(self.filename)
 
440
            return _w32c_ReadLock(self.filename)
506
441
 
507
442
 
508
443
    _lock_classes.append(('ctypes', _ctypes_WriteLock, _ctypes_ReadLock))
518
453
# We default to using the first available lock class.
519
454
_lock_type, WriteLock, ReadLock = _lock_classes[0]
520
455
 
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