195
184
if self.transport.is_readonly():
196
185
raise UnlockableTransport(self.transport)
197
self._trace("create lock directory")
198
186
self.transport.mkdir(self.path, mode=mode)
200
def _attempt_lock(self):
201
"""Make the pending directory and attempt to rename into place.
188
def attempt_lock(self):
189
"""Take the lock; fail if it's already held.
203
If the rename succeeds, we read back the info file to check that we
206
If we fail to acquire the lock, this method is responsible for
207
cleaning up the pending directory if possible. (But it doesn't do
210
:returns: The nonce of the lock, if it was successfully acquired.
212
:raises LockContention: If the lock is held by someone else. The exception
213
contains the info of the current holder of the lock.
191
If you wish to block until the lock can be obtained, call wait_lock()
215
self._trace("lock_write...")
216
start_time = time.time()
217
tmpname = self._create_pending_dir()
194
if self._fake_read_lock:
195
raise LockContention(self)
196
if self.transport.is_readonly():
197
raise UnlockableTransport(self.transport)
199
tmpname = '%s/pending.%s.tmp' % (self.path, rand_chars(20))
201
self.transport.mkdir(tmpname)
203
# This may raise a FileExists exception
204
# which is okay, it will be caught later and determined
205
# to be a LockContention.
206
self.create(mode=self._dir_modebits)
208
# After creating the lock directory, try again
209
self.transport.mkdir(tmpname)
211
info_bytes = self._prepare_info()
212
# We use put_file_non_atomic because we just created a new unique
213
# directory so we don't have to worry about files existing there.
214
# We'll rename the whole directory into place to get atomic
216
self.transport.put_bytes_non_atomic(tmpname + self.__INFO_NAME,
219
219
self.transport.rename(tmpname, self._held_dir)
220
self._lock_held = True
220
222
except (PathError, DirectoryNotEmpty, FileExists, ResourceBusy), e:
221
self._trace("... contention, %s", e)
222
self._remove_pending_dir(tmpname)
223
raise LockContention(self)
225
self._trace("... lock failed, %s", e)
226
self._remove_pending_dir(tmpname)
228
# We must check we really got the lock, because Launchpad's sftp
229
# server at one time had a bug were the rename would successfully
230
# move the new directory into the existing directory, which was
231
# incorrect. It's possible some other servers or filesystems will
232
# have a similar bug allowing someone to think they got the lock
233
# when it's already held.
235
self._trace("after locking, info=%r", info)
236
if info['nonce'] != self.nonce:
237
self._trace("rename succeeded, "
238
"but lock is still held by someone else")
239
raise LockContention(self)
240
self._lock_held = True
241
self._trace("... lock succeeded after %dms",
242
(time.time() - start_time) * 1000)
245
def _remove_pending_dir(self, tmpname):
246
"""Remove the pending directory
248
This is called if we failed to rename into place, so that the pending
249
dirs don't clutter up the lockdir.
251
self._trace("remove %s", tmpname)
253
self.transport.delete(tmpname + self.__INFO_NAME)
254
self.transport.rmdir(tmpname)
256
note("error removing pending lock: %s", e)
258
def _create_pending_dir(self):
259
tmpname = '%s/%s.tmp' % (self.path, rand_chars(10))
261
self.transport.mkdir(tmpname)
263
# This may raise a FileExists exception
264
# which is okay, it will be caught later and determined
265
# to be a LockContention.
266
self._trace("lock directory does not exist, creating it")
267
self.create(mode=self._dir_modebits)
268
# After creating the lock directory, try again
269
self.transport.mkdir(tmpname)
270
self.nonce = rand_chars(20)
271
info_bytes = self._prepare_info()
272
# We use put_file_non_atomic because we just created a new unique
273
# directory so we don't have to worry about files existing there.
274
# We'll rename the whole directory into place to get atomic
276
self.transport.put_bytes_non_atomic(tmpname + self.__INFO_NAME,
223
mutter("contention on %r: %s", self, e)
224
raise LockContention(self)
280
226
def unlock(self):
281
227
"""Release a held lock
286
232
if not self._lock_held:
287
233
raise LockNotHeld(self)
288
if self._locked_via_token:
289
self._locked_via_token = False
290
self._lock_held = False
292
# rename before deleting, because we can't atomically remove the
294
start_time = time.time()
295
self._trace("unlocking")
296
tmpname = '%s/releasing.%s.tmp' % (self.path, rand_chars(20))
297
# gotta own it to unlock
299
self.transport.rename(self._held_dir, tmpname)
300
self._lock_held = False
301
self.transport.delete(tmpname + self.__INFO_NAME)
303
self.transport.rmdir(tmpname)
304
except DirectoryNotEmpty, e:
305
# There might have been junk left over by a rename that moved
306
# another locker within the 'held' directory. do a slower
307
# deletion where we list the directory and remove everything
310
# Maybe this should be broader to allow for ftp servers with
311
# non-specific error messages?
312
self._trace("doing recursive deletion of non-empty directory "
314
self.transport.delete_tree(tmpname)
315
self._trace("... unlock succeeded after %dms",
316
(time.time() - start_time) * 1000)
234
# rename before deleting, because we can't atomically remove the whole
236
tmpname = '%s/releasing.%s.tmp' % (self.path, rand_chars(20))
237
# gotta own it to unlock
239
self.transport.rename(self._held_dir, tmpname)
240
self._lock_held = False
241
self.transport.delete(tmpname + self.__INFO_NAME)
242
self.transport.rmdir(tmpname)
318
244
def break_lock(self):
319
245
"""Break a lock not held by this instance of LockDir.
435
360
def _parse_info(self, info_file):
436
361
return read_stanza(info_file.readlines()).as_dict()
438
def attempt_lock(self):
439
"""Take the lock; fail if it's already held.
441
If you wish to block until the lock can be obtained, call wait_lock()
444
:return: The lock token.
445
:raises LockContention: if the lock is held by someone else.
447
if self._fake_read_lock:
448
raise LockContention(self)
449
if self.transport.is_readonly():
450
raise UnlockableTransport(self.transport)
451
return self._attempt_lock()
453
def wait_lock(self, timeout=None, poll=None, max_attempts=None):
363
def wait_lock(self, timeout=None, poll=None):
454
364
"""Wait a certain period for a lock.
456
366
If the lock can be acquired within the bounded time, it
458
368
is raised. Either way, this function should return within
459
369
approximately `timeout` seconds. (It may be a bit more if
460
370
a transport operation takes a long time to complete.)
462
:param timeout: Approximate maximum amount of time to wait for the
465
:param poll: Delay in seconds between retrying the lock.
467
:param max_attempts: Maximum number of times to try to lock.
469
:return: The lock token.
471
372
if timeout is None:
472
373
timeout = _DEFAULT_TIMEOUT_SECONDS
474
375
poll = _DEFAULT_POLL_SECONDS
475
# XXX: the transport interface doesn't let us guard against operations
476
# there taking a long time, so the total elapsed time or poll interval
477
# may be more than was requested.
377
# XXX: the transport interface doesn't let us guard
378
# against operations there taking a long time.
478
379
deadline = time.time() + timeout
479
380
deadline_str = None
485
return self.attempt_lock()
486
386
except LockContention:
487
# possibly report the blockage, then try again
489
# TODO: In a few cases, we find out that there's contention by
490
# reading the held info and observing that it's not ours. In
491
# those cases it's a bit redundant to read it again. However,
492
# the normal case (??) is that the rename fails and so we
493
# don't know who holds the lock. For simplicity we peek
495
388
new_info = self.peek()
389
mutter('last_info: %s, new info: %s', last_info, new_info)
496
390
if new_info is not None and new_info != last_info:
497
391
if last_info is None:
498
392
start = 'Unable to obtain'
513
407
formatted_info[2],
516
if (max_attempts is not None) and (attempt_count >= max_attempts):
517
self._trace("exceeded %d attempts")
518
raise LockContention(self)
519
410
if time.time() + poll < deadline:
520
self._trace("waiting %ss", poll)
523
self._trace("timeout after waiting %ss", timeout)
524
413
raise LockContention(self)
526
def leave_in_place(self):
527
self._locked_via_token = True
529
def dont_leave_in_place(self):
530
self._locked_via_token = False
532
def lock_write(self, token=None):
533
"""Wait for and acquire the lock.
535
:param token: if this is already locked, then lock_write will fail
536
unless the token matches the existing lock.
537
:returns: a token if this instance supports tokens, otherwise None.
538
:raises TokenLockingNotSupported: when a token is given but this
539
instance doesn't support using token locks.
540
:raises MismatchedToken: if the specified token doesn't match the token
541
of the existing lock.
543
A token should be passed in if you know that you have locked the object
544
some other way, and need to synchronise this object's state with that
547
XXX: docstring duplicated from LockableFiles.lock_write.
549
if token is not None:
550
self.validate_token(token)
552
self._lock_held = True
553
self._locked_via_token = True
556
return self.wait_lock()
415
def lock_write(self):
416
"""Wait for and acquire the lock."""
558
419
def lock_read(self):
559
420
"""Compatibility-mode shared lock.
added
removed
bzrlib/lockdir.py
