/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 breezy/lock.py

  • Committer: Jelmer Vernooij
  • Date: 2020-04-05 19:11:34 UTC
  • mto: (7490.7.16 work)
  • mto: This revision was merged to the branch mainline in revision 7501.
  • Revision ID: jelmer@jelmer.uk-20200405191134-0aebh8ikiwygxma5
Populate the .gitignore file.

Show diffs side-by-side

added added

removed removed

Lines of Context:
breezy/lock.py
14
14
# along with this program; if not, write to the Free Software
15
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
16
16
 
17
 
 
18
17
"""Locking using OS file locks or file existence.
19
18
 
20
19
Note: This method of locking is generally deprecated in favour of LockDir, but
34
33
unlock() method.
35
34
"""
36
35
 
 
36
from __future__ import absolute_import
 
37
 
 
38
import contextlib
37
39
import errno
38
40
import os
39
41
import sys
40
42
import warnings
41
43
 
42
 
from bzrlib import (
 
44
from . import (
43
45
    debug,
44
46
    errors,
45
47
    osutils,
46
48
    trace,
47
49
    )
48
 
from bzrlib.hooks import HookPoint, Hooks
 
50
from .hooks import Hooks
 
51
from .i18n import gettext
49
52
 
50
53
 
51
54
class LockHooks(Hooks):
52
55
 
53
56
    def __init__(self):
54
 
        Hooks.__init__(self)
55
 
        self.create_hook(HookPoint('lock_acquired',
56
 
            "Called with a bzrlib.lock.LockResult when a physical lock is "
57
 
            "acquired.", (1, 8), None))
58
 
        self.create_hook(HookPoint('lock_released',
59
 
            "Called with a bzrlib.lock.LockResult when a physical lock is "
60
 
            "released.", (1, 8), None))
61
 
        self.create_hook(HookPoint('lock_broken',
62
 
            "Called with a bzrlib.lock.LockResult when a physical lock is "
63
 
            "broken.", (1, 15), None))
 
57
        Hooks.__init__(self, "breezy.lock", "Lock.hooks")
 
58
        self.add_hook(
 
59
            'lock_acquired',
 
60
            "Called with a breezy.lock.LockResult when a physical lock is "
 
61
            "acquired.", (1, 8))
 
62
        self.add_hook(
 
63
            'lock_released',
 
64
            "Called with a breezy.lock.LockResult when a physical lock is "
 
65
            "released.", (1, 8))
 
66
        self.add_hook(
 
67
            'lock_broken',
 
68
            "Called with a breezy.lock.LockResult when a physical lock is "
 
69
            "broken.", (1, 15))
64
70
 
65
71
 
66
72
class Lock(object):
85
91
 
86
92
    def __repr__(self):
87
93
        return '%s(%s, %s)' % (self.__class__.__name__,
88
 
                             self.lock_url, self.details)
 
94
                               self.lock_url, self.details)
 
95
 
 
96
 
 
97
class LogicalLockResult(object):
 
98
    """The result of a lock_read/lock_write/lock_tree_write call on lockables.
 
99
 
 
100
    :ivar unlock: A callable which will unlock the lock.
 
101
    """
 
102
 
 
103
    def __init__(self, unlock, token=None):
 
104
        self.unlock = unlock
 
105
        self.token = token
 
106
 
 
107
    def __repr__(self):
 
108
        return "LogicalLockResult(%s)" % (self.unlock)
 
109
 
 
110
    def __enter__(self):
 
111
        return self
 
112
 
 
113
    def __exit__(self, exc_type, exc_val, exc_tb):
 
114
        # If there was an error raised, prefer the original one
 
115
        try:
 
116
            self.unlock()
 
117
        except BaseException:
 
118
            if exc_type is None:
 
119
                raise
 
120
        return False
89
121
 
90
122
 
91
123
def cant_unlock_not_held(locked_object):
92
124
    """An attempt to unlock failed because the object was not locked.
93
125
 
94
 
    This provides a policy point from which we can generate either a warning 
95
 
    or an exception.
 
126
    This provides a policy point from which we can generate either a warning or
 
127
    an exception.
96
128
    """
97
129
    # This is typically masking some other error and called from a finally
98
130
    # block, so it's useful to have the option not to generate a new error
100
132
    # raise LockNotHeld.
101
133
    if 'unlock' in debug.debug_flags:
102
134
        warnings.warn("%r is already unlocked" % (locked_object,),
103
 
            stacklevel=3)
 
135
                      stacklevel=3)
104
136
    else:
105
137
        raise errors.LockNotHeld(locked_object)
106
138
 
111
143
except ImportError:
112
144
    have_fcntl = False
113
145
 
114
 
have_pywin32 = False
115
146
have_ctypes_win32 = False
116
147
if sys.platform == 'win32':
117
148
    import msvcrt
118
149
    try:
119
 
        import win32file, pywintypes, winerror
120
 
        have_pywin32 = True
121
 
    except ImportError:
122
 
        pass
123
 
 
124
 
    try:
125
150
        import ctypes
126
151
        have_ctypes_win32 = True
127
152
    except ImportError:
139
164
        try:
140
165
            self.f = open(self.filename, filemode)
141
166
            return self.f
142
 
        except IOError, e:
 
167
        except IOError as e:
143
168
            if e.errno in (errno.EACCES, errno.EPERM):
144
169
                raise errors.LockFailed(self.filename, str(e))
145
170
            if e.errno != errno.ENOENT:
157
182
            self.f.close()
158
183
            self.f = None
159
184
 
160
 
    def __del__(self):
161
 
        if self.f:
162
 
            from warnings import warn
163
 
            warn("lock on %r not released" % self.f)
164
 
            self.unlock()
165
 
 
166
185
    def unlock(self):
167
186
        raise NotImplementedError()
168
187
 
178
197
            fcntl.lockf(self.f, fcntl.LOCK_UN)
179
198
            self._clear_f()
180
199
 
181
 
 
182
200
    class _fcntl_WriteLock(_fcntl_FileLock):
183
201
 
184
202
        _open_locks = set()
207
225
                # LOCK_NB will cause IOError to be raised if we can't grab a
208
226
                # lock right away.
209
227
                fcntl.lockf(self.f, fcntl.LOCK_EX | fcntl.LOCK_NB)
210
 
            except IOError, e:
 
228
            except IOError as e:
211
229
                if e.errno in (errno.EAGAIN, errno.EACCES):
212
230
                    # We couldn't grab the lock
213
231
                    self.unlock()
219
237
            _fcntl_WriteLock._open_locks.remove(self.filename)
220
238
            self._unlock()
221
239
 
222
 
 
223
240
    class _fcntl_ReadLock(_fcntl_FileLock):
224
241
 
225
242
        _open_locks = {}
242
259
                # LOCK_NB will cause IOError to be raised if we can't grab a
243
260
                # lock right away.
244
261
                fcntl.lockf(self.f, fcntl.LOCK_SH | fcntl.LOCK_NB)
245
 
            except IOError, e:
 
262
            except IOError as e:
246
263
                # we should be more precise about whats a locking
247
264
                # error and whats a random-other error
248
265
                raise errors.LockContention(self.filename, e)
267
284
            """
268
285
            if self.filename in _fcntl_WriteLock._open_locks:
269
286
                raise AssertionError('file already locked: %r'
270
 
                    % (self.filename,))
 
287
                                     % (self.filename,))
271
288
            try:
272
289
                wlock = _fcntl_TemporaryWriteLock(self)
273
290
            except errors.LockError:
275
292
                return False, self
276
293
            return True, wlock
277
294
 
278
 
 
279
295
    class _fcntl_TemporaryWriteLock(_OSLock):
280
296
        """A token used when grabbing a temporary_write_lock.
281
297
 
295
311
 
296
312
            if self.filename in _fcntl_WriteLock._open_locks:
297
313
                raise AssertionError('file already locked: %r'
298
 
                    % (self.filename,))
 
314
                                     % (self.filename,))
299
315
 
300
316
            # See if we can open the file for writing. Another process might
301
317
            # have a read lock. We don't use self._open() because we don't want
303
319
            # done by _fcntl_ReadLock
304
320
            try:
305
321
                new_f = open(self.filename, 'rb+')
306
 
            except IOError, e:
 
322
            except IOError as e:
307
323
                if e.errno in (errno.EACCES, errno.EPERM):
308
324
                    raise errors.LockFailed(self.filename, str(e))
309
325
                raise
311
327
                # LOCK_NB will cause IOError to be raised if we can't grab a
312
328
                # lock right away.
313
329
                fcntl.lockf(new_f, fcntl.LOCK_EX | fcntl.LOCK_NB)
314
 
            except IOError, e:
 
330
            except IOError as e:
315
331
                # TODO: Raise a more specific error based on the type of error
316
332
                raise errors.LockContention(self.filename, e)
317
333
            _fcntl_WriteLock._open_locks.add(self.filename)
320
336
 
321
337
        def restore_read_lock(self):
322
338
            """Restore the original ReadLock."""
323
 
            # For fcntl, since we never released the read lock, just release the
324
 
            # write lock, and return the original lock.
 
339
            # For fcntl, since we never released the read lock, just release
 
340
            # the write lock, and return the original lock.
325
341
            fcntl.lockf(self.f, fcntl.LOCK_UN)
326
342
            self._clear_f()
327
343
            _fcntl_WriteLock._open_locks.remove(self.filename)
330
346
            self._read_lock = None
331
347
            return read_lock
332
348
 
333
 
 
334
349
    _lock_classes.append(('fcntl', _fcntl_WriteLock, _fcntl_ReadLock))
335
350
 
336
351
 
337
 
if have_pywin32 and sys.platform == 'win32':
338
 
    if os.path.supports_unicode_filenames:
339
 
        # for Windows NT/2K/XP/etc
340
 
        win32file_CreateFile = win32file.CreateFileW
341
 
    else:
342
 
        # for Windows 98
343
 
        win32file_CreateFile = win32file.CreateFile
344
 
 
345
 
    class _w32c_FileLock(_OSLock):
346
 
 
347
 
        def _open(self, filename, access, share, cflags, pymode):
348
 
            self.filename = osutils.realpath(filename)
349
 
            try:
350
 
                self._handle = win32file_CreateFile(filename, access, share,
351
 
                    None, win32file.OPEN_ALWAYS,
352
 
                    win32file.FILE_ATTRIBUTE_NORMAL, None)
353
 
            except pywintypes.error, e:
354
 
                if e.args[0] == winerror.ERROR_ACCESS_DENIED:
355
 
                    raise errors.LockFailed(filename, e)
356
 
                if e.args[0] == winerror.ERROR_SHARING_VIOLATION:
357
 
                    raise errors.LockContention(filename, e)
358
 
                raise
359
 
            fd = win32file._open_osfhandle(self._handle, cflags)
360
 
            self.f = os.fdopen(fd, pymode)
361
 
            return self.f
362
 
 
363
 
        def unlock(self):
364
 
            self._clear_f()
365
 
            self._handle = None
366
 
 
367
 
 
368
 
    class _w32c_ReadLock(_w32c_FileLock):
369
 
        def __init__(self, filename):
370
 
            super(_w32c_ReadLock, self).__init__()
371
 
            self._open(filename, win32file.GENERIC_READ,
372
 
                win32file.FILE_SHARE_READ, os.O_RDONLY, "rb")
373
 
 
374
 
        def temporary_write_lock(self):
375
 
            """Try to grab a write lock on the file.
376
 
 
377
 
            On platforms that support it, this will upgrade to a write lock
378
 
            without unlocking the file.
379
 
            Otherwise, this will release the read lock, and try to acquire a
380
 
            write lock.
381
 
 
382
 
            :return: A token which can be used to switch back to a read lock.
383
 
            """
384
 
            # I can't find a way to upgrade a read lock to a write lock without
385
 
            # unlocking first. So here, we do just that.
386
 
            self.unlock()
387
 
            try:
388
 
                wlock = _w32c_WriteLock(self.filename)
389
 
            except errors.LockError:
390
 
                return False, _w32c_ReadLock(self.filename)
391
 
            return True, wlock
392
 
 
393
 
 
394
 
    class _w32c_WriteLock(_w32c_FileLock):
395
 
        def __init__(self, filename):
396
 
            super(_w32c_WriteLock, self).__init__()
397
 
            self._open(filename,
398
 
                win32file.GENERIC_READ | win32file.GENERIC_WRITE, 0,
399
 
                os.O_RDWR, "rb+")
400
 
 
401
 
        def restore_read_lock(self):
402
 
            """Restore the original ReadLock."""
403
 
            # For win32 we had to completely let go of the original lock, so we
404
 
            # just unlock and create a new read lock.
405
 
            self.unlock()
406
 
            return _w32c_ReadLock(self.filename)
407
 
 
408
 
 
409
 
    _lock_classes.append(('pywin32', _w32c_WriteLock, _w32c_ReadLock))
410
 
 
411
 
 
412
352
if have_ctypes_win32:
413
 
    from ctypes.wintypes import DWORD, LPCSTR, LPCWSTR
414
 
    LPSECURITY_ATTRIBUTES = ctypes.c_void_p # used as NULL no need to declare
415
 
    HANDLE = ctypes.c_int # rather than unsigned as in ctypes.wintypes
416
 
    if os.path.supports_unicode_filenames:
417
 
        _function_name = "CreateFileW"
418
 
        LPTSTR = LPCWSTR
419
 
    else:
420
 
        _function_name = "CreateFileA"
421
 
        class LPTSTR(LPCSTR):
422
 
            def __new__(cls, obj):
423
 
                return LPCSTR.__new__(cls, obj.encode("mbcs"))
 
353
    from ctypes.wintypes import DWORD, LPWSTR
 
354
    LPSECURITY_ATTRIBUTES = ctypes.c_void_p  # used as NULL no need to declare
 
355
    HANDLE = ctypes.c_int  # rather than unsigned as in ctypes.wintypes
 
356
    _function_name = "CreateFileW"
424
357
 
425
358
    # CreateFile <http://msdn.microsoft.com/en-us/library/aa363858.aspx>
426
359
    _CreateFile = ctypes.WINFUNCTYPE(
427
 
            HANDLE,                # return value
428
 
            LPTSTR,                # lpFileName
429
 
            DWORD,                 # dwDesiredAccess
430
 
            DWORD,                 # dwShareMode
431
 
            LPSECURITY_ATTRIBUTES, # lpSecurityAttributes
432
 
            DWORD,                 # dwCreationDisposition
433
 
            DWORD,                 # dwFlagsAndAttributes
434
 
            HANDLE                 # hTemplateFile
 
360
        HANDLE,                # return value
 
361
        LPWSTR,                # lpFileName
 
362
        DWORD,                 # dwDesiredAccess
 
363
        DWORD,                 # dwShareMode
 
364
        LPSECURITY_ATTRIBUTES,  # lpSecurityAttributes
 
365
        DWORD,                 # dwCreationDisposition
 
366
        DWORD,                 # dwFlagsAndAttributes
 
367
        HANDLE                 # hTemplateFile
435
368
        )((_function_name, ctypes.windll.kernel32))
436
369
 
437
370
    INVALID_HANDLE_VALUE = -1
450
383
        def _open(self, filename, access, share, cflags, pymode):
451
384
            self.filename = osutils.realpath(filename)
452
385
            handle = _CreateFile(filename, access, share, None, OPEN_ALWAYS,
453
 
                FILE_ATTRIBUTE_NORMAL, 0)
 
386
                                 FILE_ATTRIBUTE_NORMAL, 0)
454
387
            if handle in (INVALID_HANDLE_VALUE, 0):
455
388
                e = ctypes.WinError()
456
389
                if e.args[0] == ERROR_ACCESS_DENIED:
465
398
        def unlock(self):
466
399
            self._clear_f()
467
400
 
468
 
 
469
401
    class _ctypes_ReadLock(_ctypes_FileLock):
470
402
        def __init__(self, filename):
471
403
            super(_ctypes_ReadLock, self).__init__()
472
404
            self._open(filename, GENERIC_READ, FILE_SHARE_READ, os.O_RDONLY,
473
 
                "rb")
 
405
                       "rb")
474
406
 
475
407
        def temporary_write_lock(self):
476
408
            """Try to grab a write lock on the file.
495
427
        def __init__(self, filename):
496
428
            super(_ctypes_WriteLock, self).__init__()
497
429
            self._open(filename, GENERIC_READ | GENERIC_WRITE, 0, os.O_RDWR,
498
 
                "rb+")
 
430
                       "rb+")
499
431
 
500
432
        def restore_read_lock(self):
501
433
            """Restore the original ReadLock."""
504
436
            self.unlock()
505
437
            return _ctypes_ReadLock(self.filename)
506
438
 
507
 
 
508
439
    _lock_classes.append(('ctypes', _ctypes_WriteLock, _ctypes_ReadLock))
509
440
 
510
441
 
511
442
if len(_lock_classes) == 0:
512
443
    raise NotImplementedError(
513
 
        "We must have one of fcntl, pywin32, or ctypes available"
 
444
        "We must have one of fcntl or ctypes available"
514
445
        " to support OS locking."
515
446
        )
516
447
 
527
458
    locked the same way), and -Drelock is set, then this will trace.note a
528
459
    message about it.
529
460
    """
530
 
    
 
461
 
531
462
    _prev_lock = None
532
463
 
533
464
    def _note_lock(self, lock_type):
536
467
                type_name = 'read'
537
468
            else:
538
469
                type_name = 'write'
539
 
            trace.note('%r was %s locked again', self, type_name)
 
470
            trace.note(gettext('{0!r} was {1} locked again'), self, type_name)
540
471
        self._prev_lock = lock_type
541
472
 
 
473
 
 
474
@contextlib.contextmanager
 
475
def write_locked(lockable):
 
476
    lockable.lock_write()
 
477
    try:
 
478
        yield lockable
 
479
    finally:
 
480
        lockable.unlock()