~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/lock.py

  • Committer: Martin Pool
  • Date: 2009-07-10 07:14:02 UTC
  • mto: (4525.1.1 integration)
  • mto: This revision was merged to the branch mainline in revision 4526.
  • Revision ID: mbp@sourcefrog.net-20090710071402-dga5lhvdup5jeere
Rename remaining *_implementations tests

Show diffs side-by-side

added added

removed removed

Lines of Context:
 
1
# Copyright (C) 2005, 2006, 2007, 2008, 2009 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., 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.
 
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 os
 
39
import sys
 
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
 
 
118
    def _open(self, filename, filemode):
 
119
        self.filename = osutils.realpath(filename)
 
120
        try:
 
121
            self.f = open(self.filename, filemode)
 
122
            return self.f
 
123
        except IOError, e:
 
124
            if e.errno in (errno.EACCES, errno.EPERM):
 
125
                raise errors.LockFailed(self.filename, str(e))
 
126
            if e.errno != errno.ENOENT:
 
127
                raise
 
128
 
 
129
            # maybe this is an old branch (before may 2005)
 
130
            trace.mutter("trying to create missing lock %r", self.filename)
 
131
 
 
132
            self.f = open(self.filename, 'wb+')
 
133
            return self.f
 
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
 
140
 
 
141
    def __del__(self):
 
142
        if self.f:
 
143
            from warnings import warn
 
144
            warn("lock on %r not released" % self.f)
 
145
            self.unlock()
 
146
 
 
147
    def unlock(self):
 
148
        raise NotImplementedError()
 
149
 
 
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()
 
161
 
 
162
 
 
163
    class _fcntl_WriteLock(_fcntl_FileLock):
 
164
 
 
165
        _open_locks = set()
 
166
 
 
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)
 
180
            try:
 
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()
 
195
 
 
196
 
 
197
    class _fcntl_ReadLock(_fcntl_FileLock):
 
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
    if os.path.supports_unicode_filenames:
 
305
        # for Windows NT/2K/XP/etc
 
306
        win32file_CreateFile = win32file.CreateFileW
 
307
    else:
 
308
        # for Windows 98
 
309
        win32file_CreateFile = win32file.CreateFile
 
310
 
 
311
    class _w32c_FileLock(_OSLock):
 
312
 
 
313
        def _open(self, filename, access, share, cflags, pymode):
 
314
            self.filename = osutils.realpath(filename)
 
315
            try:
 
316
                self._handle = win32file_CreateFile(filename, access, share,
 
317
                    None, win32file.OPEN_ALWAYS,
 
318
                    win32file.FILE_ATTRIBUTE_NORMAL, None)
 
319
            except pywintypes.error, e:
 
320
                if e.args[0] == winerror.ERROR_ACCESS_DENIED:
 
321
                    raise errors.LockFailed(filename, e)
 
322
                if e.args[0] == winerror.ERROR_SHARING_VIOLATION:
 
323
                    raise errors.LockContention(filename, e)
 
324
                raise
 
325
            fd = win32file._open_osfhandle(self._handle, cflags)
 
326
            self.f = os.fdopen(fd, pymode)
 
327
            return self.f
 
328
 
 
329
        def unlock(self):
 
330
            self._clear_f()
 
331
            self._handle = None
 
332
 
 
333
 
 
334
    class _w32c_ReadLock(_w32c_FileLock):
 
335
        def __init__(self, filename):
 
336
            super(_w32c_ReadLock, self).__init__()
 
337
            self._open(filename, win32file.GENERIC_READ,
 
338
                win32file.FILE_SHARE_READ, os.O_RDONLY, "rb")
 
339
 
 
340
        def temporary_write_lock(self):
 
341
            """Try to grab a write lock on the file.
 
342
 
 
343
            On platforms that support it, this will upgrade to a write lock
 
344
            without unlocking the file.
 
345
            Otherwise, this will release the read lock, and try to acquire a
 
346
            write lock.
 
347
 
 
348
            :return: A token which can be used to switch back to a read lock.
 
349
            """
 
350
            # I can't find a way to upgrade a read lock to a write lock without
 
351
            # unlocking first. So here, we do just that.
 
352
            self.unlock()
 
353
            try:
 
354
                wlock = _w32c_WriteLock(self.filename)
 
355
            except errors.LockError:
 
356
                return False, _w32c_ReadLock(self.filename)
 
357
            return True, wlock
 
358
 
 
359
 
 
360
    class _w32c_WriteLock(_w32c_FileLock):
 
361
        def __init__(self, filename):
 
362
            super(_w32c_WriteLock, self).__init__()
 
363
            self._open(filename,
 
364
                win32file.GENERIC_READ | win32file.GENERIC_WRITE, 0,
 
365
                os.O_RDWR, "rb+")
 
366
 
 
367
        def restore_read_lock(self):
 
368
            """Restore the original ReadLock."""
 
369
            # For win32 we had to completely let go of the original lock, so we
 
370
            # just unlock and create a new read lock.
 
371
            self.unlock()
 
372
            return _w32c_ReadLock(self.filename)
 
373
 
 
374
 
 
375
    _lock_classes.append(('pywin32', _w32c_WriteLock, _w32c_ReadLock))
 
376
 
 
377
 
 
378
if have_ctypes_win32:
 
379
    from ctypes.wintypes import DWORD, LPCSTR, LPCWSTR
 
380
    LPSECURITY_ATTRIBUTES = ctypes.c_void_p # used as NULL no need to declare
 
381
    HANDLE = ctypes.c_int # rather than unsigned as in ctypes.wintypes
 
382
    if os.path.supports_unicode_filenames:
 
383
        _function_name = "CreateFileW"
 
384
        LPTSTR = LPCWSTR
 
385
    else:
 
386
        _function_name = "CreateFileA"
 
387
        class LPTSTR(LPCSTR):
 
388
            def __new__(cls, obj):
 
389
                return LPCSTR.__new__(cls, obj.encode("mbcs"))
 
390
 
 
391
    # CreateFile <http://msdn.microsoft.com/en-us/library/aa363858.aspx>
 
392
    _CreateFile = ctypes.WINFUNCTYPE(
 
393
            HANDLE,                # return value
 
394
            LPTSTR,                # lpFileName
 
395
            DWORD,                 # dwDesiredAccess
 
396
            DWORD,                 # dwShareMode
 
397
            LPSECURITY_ATTRIBUTES, # lpSecurityAttributes
 
398
            DWORD,                 # dwCreationDisposition
 
399
            DWORD,                 # dwFlagsAndAttributes
 
400
            HANDLE                 # hTemplateFile
 
401
        )((_function_name, ctypes.windll.kernel32))
 
402
    
 
403
    INVALID_HANDLE_VALUE = -1
 
404
    
 
405
    GENERIC_READ = 0x80000000
 
406
    GENERIC_WRITE = 0x40000000
 
407
    FILE_SHARE_READ = 1
 
408
    OPEN_ALWAYS = 4
 
409
    FILE_ATTRIBUTE_NORMAL = 128
 
410
    
 
411
    ERROR_ACCESS_DENIED = 5
 
412
    ERROR_SHARING_VIOLATION = 32
 
413
 
 
414
    class _ctypes_FileLock(_OSLock):
 
415
 
 
416
        def _open(self, filename, access, share, cflags, pymode):
 
417
            self.filename = osutils.realpath(filename)
 
418
            handle = _CreateFile(filename, access, share, None, OPEN_ALWAYS,
 
419
                FILE_ATTRIBUTE_NORMAL, 0)
 
420
            if handle in (INVALID_HANDLE_VALUE, 0):
 
421
                e = ctypes.WinError()
 
422
                if e.args[0] == ERROR_ACCESS_DENIED:
 
423
                    raise errors.LockFailed(filename, e)
 
424
                if e.args[0] == ERROR_SHARING_VIOLATION:
 
425
                    raise errors.LockContention(filename, e)
 
426
                raise e
 
427
            fd = msvcrt.open_osfhandle(handle, cflags)
 
428
            self.f = os.fdopen(fd, pymode)
 
429
            return self.f
 
430
 
 
431
        def unlock(self):
 
432
            self._clear_f()
 
433
 
 
434
 
 
435
    class _ctypes_ReadLock(_ctypes_FileLock):
 
436
        def __init__(self, filename):
 
437
            super(_ctypes_ReadLock, self).__init__()
 
438
            self._open(filename, GENERIC_READ, FILE_SHARE_READ, os.O_RDONLY,
 
439
                "rb")
 
440
 
 
441
        def temporary_write_lock(self):
 
442
            """Try to grab a write lock on the file.
 
443
 
 
444
            On platforms that support it, this will upgrade to a write lock
 
445
            without unlocking the file.
 
446
            Otherwise, this will release the read lock, and try to acquire a
 
447
            write lock.
 
448
 
 
449
            :return: A token which can be used to switch back to a read lock.
 
450
            """
 
451
            # I can't find a way to upgrade a read lock to a write lock without
 
452
            # unlocking first. So here, we do just that.
 
453
            self.unlock()
 
454
            try:
 
455
                wlock = _ctypes_WriteLock(self.filename)
 
456
            except errors.LockError:
 
457
                return False, _ctypes_ReadLock(self.filename)
 
458
            return True, wlock
 
459
 
 
460
    class _ctypes_WriteLock(_ctypes_FileLock):
 
461
        def __init__(self, filename):
 
462
            super(_ctypes_WriteLock, self).__init__()
 
463
            self._open(filename, GENERIC_READ | GENERIC_WRITE, 0, os.O_RDWR,
 
464
                "rb+")
 
465
 
 
466
        def restore_read_lock(self):
 
467
            """Restore the original ReadLock."""
 
468
            # For win32 we had to completely let go of the original lock, so we
 
469
            # just unlock and create a new read lock.
 
470
            self.unlock()
 
471
            return _ctypes_ReadLock(self.filename)
 
472
 
 
473
 
 
474
    _lock_classes.append(('ctypes', _ctypes_WriteLock, _ctypes_ReadLock))
 
475
 
 
476
 
 
477
if len(_lock_classes) == 0:
 
478
    raise NotImplementedError(
 
479
        "We must have one of fcntl, pywin32, or ctypes available"
 
480
        " to support OS locking."
 
481
        )
 
482
 
 
483
 
 
484
# We default to using the first available lock class.
 
485
_lock_type, WriteLock, ReadLock = _lock_classes[0]
 
486