/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: Aaron Bentley
  • Date: 2007-04-01 03:52:31 UTC
  • mto: This revision was merged to the branch mainline in revision 2389.
  • Revision ID: aaron.bentley@utoronto.ca-20070401035231-w87zy7hrpre4v81m
rename get_target_revision to install_revisions

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
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
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
 
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
 
 
145
 
class _OSLock(object):
 
45
 
 
46
 
 
47
class _base_Lock(object):
146
48
 
147
49
    def __init__(self):
148
50
        self.f = None
155
57
            return self.f
156
58
        except IOError, e:
157
59
            if e.errno in (errno.EACCES, errno.EPERM):
158
 
                raise errors.LockFailed(self.filename, str(e))
 
60
                raise errors.ReadOnlyLockError(self.filename, str(e))
159
61
            if e.errno != errno.ENOENT:
160
62
                raise
161
63
 
181
83
        raise NotImplementedError()
182
84
 
183
85
 
 
86
try:
 
87
    import fcntl
 
88
    have_fcntl = True
 
89
except ImportError:
 
90
    have_fcntl = False
 
91
try:
 
92
    import win32con, win32file, pywintypes, winerror, msvcrt
 
93
    have_pywin32 = True
 
94
except ImportError:
 
95
    have_pywin32 = False
 
96
try:
 
97
    import ctypes, msvcrt
 
98
    have_ctypes = True
 
99
except ImportError:
 
100
    have_ctypes = False
 
101
 
 
102
 
184
103
_lock_classes = []
185
104
 
186
105
 
187
106
if have_fcntl:
188
 
 
189
 
    class _fcntl_FileLock(_OSLock):
 
107
    LOCK_SH = fcntl.LOCK_SH
 
108
    LOCK_NB = fcntl.LOCK_NB
 
109
    lock_EX = fcntl.LOCK_EX
 
110
 
 
111
 
 
112
    class _fcntl_FileLock(_base_Lock):
190
113
 
191
114
        def _unlock(self):
192
115
            fcntl.lockf(self.f, fcntl.LOCK_UN)
195
118
 
196
119
    class _fcntl_WriteLock(_fcntl_FileLock):
197
120
 
198
 
        _open_locks = set()
 
121
        open_locks = {}
199
122
 
200
123
        def __init__(self, filename):
 
124
            # standard IO errors get exposed directly.
201
125
            super(_fcntl_WriteLock, self).__init__()
202
 
            # Check we can grab a lock before we actually open the file.
203
 
            self.filename = osutils.realpath(filename)
204
 
            if self.filename in _fcntl_WriteLock._open_locks:
 
126
            self._open(filename, 'rb+')
 
127
            if self.filename in self.open_locks:
205
128
                self._clear_f()
206
129
                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
 
 
215
 
            self._open(self.filename, 'rb+')
216
130
            # 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.
 
131
            # at thisi point unlock() will be called, because self.f is set.
218
132
            # TODO: make this fully threadsafe, if we decide we care.
219
 
            _fcntl_WriteLock._open_locks.add(self.filename)
 
133
            self.open_locks[self.filename] = self.filename
220
134
            try:
221
135
                # LOCK_NB will cause IOError to be raised if we can't grab a
222
136
                # lock right away.
227
141
                    self.unlock()
228
142
                # we should be more precise about whats a locking
229
143
                # error and whats a random-other error
230
 
                raise errors.LockContention(self.filename, e)
 
144
                raise errors.LockError(e)
231
145
 
232
146
        def unlock(self):
233
 
            _fcntl_WriteLock._open_locks.remove(self.filename)
 
147
            del self.open_locks[self.filename]
234
148
            self._unlock()
235
149
 
236
150
 
237
151
    class _fcntl_ReadLock(_fcntl_FileLock):
238
152
 
239
 
        _open_locks = {}
 
153
        open_locks = {}
240
154
 
241
155
        def __init__(self, filename):
242
156
            super(_fcntl_ReadLock, self).__init__()
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,))
252
 
            _fcntl_ReadLock._open_locks.setdefault(self.filename, 0)
253
 
            _fcntl_ReadLock._open_locks[self.filename] += 1
254
157
            self._open(filename, 'rb')
255
158
            try:
256
159
                # LOCK_NB will cause IOError to be raised if we can't grab a
259
162
            except IOError, e:
260
163
                # we should be more precise about whats a locking
261
164
                # error and whats a random-other error
262
 
                raise errors.LockContention(self.filename, e)
 
165
                raise errors.LockError(e)
263
166
 
264
167
        def unlock(self):
265
 
            count = _fcntl_ReadLock._open_locks[self.filename]
266
 
            if count == 1:
267
 
                del _fcntl_ReadLock._open_locks[self.filename]
268
 
            else:
269
 
                _fcntl_ReadLock._open_locks[self.filename] = count - 1
270
168
            self._unlock()
271
169
 
272
 
        def temporary_write_lock(self):
273
 
            """Try to grab a write lock on the file.
274
 
 
275
 
            On platforms that support it, this will upgrade to a write lock
276
 
            without unlocking the file.
277
 
            Otherwise, this will release the read lock, and try to acquire a
278
 
            write lock.
279
 
 
280
 
            :return: A token which can be used to switch back to a read lock.
281
 
            """
282
 
            if self.filename in _fcntl_WriteLock._open_locks:
283
 
                raise AssertionError('file already locked: %r'
284
 
                    % (self.filename,))
285
 
            try:
286
 
                wlock = _fcntl_TemporaryWriteLock(self)
287
 
            except errors.LockError:
288
 
                # We didn't unlock, so we can just return 'self'
289
 
                return False, self
290
 
            return True, wlock
291
 
 
292
 
 
293
 
    class _fcntl_TemporaryWriteLock(_OSLock):
294
 
        """A token used when grabbing a temporary_write_lock.
295
 
 
296
 
        Call restore_read_lock() when you are done with the write lock.
297
 
        """
298
 
 
299
 
        def __init__(self, read_lock):
300
 
            super(_fcntl_TemporaryWriteLock, self).__init__()
301
 
            self._read_lock = read_lock
302
 
            self.filename = read_lock.filename
303
 
 
304
 
            count = _fcntl_ReadLock._open_locks[self.filename]
305
 
            if count > 1:
306
 
                # Something else also has a read-lock, so we cannot grab a
307
 
                # write lock.
308
 
                raise errors.LockContention(self.filename)
309
 
 
310
 
            if self.filename in _fcntl_WriteLock._open_locks:
311
 
                raise AssertionError('file already locked: %r'
312
 
                    % (self.filename,))
313
 
 
314
 
            # See if we can open the file for writing. Another process might
315
 
            # have a read lock. We don't use self._open() because we don't want
316
 
            # to create the file if it exists. That would have already been
317
 
            # done by _fcntl_ReadLock
318
 
            try:
319
 
                new_f = open(self.filename, 'rb+')
320
 
            except IOError, e:
321
 
                if e.errno in (errno.EACCES, errno.EPERM):
322
 
                    raise errors.LockFailed(self.filename, str(e))
323
 
                raise
324
 
            try:
325
 
                # LOCK_NB will cause IOError to be raised if we can't grab a
326
 
                # lock right away.
327
 
                fcntl.lockf(new_f, fcntl.LOCK_EX | fcntl.LOCK_NB)
328
 
            except IOError, e:
329
 
                # TODO: Raise a more specific error based on the type of error
330
 
                raise errors.LockContention(self.filename, e)
331
 
            _fcntl_WriteLock._open_locks.add(self.filename)
332
 
 
333
 
            self.f = new_f
334
 
 
335
 
        def restore_read_lock(self):
336
 
            """Restore the original ReadLock."""
337
 
            # For fcntl, since we never released the read lock, just release the
338
 
            # write lock, and return the original lock.
339
 
            fcntl.lockf(self.f, fcntl.LOCK_UN)
340
 
            self._clear_f()
341
 
            _fcntl_WriteLock._open_locks.remove(self.filename)
342
 
            # Avoid reference cycles
343
 
            read_lock = self._read_lock
344
 
            self._read_lock = None
345
 
            return read_lock
346
 
 
347
170
 
348
171
    _lock_classes.append(('fcntl', _fcntl_WriteLock, _fcntl_ReadLock))
349
172
 
350
173
 
351
174
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
358
 
 
359
 
    class _w32c_FileLock(_OSLock):
360
 
 
361
 
        def _open(self, filename, access, share, cflags, pymode):
362
 
            self.filename = osutils.realpath(filename)
 
175
    LOCK_SH = 0 # the default
 
176
    LOCK_EX = win32con.LOCKFILE_EXCLUSIVE_LOCK
 
177
    LOCK_NB = win32con.LOCKFILE_FAIL_IMMEDIATELY
 
178
 
 
179
 
 
180
    class _w32c_FileLock(_base_Lock):
 
181
 
 
182
        def _lock(self, filename, openmode, lockmode):
 
183
            self._open(filename, openmode)
 
184
 
 
185
            self.hfile = msvcrt.get_osfhandle(self.f.fileno())
 
186
            overlapped = pywintypes.OVERLAPPED()
363
187
            try:
364
 
                self._handle = win32file_CreateFile(filename, access, share,
365
 
                    None, win32file.OPEN_ALWAYS,
366
 
                    win32file.FILE_ATTRIBUTE_NORMAL, None)
 
188
                win32file.LockFileEx(self.hfile, lockmode, 0, 0x7fff0000,
 
189
                                     overlapped)
367
190
            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)
 
191
                self._clear_f()
 
192
                if e.args[0] in (winerror.ERROR_LOCK_VIOLATION,):
 
193
                    raise errors.LockContention(filename)
 
194
                ## import pdb; pdb.set_trace()
372
195
                raise
373
 
            fd = win32file._open_osfhandle(self._handle, cflags)
374
 
            self.f = os.fdopen(fd, pymode)
375
 
            return self.f
 
196
            except Exception, e:
 
197
                self._clear_f()
 
198
                raise errors.LockError(e)
376
199
 
377
200
        def unlock(self):
378
 
            self._clear_f()
379
 
            self._handle = None
 
201
            overlapped = pywintypes.OVERLAPPED()
 
202
            try:
 
203
                win32file.UnlockFileEx(self.hfile, 0, 0x7fff0000, overlapped)
 
204
                self._clear_f()
 
205
            except Exception, e:
 
206
                raise errors.LockError(e)
380
207
 
381
208
 
382
209
    class _w32c_ReadLock(_w32c_FileLock):
383
210
        def __init__(self, filename):
384
211
            super(_w32c_ReadLock, self).__init__()
385
 
            self._open(filename, win32file.GENERIC_READ,
386
 
                win32file.FILE_SHARE_READ, os.O_RDONLY, "rb")
387
 
 
388
 
        def temporary_write_lock(self):
389
 
            """Try to grab a write lock on the file.
390
 
 
391
 
            On platforms that support it, this will upgrade to a write lock
392
 
            without unlocking the file.
393
 
            Otherwise, this will release the read lock, and try to acquire a
394
 
            write lock.
395
 
 
396
 
            :return: A token which can be used to switch back to a read lock.
397
 
            """
398
 
            # I can't find a way to upgrade a read lock to a write lock without
399
 
            # unlocking first. So here, we do just that.
400
 
            self.unlock()
401
 
            try:
402
 
                wlock = _w32c_WriteLock(self.filename)
403
 
            except errors.LockError:
404
 
                return False, _w32c_ReadLock(self.filename)
405
 
            return True, wlock
 
212
            self._lock(filename, 'rb', LOCK_SH + LOCK_NB)
406
213
 
407
214
 
408
215
    class _w32c_WriteLock(_w32c_FileLock):
409
216
        def __init__(self, filename):
410
217
            super(_w32c_WriteLock, self).__init__()
411
 
            self._open(filename,
412
 
                win32file.GENERIC_READ | win32file.GENERIC_WRITE, 0,
413
 
                os.O_RDWR, "rb+")
414
 
 
415
 
        def restore_read_lock(self):
416
 
            """Restore the original ReadLock."""
417
 
            # For win32 we had to completely let go of the original lock, so we
418
 
            # just unlock and create a new read lock.
419
 
            self.unlock()
420
 
            return _w32c_ReadLock(self.filename)
 
218
            self._lock(filename, 'rb+', LOCK_EX + LOCK_NB)
421
219
 
422
220
 
423
221
    _lock_classes.append(('pywin32', _w32c_WriteLock, _w32c_ReadLock))
424
222
 
425
223
 
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
461
 
 
462
 
    class _ctypes_FileLock(_OSLock):
463
 
 
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
 
224
if have_ctypes and sys.platform == 'win32':
 
225
    # These constants were copied from the win32con.py module.
 
226
    LOCKFILE_FAIL_IMMEDIATELY = 1
 
227
    LOCKFILE_EXCLUSIVE_LOCK = 2
 
228
    # Constant taken from winerror.py module
 
229
    ERROR_LOCK_VIOLATION = 33
 
230
 
 
231
    LOCK_SH = 0
 
232
    LOCK_EX = LOCKFILE_EXCLUSIVE_LOCK
 
233
    LOCK_NB = LOCKFILE_FAIL_IMMEDIATELY
 
234
    _LockFileEx = ctypes.windll.kernel32.LockFileEx
 
235
    _UnlockFileEx = ctypes.windll.kernel32.UnlockFileEx
 
236
    _GetLastError = ctypes.windll.kernel32.GetLastError
 
237
 
 
238
    ### Define the OVERLAPPED structure.
 
239
    #   http://msdn2.microsoft.com/en-us/library/ms684342.aspx
 
240
    # typedef struct _OVERLAPPED {
 
241
    #   ULONG_PTR Internal;
 
242
    #   ULONG_PTR InternalHigh;
 
243
    #   union {
 
244
    #     struct {
 
245
    #       DWORD Offset;
 
246
    #       DWORD OffsetHigh;
 
247
    #     };
 
248
    #     PVOID Pointer;
 
249
    #   };
 
250
    #   HANDLE hEvent;
 
251
    # } OVERLAPPED,
 
252
 
 
253
    class _inner_struct(ctypes.Structure):
 
254
        _fields_ = [('Offset', ctypes.c_uint), # DWORD
 
255
                    ('OffsetHigh', ctypes.c_uint), # DWORD
 
256
                   ]
 
257
 
 
258
    class _inner_union(ctypes.Union):
 
259
        _fields_  = [('anon_struct', _inner_struct), # struct
 
260
                     ('Pointer', ctypes.c_void_p), # PVOID
 
261
                    ]
 
262
 
 
263
    class OVERLAPPED(ctypes.Structure):
 
264
        _fields_ = [('Internal', ctypes.c_void_p), # ULONG_PTR
 
265
                    ('InternalHigh', ctypes.c_void_p), # ULONG_PTR
 
266
                    ('_inner_union', _inner_union),
 
267
                    ('hEvent', ctypes.c_void_p), # HANDLE
 
268
                   ]
 
269
 
 
270
    class _ctypes_FileLock(_base_Lock):
 
271
 
 
272
        def _lock(self, filename, openmode, lockmode):
 
273
            self._open(filename, openmode)
 
274
 
 
275
            self.hfile = msvcrt.get_osfhandle(self.f.fileno())
 
276
            overlapped = OVERLAPPED()
 
277
            result = _LockFileEx(self.hfile, # HANDLE hFile
 
278
                                 lockmode,   # DWORD dwFlags
 
279
                                 0,          # DWORD dwReserved
 
280
                                 0x7fffffff, # DWORD nNumberOfBytesToLockLow
 
281
                                 0x00000000, # DWORD nNumberOfBytesToLockHigh
 
282
                                 ctypes.byref(overlapped), # lpOverlapped
 
283
                                )
 
284
            if result == 0:
 
285
                self._clear_f()
 
286
                last_err = _GetLastError()
 
287
                if last_err in (ERROR_LOCK_VIOLATION,):
 
288
                    raise errors.LockContention(filename)
 
289
                raise errors.LockError('Unknown locking error: %s'
 
290
                                       % (last_err,))
478
291
 
479
292
        def unlock(self):
 
293
            overlapped = OVERLAPPED()
 
294
            result = _UnlockFileEx(self.hfile, # HANDLE hFile
 
295
                                   0,          # DWORD dwReserved
 
296
                                   0x7fffffff, # DWORD nNumberOfBytesToLockLow
 
297
                                   0x00000000, # DWORD nNumberOfBytesToLockHigh
 
298
                                   ctypes.byref(overlapped), # lpOverlapped
 
299
                                  )
480
300
            self._clear_f()
 
301
            if result == 0:
 
302
                self._clear_f()
 
303
                last_err = _GetLastError()
 
304
                raise errors.LockError('Unknown unlocking error: %s'
 
305
                                       % (last_err,))
481
306
 
482
307
 
483
308
    class _ctypes_ReadLock(_ctypes_FileLock):
484
309
        def __init__(self, filename):
485
310
            super(_ctypes_ReadLock, self).__init__()
486
 
            self._open(filename, GENERIC_READ, FILE_SHARE_READ, os.O_RDONLY,
487
 
                "rb")
488
 
 
489
 
        def temporary_write_lock(self):
490
 
            """Try to grab a write lock on the file.
491
 
 
492
 
            On platforms that support it, this will upgrade to a write lock
493
 
            without unlocking the file.
494
 
            Otherwise, this will release the read lock, and try to acquire a
495
 
            write lock.
496
 
 
497
 
            :return: A token which can be used to switch back to a read lock.
498
 
            """
499
 
            # I can't find a way to upgrade a read lock to a write lock without
500
 
            # unlocking first. So here, we do just that.
501
 
            self.unlock()
502
 
            try:
503
 
                wlock = _ctypes_WriteLock(self.filename)
504
 
            except errors.LockError:
505
 
                return False, _ctypes_ReadLock(self.filename)
506
 
            return True, wlock
 
311
            self._lock(filename, 'rb', LOCK_SH + LOCK_NB)
 
312
 
507
313
 
508
314
    class _ctypes_WriteLock(_ctypes_FileLock):
509
315
        def __init__(self, filename):
510
316
            super(_ctypes_WriteLock, self).__init__()
511
 
            self._open(filename, GENERIC_READ | GENERIC_WRITE, 0, os.O_RDWR,
512
 
                "rb+")
513
 
 
514
 
        def restore_read_lock(self):
515
 
            """Restore the original ReadLock."""
516
 
            # For win32 we had to completely let go of the original lock, so we
517
 
            # just unlock and create a new read lock.
518
 
            self.unlock()
519
 
            return _ctypes_ReadLock(self.filename)
 
317
            self._lock(filename, 'rb+', LOCK_EX + LOCK_NB)
520
318
 
521
319
 
522
320
    _lock_classes.append(('ctypes', _ctypes_WriteLock, _ctypes_ReadLock))
532
330
# We default to using the first available lock class.
533
331
_lock_type, WriteLock, ReadLock = _lock_classes[0]
534
332
 
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