~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: 2008-06-20 01:09:18 UTC
  • mfrom: (3505.1.1 ianc-integration)
  • Revision ID: pqm@pqm.ubuntu.com-20080620010918-64z4xylh1ap5hgyf
Accept user names with @s in URLs (Neil Martinsen-Burrell)

Show diffs side-by-side

added added

removed removed

Lines of Context:
 
1
# Copyright (C) 2005, 2006, 2007 Canonical Ltd
 
2
#
 
3
# This program is free software; you can redistribute it and/or modify
 
4
# it under the terms of the GNU General Public License as published by
 
5
# the Free Software Foundation; either version 2 of the License, or
 
6
# (at your option) any later version.
 
7
#
 
8
# This program is distributed in the hope that it will be useful,
 
9
# but WITHOUT ANY WARRANTY; without even the implied warranty of
 
10
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
11
# GNU General Public License for more details.
 
12
#
 
13
# You should have received a copy of the GNU General Public License
 
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 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.
 
23
 
 
24
This module causes two methods, lock() and unlock() to be defined in
 
25
any way that works on the current platform.
 
26
 
 
27
It is not specified whether these locks are reentrant (i.e. can be
 
28
taken repeatedly by a single process) or whether they exclude
 
29
different threads in a single process.  That reentrancy is provided by
 
30
LockableFiles.
 
31
 
 
32
This defines two classes: ReadLock and WriteLock, which can be
 
33
implemented in different ways on different platforms.  Both have an
 
34
unlock() method.
 
35
"""
 
36
 
 
37
import errno
 
38
import sys
 
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
 
 
53
    def _open(self, filename, filemode):
 
54
        self.filename = osutils.realpath(filename)
 
55
        try:
 
56
            self.f = open(self.filename, filemode)
 
57
            return self.f
 
58
        except IOError, e:
 
59
            if e.errno in (errno.EACCES, errno.EPERM):
 
60
                raise errors.LockFailed(self.filename, str(e))
 
61
            if e.errno != errno.ENOENT:
 
62
                raise
 
63
 
 
64
            # maybe this is an old branch (before may 2005)
 
65
            trace.mutter("trying to create missing lock %r", self.filename)
 
66
 
 
67
            self.f = open(self.filename, 'wb+')
 
68
            return self.f
 
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
 
75
 
 
76
    def __del__(self):
 
77
        if self.f:
 
78
            from warnings import warn
 
79
            warn("lock on %r not released" % self.f)
 
80
            self.unlock()
 
81
 
 
82
    def unlock(self):
 
83
        raise NotImplementedError()
 
84
 
 
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
 
 
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):
 
115
            fcntl.lockf(self.f, fcntl.LOCK_UN)
 
116
            self._clear_f()
 
117
 
 
118
 
 
119
    class _fcntl_WriteLock(_fcntl_FileLock):
 
120
 
 
121
        _open_locks = set()
 
122
 
 
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)
 
136
            try:
 
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()
 
151
 
 
152
 
 
153
    class _fcntl_ReadLock(_fcntl_FileLock):
 
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
            if self.filename in _fcntl_WriteLock._open_locks:
 
191
                raise AssertionError('file already locked: %r'
 
192
                    % (self.filename,))
 
193
            try:
 
194
                wlock = _fcntl_TemporaryWriteLock(self)
 
195
            except errors.LockError:
 
196
                # We didn't unlock, so we can just return 'self'
 
197
                return False, self
 
198
            return True, wlock
 
199
 
 
200
 
 
201
    class _fcntl_TemporaryWriteLock(_OSLock):
 
202
        """A token used when grabbing a temporary_write_lock.
 
203
 
 
204
        Call restore_read_lock() when you are done with the write lock.
 
205
        """
 
206
 
 
207
        def __init__(self, read_lock):
 
208
            super(_fcntl_TemporaryWriteLock, self).__init__()
 
209
            self._read_lock = read_lock
 
210
            self.filename = read_lock.filename
 
211
 
 
212
            count = _fcntl_ReadLock._open_locks[self.filename]
 
213
            if count > 1:
 
214
                # Something else also has a read-lock, so we cannot grab a
 
215
                # write lock.
 
216
                raise errors.LockContention(self.filename)
 
217
 
 
218
            if self.filename in _fcntl_WriteLock._open_locks:
 
219
                raise AssertionError('file already locked: %r'
 
220
                    % (self.filename,))
 
221
 
 
222
            # See if we can open the file for writing. Another process might
 
223
            # have a read lock. We don't use self._open() because we don't want
 
224
            # to create the file if it exists. That would have already been
 
225
            # done by _fcntl_ReadLock
 
226
            try:
 
227
                new_f = open(self.filename, 'rb+')
 
228
            except IOError, e:
 
229
                if e.errno in (errno.EACCES, errno.EPERM):
 
230
                    raise errors.LockFailed(self.filename, str(e))
 
231
                raise
 
232
            try:
 
233
                # LOCK_NB will cause IOError to be raised if we can't grab a
 
234
                # lock right away.
 
235
                fcntl.lockf(new_f, fcntl.LOCK_EX | fcntl.LOCK_NB)
 
236
            except IOError, e:
 
237
                # TODO: Raise a more specific error based on the type of error
 
238
                raise errors.LockContention(e)
 
239
            _fcntl_WriteLock._open_locks.add(self.filename)
 
240
 
 
241
            self.f = new_f
 
242
 
 
243
        def restore_read_lock(self):
 
244
            """Restore the original ReadLock."""
 
245
            # For fcntl, since we never released the read lock, just release the
 
246
            # write lock, and return the original lock.
 
247
            fcntl.lockf(self.f, fcntl.LOCK_UN)
 
248
            self._clear_f()
 
249
            _fcntl_WriteLock._open_locks.remove(self.filename)
 
250
            # Avoid reference cycles
 
251
            read_lock = self._read_lock
 
252
            self._read_lock = None
 
253
            return read_lock
 
254
 
 
255
 
 
256
    _lock_classes.append(('fcntl', _fcntl_WriteLock, _fcntl_ReadLock))
 
257
 
 
258
 
 
259
if have_pywin32 and sys.platform == 'win32':
 
260
    LOCK_SH = 0 # the default
 
261
    LOCK_EX = win32con.LOCKFILE_EXCLUSIVE_LOCK
 
262
    LOCK_NB = win32con.LOCKFILE_FAIL_IMMEDIATELY
 
263
 
 
264
 
 
265
    class _w32c_FileLock(_OSLock):
 
266
 
 
267
        def _lock(self, filename, openmode, lockmode):
 
268
            self._open(filename, openmode)
 
269
 
 
270
            self.hfile = msvcrt.get_osfhandle(self.f.fileno())
 
271
            overlapped = pywintypes.OVERLAPPED()
 
272
            try:
 
273
                win32file.LockFileEx(self.hfile, lockmode, 0, 0x7fff0000,
 
274
                                     overlapped)
 
275
            except pywintypes.error, e:
 
276
                self._clear_f()
 
277
                if e.args[0] in (winerror.ERROR_LOCK_VIOLATION,):
 
278
                    raise errors.LockContention(filename)
 
279
                ## import pdb; pdb.set_trace()
 
280
                raise
 
281
            except Exception, e:
 
282
                self._clear_f()
 
283
                raise errors.LockContention(e)
 
284
 
 
285
        def unlock(self):
 
286
            overlapped = pywintypes.OVERLAPPED()
 
287
            try:
 
288
                win32file.UnlockFileEx(self.hfile, 0, 0x7fff0000, overlapped)
 
289
                self._clear_f()
 
290
            except Exception, e:
 
291
                raise errors.LockContention(e)
 
292
 
 
293
 
 
294
    class _w32c_ReadLock(_w32c_FileLock):
 
295
        def __init__(self, filename):
 
296
            super(_w32c_ReadLock, self).__init__()
 
297
            self._lock(filename, 'rb', LOCK_SH + LOCK_NB)
 
298
 
 
299
        def temporary_write_lock(self):
 
300
            """Try to grab a write lock on the file.
 
301
 
 
302
            On platforms that support it, this will upgrade to a write lock
 
303
            without unlocking the file.
 
304
            Otherwise, this will release the read lock, and try to acquire a
 
305
            write lock.
 
306
 
 
307
            :return: A token which can be used to switch back to a read lock.
 
308
            """
 
309
            # I can't find a way to upgrade a read lock to a write lock without
 
310
            # unlocking first. So here, we do just that.
 
311
            self.unlock()
 
312
            try:
 
313
                wlock = _w32c_WriteLock(self.filename)
 
314
            except errors.LockError:
 
315
                return False, _w32c_ReadLock(self.filename)
 
316
            return True, wlock
 
317
 
 
318
 
 
319
    class _w32c_WriteLock(_w32c_FileLock):
 
320
        def __init__(self, filename):
 
321
            super(_w32c_WriteLock, self).__init__()
 
322
            self._lock(filename, 'rb+', LOCK_EX + LOCK_NB)
 
323
 
 
324
        def restore_read_lock(self):
 
325
            """Restore the original ReadLock."""
 
326
            # For win32 we had to completely let go of the original lock, so we
 
327
            # just unlock and create a new read lock.
 
328
            self.unlock()
 
329
            return _w32c_ReadLock(self.filename)
 
330
 
 
331
 
 
332
    _lock_classes.append(('pywin32', _w32c_WriteLock, _w32c_ReadLock))
 
333
 
 
334
 
 
335
if have_ctypes and sys.platform == 'win32':
 
336
    # These constants were copied from the win32con.py module.
 
337
    LOCKFILE_FAIL_IMMEDIATELY = 1
 
338
    LOCKFILE_EXCLUSIVE_LOCK = 2
 
339
    # Constant taken from winerror.py module
 
340
    ERROR_LOCK_VIOLATION = 33
 
341
 
 
342
    LOCK_SH = 0
 
343
    LOCK_EX = LOCKFILE_EXCLUSIVE_LOCK
 
344
    LOCK_NB = LOCKFILE_FAIL_IMMEDIATELY
 
345
    _LockFileEx = ctypes.windll.kernel32.LockFileEx
 
346
    _UnlockFileEx = ctypes.windll.kernel32.UnlockFileEx
 
347
    _GetLastError = ctypes.windll.kernel32.GetLastError
 
348
 
 
349
    ### Define the OVERLAPPED structure.
 
350
    #   http://msdn2.microsoft.com/en-us/library/ms684342.aspx
 
351
    # typedef struct _OVERLAPPED {
 
352
    #   ULONG_PTR Internal;
 
353
    #   ULONG_PTR InternalHigh;
 
354
    #   union {
 
355
    #     struct {
 
356
    #       DWORD Offset;
 
357
    #       DWORD OffsetHigh;
 
358
    #     };
 
359
    #     PVOID Pointer;
 
360
    #   };
 
361
    #   HANDLE hEvent;
 
362
    # } OVERLAPPED,
 
363
 
 
364
    class _inner_struct(ctypes.Structure):
 
365
        _fields_ = [('Offset', ctypes.c_uint), # DWORD
 
366
                    ('OffsetHigh', ctypes.c_uint), # DWORD
 
367
                   ]
 
368
 
 
369
    class _inner_union(ctypes.Union):
 
370
        _fields_  = [('anon_struct', _inner_struct), # struct
 
371
                     ('Pointer', ctypes.c_void_p), # PVOID
 
372
                    ]
 
373
 
 
374
    class OVERLAPPED(ctypes.Structure):
 
375
        _fields_ = [('Internal', ctypes.c_void_p), # ULONG_PTR
 
376
                    ('InternalHigh', ctypes.c_void_p), # ULONG_PTR
 
377
                    ('_inner_union', _inner_union),
 
378
                    ('hEvent', ctypes.c_void_p), # HANDLE
 
379
                   ]
 
380
 
 
381
    class _ctypes_FileLock(_OSLock):
 
382
 
 
383
        def _lock(self, filename, openmode, lockmode):
 
384
            self._open(filename, openmode)
 
385
 
 
386
            self.hfile = msvcrt.get_osfhandle(self.f.fileno())
 
387
            overlapped = OVERLAPPED()
 
388
            result = _LockFileEx(self.hfile, # HANDLE hFile
 
389
                                 lockmode,   # DWORD dwFlags
 
390
                                 0,          # DWORD dwReserved
 
391
                                 0x7fffffff, # DWORD nNumberOfBytesToLockLow
 
392
                                 0x00000000, # DWORD nNumberOfBytesToLockHigh
 
393
                                 ctypes.byref(overlapped), # lpOverlapped
 
394
                                )
 
395
            if result == 0:
 
396
                self._clear_f()
 
397
                last_err = _GetLastError()
 
398
                if last_err in (ERROR_LOCK_VIOLATION,):
 
399
                    raise errors.LockContention(filename)
 
400
                raise errors.LockContention('Unknown locking error: %s'
 
401
                                            % (last_err,))
 
402
 
 
403
        def unlock(self):
 
404
            overlapped = OVERLAPPED()
 
405
            result = _UnlockFileEx(self.hfile, # HANDLE hFile
 
406
                                   0,          # DWORD dwReserved
 
407
                                   0x7fffffff, # DWORD nNumberOfBytesToLockLow
 
408
                                   0x00000000, # DWORD nNumberOfBytesToLockHigh
 
409
                                   ctypes.byref(overlapped), # lpOverlapped
 
410
                                  )
 
411
            self._clear_f()
 
412
            if result == 0:
 
413
                self._clear_f()
 
414
                last_err = _GetLastError()
 
415
                raise errors.LockContention('Unknown unlocking error: %s'
 
416
                                            % (last_err,))
 
417
 
 
418
 
 
419
    class _ctypes_ReadLock(_ctypes_FileLock):
 
420
        def __init__(self, filename):
 
421
            super(_ctypes_ReadLock, self).__init__()
 
422
            self._lock(filename, 'rb', LOCK_SH + LOCK_NB)
 
423
 
 
424
        def temporary_write_lock(self):
 
425
            """Try to grab a write lock on the file.
 
426
 
 
427
            On platforms that support it, this will upgrade to a write lock
 
428
            without unlocking the file.
 
429
            Otherwise, this will release the read lock, and try to acquire a
 
430
            write lock.
 
431
 
 
432
            :return: A token which can be used to switch back to a read lock.
 
433
            """
 
434
            # I can't find a way to upgrade a read lock to a write lock without
 
435
            # unlocking first. So here, we do just that.
 
436
            self.unlock()
 
437
            try:
 
438
                wlock = _ctypes_WriteLock(self.filename)
 
439
            except errors.LockError:
 
440
                return False, _ctypes_ReadLock(self.filename)
 
441
            return True, wlock
 
442
 
 
443
    class _ctypes_WriteLock(_ctypes_FileLock):
 
444
        def __init__(self, filename):
 
445
            super(_ctypes_WriteLock, self).__init__()
 
446
            self._lock(filename, 'rb+', LOCK_EX + LOCK_NB)
 
447
 
 
448
        def restore_read_lock(self):
 
449
            """Restore the original ReadLock."""
 
450
            # For win32 we had to completely let go of the original lock, so we
 
451
            # just unlock and create a new read lock.
 
452
            self.unlock()
 
453
            return _ctypes_ReadLock(self.filename)
 
454
 
 
455
 
 
456
    _lock_classes.append(('ctypes', _ctypes_WriteLock, _ctypes_ReadLock))
 
457
 
 
458
 
 
459
if len(_lock_classes) == 0:
 
460
    raise NotImplementedError(
 
461
        "We must have one of fcntl, pywin32, or ctypes available"
 
462
        " to support OS locking."
 
463
        )
 
464
 
 
465
 
 
466
# We default to using the first available lock class.
 
467
_lock_type, WriteLock, ReadLock = _lock_classes[0]
 
468