195
185
if self.transport.is_readonly():
196
186
raise UnlockableTransport(self.transport)
197
self._trace("create lock directory")
198
187
self.transport.mkdir(self.path, mode=mode)
200
def _attempt_lock(self):
201
"""Make the pending directory and attempt to rename into place.
189
def attempt_lock(self):
190
"""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.
192
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()
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
self.nonce = rand_chars(20)
213
info_bytes = self._prepare_info()
214
# We use put_file_non_atomic because we just created a new unique
215
# directory so we don't have to worry about files existing there.
216
# We'll rename the whole directory into place to get atomic
218
self.transport.put_bytes_non_atomic(tmpname + self.__INFO_NAME,
219
221
self.transport.rename(tmpname, self._held_dir)
222
self._lock_held = True
224
except errors.PermissionDenied:
220
226
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,
227
mutter("contention on %r: %s", self, e)
228
raise LockContention(self)
280
230
def unlock(self):
281
231
"""Release a held lock
292
242
# rename before deleting, because we can't atomically remove the
294
start_time = time.time()
295
self._trace("unlocking")
296
244
tmpname = '%s/releasing.%s.tmp' % (self.path, rand_chars(20))
297
245
# gotta own it to unlock
299
247
self.transport.rename(self._held_dir, tmpname)
300
248
self._lock_held = False
301
249
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)
250
self.transport.rmdir(tmpname)
318
252
def break_lock(self):
319
253
"""Break a lock not held by this instance of LockDir.
435
368
def _parse_info(self, info_file):
436
369
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):
371
def wait_lock(self, timeout=None, poll=None):
454
372
"""Wait a certain period for a lock.
456
374
If the lock can be acquired within the bounded time, it
458
376
is raised. Either way, this function should return within
459
377
approximately `timeout` seconds. (It may be a bit more if
460
378
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
380
if timeout is None:
472
381
timeout = _DEFAULT_TIMEOUT_SECONDS
474
383
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.
385
# XXX: the transport interface doesn't let us guard
386
# against operations there taking a long time.
478
387
deadline = time.time() + timeout
479
388
deadline_str = None
485
return self.attempt_lock()
486
394
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
396
new_info = self.peek()
397
mutter('last_info: %s, new info: %s', last_info, new_info)
496
398
if new_info is not None and new_info != last_info:
497
399
if last_info is None:
498
400
start = 'Unable to obtain'
added
removed
bzrlib/lockdir.py
