192
182
This is typically only called when the object/directory containing the
193
183
directory is first created. The lock is not held when it's created.
195
self._trace("create lock directory")
197
self.transport.mkdir(self.path, mode=mode)
198
except (TransportError, PathError), e:
199
raise LockFailed(self, e)
202
def _attempt_lock(self):
203
"""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.
205
If the rename succeeds, we read back the info file to check that we
208
If we fail to acquire the lock, this method is responsible for
209
cleaning up the pending directory if possible. (But it doesn't do
212
:returns: The nonce of the lock, if it was successfully acquired.
214
:raises LockContention: If the lock is held by someone else. The exception
215
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()
217
self._trace("lock_write...")
218
start_time = time.time()
220
tmpname = self._create_pending_dir()
221
except (errors.TransportError, PathError), e:
222
self._trace("... failed to create pending dir, %s", e)
223
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,
225
220
self.transport.rename(tmpname, self._held_dir)
226
except (errors.TransportError, PathError, DirectoryNotEmpty,
227
FileExists, ResourceBusy), e:
228
self._trace("... contention, %s", e)
229
self._remove_pending_dir(tmpname)
230
raise LockContention(self)
232
self._trace("... lock failed, %s", e)
233
self._remove_pending_dir(tmpname)
221
self._lock_held = True
223
except errors.PermissionDenied:
235
# We must check we really got the lock, because Launchpad's sftp
236
# server at one time had a bug were the rename would successfully
237
# move the new directory into the existing directory, which was
238
# incorrect. It's possible some other servers or filesystems will
239
# have a similar bug allowing someone to think they got the lock
240
# when it's already held.
242
self._trace("after locking, info=%r", info)
243
if info['nonce'] != self.nonce:
244
self._trace("rename succeeded, "
245
"but lock is still held by someone else")
225
except (PathError, DirectoryNotEmpty, FileExists, ResourceBusy), e:
226
mutter("contention on %r: %s", self, e)
246
227
raise LockContention(self)
247
self._lock_held = True
248
self._trace("... lock succeeded after %dms",
249
(time.time() - start_time) * 1000)
252
def _remove_pending_dir(self, tmpname):
253
"""Remove the pending directory
255
This is called if we failed to rename into place, so that the pending
256
dirs don't clutter up the lockdir.
258
self._trace("remove %s", tmpname)
260
self.transport.delete(tmpname + self.__INFO_NAME)
261
self.transport.rmdir(tmpname)
263
note("error removing pending lock: %s", e)
265
def _create_pending_dir(self):
266
tmpname = '%s/%s.tmp' % (self.path, rand_chars(10))
268
self.transport.mkdir(tmpname)
270
# This may raise a FileExists exception
271
# which is okay, it will be caught later and determined
272
# to be a LockContention.
273
self._trace("lock directory does not exist, creating it")
274
self.create(mode=self._dir_modebits)
275
# After creating the lock directory, try again
276
self.transport.mkdir(tmpname)
277
self.nonce = rand_chars(20)
278
info_bytes = self._prepare_info()
279
# We use put_file_non_atomic because we just created a new unique
280
# directory so we don't have to worry about files existing there.
281
# We'll rename the whole directory into place to get atomic
283
self.transport.put_bytes_non_atomic(tmpname + self.__INFO_NAME,
287
229
def unlock(self):
288
230
"""Release a held lock
293
235
if not self._lock_held:
294
236
raise LockNotHeld(self)
295
if self._locked_via_token:
296
self._locked_via_token = False
297
self._lock_held = False
299
# rename before deleting, because we can't atomically remove the
301
start_time = time.time()
302
self._trace("unlocking")
303
tmpname = '%s/releasing.%s.tmp' % (self.path, rand_chars(20))
304
# gotta own it to unlock
306
self.transport.rename(self._held_dir, tmpname)
307
self._lock_held = False
308
self.transport.delete(tmpname + self.__INFO_NAME)
310
self.transport.rmdir(tmpname)
311
except DirectoryNotEmpty, e:
312
# There might have been junk left over by a rename that moved
313
# another locker within the 'held' directory. do a slower
314
# deletion where we list the directory and remove everything
317
# Maybe this should be broader to allow for ftp servers with
318
# non-specific error messages?
319
self._trace("doing recursive deletion of non-empty directory "
321
self.transport.delete_tree(tmpname)
322
self._trace("... unlock succeeded after %dms",
323
(time.time() - start_time) * 1000)
237
# rename before deleting, because we can't atomically remove the whole
239
tmpname = '%s/releasing.%s.tmp' % (self.path, rand_chars(20))
240
# gotta own it to unlock
242
self.transport.rename(self._held_dir, tmpname)
243
self._lock_held = False
244
self.transport.delete(tmpname + self.__INFO_NAME)
245
self.transport.rmdir(tmpname)
325
247
def break_lock(self):
326
248
"""Break a lock not held by this instance of LockDir.
461
371
is raised. Either way, this function should return within
462
372
approximately `timeout` seconds. (It may be a bit more if
463
373
a transport operation takes a long time to complete.)
465
:param timeout: Approximate maximum amount of time to wait for the
468
:param poll: Delay in seconds between retrying the lock.
470
:param max_attempts: Maximum number of times to try to lock.
472
:return: The lock token.
474
375
if timeout is None:
475
376
timeout = _DEFAULT_TIMEOUT_SECONDS
477
378
poll = _DEFAULT_POLL_SECONDS
478
# XXX: the transport interface doesn't let us guard against operations
479
# there taking a long time, so the total elapsed time or poll interval
480
# may be more than was requested.
380
# XXX: the transport interface doesn't let us guard
381
# against operations there taking a long time.
481
382
deadline = time.time() + timeout
482
383
deadline_str = None
488
return self.attempt_lock()
489
389
except LockContention:
490
# possibly report the blockage, then try again
492
# TODO: In a few cases, we find out that there's contention by
493
# reading the held info and observing that it's not ours. In
494
# those cases it's a bit redundant to read it again. However,
495
# the normal case (??) is that the rename fails and so we
496
# don't know who holds the lock. For simplicity we peek
498
391
new_info = self.peek()
392
mutter('last_info: %s, new info: %s', last_info, new_info)
499
393
if new_info is not None and new_info != last_info:
500
394
if last_info is None:
501
395
start = 'Unable to obtain'
506
400
if deadline_str is None:
507
401
deadline_str = time.strftime('%H:%M:%S',
508
402
time.localtime(deadline))
509
lock_url = self.transport.abspath(self.path)
510
403
self._report_function('%s %s\n'
512
405
'%s\n' # locked ... ago
513
'Will continue to try until %s, unless '
515
'If you\'re sure that it\'s not being '
516
'modified, use bzr break-lock %s',
406
'Will continue to try until %s\n',
518
408
formatted_info[0],
519
409
formatted_info[1],
520
410
formatted_info[2],
524
if (max_attempts is not None) and (attempt_count >= max_attempts):
525
self._trace("exceeded %d attempts")
526
raise LockContention(self)
527
413
if time.time() + poll < deadline:
528
self._trace("waiting %ss", poll)
531
self._trace("timeout after waiting %ss", timeout)
532
416
raise LockContention(self)
534
def leave_in_place(self):
535
self._locked_via_token = True
537
def dont_leave_in_place(self):
538
self._locked_via_token = False
540
def lock_write(self, token=None):
541
"""Wait for and acquire the lock.
543
:param token: if this is already locked, then lock_write will fail
544
unless the token matches the existing lock.
545
:returns: a token if this instance supports tokens, otherwise None.
546
:raises TokenLockingNotSupported: when a token is given but this
547
instance doesn't support using token locks.
548
:raises MismatchedToken: if the specified token doesn't match the token
549
of the existing lock.
551
A token should be passed in if you know that you have locked the object
552
some other way, and need to synchronise this object's state with that
555
XXX: docstring duplicated from LockableFiles.lock_write.
557
if token is not None:
558
self.validate_token(token)
560
self._lock_held = True
561
self._locked_via_token = True
564
return self.wait_lock()
418
def lock_write(self):
419
"""Wait for and acquire the lock."""
566
422
def lock_read(self):
567
423
"""Compatibility-mode shared lock.
added
removed
bzrlib/lockdir.py
