1
# Copyright (C) 2006 Canonical Ltd
1
# Copyright (C) 2006, 2007 Canonical Ltd
3
3
# This program is free software; you can redistribute it and/or modify
4
4
# it under the terms of the GNU General Public License as published by
5
5
# the Free Software Foundation; either version 2 of the License, or
6
6
# (at your option) any later version.
8
8
# This program is distributed in the hope that it will be useful,
9
9
# but WITHOUT ANY WARRANTY; without even the implied warranty of
10
10
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
11
11
# GNU General Public License for more details.
13
13
# You should have received a copy of the GNU General Public License
14
14
# along with this program; if not, write to the Free Software
15
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
106
118
LockBreakMismatch,
114
127
UnlockableTransport,
116
from bzrlib.trace import mutter
129
from bzrlib.trace import mutter, note
117
130
from bzrlib.transport import Transport
118
from bzrlib.osutils import rand_chars
119
from bzrlib.rio import RioWriter, read_stanza, Stanza
131
from bzrlib.osutils import rand_chars, format_delta
132
from bzrlib.rio import read_stanza, Stanza
121
136
# XXX: At the moment there is no consideration of thread safety on LockDir
122
137
# objects. This should perhaps be updated - e.g. if two threads try to take a
123
138
# lock at the same time they should *both* get it. But then that's unlikely
124
139
# to be a good idea.
126
# TODO: Transport could offer a simpler put() method that avoids the
127
# rename-into-place for cases like creating the lock template, where there is
128
# no chance that the file already exists.
130
141
# TODO: Perhaps store some kind of note like the bzr command line in the lock
174
187
is_held = property(lambda self: self._lock_held)
189
def create(self, mode=None):
177
190
"""Create the on-disk lock.
179
192
This is typically only called when the object/directory containing the
180
193
directory is first created. The lock is not held when it's created.
182
if self.transport.is_readonly():
183
raise UnlockableTransport(self.transport)
184
self.transport.mkdir(self.path)
186
def attempt_lock(self):
187
"""Take the lock; fail if it's already held.
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.
189
If you wish to block until the lock can be obtained, call wait_lock()
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 self._fake_read_lock:
193
raise LockContention(self)
194
if self.transport.is_readonly():
195
raise UnlockableTransport(self.transport)
197
tmpname = '%s/pending.%s.tmp' % (self.path, rand_chars(20))
198
self.transport.mkdir(tmpname)
200
self._prepare_info(sio)
202
self.transport.put(tmpname + self.__INFO_NAME, sio)
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)
203
225
self.transport.rename(tmpname, self._held_dir)
204
self._lock_held = True
206
except (PathError, DirectoryNotEmpty, FileExists, ResourceBusy), e:
207
mutter("contention on %r: %s", self, e)
208
raise LockContention(self)
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)
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")
246
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,
210
287
def unlock(self):
211
288
"""Release a held lock
216
293
if not self._lock_held:
217
294
raise LockNotHeld(self)
218
# rename before deleting, because we can't atomically remove the whole
220
tmpname = '%s/releasing.%s.tmp' % (self.path, rand_chars(20))
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)
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)
325
def break_lock(self):
326
"""Break a lock not held by this instance of LockDir.
328
This is a UI centric function: it uses the bzrlib.ui.ui_factory to
329
prompt for input if a lock is detected and there is any doubt about
330
it possibly being still active.
332
self._check_not_locked()
333
holder_info = self.peek()
334
if holder_info is not None:
335
lock_info = '\n'.join(self._format_lock_info(holder_info))
336
if bzrlib.ui.ui_factory.get_boolean("Break %s" % lock_info):
337
self.force_break(holder_info)
226
339
def force_break(self, dead_holder_info):
227
340
"""Release a lock held by another process.
299
416
info = self._read_info_file(self._held_info_path)
300
assert isinstance(info, dict), \
301
"bad parse result %r" % info
417
self._trace("peek -> held")
303
419
except NoSuchFile, e:
420
self._trace("peek -> not held")
306
def _prepare_info(self, outf):
422
def _prepare_info(self):
307
423
"""Write information about a pending lock to a temporary file.
310
426
# XXX: is creating this here inefficient?
311
427
config = bzrlib.config.GlobalConfig()
429
user = config.user_email()
430
except errors.NoEmailInUsername:
431
user = config.username()
312
432
s = Stanza(hostname=socket.gethostname(),
313
433
pid=str(os.getpid()),
314
434
start_time=str(int(time.time())),
315
435
nonce=self.nonce,
316
user=config.user_email(),
318
RioWriter(outf).write_stanza(s)
320
440
def _parse_info(self, info_file):
321
441
return read_stanza(info_file.readlines()).as_dict()
323
def wait_lock(self, timeout=_DEFAULT_TIMEOUT_SECONDS,
324
poll=_DEFAULT_POLL_SECONDS):
443
def attempt_lock(self):
444
"""Take the lock; fail if it's already held.
446
If you wish to block until the lock can be obtained, call wait_lock()
449
:return: The lock token.
450
:raises LockContention: if the lock is held by someone else.
452
if self._fake_read_lock:
453
raise LockContention(self)
454
return self._attempt_lock()
456
def wait_lock(self, timeout=None, poll=None, max_attempts=None):
325
457
"""Wait a certain period for a lock.
327
459
If the lock can be acquired within the bounded time, it
329
461
is raised. Either way, this function should return within
330
462
approximately `timeout` seconds. (It may be a bit more if
331
463
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.
333
# XXX: the transport interface doesn't let us guard
334
# against operations there taking a long time.
475
timeout = _DEFAULT_TIMEOUT_SECONDS
477
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.
335
481
deadline = time.time() + timeout
488
return self.attempt_lock()
340
489
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
new_info = self.peek()
499
if new_info is not None and new_info != last_info:
500
if last_info is None:
501
start = 'Unable to obtain'
503
start = 'Lock owner changed for'
505
formatted_info = self._format_lock_info(new_info)
506
if deadline_str is None:
507
deadline_str = time.strftime('%H:%M:%S',
508
time.localtime(deadline))
509
self._report_function('%s %s\n'
511
'%s\n' # locked ... ago
512
'Will continue to try until %s\n',
519
if (max_attempts is not None) and (attempt_count >= max_attempts):
520
self._trace("exceeded %d attempts")
521
raise LockContention(self)
342
522
if time.time() + poll < deadline:
523
self._trace("waiting %ss", poll)
526
self._trace("timeout after waiting %ss", timeout)
345
527
raise LockContention(self)
347
def lock_write(self):
348
"""Wait for and acquire the lock."""
529
def leave_in_place(self):
530
self._locked_via_token = True
532
def dont_leave_in_place(self):
533
self._locked_via_token = False
535
def lock_write(self, token=None):
536
"""Wait for and acquire the lock.
538
:param token: if this is already locked, then lock_write will fail
539
unless the token matches the existing lock.
540
:returns: a token if this instance supports tokens, otherwise None.
541
:raises TokenLockingNotSupported: when a token is given but this
542
instance doesn't support using token locks.
543
:raises MismatchedToken: if the specified token doesn't match the token
544
of the existing lock.
546
A token should be passed in if you know that you have locked the object
547
some other way, and need to synchronise this object's state with that
550
XXX: docstring duplicated from LockableFiles.lock_write.
552
if token is not None:
553
self.validate_token(token)
555
self._lock_held = True
556
self._locked_via_token = True
559
return self.wait_lock()
351
561
def lock_read(self):
352
"""Compatability-mode shared lock.
562
"""Compatibility-mode shared lock.
354
564
LockDir doesn't support shared read-only locks, so this
355
565
just pretends that the lock is taken but really does nothing.
363
573
raise LockContention(self)
364
574
self._fake_read_lock = True
366
def wait(self, timeout=20, poll=0.5):
367
"""Wait a certain period for a lock to be released."""
368
# XXX: the transport interface doesn't let us guard
369
# against operations there taking a long time.
370
deadline = time.time() + timeout
374
if time.time() + poll < deadline:
377
raise LockContention(self)
576
def _format_lock_info(self, info):
577
"""Turn the contents of peek() into something for the user"""
578
lock_url = self.transport.abspath(self.path)
579
delta = time.time() - int(info['start_time'])
581
'lock %s' % (lock_url,),
582
'held by %(user)s on host %(hostname)s [process #%(pid)s]' % info,
583
'locked %s' % (format_delta(delta),),
586
def validate_token(self, token):
587
if token is not None:
593
lock_token = info.get('nonce')
594
if token != lock_token:
595
raise errors.TokenMismatch(token, lock_token)
597
self._trace("revalidated by token %r", token)
599
def _trace(self, format, *args):
600
if 'lock' not in debug.debug_flags:
602
mutter(str(self) + ": " + (format % args))
added
removed
bzrlib/lockdir.py
