~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/lock.py

  • Committer: Canonical.com Patch Queue Manager
  • Date: 2009-06-30 17:12:32 UTC
  • mfrom: (4398.3.2 register-serializer9)
  • Revision ID: pqm@pqm.ubuntu.com-20090630171232-h997nd3w5w89v60t
(Jelmer) Pass create_prefix paremeter to BzrDir.push_branch.

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, 2008, 2009 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
 
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
16
 
 
17
 
 
18
 
"""Locking wrappers.
19
 
 
20
 
This only does local locking using OS locks for now.
 
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 
16
 
 
17
 
 
18
"""Locking using OS file locks or file existence.
 
19
 
 
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
import os
38
39
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):
 
40
 
 
41
from bzrlib import (
 
42
    errors,
 
43
    osutils,
 
44
    trace,
 
45
    )
 
46
from bzrlib.hooks import HookPoint, Hooks
 
47
 
 
48
 
 
49
class LockHooks(Hooks):
 
50
 
 
51
    def __init__(self):
 
52
        Hooks.__init__(self)
 
53
        self.create_hook(HookPoint('lock_acquired',
 
54
            "Called with a bzrlib.lock.LockResult when a physical lock is "
 
55
            "acquired.", (1, 8), None))
 
56
        self.create_hook(HookPoint('lock_released',
 
57
            "Called with a bzrlib.lock.LockResult when a physical lock is "
 
58
            "released.", (1, 8), None))
 
59
        self.create_hook(HookPoint('lock_broken',
 
60
            "Called with a bzrlib.lock.LockResult when a physical lock is "
 
61
            "broken.", (1, 15), None))
 
62
 
 
63
 
 
64
class Lock(object):
 
65
    """Base class for locks.
 
66
 
 
67
    :cvar hooks: Hook dictionary for operations on locks.
 
68
    """
 
69
 
 
70
    hooks = LockHooks()
 
71
 
 
72
 
 
73
class LockResult(object):
 
74
    """Result of an operation on a lock; passed to a hook"""
 
75
 
 
76
    def __init__(self, lock_url, details=None):
 
77
        """Create a lock result for lock with optional details about the lock."""
 
78
        self.lock_url = lock_url
 
79
        self.details = details
 
80
 
 
81
    def __eq__(self, other):
 
82
        return self.lock_url == other.lock_url and self.details == other.details
 
83
 
 
84
    def __repr__(self):
 
85
        return '%s(%s%s)' % (self.__class__.__name__,
 
86
                             self.lock_url, self.details)
 
87
 
 
88
 
 
89
try:
 
90
    import fcntl
 
91
    have_fcntl = True
 
92
except ImportError:
 
93
    have_fcntl = False
 
94
 
 
95
have_pywin32 = False
 
96
have_ctypes_win32 = False
 
97
if sys.platform == 'win32':
 
98
    import msvcrt
 
99
    try:
 
100
        import win32file, pywintypes, winerror
 
101
        have_pywin32 = True
 
102
    except ImportError:
 
103
        pass
 
104
 
 
105
    try:
 
106
        import ctypes
 
107
        have_ctypes_win32 = True
 
108
    except ImportError:
 
109
        pass
 
110
 
 
111
 
 
112
class _OSLock(object):
 
113
 
 
114
    def __init__(self):
 
115
        self.f = None
 
116
        self.filename = None
 
117
 
45
118
    def _open(self, filename, filemode):
46
 
        import errno
 
119
        self.filename = osutils.realpath(filename)
47
120
        try:
48
 
            self.f = open(filename, filemode)
 
121
            self.f = open(self.filename, filemode)
49
122
            return self.f
50
123
        except IOError, e:
 
124
            if e.errno in (errno.EACCES, errno.EPERM):
 
125
                raise errors.LockFailed(self.filename, str(e))
51
126
            if e.errno != errno.ENOENT:
52
127
                raise
53
128
 
54
129
            # 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')
 
130
            trace.mutter("trying to create missing lock %r", self.filename)
 
131
 
 
132
            self.f = open(self.filename, 'wb+')
58
133
            return self.f
59
134
 
 
135
    def _clear_f(self):
 
136
        """Clear the self.f attribute cleanly."""
 
137
        if self.f:
 
138
            self.f.close()
 
139
            self.f = None
60
140
 
61
141
    def __del__(self):
62
142
        if self.f:
63
143
            from warnings import warn
64
144
            warn("lock on %r not released" % self.f)
65
145
            self.unlock()
66
 
            
67
146
 
68
147
    def unlock(self):
69
148
        raise NotImplementedError()
70
149
 
71
 
        
72
 
 
73
 
 
74
 
 
75
 
 
76
 
############################################################
77
 
# msvcrt locks
78
 
 
79
 
 
80
 
try:
81
 
    import fcntl
82
 
 
83
 
    class _fcntl_FileLock(_base_Lock):
84
 
        f = None
85
 
 
86
 
        def unlock(self):
87
 
            fcntl.flock(self.f, fcntl.LOCK_UN)
88
 
            self.f.close()
89
 
            del self.f 
 
150
 
 
151
_lock_classes = []
 
152
 
 
153
 
 
154
if have_fcntl:
 
155
 
 
156
    class _fcntl_FileLock(_OSLock):
 
157
 
 
158
        def _unlock(self):
 
159
            fcntl.lockf(self.f, fcntl.LOCK_UN)
 
160
            self._clear_f()
90
161
 
91
162
 
92
163
    class _fcntl_WriteLock(_fcntl_FileLock):
 
164
 
 
165
        _open_locks = set()
 
166
 
93
167
        def __init__(self, filename):
 
168
            super(_fcntl_WriteLock, self).__init__()
 
169
            # Check we can grab a lock before we actually open the file.
 
170
            self.filename = osutils.realpath(filename)
 
171
            if self.filename in _fcntl_WriteLock._open_locks:
 
172
                self._clear_f()
 
173
                raise errors.LockContention(self.filename)
 
174
 
 
175
            self._open(self.filename, 'rb+')
 
176
            # reserve a slot for this lock - even if the lockf call fails,
 
177
            # at thisi point unlock() will be called, because self.f is set.
 
178
            # TODO: make this fully threadsafe, if we decide we care.
 
179
            _fcntl_WriteLock._open_locks.add(self.filename)
94
180
            try:
95
 
                fcntl.flock(self._open(filename, 'wb'), fcntl.LOCK_EX)
96
 
            except Exception, e:
97
 
                raise LockError(e)
 
181
                # LOCK_NB will cause IOError to be raised if we can't grab a
 
182
                # lock right away.
 
183
                fcntl.lockf(self.f, fcntl.LOCK_EX | fcntl.LOCK_NB)
 
184
            except IOError, e:
 
185
                if e.errno in (errno.EAGAIN, errno.EACCES):
 
186
                    # We couldn't grab the lock
 
187
                    self.unlock()
 
188
                # we should be more precise about whats a locking
 
189
                # error and whats a random-other error
 
190
                raise errors.LockContention(self.filename, e)
 
191
 
 
192
        def unlock(self):
 
193
            _fcntl_WriteLock._open_locks.remove(self.filename)
 
194
            self._unlock()
98
195
 
99
196
 
100
197
    class _fcntl_ReadLock(_fcntl_FileLock):
101
 
        def __init__(self, filename):
102
 
            try:
103
 
                fcntl.flock(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', 0)
143
 
 
144
 
        class _w32c_WriteLock(_w32c_FileLock):
145
 
            def __init__(self, filename):
146
 
                _w32c_FileLock._lock(self, filename, 'wb',
147
 
                                     win32con.LOCKFILE_EXCLUSIVE_LOCK)
148
 
 
149
 
 
150
 
 
151
 
        WriteLock = _w32c_WriteLock
152
 
        ReadLock = _w32c_ReadLock
153
 
 
154
 
    except ImportError:
155
 
        try:
156
 
            import msvcrt
157
 
 
158
 
 
159
 
            # Unfortunately, msvcrt.locking() doesn't distinguish between
160
 
            # read locks and write locks. Also, the way the combinations
161
 
            # work to get non-blocking is not the same, so we
162
 
            # have to write extra special functions here.
163
 
 
164
 
 
165
 
            class _msvc_FileLock(_base_Lock):
166
 
                LOCK_SH = 1
167
 
                LOCK_EX = 2
168
 
                LOCK_NB = 4
169
 
                def unlock(self):
170
 
                    _msvc_unlock(self.f)
171
 
 
172
 
 
173
 
            class _msvc_ReadLock(_msvc_FileLock):
174
 
                def __init__(self, filename):
175
 
                    _msvc_lock(self._open(filename, 'rb'), self.LOCK_SH)
176
 
 
177
 
 
178
 
            class _msvc_WriteLock(_msvc_FileLock):
179
 
                def __init__(self, filename):
180
 
                    _msvc_lock(self._open(filename, 'wb'), self.LOCK_EX)
181
 
 
182
 
 
183
 
 
184
 
            def _msvc_lock(f, flags):
185
 
                try:
186
 
                    # Unfortunately, msvcrt.LK_RLCK is equivalent to msvcrt.LK_LOCK
187
 
                    # according to the comments, LK_RLCK is open the lock for writing.
188
 
 
189
 
                    # Unfortunately, msvcrt.locking() also has the side effect that it
190
 
                    # will only block for 10 seconds at most, and then it will throw an
191
 
                    # exception, this isn't terrible, though.
192
 
                    if type(f) == file:
193
 
                        fpos = f.tell()
194
 
                        fn = f.fileno()
195
 
                        f.seek(0)
196
 
                    else:
197
 
                        fn = f
198
 
                        fpos = os.lseek(fn, 0,0)
199
 
                        os.lseek(fn, 0,0)
200
 
 
201
 
                    if flags & _msvc_FileLock.LOCK_SH:
202
 
                        if flags & _msvc_FileLock.LOCK_NB:
203
 
                            lock_mode = msvcrt.LK_NBLCK
204
 
                        else:
205
 
                            lock_mode = msvcrt.LK_LOCK
206
 
                    elif flags & _msvc_FileLock.LOCK_EX:
207
 
                        if flags & _msvc_FileLock.LOCK_NB:
208
 
                            lock_mode = msvcrt.LK_NBRLCK
209
 
                        else:
210
 
                            lock_mode = msvcrt.LK_RLCK
211
 
                    else:
212
 
                        raise ValueError('Invalid lock mode: %r' % flags)
213
 
                    try:
214
 
                        msvcrt.locking(fn, lock_mode, -1)
215
 
                    finally:
216
 
                        os.lseek(fn, fpos, 0)
217
 
                except Exception, e:
218
 
                    raise LockError(e)
219
 
 
220
 
            def _msvc_unlock(f):
221
 
                try:
222
 
                    if type(f) == file:
223
 
                        fpos = f.tell()
224
 
                        fn = f.fileno()
225
 
                        f.seek(0)
226
 
                    else:
227
 
                        fn = f
228
 
                        fpos = os.lseek(fn, 0,0)
229
 
                        os.lseek(fn, 0,0)
230
 
 
231
 
                    try:
232
 
                        msvcrt.locking(fn, msvcrt.LK_UNLCK, -1)
233
 
                    finally:
234
 
                        os.lseek(fn, fpos, 0)
235
 
                except Exception, e:
236
 
                    raise LockError(e)
237
 
 
238
 
 
239
 
 
240
 
            WriteLock = _msvc_WriteLock
241
 
            ReadLock = _msvc_ReadLock
242
 
        except ImportError:
243
 
            raise NotImplementedError("please write a locking method "
244
 
                                      "for platform %r" % sys.platform)
245
 
 
246
 
 
247
 
 
248
 
 
249
 
 
250
 
 
 
198
 
 
199
        _open_locks = {}
 
200
 
 
201
        def __init__(self, filename):
 
202
            super(_fcntl_ReadLock, self).__init__()
 
203
            self.filename = osutils.realpath(filename)
 
204
            _fcntl_ReadLock._open_locks.setdefault(self.filename, 0)
 
205
            _fcntl_ReadLock._open_locks[self.filename] += 1
 
206
            self._open(filename, 'rb')
 
207
            try:
 
208
                # LOCK_NB will cause IOError to be raised if we can't grab a
 
209
                # lock right away.
 
210
                fcntl.lockf(self.f, fcntl.LOCK_SH | fcntl.LOCK_NB)
 
211
            except IOError, e:
 
212
                # we should be more precise about whats a locking
 
213
                # error and whats a random-other error
 
214
                raise errors.LockContention(self.filename, e)
 
215
 
 
216
        def unlock(self):
 
217
            count = _fcntl_ReadLock._open_locks[self.filename]
 
218
            if count == 1:
 
219
                del _fcntl_ReadLock._open_locks[self.filename]
 
220
            else:
 
221
                _fcntl_ReadLock._open_locks[self.filename] = count - 1
 
222
            self._unlock()
 
223
 
 
224
        def temporary_write_lock(self):
 
225
            """Try to grab a write lock on the file.
 
226
 
 
227
            On platforms that support it, this will upgrade to a write lock
 
228
            without unlocking the file.
 
229
            Otherwise, this will release the read lock, and try to acquire a
 
230
            write lock.
 
231
 
 
232
            :return: A token which can be used to switch back to a read lock.
 
233
            """
 
234
            if self.filename in _fcntl_WriteLock._open_locks:
 
235
                raise AssertionError('file already locked: %r'
 
236
                    % (self.filename,))
 
237
            try:
 
238
                wlock = _fcntl_TemporaryWriteLock(self)
 
239
            except errors.LockError:
 
240
                # We didn't unlock, so we can just return 'self'
 
241
                return False, self
 
242
            return True, wlock
 
243
 
 
244
 
 
245
    class _fcntl_TemporaryWriteLock(_OSLock):
 
246
        """A token used when grabbing a temporary_write_lock.
 
247
 
 
248
        Call restore_read_lock() when you are done with the write lock.
 
249
        """
 
250
 
 
251
        def __init__(self, read_lock):
 
252
            super(_fcntl_TemporaryWriteLock, self).__init__()
 
253
            self._read_lock = read_lock
 
254
            self.filename = read_lock.filename
 
255
 
 
256
            count = _fcntl_ReadLock._open_locks[self.filename]
 
257
            if count > 1:
 
258
                # Something else also has a read-lock, so we cannot grab a
 
259
                # write lock.
 
260
                raise errors.LockContention(self.filename)
 
261
 
 
262
            if self.filename in _fcntl_WriteLock._open_locks:
 
263
                raise AssertionError('file already locked: %r'
 
264
                    % (self.filename,))
 
265
 
 
266
            # See if we can open the file for writing. Another process might
 
267
            # have a read lock. We don't use self._open() because we don't want
 
268
            # to create the file if it exists. That would have already been
 
269
            # done by _fcntl_ReadLock
 
270
            try:
 
271
                new_f = open(self.filename, 'rb+')
 
272
            except IOError, e:
 
273
                if e.errno in (errno.EACCES, errno.EPERM):
 
274
                    raise errors.LockFailed(self.filename, str(e))
 
275
                raise
 
276
            try:
 
277
                # LOCK_NB will cause IOError to be raised if we can't grab a
 
278
                # lock right away.
 
279
                fcntl.lockf(new_f, fcntl.LOCK_EX | fcntl.LOCK_NB)
 
280
            except IOError, e:
 
281
                # TODO: Raise a more specific error based on the type of error
 
282
                raise errors.LockContention(self.filename, e)
 
283
            _fcntl_WriteLock._open_locks.add(self.filename)
 
284
 
 
285
            self.f = new_f
 
286
 
 
287
        def restore_read_lock(self):
 
288
            """Restore the original ReadLock."""
 
289
            # For fcntl, since we never released the read lock, just release the
 
290
            # write lock, and return the original lock.
 
291
            fcntl.lockf(self.f, fcntl.LOCK_UN)
 
292
            self._clear_f()
 
293
            _fcntl_WriteLock._open_locks.remove(self.filename)
 
294
            # Avoid reference cycles
 
295
            read_lock = self._read_lock
 
296
            self._read_lock = None
 
297
            return read_lock
 
298
 
 
299
 
 
300
    _lock_classes.append(('fcntl', _fcntl_WriteLock, _fcntl_ReadLock))
 
301
 
 
302
 
 
303
if have_pywin32 and sys.platform == 'win32':
 
304
 
 
305
    class _w32c_FileLock(_OSLock):
 
306
 
 
307
        def _open(self, filename, access, share, cflags, pymode):
 
308
            self.filename = osutils.realpath(filename)
 
309
            try:
 
310
                self._handle = win32file.CreateFile(filename, access, share,
 
311
                    None, win32file.OPEN_ALWAYS,
 
312
                    win32file.FILE_ATTRIBUTE_NORMAL, None)
 
313
            except pywintypes.error, e:
 
314
                if e.args[0] == winerror.ERROR_ACCESS_DENIED:
 
315
                    raise errors.LockFailed(filename, e)
 
316
                if e.args[0] == winerror.ERROR_SHARING_VIOLATION:
 
317
                    raise errors.LockContention(filename, e)
 
318
                raise
 
319
            fd = win32file._open_osfhandle(self._handle, cflags)
 
320
            self.f = os.fdopen(fd, pymode)
 
321
            return self.f
 
322
 
 
323
        def unlock(self):
 
324
            self._clear_f()
 
325
            self._handle = None
 
326
 
 
327
 
 
328
    class _w32c_ReadLock(_w32c_FileLock):
 
329
        def __init__(self, filename):
 
330
            super(_w32c_ReadLock, self).__init__()
 
331
            self._open(filename, win32file.GENERIC_READ,
 
332
                win32file.FILE_SHARE_READ, os.O_RDONLY, "rb")
 
333
 
 
334
        def temporary_write_lock(self):
 
335
            """Try to grab a write lock on the file.
 
336
 
 
337
            On platforms that support it, this will upgrade to a write lock
 
338
            without unlocking the file.
 
339
            Otherwise, this will release the read lock, and try to acquire a
 
340
            write lock.
 
341
 
 
342
            :return: A token which can be used to switch back to a read lock.
 
343
            """
 
344
            # I can't find a way to upgrade a read lock to a write lock without
 
345
            # unlocking first. So here, we do just that.
 
346
            self.unlock()
 
347
            try:
 
348
                wlock = _w32c_WriteLock(self.filename)
 
349
            except errors.LockError:
 
350
                return False, _w32c_ReadLock(self.filename)
 
351
            return True, wlock
 
352
 
 
353
 
 
354
    class _w32c_WriteLock(_w32c_FileLock):
 
355
        def __init__(self, filename):
 
356
            super(_w32c_WriteLock, self).__init__()
 
357
            self._open(filename,
 
358
                win32file.GENERIC_READ | win32file.GENERIC_WRITE, 0,
 
359
                os.O_RDWR, "rb+")
 
360
 
 
361
        def restore_read_lock(self):
 
362
            """Restore the original ReadLock."""
 
363
            # For win32 we had to completely let go of the original lock, so we
 
364
            # just unlock and create a new read lock.
 
365
            self.unlock()
 
366
            return _w32c_ReadLock(self.filename)
 
367
 
 
368
 
 
369
    _lock_classes.append(('pywin32', _w32c_WriteLock, _w32c_ReadLock))
 
370
 
 
371
 
 
372
if have_ctypes_win32:
 
373
    from ctypes.wintypes import DWORD, LPCSTR, LPCWSTR
 
374
    LPSECURITY_ATTRIBUTES = ctypes.c_void_p # used as NULL no need to declare
 
375
    HANDLE = ctypes.c_int # rather than unsigned as in ctypes.wintypes
 
376
    if os.path.supports_unicode_filenames:
 
377
        _function_name = "CreateFileW"
 
378
        LPTSTR = LPCWSTR
 
379
    else:
 
380
        _function_name = "CreateFileA"
 
381
        class LPTSTR(LPCSTR):
 
382
            def __new__(cls, obj):
 
383
                return LPCSTR.__new__(cls, obj.encode("mbcs"))
 
384
 
 
385
    # CreateFile <http://msdn.microsoft.com/en-us/library/aa363858.aspx>
 
386
    _CreateFile = ctypes.WINFUNCTYPE(
 
387
            HANDLE,                # return value
 
388
            LPTSTR,                # lpFileName
 
389
            DWORD,                 # dwDesiredAccess
 
390
            DWORD,                 # dwShareMode
 
391
            LPSECURITY_ATTRIBUTES, # lpSecurityAttributes
 
392
            DWORD,                 # dwCreationDisposition
 
393
            DWORD,                 # dwFlagsAndAttributes
 
394
            HANDLE                 # hTemplateFile
 
395
        )((_function_name, ctypes.windll.kernel32))
 
396
    
 
397
    INVALID_HANDLE_VALUE = -1
 
398
    
 
399
    GENERIC_READ = 0x80000000
 
400
    GENERIC_WRITE = 0x40000000
 
401
    FILE_SHARE_READ = 1
 
402
    OPEN_ALWAYS = 4
 
403
    FILE_ATTRIBUTE_NORMAL = 128
 
404
    
 
405
    ERROR_ACCESS_DENIED = 5
 
406
    ERROR_SHARING_VIOLATION = 32
 
407
 
 
408
    class _ctypes_FileLock(_OSLock):
 
409
 
 
410
        def _open(self, filename, access, share, cflags, pymode):
 
411
            self.filename = osutils.realpath(filename)
 
412
            handle = _CreateFile(filename, access, share, None, OPEN_ALWAYS,
 
413
                FILE_ATTRIBUTE_NORMAL, 0)
 
414
            if handle in (INVALID_HANDLE_VALUE, 0):
 
415
                e = ctypes.WinError()
 
416
                if e.args[0] == ERROR_ACCESS_DENIED:
 
417
                    raise errors.LockFailed(filename, e)
 
418
                if e.args[0] == ERROR_SHARING_VIOLATION:
 
419
                    raise errors.LockContention(filename, e)
 
420
                raise e
 
421
            fd = msvcrt.open_osfhandle(handle, cflags)
 
422
            self.f = os.fdopen(fd, pymode)
 
423
            return self.f
 
424
 
 
425
        def unlock(self):
 
426
            self._clear_f()
 
427
 
 
428
 
 
429
    class _ctypes_ReadLock(_ctypes_FileLock):
 
430
        def __init__(self, filename):
 
431
            super(_ctypes_ReadLock, self).__init__()
 
432
            self._open(filename, GENERIC_READ, FILE_SHARE_READ, os.O_RDONLY,
 
433
                "rb")
 
434
 
 
435
        def temporary_write_lock(self):
 
436
            """Try to grab a write lock on the file.
 
437
 
 
438
            On platforms that support it, this will upgrade to a write lock
 
439
            without unlocking the file.
 
440
            Otherwise, this will release the read lock, and try to acquire a
 
441
            write lock.
 
442
 
 
443
            :return: A token which can be used to switch back to a read lock.
 
444
            """
 
445
            # I can't find a way to upgrade a read lock to a write lock without
 
446
            # unlocking first. So here, we do just that.
 
447
            self.unlock()
 
448
            try:
 
449
                wlock = _ctypes_WriteLock(self.filename)
 
450
            except errors.LockError:
 
451
                return False, _ctypes_ReadLock(self.filename)
 
452
            return True, wlock
 
453
 
 
454
    class _ctypes_WriteLock(_ctypes_FileLock):
 
455
        def __init__(self, filename):
 
456
            super(_ctypes_WriteLock, self).__init__()
 
457
            self._open(filename, GENERIC_READ | GENERIC_WRITE, 0, os.O_RDWR,
 
458
                "rb+")
 
459
 
 
460
        def restore_read_lock(self):
 
461
            """Restore the original ReadLock."""
 
462
            # For win32 we had to completely let go of the original lock, so we
 
463
            # just unlock and create a new read lock.
 
464
            self.unlock()
 
465
            return _ctypes_ReadLock(self.filename)
 
466
 
 
467
 
 
468
    _lock_classes.append(('ctypes', _ctypes_WriteLock, _ctypes_ReadLock))
 
469
 
 
470
 
 
471
if len(_lock_classes) == 0:
 
472
    raise NotImplementedError(
 
473
        "We must have one of fcntl, pywin32, or ctypes available"
 
474
        " to support OS locking."
 
475
        )
 
476
 
 
477
 
 
478
# We default to using the first available lock class.
 
479
_lock_type, WriteLock, ReadLock = _lock_classes[0]
251
480