194
173
This is typically only called when the object/directory containing the
195
174
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.
176
if self.transport.is_readonly():
177
raise UnlockableTransport(self.transport)
178
self.transport.mkdir(self.path, mode=mode)
180
def attempt_lock(self):
181
"""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.
183
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)
186
if self._fake_read_lock:
187
raise LockContention(self)
188
if self.transport.is_readonly():
189
raise UnlockableTransport(self.transport)
191
tmpname = '%s/pending.%s.tmp' % (self.path, rand_chars(20))
192
self.transport.mkdir(tmpname)
194
self._prepare_info(sio)
196
# append will create a new file; we use append rather than put
197
# because we don't want to write to a temporary file and rename
198
# into place, because that's going to happen to the whole
200
self.transport.append(tmpname + self.__INFO_NAME, sio)
227
201
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,
202
self._lock_held = True
204
except (PathError, DirectoryNotEmpty, FileExists, ResourceBusy), e:
205
mutter("contention on %r: %s", self, e)
206
raise LockContention(self)
289
208
def unlock(self):
290
209
"""Release a held lock
295
214
if not self._lock_held:
296
215
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)
216
# rename before deleting, because we can't atomically remove the whole
218
tmpname = '%s/releasing.%s.tmp' % (self.path, rand_chars(20))
219
# gotta own it to unlock
221
self.transport.rename(self._held_dir, tmpname)
222
self._lock_held = False
223
self.transport.delete(tmpname + self.__INFO_NAME)
224
self.transport.rmdir(tmpname)
327
226
def break_lock(self):
328
227
"""Break a lock not held by this instance of LockDir.
418
321
info = self._read_info_file(self._held_info_path)
419
self._trace("peek -> held")
420
322
assert isinstance(info, dict), \
421
323
"bad parse result %r" % info
423
325
except NoSuchFile, e:
424
self._trace("peek -> not held")
426
def _prepare_info(self):
328
def _prepare_info(self, outf):
427
329
"""Write information about a pending lock to a temporary file.
430
332
# XXX: is creating this here inefficient?
431
333
config = bzrlib.config.GlobalConfig()
433
user = config.user_email()
434
except errors.NoEmailInUsername:
435
user = config.username()
436
334
s = Stanza(hostname=socket.gethostname(),
437
335
pid=str(os.getpid()),
438
336
start_time=str(int(time.time())),
439
337
nonce=self.nonce,
338
user=config.user_email(),
340
RioWriter(outf).write_stanza(s)
444
342
def _parse_info(self, info_file):
445
343
return read_stanza(info_file.readlines()).as_dict()
447
def attempt_lock(self):
448
"""Take the lock; fail if it's already held.
450
If you wish to block until the lock can be obtained, call wait_lock()
453
:return: The lock token.
454
:raises LockContention: if the lock is held by someone else.
456
if self._fake_read_lock:
457
raise LockContention(self)
458
return self._attempt_lock()
460
def wait_lock(self, timeout=None, poll=None, max_attempts=None):
345
def wait_lock(self, timeout=_DEFAULT_TIMEOUT_SECONDS,
346
poll=_DEFAULT_POLL_SECONDS):
461
347
"""Wait a certain period for a lock.
463
349
If the lock can be acquired within the bounded time, it
465
351
is raised. Either way, this function should return within
466
352
approximately `timeout` seconds. (It may be a bit more if
467
353
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.
479
timeout = _DEFAULT_TIMEOUT_SECONDS
481
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.
355
# XXX: the transport interface doesn't let us guard
356
# against operations there taking a long time.
485
357
deadline = time.time() + timeout
492
return self.attempt_lock()
493
362
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
new_info = self.peek()
503
if new_info is not None and new_info != last_info:
504
if last_info is None:
505
start = 'Unable to obtain'
507
start = 'Lock owner changed for'
509
formatted_info = self._format_lock_info(new_info)
510
if deadline_str is None:
511
deadline_str = time.strftime('%H:%M:%S',
512
time.localtime(deadline))
513
self._report_function('%s %s\n'
515
'%s\n' # locked ... ago
516
'Will continue to try until %s\n',
523
if (max_attempts is not None) and (attempt_count >= max_attempts):
524
self._trace("exceeded %d attempts")
525
raise LockContention(self)
526
364
if time.time() + poll < deadline:
527
self._trace("waiting %ss", poll)
530
self._trace("timeout after waiting %ss", timeout)
531
367
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()
369
def lock_write(self):
370
"""Wait for and acquire the lock."""
565
373
def lock_read(self):
566
374
"""Compatibility-mode shared lock.
577
385
raise LockContention(self)
578
386
self._fake_read_lock = True
580
def _format_lock_info(self, info):
581
"""Turn the contents of peek() into something for the user"""
582
lock_url = self.transport.abspath(self.path)
583
delta = time.time() - int(info['start_time'])
585
'lock %s' % (lock_url,),
586
'held by %(user)s on host %(hostname)s [process #%(pid)s]' % info,
587
'locked %s' % (format_delta(delta),),
590
def validate_token(self, token):
591
if token is not None:
597
lock_token = info.get('nonce')
598
if token != lock_token:
599
raise errors.TokenMismatch(token, lock_token)
601
self._trace("revalidated by token %r", token)
603
def _trace(self, format, *args):
604
if 'lock' not in debug.debug_flags:
606
mutter(str(self) + ": " + (format % args))
388
def wait(self, timeout=20, poll=0.5):
389
"""Wait a certain period for a lock to be released."""
390
# XXX: the transport interface doesn't let us guard
391
# against operations there taking a long time.
392
deadline = time.time() + timeout
396
if time.time() + poll < deadline:
399
raise LockContention(self)
added
removed
bzrlib/lockdir.py
