← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/lockable_files.py

  • Committer: Robert Collins
  • Date: 2007-04-23 02:29:35 UTC
  • mfrom: (2441 +trunk)
  • mto: This revision was merged to the branch mainline in revision 2442.
  • Revision ID: robertc@robertcollins.net-20070423022935-9hhongamvk6bfdso
Resolve conflicts with bzr.dev.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/lockable_files.py
222
222
            raise errors.BzrBadParameterNotString(a_string)
223
223
        self.put_bytes(path, a_string.encode('utf-8'))
224
224
 
225
 
    def lock_write(self):
 
225
    def leave_in_place(self):
 
226
        """Set this LockableFiles to not clear the physical lock on unlock."""
 
227
        self._lock.leave_in_place()
 
228
 
 
229
    def dont_leave_in_place(self):
 
230
        """Set this LockableFiles to clear the physical lock on unlock."""
 
231
        self._lock.dont_leave_in_place()
 
232
 
 
233
    def lock_write(self, token=None):
 
234
        """Lock this group of files for writing.
 
235
        
 
236
        :param token: if this is already locked, then lock_write will fail
 
237
            unless the token matches the existing lock.
 
238
        :returns: a token if this instance supports tokens, otherwise None.
 
239
        :raises TokenLockingNotSupported: when a token is given but this
 
240
            instance doesn't support using token locks.
 
241
        :raises MismatchedToken: if the specified token doesn't match the token
 
242
            of the existing lock.
 
243
 
 
244
        A token should be passed in if you know that you have locked the object
 
245
        some other way, and need to synchronise this object's state with that
 
246
        fact.
 
247
        """
226
248
        # mutter("lock write: %s (%s)", self, self._lock_count)
227
249
        # TODO: Upgrade locking to support using a Transport,
228
250
        # and potentially a remote locking protocol
229
251
        if self._lock_mode:
230
252
            if self._lock_mode != 'w' or not self.get_transaction().writeable():
231
253
                raise errors.ReadOnlyError(self)
 
254
            self._lock.validate_token(token)
232
255
            self._lock_count += 1
 
256
            return self._token_from_lock
233
257
        else:
234
 
            self._lock.lock_write()
 
258
            token_from_lock = self._lock.lock_write(token=token)
235
259
            #note('write locking %s', self)
236
260
            #traceback.print_stack()
237
261
            self._lock_mode = 'w'
238
262
            self._lock_count = 1
239
263
            self._set_transaction(transactions.WriteTransaction())
 
264
            self._token_from_lock = token_from_lock
 
265
            return token_from_lock
240
266
 
241
267
    def lock_read(self):
242
268
        # mutter("lock read: %s (%s)", self, self._lock_count)
333
359
    def break_lock(self):
334
360
        raise NotImplementedError(self.break_lock)
335
361
 
336
 
    def lock_write(self):
 
362
    def leave_in_place(self):
 
363
        raise NotImplementedError(self.leave_in_place)
 
364
 
 
365
    def dont_leave_in_place(self):
 
366
        raise NotImplementedError(self.dont_leave_in_place)
 
367
 
 
368
    def lock_write(self, token=None):
 
369
        if token is not None:
 
370
            raise errors.TokenLockingNotSupported(self)
337
371
        self._lock = self._transport.lock_write(self._escaped_name)
338
372
 
339
373
    def lock_read(self):
351
385
        # for old-style locks, create the file now
352
386
        self._transport.put_bytes(self._escaped_name, '',
353
387
                            mode=self._file_modebits)
 
388
 
 
389
    def validate_token(self, token):
 
390
        if token is not None:
 
391
            raise errors.TokenLockingNotSupported(self)
 
392