← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/lockable_files.py

(mbp) merge bzr.dev to 0.8, prepare for release

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/lockable_files.py
21
21
import bzrlib
22
22
from bzrlib.decorators import *
23
23
import bzrlib.errors as errors
24
 
from bzrlib.errors import LockError, ReadOnlyError
 
24
from bzrlib.errors import BzrError
25
25
from bzrlib.osutils import file_iterator, safe_unicode
26
26
from bzrlib.symbol_versioning import *
27
27
from bzrlib.trace import mutter, note
91
91
        This should normally be called only when the LockableFiles directory
92
92
        is first created on disk.
93
93
        """
94
 
        self._lock.create()
 
94
        self._lock.create(mode=self._dir_mode)
95
95
 
96
96
    def __repr__(self):
97
97
        return '%s(%r)' % (self.__class__.__name__,
107
107
            warn("file group %r was not explicitly unlocked" % self)
108
108
            self._lock.unlock()
109
109
 
 
110
    def break_lock(self):
 
111
        """Break the lock of this lockable files group if it is held.
 
112
 
 
113
        The current ui factory will be used to prompt for user conformation.
 
114
        """
 
115
        self._lock.break_lock()
 
116
 
110
117
    def _escape(self, file_or_path):
111
118
        if not isinstance(file_or_path, basestring):
112
119
            file_or_path = '/'.join(file_or_path)
208
215
        # and potentially a remote locking protocol
209
216
        if self._lock_mode:
210
217
            if self._lock_mode != 'w' or not self.get_transaction().writeable():
211
 
                raise ReadOnlyError(self)
 
218
                raise errors.ReadOnlyError(self)
212
219
            self._lock_count += 1
213
220
        else:
214
221
            self._lock.lock_write()
244
251
            #note('unlocking %s', self)
245
252
            #traceback.print_stack()
246
253
            self._finish_transaction()
247
 
            self._lock.unlock()
248
 
            self._lock_mode = self._lock_count = None
 
254
            try:
 
255
                self._lock.unlock()
 
256
            finally:
 
257
                self._lock_mode = self._lock_count = None
249
258
 
250
259
    def is_locked(self):
251
260
        """Return true if this LockableFiles group is locked"""
252
261
        return self._lock_count >= 1
253
262
 
 
263
    def get_physical_lock_status(self):
 
264
        """Return physical lock status.
 
265
        
 
266
        Returns true if a lock is held on the transport. If no lock is held, or
 
267
        the underlying locking mechanism does not support querying lock
 
268
        status, false is returned.
 
269
        """
 
270
        try:
 
271
            return self._lock.peek() is not None
 
272
        except NotImplementedError:
 
273
            return False
 
274
 
254
275
    def get_transaction(self):
255
276
        """Return the current active transaction.
256
277
 
296
317
        self._file_modebits = file_modebits
297
318
        self._dir_modebits = dir_modebits
298
319
 
 
320
    def break_lock(self):
 
321
        raise NotImplementedError(self.break_lock)
 
322
 
299
323
    def lock_write(self):
300
324
        self._lock = self._transport.lock_write(self._escaped_name)
301
325
 
306
330
        self._lock.unlock()
307
331
        self._lock = None
308
332
 
309
 
    def create(self):
 
333
    def peek(self):
 
334
        raise NotImplementedError()
 
335
 
 
336
    def create(self, mode=None):
310
337
        """Create lock mechanism"""
311
338
        # for old-style locks, create the file now
312
339
        self._transport.put(self._escaped_name, StringIO(),