/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: Martin
  • Date: 2017-06-05 20:48:31 UTC
  • mto: This revision was merged to the branch mainline in revision 6658.
  • Revision ID: gzlist@googlemail.com-20170605204831-20accykspjcrx0a8
Apply 2to3 dict fixer and clean up resulting mess using view helpers

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
49
 
 
 
50
from .hooks import Hooks
 
51
from .i18n import gettext
50
52
 
51
53
class LockHooks(Hooks):
52
54
 
53
55
    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))
 
56
        Hooks.__init__(self, "breezy.lock", "Lock.hooks")
 
57
        self.add_hook('lock_acquired',
 
58
            "Called with a breezy.lock.LockResult when a physical lock is "
 
59
            "acquired.", (1, 8))
 
60
        self.add_hook('lock_released',
 
61
            "Called with a breezy.lock.LockResult when a physical lock is "
 
62
            "released.", (1, 8))
 
63
        self.add_hook('lock_broken',
 
64
            "Called with a breezy.lock.LockResult when a physical lock is "
 
65
            "broken.", (1, 15))
64
66
 
65
67
 
66
68
class Lock(object):
153
155
        try:
154
156
            self.f = open(self.filename, filemode)
155
157
            return self.f
156
 
        except IOError, e:
 
158
        except IOError as e:
157
159
            if e.errno in (errno.EACCES, errno.EPERM):
158
160
                raise errors.LockFailed(self.filename, str(e))
159
161
            if e.errno != errno.ENOENT:
171
173
            self.f.close()
172
174
            self.f = None
173
175
 
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
176
    def unlock(self):
181
177
        raise NotImplementedError()
182
178
 
221
217
                # LOCK_NB will cause IOError to be raised if we can't grab a
222
218
                # lock right away.
223
219
                fcntl.lockf(self.f, fcntl.LOCK_EX | fcntl.LOCK_NB)
224
 
            except IOError, e:
 
220
            except IOError as e:
225
221
                if e.errno in (errno.EAGAIN, errno.EACCES):
226
222
                    # We couldn't grab the lock
227
223
                    self.unlock()
256
252
                # LOCK_NB will cause IOError to be raised if we can't grab a
257
253
                # lock right away.
258
254
                fcntl.lockf(self.f, fcntl.LOCK_SH | fcntl.LOCK_NB)
259
 
            except IOError, e:
 
255
            except IOError as e:
260
256
                # we should be more precise about whats a locking
261
257
                # error and whats a random-other error
262
258
                raise errors.LockContention(self.filename, e)
317
313
            # done by _fcntl_ReadLock
318
314
            try:
319
315
                new_f = open(self.filename, 'rb+')
320
 
            except IOError, e:
 
316
            except IOError as e:
321
317
                if e.errno in (errno.EACCES, errno.EPERM):
322
318
                    raise errors.LockFailed(self.filename, str(e))
323
319
                raise
325
321
                # LOCK_NB will cause IOError to be raised if we can't grab a
326
322
                # lock right away.
327
323
                fcntl.lockf(new_f, fcntl.LOCK_EX | fcntl.LOCK_NB)
328
 
            except IOError, e:
 
324
            except IOError as e:
329
325
                # TODO: Raise a more specific error based on the type of error
330
326
                raise errors.LockContention(self.filename, e)
331
327
            _fcntl_WriteLock._open_locks.add(self.filename)
364
360
                self._handle = win32file_CreateFile(filename, access, share,
365
361
                    None, win32file.OPEN_ALWAYS,
366
362
                    win32file.FILE_ATTRIBUTE_NORMAL, None)
367
 
            except pywintypes.error, e:
 
363
            except pywintypes.error as e:
368
364
                if e.args[0] == winerror.ERROR_ACCESS_DENIED:
369
365
                    raise errors.LockFailed(filename, e)
370
366
                if e.args[0] == winerror.ERROR_SHARING_VIOLATION:
541
537
    locked the same way), and -Drelock is set, then this will trace.note a
542
538
    message about it.
543
539
    """
544
 
    
 
540
 
545
541
    _prev_lock = None
546
542
 
547
543
    def _note_lock(self, lock_type):
550
546
                type_name = 'read'
551
547
            else:
552
548
                type_name = 'write'
553
 
            trace.note('%r was %s locked again', self, type_name)
 
549
            trace.note(gettext('{0!r} was {1} locked again'), self, type_name)
554
550
        self._prev_lock = lock_type
555
551
 
 
552
@contextlib.contextmanager
 
553
def write_locked(lockable):
 
554
    lockable.lock_write()
 
555
    try:
 
556
        yield lockable
 
557
    finally:
 
558
        lockable.unlock()