← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/lock.py

  • Committer: John Arbash Meinel
  • Date: 2010-08-13 19:08:57 UTC
  • mto: (5050.17.7 2.2)
  • mto: This revision was merged to the branch mainline in revision 5379.
  • Revision ID: john@arbash-meinel.com-20100813190857-mvzwnimrxvm0zimp
Lots of documentation updates.

We had a lot of http links pointing to the old domain. They should
all now be properly updated to the new domain. (only bazaar-vcs.org
entry left is for pqm, which seems to still reside at the old url.)

Also removed one 'TODO' doc entry about switching to binary xdelta, since
we basically did just that with groupcompress.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/lock.py
1
 
# Copyright (C) 2005, 2006, 2007, 2008, 2009 Canonical Ltd
 
1
# Copyright (C) 2005-2010 Canonical Ltd
2
2
#
3
3
# This program is free software; you can redistribute it and/or modify
4
4
# it under the terms of the GNU General Public License as published by
84
84
        return self.lock_url == other.lock_url and self.details == other.details
85
85
 
86
86
    def __repr__(self):
87
 
        return '%s(%s%s)' % (self.__class__.__name__,
 
87
        return '%s(%s, %s)' % (self.__class__.__name__,
88
88
                             self.lock_url, self.details)
89
89
 
90
90
 
 
91
class LogicalLockResult(object):
 
92
    """The result of a lock_read/lock_write/lock_tree_write call on lockables.
 
93
 
 
94
    :ivar unlock: A callable which will unlock the lock.
 
95
    """
 
96
 
 
97
    def __init__(self, unlock):
 
98
        self.unlock = unlock
 
99
 
 
100
    def __repr__(self):
 
101
        return "LogicalLockResult(%s)" % (self.unlock)
 
102
 
 
103
 
 
104
 
91
105
def cant_unlock_not_held(locked_object):
92
106
    """An attempt to unlock failed because the object was not locked.
93
107
 
190
204
            if self.filename in _fcntl_WriteLock._open_locks:
191
205
                self._clear_f()
192
206
                raise errors.LockContention(self.filename)
 
207
            if self.filename in _fcntl_ReadLock._open_locks:
 
208
                if 'strict_locks' in debug.debug_flags:
 
209
                    self._clear_f()
 
210
                    raise errors.LockContention(self.filename)
 
211
                else:
 
212
                    trace.mutter('Write lock taken w/ an open read lock on: %s'
 
213
                                 % (self.filename,))
193
214
 
194
215
            self._open(self.filename, 'rb+')
195
216
            # reserve a slot for this lock - even if the lockf call fails,
196
 
            # at thisi point unlock() will be called, because self.f is set.
 
217
            # at this point unlock() will be called, because self.f is set.
197
218
            # TODO: make this fully threadsafe, if we decide we care.
198
219
            _fcntl_WriteLock._open_locks.add(self.filename)
199
220
            try:
220
241
        def __init__(self, filename):
221
242
            super(_fcntl_ReadLock, self).__init__()
222
243
            self.filename = osutils.realpath(filename)
 
244
            if self.filename in _fcntl_WriteLock._open_locks:
 
245
                if 'strict_locks' in debug.debug_flags:
 
246
                    # We raise before calling _open so we don't need to
 
247
                    # _clear_f
 
248
                    raise errors.LockContention(self.filename)
 
249
                else:
 
250
                    trace.mutter('Read lock taken w/ an open write lock on: %s'
 
251
                                 % (self.filename,))
223
252
            _fcntl_ReadLock._open_locks.setdefault(self.filename, 0)
224
253
            _fcntl_ReadLock._open_locks[self.filename] += 1
225
254
            self._open(filename, 'rb')
418
447
            DWORD,                 # dwFlagsAndAttributes
419
448
            HANDLE                 # hTemplateFile
420
449
        )((_function_name, ctypes.windll.kernel32))
421
 
    
 
450
 
422
451
    INVALID_HANDLE_VALUE = -1
423
 
    
 
452
 
424
453
    GENERIC_READ = 0x80000000
425
454
    GENERIC_WRITE = 0x40000000
426
455
    FILE_SHARE_READ = 1
427
456
    OPEN_ALWAYS = 4
428
457
    FILE_ATTRIBUTE_NORMAL = 128
429
 
    
 
458
 
430
459
    ERROR_ACCESS_DENIED = 5
431
460
    ERROR_SHARING_VIOLATION = 32
432
461
 
503
532
# We default to using the first available lock class.
504
533
_lock_type, WriteLock, ReadLock = _lock_classes[0]
505
534
 
 
535
 
 
536
class _RelockDebugMixin(object):
 
537
    """Mixin support for -Drelock flag.
 
538
 
 
539
    Add this as a base class then call self._note_lock with 'r' or 'w' when
 
540
    acquiring a read- or write-lock.  If this object was previously locked (and
 
541
    locked the same way), and -Drelock is set, then this will trace.note a
 
542
    message about it.
 
543
    """
 
544
    
 
545
    _prev_lock = None
 
546
 
 
547
    def _note_lock(self, lock_type):
 
548
        if 'relock' in debug.debug_flags and self._prev_lock == lock_type:
 
549
            if lock_type == 'r':
 
550
                type_name = 'read'
 
551
            else:
 
552
                type_name = 'write'
 
553
            trace.note('%r was %s locked again', self, type_name)
 
554
        self._prev_lock = lock_type
 
555