/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: 2019-03-05 07:32:38 UTC
  • mto: (7290.1.21 work)
  • mto: This revision was merged to the branch mainline in revision 7311.
  • Revision ID: jelmer@jelmer.uk-20190305073238-zlqn981opwnqsmzi
Add appveyor configuration.

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)
89
95
 
90
96
 
91
97
class LogicalLockResult(object):
94
100
    :ivar unlock: A callable which will unlock the lock.
95
101
    """
96
102
 
97
 
    def __init__(self, unlock):
 
103
    def __init__(self, unlock, token=None):
98
104
        self.unlock = unlock
 
105
        self.token = token
99
106
 
100
107
    def __repr__(self):
101
108
        return "LogicalLockResult(%s)" % (self.unlock)
102
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
103
121
 
104
122
 
105
123
def cant_unlock_not_held(locked_object):
106
124
    """An attempt to unlock failed because the object was not locked.
107
125
 
108
 
    This provides a policy point from which we can generate either a warning 
109
 
    or an exception.
 
126
    This provides a policy point from which we can generate either a warning or
 
127
    an exception.
110
128
    """
111
129
    # This is typically masking some other error and called from a finally
112
130
    # block, so it's useful to have the option not to generate a new error
114
132
    # raise LockNotHeld.
115
133
    if 'unlock' in debug.debug_flags:
116
134
        warnings.warn("%r is already unlocked" % (locked_object,),
117
 
            stacklevel=3)
 
135
                      stacklevel=3)
118
136
    else:
119
137
        raise errors.LockNotHeld(locked_object)
120
138
 
130
148
if sys.platform == 'win32':
131
149
    import msvcrt
132
150
    try:
133
 
        import win32file, pywintypes, winerror
 
151
        import win32file
 
152
        import pywintypes
 
153
        import winerror
134
154
        have_pywin32 = True
135
155
    except ImportError:
136
156
        pass
153
173
        try:
154
174
            self.f = open(self.filename, filemode)
155
175
            return self.f
156
 
        except IOError, e:
 
176
        except IOError as e:
157
177
            if e.errno in (errno.EACCES, errno.EPERM):
158
178
                raise errors.LockFailed(self.filename, str(e))
159
179
            if e.errno != errno.ENOENT:
171
191
            self.f.close()
172
192
            self.f = None
173
193
 
174
 
    def __del__(self):
175
 
        if self.f:
176
 
            from warnings import warn
177
 
            warn("lock on %r not released" % self.f)
178
 
            self.unlock()
179
 
 
180
194
    def unlock(self):
181
195
        raise NotImplementedError()
182
196
 
192
206
            fcntl.lockf(self.f, fcntl.LOCK_UN)
193
207
            self._clear_f()
194
208
 
195
 
 
196
209
    class _fcntl_WriteLock(_fcntl_FileLock):
197
210
 
198
211
        _open_locks = set()
221
234
                # LOCK_NB will cause IOError to be raised if we can't grab a
222
235
                # lock right away.
223
236
                fcntl.lockf(self.f, fcntl.LOCK_EX | fcntl.LOCK_NB)
224
 
            except IOError, e:
 
237
            except IOError as e:
225
238
                if e.errno in (errno.EAGAIN, errno.EACCES):
226
239
                    # We couldn't grab the lock
227
240
                    self.unlock()
233
246
            _fcntl_WriteLock._open_locks.remove(self.filename)
234
247
            self._unlock()
235
248
 
236
 
 
237
249
    class _fcntl_ReadLock(_fcntl_FileLock):
238
250
 
239
251
        _open_locks = {}
256
268
                # LOCK_NB will cause IOError to be raised if we can't grab a
257
269
                # lock right away.
258
270
                fcntl.lockf(self.f, fcntl.LOCK_SH | fcntl.LOCK_NB)
259
 
            except IOError, e:
 
271
            except IOError as e:
260
272
                # we should be more precise about whats a locking
261
273
                # error and whats a random-other error
262
274
                raise errors.LockContention(self.filename, e)
281
293
            """
282
294
            if self.filename in _fcntl_WriteLock._open_locks:
283
295
                raise AssertionError('file already locked: %r'
284
 
                    % (self.filename,))
 
296
                                     % (self.filename,))
285
297
            try:
286
298
                wlock = _fcntl_TemporaryWriteLock(self)
287
299
            except errors.LockError:
289
301
                return False, self
290
302
            return True, wlock
291
303
 
292
 
 
293
304
    class _fcntl_TemporaryWriteLock(_OSLock):
294
305
        """A token used when grabbing a temporary_write_lock.
295
306
 
309
320
 
310
321
            if self.filename in _fcntl_WriteLock._open_locks:
311
322
                raise AssertionError('file already locked: %r'
312
 
                    % (self.filename,))
 
323
                                     % (self.filename,))
313
324
 
314
325
            # See if we can open the file for writing. Another process might
315
326
            # have a read lock. We don't use self._open() because we don't want
317
328
            # done by _fcntl_ReadLock
318
329
            try:
319
330
                new_f = open(self.filename, 'rb+')
320
 
            except IOError, e:
 
331
            except IOError as e:
321
332
                if e.errno in (errno.EACCES, errno.EPERM):
322
333
                    raise errors.LockFailed(self.filename, str(e))
323
334
                raise
325
336
                # LOCK_NB will cause IOError to be raised if we can't grab a
326
337
                # lock right away.
327
338
                fcntl.lockf(new_f, fcntl.LOCK_EX | fcntl.LOCK_NB)
328
 
            except IOError, e:
 
339
            except IOError as e:
329
340
                # TODO: Raise a more specific error based on the type of error
330
341
                raise errors.LockContention(self.filename, e)
331
342
            _fcntl_WriteLock._open_locks.add(self.filename)
334
345
 
335
346
        def restore_read_lock(self):
336
347
            """Restore the original ReadLock."""
337
 
            # For fcntl, since we never released the read lock, just release the
338
 
            # write lock, and return the original lock.
 
348
            # For fcntl, since we never released the read lock, just release
 
349
            # the write lock, and return the original lock.
339
350
            fcntl.lockf(self.f, fcntl.LOCK_UN)
340
351
            self._clear_f()
341
352
            _fcntl_WriteLock._open_locks.remove(self.filename)
344
355
            self._read_lock = None
345
356
            return read_lock
346
357
 
347
 
 
348
358
    _lock_classes.append(('fcntl', _fcntl_WriteLock, _fcntl_ReadLock))
349
359
 
350
360
 
351
361
if have_pywin32 and sys.platform == 'win32':
352
 
    if os.path.supports_unicode_filenames:
353
 
        # for Windows NT/2K/XP/etc
354
 
        win32file_CreateFile = win32file.CreateFileW
355
 
    else:
356
 
        # for Windows 98
357
 
        win32file_CreateFile = win32file.CreateFile
 
362
    win32file_CreateFile = win32file.CreateFileW
358
363
 
359
364
    class _w32c_FileLock(_OSLock):
360
365
 
361
366
        def _open(self, filename, access, share, cflags, pymode):
362
367
            self.filename = osutils.realpath(filename)
363
368
            try:
364
 
                self._handle = win32file_CreateFile(filename, access, share,
365
 
                    None, win32file.OPEN_ALWAYS,
 
369
                self._handle = win32file_CreateFile(
 
370
                    filename, access, share, None, win32file.OPEN_ALWAYS,
366
371
                    win32file.FILE_ATTRIBUTE_NORMAL, None)
367
 
            except pywintypes.error, e:
 
372
            except pywintypes.error as e:
368
373
                if e.args[0] == winerror.ERROR_ACCESS_DENIED:
369
374
                    raise errors.LockFailed(filename, e)
370
375
                if e.args[0] == winerror.ERROR_SHARING_VIOLATION:
378
383
            self._clear_f()
379
384
            self._handle = None
380
385
 
381
 
 
382
386
    class _w32c_ReadLock(_w32c_FileLock):
383
387
        def __init__(self, filename):
384
388
            super(_w32c_ReadLock, self).__init__()
385
389
            self._open(filename, win32file.GENERIC_READ,
386
 
                win32file.FILE_SHARE_READ, os.O_RDONLY, "rb")
 
390
                       win32file.FILE_SHARE_READ, os.O_RDONLY, "rb")
387
391
 
388
392
        def temporary_write_lock(self):
389
393
            """Try to grab a write lock on the file.
404
408
                return False, _w32c_ReadLock(self.filename)
405
409
            return True, wlock
406
410
 
407
 
 
408
411
    class _w32c_WriteLock(_w32c_FileLock):
409
412
        def __init__(self, filename):
410
413
            super(_w32c_WriteLock, self).__init__()
411
414
            self._open(filename,
412
 
                win32file.GENERIC_READ | win32file.GENERIC_WRITE, 0,
413
 
                os.O_RDWR, "rb+")
 
415
                       win32file.GENERIC_READ | win32file.GENERIC_WRITE, 0,
 
416
                       os.O_RDWR, "rb+")
414
417
 
415
418
        def restore_read_lock(self):
416
419
            """Restore the original ReadLock."""
419
422
            self.unlock()
420
423
            return _w32c_ReadLock(self.filename)
421
424
 
422
 
 
423
425
    _lock_classes.append(('pywin32', _w32c_WriteLock, _w32c_ReadLock))
424
426
 
425
427
 
426
428
if have_ctypes_win32:
427
 
    from ctypes.wintypes import DWORD, LPCSTR, LPCWSTR
428
 
    LPSECURITY_ATTRIBUTES = ctypes.c_void_p # used as NULL no need to declare
429
 
    HANDLE = ctypes.c_int # rather than unsigned as in ctypes.wintypes
430
 
    if os.path.supports_unicode_filenames:
431
 
        _function_name = "CreateFileW"
432
 
        LPTSTR = LPCWSTR
433
 
    else:
434
 
        _function_name = "CreateFileA"
435
 
        class LPTSTR(LPCSTR):
436
 
            def __new__(cls, obj):
437
 
                return LPCSTR.__new__(cls, obj.encode("mbcs"))
 
429
    from ctypes.wintypes import DWORD, LPWSTR
 
430
    LPSECURITY_ATTRIBUTES = ctypes.c_void_p  # used as NULL no need to declare
 
431
    HANDLE = ctypes.c_int  # rather than unsigned as in ctypes.wintypes
 
432
    _function_name = "CreateFileW"
438
433
 
439
434
    # CreateFile <http://msdn.microsoft.com/en-us/library/aa363858.aspx>
440
435
    _CreateFile = ctypes.WINFUNCTYPE(
441
 
            HANDLE,                # return value
442
 
            LPTSTR,                # lpFileName
443
 
            DWORD,                 # dwDesiredAccess
444
 
            DWORD,                 # dwShareMode
445
 
            LPSECURITY_ATTRIBUTES, # lpSecurityAttributes
446
 
            DWORD,                 # dwCreationDisposition
447
 
            DWORD,                 # dwFlagsAndAttributes
448
 
            HANDLE                 # hTemplateFile
 
436
        HANDLE,                # return value
 
437
        LPWSTR,                # lpFileName
 
438
        DWORD,                 # dwDesiredAccess
 
439
        DWORD,                 # dwShareMode
 
440
        LPSECURITY_ATTRIBUTES,  # lpSecurityAttributes
 
441
        DWORD,                 # dwCreationDisposition
 
442
        DWORD,                 # dwFlagsAndAttributes
 
443
        HANDLE                 # hTemplateFile
449
444
        )((_function_name, ctypes.windll.kernel32))
450
445
 
451
446
    INVALID_HANDLE_VALUE = -1
464
459
        def _open(self, filename, access, share, cflags, pymode):
465
460
            self.filename = osutils.realpath(filename)
466
461
            handle = _CreateFile(filename, access, share, None, OPEN_ALWAYS,
467
 
                FILE_ATTRIBUTE_NORMAL, 0)
 
462
                                 FILE_ATTRIBUTE_NORMAL, 0)
468
463
            if handle in (INVALID_HANDLE_VALUE, 0):
469
464
                e = ctypes.WinError()
470
465
                if e.args[0] == ERROR_ACCESS_DENIED:
479
474
        def unlock(self):
480
475
            self._clear_f()
481
476
 
482
 
 
483
477
    class _ctypes_ReadLock(_ctypes_FileLock):
484
478
        def __init__(self, filename):
485
479
            super(_ctypes_ReadLock, self).__init__()
486
480
            self._open(filename, GENERIC_READ, FILE_SHARE_READ, os.O_RDONLY,
487
 
                "rb")
 
481
                       "rb")
488
482
 
489
483
        def temporary_write_lock(self):
490
484
            """Try to grab a write lock on the file.
509
503
        def __init__(self, filename):
510
504
            super(_ctypes_WriteLock, self).__init__()
511
505
            self._open(filename, GENERIC_READ | GENERIC_WRITE, 0, os.O_RDWR,
512
 
                "rb+")
 
506
                       "rb+")
513
507
 
514
508
        def restore_read_lock(self):
515
509
            """Restore the original ReadLock."""
518
512
            self.unlock()
519
513
            return _ctypes_ReadLock(self.filename)
520
514
 
521
 
 
522
515
    _lock_classes.append(('ctypes', _ctypes_WriteLock, _ctypes_ReadLock))
523
516
 
524
517
 
541
534
    locked the same way), and -Drelock is set, then this will trace.note a
542
535
    message about it.
543
536
    """
544
 
    
 
537
 
545
538
    _prev_lock = None
546
539
 
547
540
    def _note_lock(self, lock_type):
550
543
                type_name = 'read'
551
544
            else:
552
545
                type_name = 'write'
553
 
            trace.note('%r was %s locked again', self, type_name)
 
546
            trace.note(gettext('{0!r} was {1} locked again'), self, type_name)
554
547
        self._prev_lock = lock_type
555
548
 
 
549
 
 
550
@contextlib.contextmanager
 
551
def write_locked(lockable):
 
552
    lockable.lock_write()
 
553
    try:
 
554
        yield lockable
 
555
    finally:
 
556
        lockable.unlock()