← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/lockdir.py

  • Committer: Tarmac
  • Author(s): Vincent Ladeuil
  • Date: 2017-01-30 14:42:05 UTC
  • mfrom: (6620.1.1 trunk)
  • Revision ID: tarmac-20170130144205-r8fh2xpmiuxyozpv
Merge  2.7 into trunk including fix for bug #1657238 [r=vila]

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/lockdir.py
1
 
# Copyright (C) 2006, 2007, 2008 Canonical Ltd
 
1
# Copyright (C) 2006-2011 Canonical Ltd
2
2
#
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
12
12
#
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
 
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
16
16
 
17
17
"""On-disk mutex protecting a resource
18
18
 
21
21
internal locks (such as flock etc) because they can be seen across all
22
22
transports, including http.
23
23
 
24
 
Objects can be read if there is only physical read access; therefore 
 
24
Objects can be read if there is only physical read access; therefore
25
25
readers can never be required to create a lock, though they will
26
26
check whether a writer is using the lock.  Writers can't detect
27
27
whether anyone else is reading from the resource as they write.
56
56
 
57
57
The desired characteristics are:
58
58
 
59
 
* Locks are not reentrant.  (That is, a client that tries to take a 
 
59
* Locks are not reentrant.  (That is, a client that tries to take a
60
60
  lock it already holds may deadlock or fail.)
61
61
* Stale locks can be guessed at by a heuristic
62
62
* Lost locks can be broken by any client
78
78
and deadlocks will likely occur if the locks are aliased.
79
79
 
80
80
In the future we may add a "freshen" method which can be called
81
 
by a lock holder to check that their lock has not been broken, and to 
 
81
by a lock holder to check that their lock has not been broken, and to
82
82
update the timestamp within it.
83
83
 
84
84
Example usage:
92
92
>>> # do something here
93
93
>>> l.unlock()
94
94
 
 
95
Some classes of stale locks can be predicted by checking: the host name is the
 
96
same as the local host name; the user name is the same as the local user; the
 
97
process id no longer exists.  The check on user name is not strictly necessary
 
98
but helps protect against colliding host names.
95
99
"""
96
100
 
 
101
from __future__ import absolute_import
 
102
 
97
103
 
98
104
# TODO: We sometimes have the problem that our attempt to rename '1234' to
99
105
# 'held' fails because the transport server moves into an existing directory,
107
113
import time
108
114
 
109
115
from bzrlib import (
 
116
    config,
110
117
    debug,
111
118
    errors,
112
119
    lock,
 
120
    osutils,
 
121
    ui,
 
122
    urlutils,
113
123
    )
114
 
import bzrlib.config
 
124
from bzrlib.decorators import only_raises
115
125
from bzrlib.errors import (
116
126
        DirectoryNotEmpty,
117
127
        FileExists,
118
128
        LockBreakMismatch,
119
129
        LockBroken,
120
130
        LockContention,
 
131
        LockCorrupt,
121
132
        LockFailed,
122
133
        LockNotHeld,
123
134
        NoSuchFile,
125
136
        ResourceBusy,
126
137
        TransportError,
127
138
        )
128
 
from bzrlib.hooks import Hooks
129
139
from bzrlib.trace import mutter, note
130
140
from bzrlib.osutils import format_delta, rand_chars, get_host_name
131
 
import bzrlib.ui
 
141
from bzrlib.i18n import gettext
132
142
 
133
143
from bzrlib.lazy_import import lazy_import
134
144
lazy_import(globals(), """
150
160
# files/dirs created.
151
161
 
152
162
 
153
 
_DEFAULT_TIMEOUT_SECONDS = 300
 
163
_DEFAULT_TIMEOUT_SECONDS = 30
154
164
_DEFAULT_POLL_SECONDS = 1.0
155
165
 
156
166
 
160
170
 
161
171
    __INFO_NAME = '/info'
162
172
 
163
 
    def __init__(self, transport, path, file_modebits=0644, dir_modebits=0755):
 
173
    def __init__(self, transport, path, file_modebits=0644, dir_modebits=0755,
 
174
        extra_holder_info=None):
164
175
        """Create a new LockDir object.
165
176
 
166
177
        The LockDir is initially unlocked - this just creates the object.
167
178
 
168
179
        :param transport: Transport which will contain the lock
169
180
 
170
 
        :param path: Path to the lock within the base directory of the 
 
181
        :param path: Path to the lock within the base directory of the
171
182
            transport.
 
183
 
 
184
        :param extra_holder_info: If passed, {str:str} dict of extra or
 
185
            updated information to insert into the info file when the lock is
 
186
            taken.
172
187
        """
173
188
        self.transport = transport
174
189
        self.path = path
179
194
        self._held_info_path = self._held_dir + self.__INFO_NAME
180
195
        self._file_modebits = file_modebits
181
196
        self._dir_modebits = dir_modebits
182
 
 
183
197
        self._report_function = note
 
198
        self.extra_holder_info = extra_holder_info
 
199
        self._warned_about_lock_holder = None
184
200
 
185
201
    def __repr__(self):
186
202
        return '%s(%s%s)' % (self.__class__.__name__,
192
208
    def create(self, mode=None):
193
209
        """Create the on-disk lock.
194
210
 
195
 
        This is typically only called when the object/directory containing the 
 
211
        This is typically only called when the object/directory containing the
196
212
        directory is first created.  The lock is not held when it's created.
197
213
        """
198
214
        self._trace("create lock directory")
201
217
        except (TransportError, PathError), e:
202
218
            raise LockFailed(self, e)
203
219
 
204
 
 
205
220
    def _attempt_lock(self):
206
221
        """Make the pending directory and attempt to rename into place.
207
 
        
 
222
 
208
223
        If the rename succeeds, we read back the info file to check that we
209
224
        really got the lock.
210
225
 
214
229
 
215
230
        :returns: The nonce of the lock, if it was successfully acquired.
216
231
 
217
 
        :raises LockContention: If the lock is held by someone else.  The exception
218
 
            contains the info of the current holder of the lock.
 
232
        :raises LockContention: If the lock is held by someone else.  The
 
233
            exception contains the info of the current holder of the lock.
219
234
        """
220
235
        self._trace("lock_write...")
221
236
        start_time = time.time()
224
239
        except (errors.TransportError, PathError), e:
225
240
            self._trace("... failed to create pending dir, %s", e)
226
241
            raise LockFailed(self, e)
227
 
        try:
228
 
            self.transport.rename(tmpname, self._held_dir)
229
 
        except (errors.TransportError, PathError, DirectoryNotEmpty,
230
 
                FileExists, ResourceBusy), e:
231
 
            self._trace("... contention, %s", e)
232
 
            self._remove_pending_dir(tmpname)
233
 
            raise LockContention(self)
234
 
        except Exception, e:
235
 
            self._trace("... lock failed, %s", e)
236
 
            self._remove_pending_dir(tmpname)
237
 
            raise
 
242
        while True:
 
243
            try:
 
244
                self.transport.rename(tmpname, self._held_dir)
 
245
                break
 
246
            except (errors.TransportError, PathError, DirectoryNotEmpty,
 
247
                    FileExists, ResourceBusy), e:
 
248
                self._trace("... contention, %s", e)
 
249
                other_holder = self.peek()
 
250
                self._trace("other holder is %r" % other_holder)
 
251
                try:
 
252
                    self._handle_lock_contention(other_holder)
 
253
                except:
 
254
                    self._remove_pending_dir(tmpname)
 
255
                    raise
 
256
            except Exception, e:
 
257
                self._trace("... lock failed, %s", e)
 
258
                self._remove_pending_dir(tmpname)
 
259
                raise
238
260
        # We must check we really got the lock, because Launchpad's sftp
239
261
        # server at one time had a bug were the rename would successfully
240
262
        # move the new directory into the existing directory, which was
241
263
        # incorrect.  It's possible some other servers or filesystems will
242
264
        # have a similar bug allowing someone to think they got the lock
243
265
        # when it's already held.
 
266
        #
 
267
        # See <https://bugs.launchpad.net/bzr/+bug/498378> for one case.
 
268
        #
 
269
        # Strictly the check is unnecessary and a waste of time for most
 
270
        # people, but probably worth trapping if something is wrong.
244
271
        info = self.peek()
245
272
        self._trace("after locking, info=%r", info)
246
 
        if info['nonce'] != self.nonce:
 
273
        if info is None:
 
274
            raise LockFailed(self, "lock was renamed into place, but "
 
275
                "now is missing!")
 
276
        if info.get('nonce') != self.nonce:
247
277
            self._trace("rename succeeded, "
248
278
                "but lock is still held by someone else")
249
279
            raise LockContention(self)
252
282
                (time.time() - start_time) * 1000)
253
283
        return self.nonce
254
284
 
 
285
    def _handle_lock_contention(self, other_holder):
 
286
        """A lock we want to take is held by someone else.
 
287
 
 
288
        This function can: tell the user about it; possibly detect that it's
 
289
        safe or appropriate to steal the lock, or just raise an exception.
 
290
 
 
291
        If this function returns (without raising an exception) the lock will
 
292
        be attempted again.
 
293
 
 
294
        :param other_holder: A LockHeldInfo for the current holder; note that
 
295
            it might be None if the lock can be seen to be held but the info
 
296
            can't be read.
 
297
        """
 
298
        if (other_holder is not None):
 
299
            if other_holder.is_lock_holder_known_dead():
 
300
                if self.get_config().get('locks.steal_dead'):
 
301
                    ui.ui_factory.show_user_warning(
 
302
                        'locks_steal_dead',
 
303
                        lock_url=urlutils.join(self.transport.base, self.path),
 
304
                        other_holder_info=unicode(other_holder))
 
305
                    self.force_break(other_holder)
 
306
                    self._trace("stole lock from dead holder")
 
307
                    return
 
308
        raise LockContention(self)
 
309
 
255
310
    def _remove_pending_dir(self, tmpname):
256
311
        """Remove the pending directory
257
312
 
258
 
        This is called if we failed to rename into place, so that the pending 
 
313
        This is called if we failed to rename into place, so that the pending
259
314
        dirs don't clutter up the lockdir.
260
315
        """
261
316
        self._trace("remove %s", tmpname)
263
318
            self.transport.delete(tmpname + self.__INFO_NAME)
264
319
            self.transport.rmdir(tmpname)
265
320
        except PathError, e:
266
 
            note("error removing pending lock: %s", e)
 
321
            note(gettext("error removing pending lock: %s"), e)
267
322
 
268
323
    def _create_pending_dir(self):
269
324
        tmpname = '%s/%s.tmp' % (self.path, rand_chars(10))
277
332
            self.create(mode=self._dir_modebits)
278
333
            # After creating the lock directory, try again
279
334
            self.transport.mkdir(tmpname)
280
 
        self.nonce = rand_chars(20)
281
 
        info_bytes = self._prepare_info()
 
335
        info = LockHeldInfo.for_this_process(self.extra_holder_info)
 
336
        self.nonce = info.get('nonce')
282
337
        # We use put_file_non_atomic because we just created a new unique
283
338
        # directory so we don't have to worry about files existing there.
284
339
        # We'll rename the whole directory into place to get atomic
285
340
        # properties
286
341
        self.transport.put_bytes_non_atomic(tmpname + self.__INFO_NAME,
287
 
                                            info_bytes)
 
342
            info.to_bytes())
288
343
        return tmpname
289
344
 
 
345
    @only_raises(LockNotHeld, LockBroken)
290
346
    def unlock(self):
291
347
        """Release a held lock
292
348
        """
294
350
            self._fake_read_lock = False
295
351
            return
296
352
        if not self._lock_held:
297
 
            raise LockNotHeld(self)
 
353
            return lock.cant_unlock_not_held(self)
298
354
        if self._locked_via_token:
299
355
            self._locked_via_token = False
300
356
            self._lock_held = False
326
382
            self._trace("... unlock succeeded after %dms",
327
383
                    (time.time() - start_time) * 1000)
328
384
            result = lock.LockResult(self.transport.abspath(self.path),
329
 
                old_nonce)
 
385
                                     old_nonce)
330
386
            for hook in self.hooks['lock_released']:
331
387
                hook(result)
332
388
 
333
389
    def break_lock(self):
334
390
        """Break a lock not held by this instance of LockDir.
335
391
 
336
 
        This is a UI centric function: it uses the bzrlib.ui.ui_factory to
 
392
        This is a UI centric function: it uses the ui.ui_factory to
337
393
        prompt for input if a lock is detected and there is any doubt about
338
 
        it possibly being still active.
 
394
        it possibly being still active.  force_break is the non-interactive
 
395
        version.
 
396
 
 
397
        :returns: LockResult for the broken lock.
339
398
        """
340
399
        self._check_not_locked()
341
 
        holder_info = self.peek()
 
400
        try:
 
401
            holder_info = self.peek()
 
402
        except LockCorrupt, e:
 
403
            # The lock info is corrupt.
 
404
            if ui.ui_factory.get_boolean(u"Break (corrupt %r)" % (self,)):
 
405
                self.force_break_corrupt(e.file_data)
 
406
            return
342
407
        if holder_info is not None:
343
 
            lock_info = '\n'.join(self._format_lock_info(holder_info))
344
 
            if bzrlib.ui.ui_factory.get_boolean("Break %s" % lock_info):
345
 
                self.force_break(holder_info)
346
 
        
 
408
            if ui.ui_factory.confirm_action(
 
409
                u"Break %(lock_info)s",
 
410
                'bzrlib.lockdir.break',
 
411
                dict(lock_info=unicode(holder_info))):
 
412
                result = self.force_break(holder_info)
 
413
                ui.ui_factory.show_message(
 
414
                    "Broke lock %s" % result.lock_url)
 
415
 
347
416
    def force_break(self, dead_holder_info):
348
417
        """Release a lock held by another process.
349
418
 
351
420
        it still thinks it has the lock there will be two concurrent writers.
352
421
        In general the user's approval should be sought for lock breaks.
353
422
 
354
 
        dead_holder_info must be the result of a previous LockDir.peek() call;
355
 
        this is used to check that it's still held by the same process that
356
 
        the user decided was dead.  If this is not the current holder,
357
 
        LockBreakMismatch is raised.
358
 
 
359
423
        After the lock is broken it will not be held by any process.
360
 
        It is possible that another process may sneak in and take the 
 
424
        It is possible that another process may sneak in and take the
361
425
        lock before the breaking process acquires it.
 
426
 
 
427
        :param dead_holder_info:
 
428
            Must be the result of a previous LockDir.peek() call; this is used
 
429
            to check that it's still held by the same process that the user
 
430
            decided was dead.  If this is not the current holder,
 
431
            LockBreakMismatch is raised.
 
432
 
 
433
        :returns: LockResult for the broken lock.
362
434
        """
363
 
        if not isinstance(dead_holder_info, dict):
 
435
        if not isinstance(dead_holder_info, LockHeldInfo):
364
436
            raise ValueError("dead_holder_info: %r" % dead_holder_info)
365
437
        self._check_not_locked()
366
438
        current_info = self.peek()
372
444
        tmpname = '%s/broken.%s.tmp' % (self.path, rand_chars(20))
373
445
        self.transport.rename(self._held_dir, tmpname)
374
446
        # check that we actually broke the right lock, not someone else;
375
 
        # there's a small race window between checking it and doing the 
 
447
        # there's a small race window between checking it and doing the
376
448
        # rename.
377
449
        broken_info_path = tmpname + self.__INFO_NAME
378
450
        broken_info = self._read_info_file(broken_info_path)
380
452
            raise LockBreakMismatch(self, broken_info, dead_holder_info)
381
453
        self.transport.delete(broken_info_path)
382
454
        self.transport.rmdir(tmpname)
 
455
        result = lock.LockResult(self.transport.abspath(self.path),
 
456
                                 current_info.get('nonce'))
 
457
        for hook in self.hooks['lock_broken']:
 
458
            hook(result)
 
459
        return result
 
460
 
 
461
    def force_break_corrupt(self, corrupt_info_lines):
 
462
        """Release a lock that has been corrupted.
 
463
 
 
464
        This is very similar to force_break, it except it doesn't assume that
 
465
        self.peek() can work.
 
466
 
 
467
        :param corrupt_info_lines: the lines of the corrupted info file, used
 
468
            to check that the lock hasn't changed between reading the (corrupt)
 
469
            info file and calling force_break_corrupt.
 
470
        """
 
471
        # XXX: this copes with unparseable info files, but what about missing
 
472
        # info files?  Or missing lock dirs?
 
473
        self._check_not_locked()
 
474
        tmpname = '%s/broken.%s.tmp' % (self.path, rand_chars(20))
 
475
        self.transport.rename(self._held_dir, tmpname)
 
476
        # check that we actually broke the right lock, not someone else;
 
477
        # there's a small race window between checking it and doing the
 
478
        # rename.
 
479
        broken_info_path = tmpname + self.__INFO_NAME
 
480
        broken_content = self.transport.get_bytes(broken_info_path)
 
481
        broken_lines = osutils.split_lines(broken_content)
 
482
        if broken_lines != corrupt_info_lines:
 
483
            raise LockBreakMismatch(self, broken_lines, corrupt_info_lines)
 
484
        self.transport.delete(broken_info_path)
 
485
        self.transport.rmdir(tmpname)
 
486
        result = lock.LockResult(self.transport.abspath(self.path))
 
487
        for hook in self.hooks['lock_broken']:
 
488
            hook(result)
383
489
 
384
490
    def _check_not_locked(self):
385
491
        """If the lock is held by this instance, raise an error."""
393
499
        or if the lock has been affected by a bug.
394
500
 
395
501
        If the lock is not thought to be held, raises LockNotHeld.  If
396
 
        the lock is thought to be held but has been broken, raises 
 
502
        the lock is thought to be held but has been broken, raises
397
503
        LockBroken.
398
504
        """
399
505
        if not self._lock_held:
405
511
        if info.get('nonce') != self.nonce:
406
512
            # there is a lock, but not ours
407
513
            raise LockBroken(self)
408
 
        
 
514
 
409
515
    def _read_info_file(self, path):
410
516
        """Read one given info file.
411
517
 
412
518
        peek() reads the info file of the lock holder, if any.
413
519
        """
414
 
        return self._parse_info(self.transport.get(path))
 
520
        return LockHeldInfo.from_info_file_bytes(
 
521
            self.transport.get_bytes(path))
415
522
 
416
523
    def peek(self):
417
524
        """Check if the lock is held by anyone.
418
 
        
419
 
        If it is held, this returns the lock info structure as a rio Stanza,
 
525
 
 
526
        If it is held, this returns the lock info structure as a dict
420
527
        which contains some information about the current lock holder.
421
528
        Otherwise returns None.
422
529
        """
430
537
    def _prepare_info(self):
431
538
        """Write information about a pending lock to a temporary file.
432
539
        """
433
 
        # XXX: is creating this here inefficient?
434
 
        config = bzrlib.config.GlobalConfig()
435
 
        try:
436
 
            user = config.user_email()
437
 
        except errors.NoEmailInUsername:
438
 
            user = config.username()
439
 
        s = rio.Stanza(hostname=get_host_name(),
440
 
                   pid=str(os.getpid()),
441
 
                   start_time=str(int(time.time())),
442
 
                   nonce=self.nonce,
443
 
                   user=user,
444
 
                   )
445
 
        return s.to_string()
446
 
 
447
 
    def _parse_info(self, info_file):
448
 
        return rio.read_stanza(info_file.readlines()).as_dict()
449
540
 
450
541
    def attempt_lock(self):
451
542
        """Take the lock; fail if it's already held.
452
 
        
 
543
 
453
544
        If you wish to block until the lock can be obtained, call wait_lock()
454
545
        instead.
455
546
 
465
556
            hook(hook_result)
466
557
        return result
467
558
 
 
559
    def lock_url_for_display(self):
 
560
        """Give a nicely-printable representation of the URL of this lock."""
 
561
        # As local lock urls are correct we display them.
 
562
        # We avoid displaying remote lock urls.
 
563
        lock_url = self.transport.abspath(self.path)
 
564
        if lock_url.startswith('file://'):
 
565
            lock_url = lock_url.split('.bzr/')[0]
 
566
        else:
 
567
            lock_url = ''
 
568
        return lock_url
 
569
 
468
570
    def wait_lock(self, timeout=None, poll=None, max_attempts=None):
469
571
        """Wait a certain period for a lock.
470
572
 
476
578
 
477
579
        :param timeout: Approximate maximum amount of time to wait for the
478
580
        lock, in seconds.
479
 
         
 
581
 
480
582
        :param poll: Delay in seconds between retrying the lock.
481
583
 
482
584
        :param max_attempts: Maximum number of times to try to lock.
494
596
        deadline_str = None
495
597
        last_info = None
496
598
        attempt_count = 0
 
599
        lock_url = self.lock_url_for_display()
497
600
        while True:
498
601
            attempt_count += 1
499
602
            try:
510
613
            new_info = self.peek()
511
614
            if new_info is not None and new_info != last_info:
512
615
                if last_info is None:
513
 
                    start = 'Unable to obtain'
 
616
                    start = gettext('Unable to obtain')
514
617
                else:
515
 
                    start = 'Lock owner changed for'
 
618
                    start = gettext('Lock owner changed for')
516
619
                last_info = new_info
517
 
                formatted_info = self._format_lock_info(new_info)
 
620
                msg = gettext('{0} lock {1} {2}.').format(start, lock_url,
 
621
                                                                    new_info)
518
622
                if deadline_str is None:
519
623
                    deadline_str = time.strftime('%H:%M:%S',
520
 
                                                 time.localtime(deadline))
521
 
                lock_url = self.transport.abspath(self.path)
522
 
                self._report_function('%s %s\n'
523
 
                                      '%s\n' # held by
524
 
                                      '%s\n' # locked ... ago
525
 
                                      'Will continue to try until %s, unless '
526
 
                                      'you press Ctrl-C\n'
527
 
                                      'If you\'re sure that it\'s not being '
528
 
                                      'modified, use bzr break-lock %s',
529
 
                                      start,
530
 
                                      formatted_info[0],
531
 
                                      formatted_info[1],
532
 
                                      formatted_info[2],
533
 
                                      deadline_str,
534
 
                                      lock_url)
535
 
 
 
624
                                                    time.localtime(deadline))
 
625
                if timeout > 0:
 
626
                    msg += '\n' + gettext(
 
627
                             'Will continue to try until %s, unless '
 
628
                             'you press Ctrl-C.') % deadline_str
 
629
                msg += '\n' + gettext('See "bzr help break-lock" for more.')
 
630
                self._report_function(msg)
536
631
            if (max_attempts is not None) and (attempt_count >= max_attempts):
537
632
                self._trace("exceeded %d attempts")
538
633
                raise LockContention(self)
540
635
                self._trace("waiting %ss", poll)
541
636
                time.sleep(poll)
542
637
            else:
 
638
                # As timeout is always 0 for remote locks
 
639
                # this block is applicable only for local
 
640
                # lock contention
543
641
                self._trace("timeout after waiting %ss", timeout)
544
 
                raise LockContention(self)
545
 
    
 
642
                raise LockContention('(local)', lock_url)
 
643
 
546
644
    def leave_in_place(self):
547
645
        self._locked_via_token = True
548
646
 
551
649
 
552
650
    def lock_write(self, token=None):
553
651
        """Wait for and acquire the lock.
554
 
        
 
652
 
555
653
        :param token: if this is already locked, then lock_write will fail
556
654
            unless the token matches the existing lock.
557
655
        :returns: a token if this instance supports tokens, otherwise None.
563
661
        A token should be passed in if you know that you have locked the object
564
662
        some other way, and need to synchronise this object's state with that
565
663
        fact.
566
 
         
 
664
 
567
665
        XXX: docstring duplicated from LockableFiles.lock_write.
568
666
        """
569
667
        if token is not None:
578
676
    def lock_read(self):
579
677
        """Compatibility-mode shared lock.
580
678
 
581
 
        LockDir doesn't support shared read-only locks, so this 
 
679
        LockDir doesn't support shared read-only locks, so this
582
680
        just pretends that the lock is taken but really does nothing.
583
681
        """
584
 
        # At the moment Branches are commonly locked for read, but 
 
682
        # At the moment Branches are commonly locked for read, but
585
683
        # we can't rely on that remotely.  Once this is cleaned up,
586
 
        # reenable this warning to prevent it coming back in 
 
684
        # reenable this warning to prevent it coming back in
587
685
        # -- mbp 20060303
588
686
        ## warn("LockDir.lock_read falls back to write lock")
589
687
        if self._lock_held or self._fake_read_lock:
590
688
            raise LockContention(self)
591
689
        self._fake_read_lock = True
592
690
 
593
 
    def _format_lock_info(self, info):
594
 
        """Turn the contents of peek() into something for the user"""
595
 
        lock_url = self.transport.abspath(self.path)
596
 
        delta = time.time() - int(info['start_time'])
597
 
        return [
598
 
            'lock %s' % (lock_url,),
599
 
            'held by %(user)s on host %(hostname)s [process #%(pid)s]' % info,
600
 
            'locked %s' % (format_delta(delta),),
601
 
            ]
602
 
 
603
691
    def validate_token(self, token):
604
692
        if token is not None:
605
693
            info = self.peek()
617
705
        if 'lock' not in debug.debug_flags:
618
706
            return
619
707
        mutter(str(self) + ": " + (format % args))
 
708
 
 
709
    def get_config(self):
 
710
        """Get the configuration that governs this lockdir."""
 
711
        # XXX: This really should also use the locationconfig at least, but
 
712
        # that seems a bit hard to hook up at the moment. -- mbp 20110329
 
713
        # FIXME: The above is still true ;) -- vila 20110811
 
714
        return config.GlobalStack()
 
715
 
 
716
 
 
717
class LockHeldInfo(object):
 
718
    """The information recorded about a held lock.
 
719
 
 
720
    This information is recorded into the lock when it's taken, and it can be
 
721
    read back by any process with access to the lockdir.  It can be used, for
 
722
    example, to tell the user who holds the lock, or to try to detect whether
 
723
    the lock holder is still alive.
 
724
 
 
725
    Prior to bzr 2.4 a simple dict was used instead of an object.
 
726
    """
 
727
 
 
728
    def __init__(self, info_dict):
 
729
        self.info_dict = info_dict
 
730
 
 
731
    def __repr__(self):
 
732
        """Return a debugging representation of this object."""
 
733
        return "%s(%r)" % (self.__class__.__name__, self.info_dict)
 
734
 
 
735
    def __unicode__(self):
 
736
        """Return a user-oriented description of this object."""
 
737
        d = self.to_readable_dict()
 
738
        return ( gettext(
 
739
            u'held by %(user)s on %(hostname)s (process #%(pid)s), '
 
740
            u'acquired %(time_ago)s') % d)
 
741
 
 
742
    def to_readable_dict(self):
 
743
        """Turn the holder info into a dict of human-readable attributes.
 
744
 
 
745
        For example, the start time is presented relative to the current time,
 
746
        rather than as seconds since the epoch.
 
747
 
 
748
        Returns a list of [user, hostname, pid, time_ago] all as readable
 
749
        strings.
 
750
        """
 
751
        start_time = self.info_dict.get('start_time')
 
752
        if start_time is None:
 
753
            time_ago = '(unknown)'
 
754
        else:
 
755
            time_ago = format_delta(
 
756
                time.time() - int(self.info_dict['start_time']))
 
757
        user = self.info_dict.get('user', '<unknown>')
 
758
        hostname = self.info_dict.get('hostname', '<unknown>')
 
759
        pid = self.info_dict.get('pid', '<unknown>')
 
760
        return dict(
 
761
            user=user,
 
762
            hostname=hostname,
 
763
            pid=pid,
 
764
            time_ago=time_ago)
 
765
 
 
766
    def get(self, field_name):
 
767
        """Return the contents of a field from the lock info, or None."""
 
768
        return self.info_dict.get(field_name)
 
769
 
 
770
    @classmethod
 
771
    def for_this_process(cls, extra_holder_info):
 
772
        """Return a new LockHeldInfo for a lock taken by this process.
 
773
        """
 
774
        info = dict(
 
775
            hostname=get_host_name(),
 
776
            pid=str(os.getpid()),
 
777
            nonce=rand_chars(20),
 
778
            start_time=str(int(time.time())),
 
779
            user=get_username_for_lock_info(),
 
780
            )
 
781
        if extra_holder_info is not None:
 
782
            info.update(extra_holder_info)
 
783
        return cls(info)
 
784
 
 
785
    def to_bytes(self):
 
786
        s = rio.Stanza(**self.info_dict)
 
787
        return s.to_string()
 
788
 
 
789
    @classmethod
 
790
    def from_info_file_bytes(cls, info_file_bytes):
 
791
        """Construct from the contents of the held file."""
 
792
        lines = osutils.split_lines(info_file_bytes)
 
793
        try:
 
794
            stanza = rio.read_stanza(lines)
 
795
        except ValueError, e:
 
796
            mutter('Corrupt lock info file: %r', lines)
 
797
            raise LockCorrupt("could not parse lock info file: " + str(e),
 
798
                lines)
 
799
        if stanza is None:
 
800
            # see bug 185013; we fairly often end up with the info file being
 
801
            # empty after an interruption; we could log a message here but
 
802
            # there may not be much we can say
 
803
            return cls({})
 
804
        else:
 
805
            return cls(stanza.as_dict())
 
806
 
 
807
    def __cmp__(self, other):
 
808
        """Value comparison of lock holders."""
 
809
        return (
 
810
            cmp(type(self), type(other))
 
811
            or cmp(self.info_dict, other.info_dict))
 
812
 
 
813
    def is_locked_by_this_process(self):
 
814
        """True if this process seems to be the current lock holder."""
 
815
        return (
 
816
            self.get('hostname') == get_host_name()
 
817
            and self.get('pid') == str(os.getpid())
 
818
            and self.get('user') == get_username_for_lock_info())
 
819
 
 
820
    def is_lock_holder_known_dead(self):
 
821
        """True if the lock holder process is known to be dead.
 
822
 
 
823
        False if it's either known to be still alive, or if we just can't tell.
 
824
 
 
825
        We can be fairly sure the lock holder is dead if it declared the same
 
826
        hostname and there is no process with the given pid alive.  If people
 
827
        have multiple machines with the same hostname this may cause trouble.
 
828
 
 
829
        This doesn't check whether the lock holder is in fact the same process
 
830
        calling this method.  (In that case it will return true.)
 
831
        """
 
832
        if self.get('hostname') != get_host_name():
 
833
            return False
 
834
        if self.get('hostname') == 'localhost':
 
835
            # Too ambiguous.
 
836
            return False
 
837
        if self.get('user') != get_username_for_lock_info():
 
838
            # Could well be another local process by a different user, but
 
839
            # just to be safe we won't conclude about this either.
 
840
            return False
 
841
        pid_str = self.info_dict.get('pid', None)
 
842
        if not pid_str:
 
843
            mutter("no pid recorded in %r" % (self, ))
 
844
            return False
 
845
        try:
 
846
            pid = int(pid_str)
 
847
        except ValueError:
 
848
            mutter("can't parse pid %r from %r"
 
849
                % (pid_str, self))
 
850
            return False
 
851
        return osutils.is_local_pid_dead(pid)
 
852
 
 
853
 
 
854
def get_username_for_lock_info():
 
855
    """Get a username suitable for putting into a lock.
 
856
 
 
857
    It's ok if what's written here is not a proper email address as long
 
858
    as it gives some clue who the user is.
 
859
    """
 
860
    try:
 
861
        return config.GlobalStack().get('email')
 
862
    except errors.NoWhoami:
 
863
        return osutils.getuser_unicode()