/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: Andrew Bennetts
  • Date: 2008-09-08 14:00:22 UTC
  • mto: This revision was merged to the branch mainline in revision 3756.
  • Revision ID: andrew.bennetts@canonical.com-20080908140022-shou9abvakj4kpra
More minor import tidying suggested by pyflakes.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/lock.py
 
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
 
 
92
have_pywin32 = False
 
93
if sys.platform == 'win32':
 
94
    try:
 
95
        import win32con, win32file, pywintypes, winerror, msvcrt
 
96
        have_pywin32 = True
 
97
    except ImportError:
 
98
        pass
 
99
 
 
100
 
 
101
_lock_classes = []
 
102
 
 
103
 
 
104
if have_fcntl:
 
105
    LOCK_SH = fcntl.LOCK_SH
 
106
    LOCK_NB = fcntl.LOCK_NB
 
107
    lock_EX = fcntl.LOCK_EX
 
108
 
 
109
 
 
110
    class _fcntl_FileLock(_OSLock):
 
111
 
 
112
        def _unlock(self):
 
113
            fcntl.lockf(self.f, fcntl.LOCK_UN)
 
114
            self._clear_f()
 
115
 
 
116
 
 
117
    class _fcntl_WriteLock(_fcntl_FileLock):
 
118
 
 
119
        _open_locks = set()
 
120
 
 
121
        def __init__(self, filename):
 
122
            super(_fcntl_WriteLock, self).__init__()
 
123
            # Check we can grab a lock before we actually open the file.
 
124
            self.filename = osutils.realpath(filename)
 
125
            if self.filename in _fcntl_WriteLock._open_locks:
 
126
                self._clear_f()
 
127
                raise errors.LockContention(self.filename)
 
128
 
 
129
            self._open(self.filename, 'rb+')
 
130
            # reserve a slot for this lock - even if the lockf call fails,
 
131
            # at thisi point unlock() will be called, because self.f is set.
 
132
            # TODO: make this fully threadsafe, if we decide we care.
 
133
            _fcntl_WriteLock._open_locks.add(self.filename)
 
134
            try:
 
135
                # LOCK_NB will cause IOError to be raised if we can't grab a
 
136
                # lock right away.
 
137
                fcntl.lockf(self.f, fcntl.LOCK_EX | fcntl.LOCK_NB)
 
138
            except IOError, e:
 
139
                if e.errno in (errno.EAGAIN, errno.EACCES):
 
140
                    # We couldn't grab the lock
 
141
                    self.unlock()
 
142
                # we should be more precise about whats a locking
 
143
                # error and whats a random-other error
 
144
                raise errors.LockContention(e)
 
145
 
 
146
        def unlock(self):
 
147
            _fcntl_WriteLock._open_locks.remove(self.filename)
 
148
            self._unlock()
 
149
 
 
150
 
 
151
    class _fcntl_ReadLock(_fcntl_FileLock):
 
152
 
 
153
        _open_locks = {}
 
154
 
 
155
        def __init__(self, filename):
 
156
            super(_fcntl_ReadLock, self).__init__()
 
157
            self.filename = osutils.realpath(filename)
 
158
            _fcntl_ReadLock._open_locks.setdefault(self.filename, 0)
 
159
            _fcntl_ReadLock._open_locks[self.filename] += 1
 
160
            self._open(filename, 'rb')
 
161
            try:
 
162
                # LOCK_NB will cause IOError to be raised if we can't grab a
 
163
                # lock right away.
 
164
                fcntl.lockf(self.f, fcntl.LOCK_SH | fcntl.LOCK_NB)
 
165
            except IOError, e:
 
166
                # we should be more precise about whats a locking
 
167
                # error and whats a random-other error
 
168
                raise errors.LockContention(e)
 
169
 
 
170
        def unlock(self):
 
171
            count = _fcntl_ReadLock._open_locks[self.filename]
 
172
            if count == 1:
 
173
                del _fcntl_ReadLock._open_locks[self.filename]
 
174
            else:
 
175
                _fcntl_ReadLock._open_locks[self.filename] = count - 1
 
176
            self._unlock()
 
177
 
 
178
        def temporary_write_lock(self):
 
179
            """Try to grab a write lock on the file.
 
180
 
 
181
            On platforms that support it, this will upgrade to a write lock
 
182
            without unlocking the file.
 
183
            Otherwise, this will release the read lock, and try to acquire a
 
184
            write lock.
 
185
 
 
186
            :return: A token which can be used to switch back to a read lock.
 
187
            """
 
188
            if self.filename in _fcntl_WriteLock._open_locks:
 
189
                raise AssertionError('file already locked: %r'
 
190
                    % (self.filename,))
 
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
            if self.filename in _fcntl_WriteLock._open_locks:
 
217
                raise AssertionError('file already locked: %r'
 
218
                    % (self.filename,))
 
219
 
 
220
            # See if we can open the file for writing. Another process might
 
221
            # have a read lock. We don't use self._open() because we don't want
 
222
            # to create the file if it exists. That would have already been
 
223
            # done by _fcntl_ReadLock
 
224
            try:
 
225
                new_f = open(self.filename, 'rb+')
 
226
            except IOError, e:
 
227
                if e.errno in (errno.EACCES, errno.EPERM):
 
228
                    raise errors.LockFailed(self.filename, str(e))
 
229
                raise
 
230
            try:
 
231
                # LOCK_NB will cause IOError to be raised if we can't grab a
 
232
                # lock right away.
 
233
                fcntl.lockf(new_f, fcntl.LOCK_EX | fcntl.LOCK_NB)
 
234
            except IOError, e:
 
235
                # TODO: Raise a more specific error based on the type of error
 
236
                raise errors.LockContention(e)
 
237
            _fcntl_WriteLock._open_locks.add(self.filename)
 
238
 
 
239
            self.f = new_f
 
240
 
 
241
        def restore_read_lock(self):
 
242
            """Restore the original ReadLock."""
 
243
            # For fcntl, since we never released the read lock, just release the
 
244
            # write lock, and return the original lock.
 
245
            fcntl.lockf(self.f, fcntl.LOCK_UN)
 
246
            self._clear_f()
 
247
            _fcntl_WriteLock._open_locks.remove(self.filename)
 
248
            # Avoid reference cycles
 
249
            read_lock = self._read_lock
 
250
            self._read_lock = None
 
251
            return read_lock
 
252
 
 
253
 
 
254
    _lock_classes.append(('fcntl', _fcntl_WriteLock, _fcntl_ReadLock))
 
255
 
 
256
 
 
257
if have_pywin32 and sys.platform == 'win32':
 
258
    LOCK_SH = 0 # the default
 
259
    LOCK_EX = win32con.LOCKFILE_EXCLUSIVE_LOCK
 
260
    LOCK_NB = win32con.LOCKFILE_FAIL_IMMEDIATELY
 
261
 
 
262
 
 
263
    class _w32c_FileLock(_OSLock):
 
264
 
 
265
        def _lock(self, filename, openmode, lockmode):
 
266
            self._open(filename, openmode)
 
267
 
 
268
            self.hfile = msvcrt.get_osfhandle(self.f.fileno())
 
269
            overlapped = pywintypes.OVERLAPPED()
 
270
            try:
 
271
                win32file.LockFileEx(self.hfile, lockmode, 0, 0x7fff0000,
 
272
                                     overlapped)
 
273
            except pywintypes.error, e:
 
274
                self._clear_f()
 
275
                if e.args[0] in (winerror.ERROR_LOCK_VIOLATION,):
 
276
                    raise errors.LockContention(filename)
 
277
                ## import pdb; pdb.set_trace()
 
278
                raise
 
279
            except Exception, e:
 
280
                self._clear_f()
 
281
                raise errors.LockContention(e)
 
282
 
 
283
        def unlock(self):
 
284
            overlapped = pywintypes.OVERLAPPED()
 
285
            try:
 
286
                win32file.UnlockFileEx(self.hfile, 0, 0x7fff0000, overlapped)
 
287
                self._clear_f()
 
288
            except Exception, e:
 
289
                raise errors.LockContention(e)
 
290
 
 
291
 
 
292
    class _w32c_ReadLock(_w32c_FileLock):
 
293
        def __init__(self, filename):
 
294
            super(_w32c_ReadLock, self).__init__()
 
295
            self._lock(filename, 'rb', LOCK_SH + LOCK_NB)
 
296
 
 
297
        def temporary_write_lock(self):
 
298
            """Try to grab a write lock on the file.
 
299
 
 
300
            On platforms that support it, this will upgrade to a write lock
 
301
            without unlocking the file.
 
302
            Otherwise, this will release the read lock, and try to acquire a
 
303
            write lock.
 
304
 
 
305
            :return: A token which can be used to switch back to a read lock.
 
306
            """
 
307
            # I can't find a way to upgrade a read lock to a write lock without
 
308
            # unlocking first. So here, we do just that.
 
309
            self.unlock()
 
310
            try:
 
311
                wlock = _w32c_WriteLock(self.filename)
 
312
            except errors.LockError:
 
313
                return False, _w32c_ReadLock(self.filename)
 
314
            return True, wlock
 
315
 
 
316
 
 
317
    class _w32c_WriteLock(_w32c_FileLock):
 
318
        def __init__(self, filename):
 
319
            super(_w32c_WriteLock, self).__init__()
 
320
            self._lock(filename, 'rb+', LOCK_EX + LOCK_NB)
 
321
 
 
322
        def restore_read_lock(self):
 
323
            """Restore the original ReadLock."""
 
324
            # For win32 we had to completely let go of the original lock, so we
 
325
            # just unlock and create a new read lock.
 
326
            self.unlock()
 
327
            return _w32c_ReadLock(self.filename)
 
328
 
 
329
 
 
330
    _lock_classes.append(('pywin32', _w32c_WriteLock, _w32c_ReadLock))
 
331
 
 
332
 
 
333
have_ctypes_win32 = False
 
334
if sys.platform == 'win32':
 
335
    try:
 
336
        import ctypes, msvcrt
 
337
        have_ctypes_win32 = True
 
338
    except ImportError:
 
339
        pass
 
340
 
 
341
if have_ctypes_win32:
 
342
    # These constants were copied from the win32con.py module.
 
343
    LOCKFILE_FAIL_IMMEDIATELY = 1
 
344
    LOCKFILE_EXCLUSIVE_LOCK = 2
 
345
    # Constant taken from winerror.py module
 
346
    ERROR_LOCK_VIOLATION = 33
 
347
 
 
348
    LOCK_SH = 0
 
349
    LOCK_EX = LOCKFILE_EXCLUSIVE_LOCK
 
350
    LOCK_NB = LOCKFILE_FAIL_IMMEDIATELY
 
351
    _LockFileEx = ctypes.windll.kernel32.LockFileEx
 
352
    _UnlockFileEx = ctypes.windll.kernel32.UnlockFileEx
 
353
    _GetLastError = ctypes.windll.kernel32.GetLastError
 
354
 
 
355
    ### Define the OVERLAPPED structure.
 
356
    #   http://msdn2.microsoft.com/en-us/library/ms684342.aspx
 
357
    # typedef struct _OVERLAPPED {
 
358
    #   ULONG_PTR Internal;
 
359
    #   ULONG_PTR InternalHigh;
 
360
    #   union {
 
361
    #     struct {
 
362
    #       DWORD Offset;
 
363
    #       DWORD OffsetHigh;
 
364
    #     };
 
365
    #     PVOID Pointer;
 
366
    #   };
 
367
    #   HANDLE hEvent;
 
368
    # } OVERLAPPED,
 
369
 
 
370
    class _inner_struct(ctypes.Structure):
 
371
        _fields_ = [('Offset', ctypes.c_uint), # DWORD
 
372
                    ('OffsetHigh', ctypes.c_uint), # DWORD
 
373
                   ]
 
374
 
 
375
    class _inner_union(ctypes.Union):
 
376
        _fields_  = [('anon_struct', _inner_struct), # struct
 
377
                     ('Pointer', ctypes.c_void_p), # PVOID
 
378
                    ]
 
379
 
 
380
    class OVERLAPPED(ctypes.Structure):
 
381
        _fields_ = [('Internal', ctypes.c_void_p), # ULONG_PTR
 
382
                    ('InternalHigh', ctypes.c_void_p), # ULONG_PTR
 
383
                    ('_inner_union', _inner_union),
 
384
                    ('hEvent', ctypes.c_void_p), # HANDLE
 
385
                   ]
 
386
 
 
387
    class _ctypes_FileLock(_OSLock):
 
388
 
 
389
        def _lock(self, filename, openmode, lockmode):
 
390
            self._open(filename, openmode)
 
391
 
 
392
            self.hfile = msvcrt.get_osfhandle(self.f.fileno())
 
393
            overlapped = OVERLAPPED()
 
394
            result = _LockFileEx(self.hfile, # HANDLE hFile
 
395
                                 lockmode,   # DWORD dwFlags
 
396
                                 0,          # DWORD dwReserved
 
397
                                 0x7fffffff, # DWORD nNumberOfBytesToLockLow
 
398
                                 0x00000000, # DWORD nNumberOfBytesToLockHigh
 
399
                                 ctypes.byref(overlapped), # lpOverlapped
 
400
                                )
 
401
            if result == 0:
 
402
                self._clear_f()
 
403
                last_err = _GetLastError()
 
404
                if last_err in (ERROR_LOCK_VIOLATION,):
 
405
                    raise errors.LockContention(filename)
 
406
                raise errors.LockContention('Unknown locking error: %s'
 
407
                                            % (last_err,))
 
408
 
 
409
        def unlock(self):
 
410
            overlapped = OVERLAPPED()
 
411
            result = _UnlockFileEx(self.hfile, # HANDLE hFile
 
412
                                   0,          # DWORD dwReserved
 
413
                                   0x7fffffff, # DWORD nNumberOfBytesToLockLow
 
414
                                   0x00000000, # DWORD nNumberOfBytesToLockHigh
 
415
                                   ctypes.byref(overlapped), # lpOverlapped
 
416
                                  )
 
417
            self._clear_f()
 
418
            if result == 0:
 
419
                self._clear_f()
 
420
                last_err = _GetLastError()
 
421
                raise errors.LockContention('Unknown unlocking error: %s'
 
422
                                            % (last_err,))
 
423
 
 
424
 
 
425
    class _ctypes_ReadLock(_ctypes_FileLock):
 
426
        def __init__(self, filename):
 
427
            super(_ctypes_ReadLock, self).__init__()
 
428
            self._lock(filename, 'rb', LOCK_SH + LOCK_NB)
 
429
 
 
430
        def temporary_write_lock(self):
 
431
            """Try to grab a write lock on the file.
 
432
 
 
433
            On platforms that support it, this will upgrade to a write lock
 
434
            without unlocking the file.
 
435
            Otherwise, this will release the read lock, and try to acquire a
 
436
            write lock.
 
437
 
 
438
            :return: A token which can be used to switch back to a read lock.
 
439
            """
 
440
            # I can't find a way to upgrade a read lock to a write lock without
 
441
            # unlocking first. So here, we do just that.
 
442
            self.unlock()
 
443
            try:
 
444
                wlock = _ctypes_WriteLock(self.filename)
 
445
            except errors.LockError:
 
446
                return False, _ctypes_ReadLock(self.filename)
 
447
            return True, wlock
 
448
 
 
449
    class _ctypes_WriteLock(_ctypes_FileLock):
 
450
        def __init__(self, filename):
 
451
            super(_ctypes_WriteLock, self).__init__()
 
452
            self._lock(filename, 'rb+', LOCK_EX + LOCK_NB)
 
453
 
 
454
        def restore_read_lock(self):
 
455
            """Restore the original ReadLock."""
 
456
            # For win32 we had to completely let go of the original lock, so we
 
457
            # just unlock and create a new read lock.
 
458
            self.unlock()
 
459
            return _ctypes_ReadLock(self.filename)
 
460
 
 
461
 
 
462
    _lock_classes.append(('ctypes', _ctypes_WriteLock, _ctypes_ReadLock))
 
463
 
 
464
 
 
465
if len(_lock_classes) == 0:
 
466
    raise NotImplementedError(
 
467
        "We must have one of fcntl, pywin32, or ctypes available"
 
468
        " to support OS locking."
 
469
        )
 
470
 
 
471
 
 
472
# We default to using the first available lock class.
 
473
_lock_type, WriteLock, ReadLock = _lock_classes[0]
 
474