191
170
def create(self, mode=None):
192
171
"""Create the on-disk lock.
194
This is typically only called when the object/directory containing the
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.
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.
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.
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
293
212
self._fake_read_lock = False
295
214
if not self._lock_held:
296
return lock.cant_unlock_not_held(self)
297
if self._locked_via_token:
298
self._locked_via_token = False
299
self._lock_held = False
301
old_nonce = self.nonce
302
# rename before deleting, because we can't atomically remove the
304
start_time = time.time()
305
self._trace("unlocking")
306
tmpname = '%s/releasing.%s.tmp' % (self.path, rand_chars(20))
307
# gotta own it to unlock
309
self.transport.rename(self._held_dir, tmpname)
310
self._lock_held = False
311
self.transport.delete(tmpname + self.__INFO_NAME)
313
self.transport.rmdir(tmpname)
314
except DirectoryNotEmpty, e:
315
# There might have been junk left over by a rename that moved
316
# another locker within the 'held' directory. do a slower
317
# deletion where we list the directory and remove everything
320
# Maybe this should be broader to allow for ftp servers with
321
# non-specific error messages?
322
self._trace("doing recursive deletion of non-empty directory "
324
self.transport.delete_tree(tmpname)
325
self._trace("... unlock succeeded after %dms",
326
(time.time() - start_time) * 1000)
327
result = lock.LockResult(self.transport.abspath(self.path),
329
for hook in self.hooks['lock_released']:
215
raise LockNotHeld(self)
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)
332
226
def break_lock(self):
333
227
"""Break a lock not held by this instance of LockDir.
420
314
"""Check if the lock is held by anyone.
422
316
If it is held, this returns the lock info structure as a rio Stanza,
423
317
which contains some information about the current lock holder.
424
318
Otherwise returns None.
427
321
info = self._read_info_file(self._held_info_path)
428
self._trace("peek -> held")
322
assert isinstance(info, dict), \
323
"bad parse result %r" % info
430
325
except NoSuchFile, e:
431
self._trace("peek -> not held")
433
def _prepare_info(self):
328
def _prepare_info(self, outf):
434
329
"""Write information about a pending lock to a temporary file.
436
332
# XXX: is creating this here inefficient?
437
333
config = bzrlib.config.GlobalConfig()
439
user = config.user_email()
440
except errors.NoEmailInUsername:
441
user = config.username()
442
s = rio.Stanza(hostname=get_host_name(),
334
s = Stanza(hostname=socket.gethostname(),
443
335
pid=str(os.getpid()),
444
336
start_time=str(int(time.time())),
445
337
nonce=self.nonce,
338
user=config.user_email(),
340
RioWriter(outf).write_stanza(s)
450
342
def _parse_info(self, info_file):
451
return rio.read_stanza(info_file.readlines()).as_dict()
453
def attempt_lock(self):
454
"""Take the lock; fail if it's already held.
456
If you wish to block until the lock can be obtained, call wait_lock()
459
:return: The lock token.
460
:raises LockContention: if the lock is held by someone else.
462
if self._fake_read_lock:
463
raise LockContention(self)
464
result = self._attempt_lock()
465
hook_result = lock.LockResult(self.transport.abspath(self.path),
467
for hook in self.hooks['lock_acquired']:
471
def wait_lock(self, timeout=None, poll=None, max_attempts=None):
343
return read_stanza(info_file.readlines()).as_dict()
345
def wait_lock(self, timeout=_DEFAULT_TIMEOUT_SECONDS,
346
poll=_DEFAULT_POLL_SECONDS):
472
347
"""Wait a certain period for a lock.
474
349
If the lock can be acquired within the bounded time, it
476
351
is raised. Either way, this function should return within
477
352
approximately `timeout` seconds. (It may be a bit more if
478
353
a transport operation takes a long time to complete.)
480
:param timeout: Approximate maximum amount of time to wait for the
483
:param poll: Delay in seconds between retrying the lock.
485
:param max_attempts: Maximum number of times to try to lock.
487
:return: The lock token.
490
timeout = _DEFAULT_TIMEOUT_SECONDS
492
poll = _DEFAULT_POLL_SECONDS
493
# XXX: the transport interface doesn't let us guard against operations
494
# there taking a long time, so the total elapsed time or poll interval
495
# may be more than was requested.
355
# XXX: the transport interface doesn't let us guard
356
# against operations there taking a long time.
496
357
deadline = time.time() + timeout
503
return self.attempt_lock()
504
362
except LockContention:
505
# possibly report the blockage, then try again
507
# TODO: In a few cases, we find out that there's contention by
508
# reading the held info and observing that it's not ours. In
509
# those cases it's a bit redundant to read it again. However,
510
# the normal case (??) is that the rename fails and so we
511
# don't know who holds the lock. For simplicity we peek
513
new_info = self.peek()
514
if new_info is not None and new_info != last_info:
515
if last_info is None:
516
start = 'Unable to obtain'
518
start = 'Lock owner changed for'
520
formatted_info = self._format_lock_info(new_info)
521
if deadline_str is None:
522
deadline_str = time.strftime('%H:%M:%S',
523
time.localtime(deadline))
524
lock_url = self.transport.abspath(self.path)
525
self._report_function('%s %s\n'
527
'%s\n' # locked ... ago
528
'Will continue to try until %s, unless '
530
'If you\'re sure that it\'s not being '
531
'modified, use bzr break-lock %s',
539
if (max_attempts is not None) and (attempt_count >= max_attempts):
540
self._trace("exceeded %d attempts")
541
raise LockContention(self)
542
364
if time.time() + poll < deadline:
543
self._trace("waiting %ss", poll)
546
self._trace("timeout after waiting %ss", timeout)
547
367
raise LockContention(self)
549
def leave_in_place(self):
550
self._locked_via_token = True
552
def dont_leave_in_place(self):
553
self._locked_via_token = False
555
def lock_write(self, token=None):
556
"""Wait for and acquire the lock.
558
:param token: if this is already locked, then lock_write will fail
559
unless the token matches the existing lock.
560
:returns: a token if this instance supports tokens, otherwise None.
561
:raises TokenLockingNotSupported: when a token is given but this
562
instance doesn't support using token locks.
563
:raises MismatchedToken: if the specified token doesn't match the token
564
of the existing lock.
566
A token should be passed in if you know that you have locked the object
567
some other way, and need to synchronise this object's state with that
570
XXX: docstring duplicated from LockableFiles.lock_write.
572
if token is not None:
573
self.validate_token(token)
575
self._lock_held = True
576
self._locked_via_token = True
579
return self.wait_lock()
369
def lock_write(self):
370
"""Wait for and acquire the lock."""
581
373
def lock_read(self):
582
374
"""Compatibility-mode shared lock.
584
LockDir doesn't support shared read-only locks, so this
376
LockDir doesn't support shared read-only locks, so this
585
377
just pretends that the lock is taken but really does nothing.
587
# At the moment Branches are commonly locked for read, but
379
# At the moment Branches are commonly locked for read, but
588
380
# we can't rely on that remotely. Once this is cleaned up,
589
# reenable this warning to prevent it coming back in
381
# reenable this warning to prevent it coming back in
590
382
# -- mbp 20060303
591
383
## warn("LockDir.lock_read falls back to write lock")
592
384
if self._lock_held or self._fake_read_lock:
593
385
raise LockContention(self)
594
386
self._fake_read_lock = True
596
def _format_lock_info(self, info):
597
"""Turn the contents of peek() into something for the user"""
598
lock_url = self.transport.abspath(self.path)
599
delta = time.time() - int(info['start_time'])
601
'lock %s' % (lock_url,),
602
'held by %(user)s on host %(hostname)s [process #%(pid)s]' % info,
603
'locked %s' % (format_delta(delta),),
606
def validate_token(self, token):
607
if token is not None:
613
lock_token = info.get('nonce')
614
if token != lock_token:
615
raise errors.TokenMismatch(token, lock_token)
617
self._trace("revalidated by token %r", token)
619
def _trace(self, format, *args):
620
if 'lock' not in debug.debug_flags:
622
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)