~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/lock.py

  • Committer: Aaron Bentley
  • Date: 2007-12-12 15:17:13 UTC
  • mto: This revision was merged to the branch mainline in revision 3113.
  • Revision ID: abentley@panoramicfeedback.com-20071212151713-ox5n8rlx8m3nsspy
Add support for reconfiguring repositories into branches or trees

Show diffs side-by-side

added added

removed removed

Lines of Context:
1
 
# Copyright (C) 2005 Canonical Ltd
2
 
 
 
1
# Copyright (C) 2005, 2006, 2007 Canonical Ltd
 
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
5
5
# the Free Software Foundation; either version 2 of the License, or
6
6
# (at your option) any later version.
7
 
 
 
7
#
8
8
# This program is distributed in the hope that it will be useful,
9
9
# but WITHOUT ANY WARRANTY; without even the implied warranty of
10
10
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
11
11
# GNU General Public License for more details.
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
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
16
16
 
17
17
 
18
 
"""Locking wrappers.
 
18
"""Locking using OS file locks or file existence.
19
19
 
20
 
This only does local locking using OS locks for now.
 
20
Note: This method of locking is generally deprecated in favour of LockDir, but
 
21
is used to lock local WorkingTrees, and by some old formats.  It's accessed
 
22
through Transport.lock_read(), etc.
21
23
 
22
24
This module causes two methods, lock() and unlock() to be defined in
23
25
any way that works on the current platform.
24
26
 
25
27
It is not specified whether these locks are reentrant (i.e. can be
26
28
taken repeatedly by a single process) or whether they exclude
27
 
different threads in a single process.  
28
 
 
29
 
Eventually we may need to use some kind of lock representation that
30
 
will work on a dumb filesystem without actual locking primitives.
 
29
different threads in a single process.  That reentrancy is provided by
 
30
LockableFiles.
31
31
 
32
32
This defines two classes: ReadLock and WriteLock, which can be
33
33
implemented in different ways on different platforms.  Both have an
34
34
unlock() method.
35
35
"""
36
36
 
37
 
 
 
37
import errno
38
38
import sys
39
 
import os
40
 
 
41
 
from bzrlib.trace import mutter, note, warning
42
 
from bzrlib.errors import LockError
43
 
 
44
 
class _base_Lock(object):
 
39
 
 
40
from bzrlib import (
 
41
    errors,
 
42
    osutils,
 
43
    trace,
 
44
    )
 
45
 
 
46
 
 
47
class _OSLock(object):
 
48
 
 
49
    def __init__(self):
 
50
        self.f = None
 
51
        self.filename = None
 
52
 
45
53
    def _open(self, filename, filemode):
46
 
        import errno
 
54
        self.filename = osutils.realpath(filename)
47
55
        try:
48
 
            self.f = open(filename, filemode)
 
56
            self.f = open(self.filename, filemode)
49
57
            return self.f
50
58
        except IOError, e:
 
59
            if e.errno in (errno.EACCES, errno.EPERM):
 
60
                raise errors.LockFailed(self.filename, str(e))
51
61
            if e.errno != errno.ENOENT:
52
62
                raise
53
63
 
54
64
            # maybe this is an old branch (before may 2005)
55
 
            mutter("trying to create missing branch lock %r", filename)
56
 
            
57
 
            self.f = open(filename, 'wb')
 
65
            trace.mutter("trying to create missing lock %r", self.filename)
 
66
 
 
67
            self.f = open(self.filename, 'wb+')
58
68
            return self.f
59
69
 
 
70
    def _clear_f(self):
 
71
        """Clear the self.f attribute cleanly."""
 
72
        if self.f:
 
73
            self.f.close()
 
74
            self.f = None
60
75
 
61
76
    def __del__(self):
62
77
        if self.f:
63
78
            from warnings import warn
64
79
            warn("lock on %r not released" % self.f)
65
80
            self.unlock()
66
 
            
67
81
 
68
82
    def unlock(self):
69
83
        raise NotImplementedError()
70
84
 
71
 
        
72
 
 
73
 
 
74
 
 
75
 
 
76
 
############################################################
77
 
# msvcrt locks
78
 
 
79
85
 
80
86
try:
81
87
    import fcntl
82
 
 
83
 
    class _fcntl_FileLock(_base_Lock):
84
 
        f = None
85
 
 
86
 
        def unlock(self):
 
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
 
 
103
_lock_classes = []
 
104
 
 
105
 
 
106
if have_fcntl:
 
107
    LOCK_SH = fcntl.LOCK_SH
 
108
    LOCK_NB = fcntl.LOCK_NB
 
109
    lock_EX = fcntl.LOCK_EX
 
110
 
 
111
 
 
112
    class _fcntl_FileLock(_OSLock):
 
113
 
 
114
        def _unlock(self):
87
115
            fcntl.lockf(self.f, fcntl.LOCK_UN)
88
 
            self.f.close()
89
 
            del self.f 
 
116
            self._clear_f()
90
117
 
91
118
 
92
119
    class _fcntl_WriteLock(_fcntl_FileLock):
 
120
 
 
121
        _open_locks = set()
 
122
 
93
123
        def __init__(self, filename):
 
124
            super(_fcntl_WriteLock, self).__init__()
 
125
            # Check we can grab a lock before we actually open the file.
 
126
            self.filename = osutils.realpath(filename)
 
127
            if self.filename in _fcntl_WriteLock._open_locks:
 
128
                self._clear_f()
 
129
                raise errors.LockContention(self.filename)
 
130
 
 
131
            self._open(self.filename, 'rb+')
 
132
            # reserve a slot for this lock - even if the lockf call fails,
 
133
            # at thisi point unlock() will be called, because self.f is set.
 
134
            # TODO: make this fully threadsafe, if we decide we care.
 
135
            _fcntl_WriteLock._open_locks.add(self.filename)
94
136
            try:
95
 
                fcntl.lockf(self._open(filename, 'wb'), fcntl.LOCK_EX)
96
 
            except Exception, e:
97
 
                raise LockError(e)
 
137
                # LOCK_NB will cause IOError to be raised if we can't grab a
 
138
                # lock right away.
 
139
                fcntl.lockf(self.f, fcntl.LOCK_EX | fcntl.LOCK_NB)
 
140
            except IOError, e:
 
141
                if e.errno in (errno.EAGAIN, errno.EACCES):
 
142
                    # We couldn't grab the lock
 
143
                    self.unlock()
 
144
                # we should be more precise about whats a locking
 
145
                # error and whats a random-other error
 
146
                raise errors.LockContention(e)
 
147
 
 
148
        def unlock(self):
 
149
            _fcntl_WriteLock._open_locks.remove(self.filename)
 
150
            self._unlock()
98
151
 
99
152
 
100
153
    class _fcntl_ReadLock(_fcntl_FileLock):
101
 
        def __init__(self, filename):
102
 
            try:
103
 
                fcntl.lockf(self._open(filename, 'rb'), fcntl.LOCK_SH)
104
 
            except Exception, e:
105
 
                raise LockError(e)
106
 
 
107
 
    WriteLock = _fcntl_WriteLock
108
 
    ReadLock = _fcntl_ReadLock
109
 
 
110
 
except ImportError:
111
 
    try:
112
 
        import win32con, win32file, pywintypes
113
 
 
114
 
 
115
 
        LOCK_SH = 0 # the default
116
 
        LOCK_EX = win32con.LOCKFILE_EXCLUSIVE_LOCK
117
 
        LOCK_NB = win32con.LOCKFILE_FAIL_IMMEDIATELY
118
 
 
119
 
        class _w32c_FileLock(_base_Lock):
120
 
            def _lock(self, filename, openmode, lockmode):
121
 
                try:
122
 
                    self._open(filename, openmode)
123
 
                    self.hfile = win32file._get_osfhandle(self.f.fileno())
124
 
                    overlapped = pywintypes.OVERLAPPED()
125
 
                    win32file.LockFileEx(self.hfile, lockmode, 0, 0x7fff0000, overlapped)
126
 
                except Exception, e:
127
 
                    raise LockError(e)
128
 
 
129
 
            def unlock(self):
130
 
                try:
131
 
                    overlapped = pywintypes.OVERLAPPED()
132
 
                    win32file.UnlockFileEx(self.hfile, 0, 0x7fff0000, overlapped)
133
 
                    self.f.close()
134
 
                    self.f = None
135
 
                except Exception, e:
136
 
                    raise LockError(e)
137
 
 
138
 
 
139
 
 
140
 
        class _w32c_ReadLock(_w32c_FileLock):
141
 
            def __init__(self, filename):
142
 
                _w32c_FileLock._lock(self, filename, 'rb',
143
 
                                     LOCK_NB)
144
 
 
145
 
        class _w32c_WriteLock(_w32c_FileLock):
146
 
            def __init__(self, filename):
147
 
                _w32c_FileLock._lock(self, filename, 'wb',
148
 
                                     LOCK_EX + LOCK_NB)
149
 
 
150
 
 
151
 
 
152
 
        WriteLock = _w32c_WriteLock
153
 
        ReadLock = _w32c_ReadLock
154
 
 
155
 
    except ImportError:
156
 
        try:
157
 
            import msvcrt
158
 
 
159
 
 
160
 
            # Unfortunately, msvcrt.locking() doesn't distinguish between
161
 
            # read locks and write locks. Also, the way the combinations
162
 
            # work to get non-blocking is not the same, so we
163
 
            # have to write extra special functions here.
164
 
 
165
 
 
166
 
            class _msvc_FileLock(_base_Lock):
167
 
                LOCK_SH = 1
168
 
                LOCK_EX = 2
169
 
                LOCK_NB = 4
170
 
                def unlock(self):
171
 
                    _msvc_unlock(self.f)
172
 
                    self.f.close()
173
 
                    self.f = None
174
 
 
175
 
 
176
 
            class _msvc_ReadLock(_msvc_FileLock):
177
 
                def __init__(self, filename):
178
 
                    _msvc_lock(self._open(filename, 'rb'), self.LOCK_SH)
179
 
 
180
 
 
181
 
            class _msvc_WriteLock(_msvc_FileLock):
182
 
                def __init__(self, filename):
183
 
                    _msvc_lock(self._open(filename, 'wb'), self.LOCK_EX)
184
 
 
185
 
 
186
 
 
187
 
            def _msvc_lock(f, flags):
188
 
                try:
189
 
                    # Unfortunately, msvcrt.LK_RLCK is equivalent to msvcrt.LK_LOCK
190
 
                    # according to the comments, LK_RLCK is open the lock for writing.
191
 
 
192
 
                    # Unfortunately, msvcrt.locking() also has the side effect that it
193
 
                    # will only block for 10 seconds at most, and then it will throw an
194
 
                    # exception, this isn't terrible, though.
195
 
                    if type(f) == file:
196
 
                        fpos = f.tell()
197
 
                        fn = f.fileno()
198
 
                        f.seek(0)
199
 
                    else:
200
 
                        fn = f
201
 
                        fpos = os.lseek(fn, 0,0)
202
 
                        os.lseek(fn, 0,0)
203
 
 
204
 
                    if flags & _msvc_FileLock.LOCK_SH:
205
 
                        if flags & _msvc_FileLock.LOCK_NB:
206
 
                            lock_mode = msvcrt.LK_NBLCK
207
 
                        else:
208
 
                            lock_mode = msvcrt.LK_LOCK
209
 
                    elif flags & _msvc_FileLock.LOCK_EX:
210
 
                        if flags & _msvc_FileLock.LOCK_NB:
211
 
                            lock_mode = msvcrt.LK_NBRLCK
212
 
                        else:
213
 
                            lock_mode = msvcrt.LK_RLCK
214
 
                    else:
215
 
                        raise ValueError('Invalid lock mode: %r' % flags)
216
 
                    try:
217
 
                        msvcrt.locking(fn, lock_mode, -1)
218
 
                    finally:
219
 
                        os.lseek(fn, fpos, 0)
220
 
                except Exception, e:
221
 
                    raise LockError(e)
222
 
 
223
 
            def _msvc_unlock(f):
224
 
                try:
225
 
                    if type(f) == file:
226
 
                        fpos = f.tell()
227
 
                        fn = f.fileno()
228
 
                        f.seek(0)
229
 
                    else:
230
 
                        fn = f
231
 
                        fpos = os.lseek(fn, 0,0)
232
 
                        os.lseek(fn, 0,0)
233
 
 
234
 
                    try:
235
 
                        msvcrt.locking(fn, msvcrt.LK_UNLCK, -1)
236
 
                    finally:
237
 
                        os.lseek(fn, fpos, 0)
238
 
                except Exception, e:
239
 
                    raise LockError(e)
240
 
 
241
 
 
242
 
 
243
 
            WriteLock = _msvc_WriteLock
244
 
            ReadLock = _msvc_ReadLock
245
 
        except ImportError:
246
 
            raise NotImplementedError("please write a locking method "
247
 
                                      "for platform %r" % sys.platform)
248
 
 
249
 
 
250
 
 
251
 
 
252
 
 
253
 
 
 
154
 
 
155
        _open_locks = {}
 
156
 
 
157
        def __init__(self, filename):
 
158
            super(_fcntl_ReadLock, self).__init__()
 
159
            self.filename = osutils.realpath(filename)
 
160
            _fcntl_ReadLock._open_locks.setdefault(self.filename, 0)
 
161
            _fcntl_ReadLock._open_locks[self.filename] += 1
 
162
            self._open(filename, 'rb')
 
163
            try:
 
164
                # LOCK_NB will cause IOError to be raised if we can't grab a
 
165
                # lock right away.
 
166
                fcntl.lockf(self.f, fcntl.LOCK_SH | fcntl.LOCK_NB)
 
167
            except IOError, e:
 
168
                # we should be more precise about whats a locking
 
169
                # error and whats a random-other error
 
170
                raise errors.LockContention(e)
 
171
 
 
172
        def unlock(self):
 
173
            count = _fcntl_ReadLock._open_locks[self.filename]
 
174
            if count == 1:
 
175
                del _fcntl_ReadLock._open_locks[self.filename]
 
176
            else:
 
177
                _fcntl_ReadLock._open_locks[self.filename] = count - 1
 
178
            self._unlock()
 
179
 
 
180
        def temporary_write_lock(self):
 
181
            """Try to grab a write lock on the file.
 
182
 
 
183
            On platforms that support it, this will upgrade to a write lock
 
184
            without unlocking the file.
 
185
            Otherwise, this will release the read lock, and try to acquire a
 
186
            write lock.
 
187
 
 
188
            :return: A token which can be used to switch back to a read lock.
 
189
            """
 
190
            assert self.filename not in _fcntl_WriteLock._open_locks
 
191
            try:
 
192
                wlock = _fcntl_TemporaryWriteLock(self)
 
193
            except errors.LockError:
 
194
                # We didn't unlock, so we can just return 'self'
 
195
                return False, self
 
196
            return True, wlock
 
197
 
 
198
 
 
199
    class _fcntl_TemporaryWriteLock(_OSLock):
 
200
        """A token used when grabbing a temporary_write_lock.
 
201
 
 
202
        Call restore_read_lock() when you are done with the write lock.
 
203
        """
 
204
 
 
205
        def __init__(self, read_lock):
 
206
            super(_fcntl_TemporaryWriteLock, self).__init__()
 
207
            self._read_lock = read_lock
 
208
            self.filename = read_lock.filename
 
209
 
 
210
            count = _fcntl_ReadLock._open_locks[self.filename]
 
211
            if count > 1:
 
212
                # Something else also has a read-lock, so we cannot grab a
 
213
                # write lock.
 
214
                raise errors.LockContention(self.filename)
 
215
 
 
216
            assert self.filename not in _fcntl_WriteLock._open_locks
 
217
 
 
218
            # See if we can open the file for writing. Another process might
 
219
            # have a read lock. We don't use self._open() because we don't want
 
220
            # to create the file if it exists. That would have already been
 
221
            # done by _fcntl_ReadLock
 
222
            try:
 
223
                new_f = open(self.filename, 'rb+')
 
224
            except IOError, e:
 
225
                if e.errno in (errno.EACCES, errno.EPERM):
 
226
                    raise errors.LockFailed(self.filename, str(e))
 
227
                raise
 
228
            try:
 
229
                # LOCK_NB will cause IOError to be raised if we can't grab a
 
230
                # lock right away.
 
231
                fcntl.lockf(new_f, fcntl.LOCK_EX | fcntl.LOCK_NB)
 
232
            except IOError, e:
 
233
                # TODO: Raise a more specific error based on the type of error
 
234
                raise errors.LockContention(e)
 
235
            _fcntl_WriteLock._open_locks.add(self.filename)
 
236
 
 
237
            self.f = new_f
 
238
 
 
239
        def restore_read_lock(self):
 
240
            """Restore the original ReadLock."""
 
241
            # For fcntl, since we never released the read lock, just release the
 
242
            # write lock, and return the original lock.
 
243
            fcntl.lockf(self.f, fcntl.LOCK_UN)
 
244
            self._clear_f()
 
245
            _fcntl_WriteLock._open_locks.remove(self.filename)
 
246
            # Avoid reference cycles
 
247
            read_lock = self._read_lock
 
248
            self._read_lock = None
 
249
            return read_lock
 
250
 
 
251
 
 
252
    _lock_classes.append(('fcntl', _fcntl_WriteLock, _fcntl_ReadLock))
 
253
 
 
254
 
 
255
if have_pywin32 and sys.platform == 'win32':
 
256
    LOCK_SH = 0 # the default
 
257
    LOCK_EX = win32con.LOCKFILE_EXCLUSIVE_LOCK
 
258
    LOCK_NB = win32con.LOCKFILE_FAIL_IMMEDIATELY
 
259
 
 
260
 
 
261
    class _w32c_FileLock(_OSLock):
 
262
 
 
263
        def _lock(self, filename, openmode, lockmode):
 
264
            self._open(filename, openmode)
 
265
 
 
266
            self.hfile = msvcrt.get_osfhandle(self.f.fileno())
 
267
            overlapped = pywintypes.OVERLAPPED()
 
268
            try:
 
269
                win32file.LockFileEx(self.hfile, lockmode, 0, 0x7fff0000,
 
270
                                     overlapped)
 
271
            except pywintypes.error, e:
 
272
                self._clear_f()
 
273
                if e.args[0] in (winerror.ERROR_LOCK_VIOLATION,):
 
274
                    raise errors.LockContention(filename)
 
275
                ## import pdb; pdb.set_trace()
 
276
                raise
 
277
            except Exception, e:
 
278
                self._clear_f()
 
279
                raise errors.LockContention(e)
 
280
 
 
281
        def unlock(self):
 
282
            overlapped = pywintypes.OVERLAPPED()
 
283
            try:
 
284
                win32file.UnlockFileEx(self.hfile, 0, 0x7fff0000, overlapped)
 
285
                self._clear_f()
 
286
            except Exception, e:
 
287
                raise errors.LockContention(e)
 
288
 
 
289
 
 
290
    class _w32c_ReadLock(_w32c_FileLock):
 
291
        def __init__(self, filename):
 
292
            super(_w32c_ReadLock, self).__init__()
 
293
            self._lock(filename, 'rb', LOCK_SH + LOCK_NB)
 
294
 
 
295
        def temporary_write_lock(self):
 
296
            """Try to grab a write lock on the file.
 
297
 
 
298
            On platforms that support it, this will upgrade to a write lock
 
299
            without unlocking the file.
 
300
            Otherwise, this will release the read lock, and try to acquire a
 
301
            write lock.
 
302
 
 
303
            :return: A token which can be used to switch back to a read lock.
 
304
            """
 
305
            # I can't find a way to upgrade a read lock to a write lock without
 
306
            # unlocking first. So here, we do just that.
 
307
            self.unlock()
 
308
            try:
 
309
                wlock = _w32c_WriteLock(self.filename)
 
310
            except errors.LockError:
 
311
                return False, _w32c_ReadLock(self.filename)
 
312
            return True, wlock
 
313
 
 
314
 
 
315
    class _w32c_WriteLock(_w32c_FileLock):
 
316
        def __init__(self, filename):
 
317
            super(_w32c_WriteLock, self).__init__()
 
318
            self._lock(filename, 'rb+', LOCK_EX + LOCK_NB)
 
319
 
 
320
        def restore_read_lock(self):
 
321
            """Restore the original ReadLock."""
 
322
            # For win32 we had to completely let go of the original lock, so we
 
323
            # just unlock and create a new read lock.
 
324
            self.unlock()
 
325
            return _w32c_ReadLock(self.filename)
 
326
 
 
327
 
 
328
    _lock_classes.append(('pywin32', _w32c_WriteLock, _w32c_ReadLock))
 
329
 
 
330
 
 
331
if have_ctypes and sys.platform == 'win32':
 
332
    # These constants were copied from the win32con.py module.
 
333
    LOCKFILE_FAIL_IMMEDIATELY = 1
 
334
    LOCKFILE_EXCLUSIVE_LOCK = 2
 
335
    # Constant taken from winerror.py module
 
336
    ERROR_LOCK_VIOLATION = 33
 
337
 
 
338
    LOCK_SH = 0
 
339
    LOCK_EX = LOCKFILE_EXCLUSIVE_LOCK
 
340
    LOCK_NB = LOCKFILE_FAIL_IMMEDIATELY
 
341
    _LockFileEx = ctypes.windll.kernel32.LockFileEx
 
342
    _UnlockFileEx = ctypes.windll.kernel32.UnlockFileEx
 
343
    _GetLastError = ctypes.windll.kernel32.GetLastError
 
344
 
 
345
    ### Define the OVERLAPPED structure.
 
346
    #   http://msdn2.microsoft.com/en-us/library/ms684342.aspx
 
347
    # typedef struct _OVERLAPPED {
 
348
    #   ULONG_PTR Internal;
 
349
    #   ULONG_PTR InternalHigh;
 
350
    #   union {
 
351
    #     struct {
 
352
    #       DWORD Offset;
 
353
    #       DWORD OffsetHigh;
 
354
    #     };
 
355
    #     PVOID Pointer;
 
356
    #   };
 
357
    #   HANDLE hEvent;
 
358
    # } OVERLAPPED,
 
359
 
 
360
    class _inner_struct(ctypes.Structure):
 
361
        _fields_ = [('Offset', ctypes.c_uint), # DWORD
 
362
                    ('OffsetHigh', ctypes.c_uint), # DWORD
 
363
                   ]
 
364
 
 
365
    class _inner_union(ctypes.Union):
 
366
        _fields_  = [('anon_struct', _inner_struct), # struct
 
367
                     ('Pointer', ctypes.c_void_p), # PVOID
 
368
                    ]
 
369
 
 
370
    class OVERLAPPED(ctypes.Structure):
 
371
        _fields_ = [('Internal', ctypes.c_void_p), # ULONG_PTR
 
372
                    ('InternalHigh', ctypes.c_void_p), # ULONG_PTR
 
373
                    ('_inner_union', _inner_union),
 
374
                    ('hEvent', ctypes.c_void_p), # HANDLE
 
375
                   ]
 
376
 
 
377
    class _ctypes_FileLock(_OSLock):
 
378
 
 
379
        def _lock(self, filename, openmode, lockmode):
 
380
            self._open(filename, openmode)
 
381
 
 
382
            self.hfile = msvcrt.get_osfhandle(self.f.fileno())
 
383
            overlapped = OVERLAPPED()
 
384
            result = _LockFileEx(self.hfile, # HANDLE hFile
 
385
                                 lockmode,   # DWORD dwFlags
 
386
                                 0,          # DWORD dwReserved
 
387
                                 0x7fffffff, # DWORD nNumberOfBytesToLockLow
 
388
                                 0x00000000, # DWORD nNumberOfBytesToLockHigh
 
389
                                 ctypes.byref(overlapped), # lpOverlapped
 
390
                                )
 
391
            if result == 0:
 
392
                self._clear_f()
 
393
                last_err = _GetLastError()
 
394
                if last_err in (ERROR_LOCK_VIOLATION,):
 
395
                    raise errors.LockContention(filename)
 
396
                raise errors.LockContention('Unknown locking error: %s'
 
397
                                            % (last_err,))
 
398
 
 
399
        def unlock(self):
 
400
            overlapped = OVERLAPPED()
 
401
            result = _UnlockFileEx(self.hfile, # HANDLE hFile
 
402
                                   0,          # DWORD dwReserved
 
403
                                   0x7fffffff, # DWORD nNumberOfBytesToLockLow
 
404
                                   0x00000000, # DWORD nNumberOfBytesToLockHigh
 
405
                                   ctypes.byref(overlapped), # lpOverlapped
 
406
                                  )
 
407
            self._clear_f()
 
408
            if result == 0:
 
409
                self._clear_f()
 
410
                last_err = _GetLastError()
 
411
                raise errors.LockContention('Unknown unlocking error: %s'
 
412
                                            % (last_err,))
 
413
 
 
414
 
 
415
    class _ctypes_ReadLock(_ctypes_FileLock):
 
416
        def __init__(self, filename):
 
417
            super(_ctypes_ReadLock, self).__init__()
 
418
            self._lock(filename, 'rb', LOCK_SH + LOCK_NB)
 
419
 
 
420
        def temporary_write_lock(self):
 
421
            """Try to grab a write lock on the file.
 
422
 
 
423
            On platforms that support it, this will upgrade to a write lock
 
424
            without unlocking the file.
 
425
            Otherwise, this will release the read lock, and try to acquire a
 
426
            write lock.
 
427
 
 
428
            :return: A token which can be used to switch back to a read lock.
 
429
            """
 
430
            # I can't find a way to upgrade a read lock to a write lock without
 
431
            # unlocking first. So here, we do just that.
 
432
            self.unlock()
 
433
            try:
 
434
                wlock = _ctypes_WriteLock(self.filename)
 
435
            except errors.LockError:
 
436
                return False, _ctypes_ReadLock(self.filename)
 
437
            return True, wlock
 
438
 
 
439
    class _ctypes_WriteLock(_ctypes_FileLock):
 
440
        def __init__(self, filename):
 
441
            super(_ctypes_WriteLock, self).__init__()
 
442
            self._lock(filename, 'rb+', LOCK_EX + LOCK_NB)
 
443
 
 
444
        def restore_read_lock(self):
 
445
            """Restore the original ReadLock."""
 
446
            # For win32 we had to completely let go of the original lock, so we
 
447
            # just unlock and create a new read lock.
 
448
            self.unlock()
 
449
            return _ctypes_ReadLock(self.filename)
 
450
 
 
451
 
 
452
    _lock_classes.append(('ctypes', _ctypes_WriteLock, _ctypes_ReadLock))
 
453
 
 
454
 
 
455
if len(_lock_classes) == 0:
 
456
    raise NotImplementedError(
 
457
        "We must have one of fcntl, pywin32, or ctypes available"
 
458
        " to support OS locking."
 
459
        )
 
460
 
 
461
 
 
462
# We default to using the first available lock class.
 
463
_lock_type, WriteLock, ReadLock = _lock_classes[0]
254
464