194
182
This is typically only called when the object/directory containing the
195
183
directory is first created. The lock is not held when it's created.
197
self._trace("create lock directory")
199
self.transport.mkdir(self.path, mode=mode)
200
except (TransportError, PathError), e:
201
raise LockFailed(self, e)
204
def _attempt_lock(self):
205
"""Make the pending directory and attempt to rename into place.
185
if self.transport.is_readonly():
186
raise UnlockableTransport(self.transport)
187
self.transport.mkdir(self.path, mode=mode)
189
def attempt_lock(self):
190
"""Take the lock; fail if it's already held.
207
If the rename succeeds, we read back the info file to check that we
210
If we fail to acquire the lock, this method is responsible for
211
cleaning up the pending directory if possible. (But it doesn't do
214
:returns: The nonce of the lock, if it was successfully acquired.
216
:raises LockContention: If the lock is held by someone else. The exception
217
contains the info of the current holder of the lock.
192
If you wish to block until the lock can be obtained, call wait_lock()
219
self._trace("lock_write...")
220
start_time = time.time()
222
tmpname = self._create_pending_dir()
223
except (errors.TransportError, PathError), e:
224
self._trace("... failed to create pending dir, %s", e)
225
raise LockFailed(self, e)
195
if self._fake_read_lock:
196
raise LockContention(self)
197
if self.transport.is_readonly():
198
raise UnlockableTransport(self.transport)
200
tmpname = '%s/pending.%s.tmp' % (self.path, rand_chars(20))
202
self.transport.mkdir(tmpname)
204
# This may raise a FileExists exception
205
# which is okay, it will be caught later and determined
206
# to be a LockContention.
207
self.create(mode=self._dir_modebits)
209
# After creating the lock directory, try again
210
self.transport.mkdir(tmpname)
212
info_bytes = self._prepare_info()
213
# We use put_file_non_atomic because we just created a new unique
214
# directory so we don't have to worry about files existing there.
215
# We'll rename the whole directory into place to get atomic
217
self.transport.put_bytes_non_atomic(tmpname + self.__INFO_NAME,
227
220
self.transport.rename(tmpname, self._held_dir)
228
except (errors.TransportError, PathError, DirectoryNotEmpty,
229
FileExists, ResourceBusy), e:
230
self._trace("... contention, %s", e)
231
self._remove_pending_dir(tmpname)
232
raise LockContention(self)
234
self._trace("... lock failed, %s", e)
235
self._remove_pending_dir(tmpname)
237
# We must check we really got the lock, because Launchpad's sftp
238
# server at one time had a bug were the rename would successfully
239
# move the new directory into the existing directory, which was
240
# incorrect. It's possible some other servers or filesystems will
241
# have a similar bug allowing someone to think they got the lock
242
# when it's already held.
244
self._trace("after locking, info=%r", info)
245
if info['nonce'] != self.nonce:
246
self._trace("rename succeeded, "
247
"but lock is still held by someone else")
248
raise LockContention(self)
249
self._lock_held = True
250
self._trace("... lock succeeded after %dms",
251
(time.time() - start_time) * 1000)
254
def _remove_pending_dir(self, tmpname):
255
"""Remove the pending directory
257
This is called if we failed to rename into place, so that the pending
258
dirs don't clutter up the lockdir.
260
self._trace("remove %s", tmpname)
262
self.transport.delete(tmpname + self.__INFO_NAME)
263
self.transport.rmdir(tmpname)
265
note("error removing pending lock: %s", e)
267
def _create_pending_dir(self):
268
tmpname = '%s/%s.tmp' % (self.path, rand_chars(10))
270
self.transport.mkdir(tmpname)
272
# This may raise a FileExists exception
273
# which is okay, it will be caught later and determined
274
# to be a LockContention.
275
self._trace("lock directory does not exist, creating it")
276
self.create(mode=self._dir_modebits)
277
# After creating the lock directory, try again
278
self.transport.mkdir(tmpname)
279
self.nonce = rand_chars(20)
280
info_bytes = self._prepare_info()
281
# We use put_file_non_atomic because we just created a new unique
282
# directory so we don't have to worry about files existing there.
283
# We'll rename the whole directory into place to get atomic
285
self.transport.put_bytes_non_atomic(tmpname + self.__INFO_NAME,
221
self._lock_held = True
223
except (PathError, DirectoryNotEmpty, FileExists, ResourceBusy), e:
224
mutter("contention on %r: %s", self, e)
225
raise LockContention(self)
289
227
def unlock(self):
290
228
"""Release a held lock
295
233
if not self._lock_held:
296
234
raise LockNotHeld(self)
297
if self._locked_via_token:
298
self._locked_via_token = False
299
self._lock_held = False
301
# rename before deleting, because we can't atomically remove the
303
start_time = time.time()
304
self._trace("unlocking")
305
tmpname = '%s/releasing.%s.tmp' % (self.path, rand_chars(20))
306
# gotta own it to unlock
308
self.transport.rename(self._held_dir, tmpname)
309
self._lock_held = False
310
self.transport.delete(tmpname + self.__INFO_NAME)
312
self.transport.rmdir(tmpname)
313
except DirectoryNotEmpty, e:
314
# There might have been junk left over by a rename that moved
315
# another locker within the 'held' directory. do a slower
316
# deletion where we list the directory and remove everything
319
# Maybe this should be broader to allow for ftp servers with
320
# non-specific error messages?
321
self._trace("doing recursive deletion of non-empty directory "
323
self.transport.delete_tree(tmpname)
324
self._trace("... unlock succeeded after %dms",
325
(time.time() - start_time) * 1000)
235
# rename before deleting, because we can't atomically remove the whole
237
tmpname = '%s/releasing.%s.tmp' % (self.path, rand_chars(20))
238
# gotta own it to unlock
240
self.transport.rename(self._held_dir, tmpname)
241
self._lock_held = False
242
self.transport.delete(tmpname + self.__INFO_NAME)
243
self.transport.rmdir(tmpname)
327
245
def break_lock(self):
328
246
"""Break a lock not held by this instance of LockDir.
465
369
is raised. Either way, this function should return within
466
370
approximately `timeout` seconds. (It may be a bit more if
467
371
a transport operation takes a long time to complete.)
469
:param timeout: Approximate maximum amount of time to wait for the
472
:param poll: Delay in seconds between retrying the lock.
474
:param max_attempts: Maximum number of times to try to lock.
476
:return: The lock token.
478
373
if timeout is None:
479
374
timeout = _DEFAULT_TIMEOUT_SECONDS
481
376
poll = _DEFAULT_POLL_SECONDS
482
# XXX: the transport interface doesn't let us guard against operations
483
# there taking a long time, so the total elapsed time or poll interval
484
# may be more than was requested.
378
# XXX: the transport interface doesn't let us guard
379
# against operations there taking a long time.
485
380
deadline = time.time() + timeout
486
381
deadline_str = None
492
return self.attempt_lock()
493
387
except LockContention:
494
# possibly report the blockage, then try again
496
# TODO: In a few cases, we find out that there's contention by
497
# reading the held info and observing that it's not ours. In
498
# those cases it's a bit redundant to read it again. However,
499
# the normal case (??) is that the rename fails and so we
500
# don't know who holds the lock. For simplicity we peek
502
389
new_info = self.peek()
390
mutter('last_info: %s, new info: %s', last_info, new_info)
503
391
if new_info is not None and new_info != last_info:
504
392
if last_info is None:
505
393
start = 'Unable to obtain'
520
408
formatted_info[2],
523
if (max_attempts is not None) and (attempt_count >= max_attempts):
524
self._trace("exceeded %d attempts")
525
raise LockContention(self)
526
411
if time.time() + poll < deadline:
527
self._trace("waiting %ss", poll)
530
self._trace("timeout after waiting %ss", timeout)
531
414
raise LockContention(self)
533
def leave_in_place(self):
534
self._locked_via_token = True
536
def dont_leave_in_place(self):
537
self._locked_via_token = False
539
def lock_write(self, token=None):
540
"""Wait for and acquire the lock.
542
:param token: if this is already locked, then lock_write will fail
543
unless the token matches the existing lock.
544
:returns: a token if this instance supports tokens, otherwise None.
545
:raises TokenLockingNotSupported: when a token is given but this
546
instance doesn't support using token locks.
547
:raises MismatchedToken: if the specified token doesn't match the token
548
of the existing lock.
550
A token should be passed in if you know that you have locked the object
551
some other way, and need to synchronise this object's state with that
554
XXX: docstring duplicated from LockableFiles.lock_write.
556
if token is not None:
557
self.validate_token(token)
559
self._lock_held = True
560
self._locked_via_token = True
563
return self.wait_lock()
416
def lock_write(self):
417
"""Wait for and acquire the lock."""
565
420
def lock_read(self):
566
421
"""Compatibility-mode shared lock.
added
removed
bzrlib/lockdir.py
