/brz/remove-bazaar

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar

« back to all changes in this revision

Viewing changes to bzrlib/lockdir.py

  • Committer: Marius Kruger
  • Date: 2010-07-10 21:28:56 UTC
  • mto: (5384.1.1 integration)
  • mto: This revision was merged to the branch mainline in revision 5385.
  • Revision ID: marius.kruger@enerweb.co.za-20100710212856-uq4ji3go0u5se7hx
* Update documentation
* add NEWS

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/lockdir.py
1
 
# Copyright (C) 2006-2011 Canonical Ltd
 
1
# Copyright (C) 2006-2010 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
83
83
 
84
84
Example usage:
85
85
 
86
 
>>> from breezy.transport.memory import MemoryTransport
 
86
>>> from bzrlib.transport.memory import MemoryTransport
87
87
>>> # typically will be obtained from a BzrDir, Branch, etc
88
88
>>> t = MemoryTransport()
89
89
>>> l = LockDir(t, 'sample-lock')
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.
99
95
"""
100
96
 
101
 
from __future__ import absolute_import
102
 
 
103
97
 
104
98
# TODO: We sometimes have the problem that our attempt to rename '1234' to
105
99
# 'held' fails because the transport server moves into an existing directory,
112
106
import os
113
107
import time
114
108
 
115
 
from . import (
116
 
    config,
 
109
from bzrlib import (
117
110
    debug,
118
111
    errors,
119
112
    lock,
120
113
    osutils,
121
 
    rio,
122
 
    ui,
123
 
    urlutils,
124
 
    )
125
 
from .decorators import only_raises
126
 
from .errors import (
127
 
    DirectoryNotEmpty,
128
 
    FileExists,
129
 
    LockBreakMismatch,
130
 
    LockBroken,
131
 
    LockContention,
132
 
    LockCorrupt,
133
 
    LockFailed,
134
 
    LockNotHeld,
135
 
    NoSuchFile,
136
 
    PathError,
137
 
    ResourceBusy,
138
 
    TransportError,
139
 
    )
140
 
from .i18n import gettext
141
 
from .osutils import format_delta, rand_chars, get_host_name
142
 
from .sixish import (
143
 
    PY3,
144
 
    text_type,
145
 
    )
146
 
from .trace import mutter, note
 
114
    )
 
115
import bzrlib.config
 
116
from bzrlib.decorators import only_raises
 
117
from bzrlib.errors import (
 
118
        DirectoryNotEmpty,
 
119
        FileExists,
 
120
        LockBreakMismatch,
 
121
        LockBroken,
 
122
        LockContention,
 
123
        LockFailed,
 
124
        LockNotHeld,
 
125
        NoSuchFile,
 
126
        PathError,
 
127
        ResourceBusy,
 
128
        TransportError,
 
129
        )
 
130
from bzrlib.trace import mutter, note
 
131
from bzrlib.osutils import format_delta, rand_chars, get_host_name
 
132
import bzrlib.ui
147
133
 
 
134
from bzrlib.lazy_import import lazy_import
 
135
lazy_import(globals(), """
 
136
from bzrlib import rio
 
137
""")
148
138
 
149
139
# XXX: At the moment there is no consideration of thread safety on LockDir
150
140
# objects.  This should perhaps be updated - e.g. if two threads try to take a
171
161
 
172
162
    __INFO_NAME = '/info'
173
163
 
174
 
    def __init__(self, transport, path, file_modebits=0o644,
175
 
                 dir_modebits=0o755, extra_holder_info=None):
 
164
    def __init__(self, transport, path, file_modebits=0644, dir_modebits=0755):
176
165
        """Create a new LockDir object.
177
166
 
178
167
        The LockDir is initially unlocked - this just creates the object.
181
170
 
182
171
        :param path: Path to the lock within the base directory of the
183
172
            transport.
184
 
 
185
 
        :param extra_holder_info: If passed, {str:str} dict of extra or
186
 
            updated information to insert into the info file when the lock is
187
 
            taken.
188
173
        """
189
174
        self.transport = transport
190
175
        self.path = path
195
180
        self._held_info_path = self._held_dir + self.__INFO_NAME
196
181
        self._file_modebits = file_modebits
197
182
        self._dir_modebits = dir_modebits
 
183
 
198
184
        self._report_function = note
199
 
        self.extra_holder_info = extra_holder_info
200
 
        self._warned_about_lock_holder = None
201
185
 
202
186
    def __repr__(self):
203
187
        return '%s(%s%s)' % (self.__class__.__name__,
215
199
        self._trace("create lock directory")
216
200
        try:
217
201
            self.transport.mkdir(self.path, mode=mode)
218
 
        except (TransportError, PathError) as e:
 
202
        except (TransportError, PathError), e:
219
203
            raise LockFailed(self, e)
220
204
 
 
205
 
221
206
    def _attempt_lock(self):
222
207
        """Make the pending directory and attempt to rename into place.
223
208
 
230
215
 
231
216
        :returns: The nonce of the lock, if it was successfully acquired.
232
217
 
233
 
        :raises LockContention: If the lock is held by someone else.  The
234
 
            exception contains the info of the current holder of the lock.
 
218
        :raises LockContention: If the lock is held by someone else.  The exception
 
219
            contains the info of the current holder of the lock.
235
220
        """
236
221
        self._trace("lock_write...")
237
222
        start_time = time.time()
238
223
        try:
239
224
            tmpname = self._create_pending_dir()
240
 
        except (errors.TransportError, PathError) as e:
 
225
        except (errors.TransportError, PathError), e:
241
226
            self._trace("... failed to create pending dir, %s", e)
242
227
            raise LockFailed(self, e)
243
 
        while True:
244
 
            try:
245
 
                self.transport.rename(tmpname, self._held_dir)
246
 
                break
247
 
            except (errors.TransportError, PathError, DirectoryNotEmpty,
248
 
                    FileExists, ResourceBusy) as e:
249
 
                self._trace("... contention, %s", e)
250
 
                other_holder = self.peek()
251
 
                self._trace("other holder is %r" % other_holder)
252
 
                try:
253
 
                    self._handle_lock_contention(other_holder)
254
 
                except BaseException:
255
 
                    self._remove_pending_dir(tmpname)
256
 
                    raise
257
 
            except Exception as e:
258
 
                self._trace("... lock failed, %s", e)
259
 
                self._remove_pending_dir(tmpname)
260
 
                raise
 
228
        try:
 
229
            self.transport.rename(tmpname, self._held_dir)
 
230
        except (errors.TransportError, PathError, DirectoryNotEmpty,
 
231
                FileExists, ResourceBusy), e:
 
232
            self._trace("... contention, %s", e)
 
233
            self._remove_pending_dir(tmpname)
 
234
            raise LockContention(self)
 
235
        except Exception, e:
 
236
            self._trace("... lock failed, %s", e)
 
237
            self._remove_pending_dir(tmpname)
 
238
            raise
261
239
        # We must check we really got the lock, because Launchpad's sftp
262
240
        # server at one time had a bug were the rename would successfully
263
241
        # move the new directory into the existing directory, which was
273
251
        self._trace("after locking, info=%r", info)
274
252
        if info is None:
275
253
            raise LockFailed(self, "lock was renamed into place, but "
276
 
                             "now is missing!")
 
254
                "now is missing!")
277
255
        if info.get('nonce') != self.nonce:
278
256
            self._trace("rename succeeded, "
279
 
                        "but lock is still held by someone else")
 
257
                "but lock is still held by someone else")
280
258
            raise LockContention(self)
281
259
        self._lock_held = True
282
260
        self._trace("... lock succeeded after %dms",
283
 
                    (time.time() - start_time) * 1000)
 
261
                (time.time() - start_time) * 1000)
284
262
        return self.nonce
285
263
 
286
 
    def _handle_lock_contention(self, other_holder):
287
 
        """A lock we want to take is held by someone else.
288
 
 
289
 
        This function can: tell the user about it; possibly detect that it's
290
 
        safe or appropriate to steal the lock, or just raise an exception.
291
 
 
292
 
        If this function returns (without raising an exception) the lock will
293
 
        be attempted again.
294
 
 
295
 
        :param other_holder: A LockHeldInfo for the current holder; note that
296
 
            it might be None if the lock can be seen to be held but the info
297
 
            can't be read.
298
 
        """
299
 
        if (other_holder is not None):
300
 
            if other_holder.is_lock_holder_known_dead():
301
 
                if self.get_config().get('locks.steal_dead'):
302
 
                    ui.ui_factory.show_user_warning(
303
 
                        'locks_steal_dead',
304
 
                        lock_url=urlutils.join(self.transport.base, self.path),
305
 
                        other_holder_info=text_type(other_holder))
306
 
                    self.force_break(other_holder)
307
 
                    self._trace("stole lock from dead holder")
308
 
                    return
309
 
        raise LockContention(self)
310
 
 
311
264
    def _remove_pending_dir(self, tmpname):
312
265
        """Remove the pending directory
313
266
 
318
271
        try:
319
272
            self.transport.delete(tmpname + self.__INFO_NAME)
320
273
            self.transport.rmdir(tmpname)
321
 
        except PathError as e:
322
 
            note(gettext("error removing pending lock: %s"), e)
 
274
        except PathError, e:
 
275
            note("error removing pending lock: %s", e)
323
276
 
324
277
    def _create_pending_dir(self):
325
278
        tmpname = '%s/%s.tmp' % (self.path, rand_chars(10))
333
286
            self.create(mode=self._dir_modebits)
334
287
            # After creating the lock directory, try again
335
288
            self.transport.mkdir(tmpname)
336
 
        info = LockHeldInfo.for_this_process(self.extra_holder_info)
337
 
        self.nonce = info.get('nonce')
 
289
        self.nonce = rand_chars(20)
 
290
        info_bytes = self._prepare_info()
338
291
        # We use put_file_non_atomic because we just created a new unique
339
292
        # directory so we don't have to worry about files existing there.
340
293
        # We'll rename the whole directory into place to get atomic
341
294
        # properties
342
295
        self.transport.put_bytes_non_atomic(tmpname + self.__INFO_NAME,
343
 
                                            info.to_bytes())
 
296
                                            info_bytes)
344
297
        return tmpname
345
298
 
346
299
    @only_raises(LockNotHeld, LockBroken)
369
322
            self.transport.delete(tmpname + self.__INFO_NAME)
370
323
            try:
371
324
                self.transport.rmdir(tmpname)
372
 
            except DirectoryNotEmpty:
 
325
            except DirectoryNotEmpty, e:
373
326
                # There might have been junk left over by a rename that moved
374
327
                # another locker within the 'held' directory.  do a slower
375
328
                # deletion where we list the directory and remove everything
376
329
                # within it.
 
330
                #
 
331
                # Maybe this should be broader to allow for ftp servers with
 
332
                # non-specific error messages?
377
333
                self._trace("doing recursive deletion of non-empty directory "
378
 
                            "%s", tmpname)
 
334
                        "%s", tmpname)
379
335
                self.transport.delete_tree(tmpname)
380
336
            self._trace("... unlock succeeded after %dms",
381
 
                        (time.time() - start_time) * 1000)
 
337
                    (time.time() - start_time) * 1000)
382
338
            result = lock.LockResult(self.transport.abspath(self.path),
383
339
                                     old_nonce)
384
340
            for hook in self.hooks['lock_released']:
387
343
    def break_lock(self):
388
344
        """Break a lock not held by this instance of LockDir.
389
345
 
390
 
        This is a UI centric function: it uses the ui.ui_factory to
 
346
        This is a UI centric function: it uses the bzrlib.ui.ui_factory to
391
347
        prompt for input if a lock is detected and there is any doubt about
392
 
        it possibly being still active.  force_break is the non-interactive
393
 
        version.
394
 
 
395
 
        :returns: LockResult for the broken lock.
 
348
        it possibly being still active.
396
349
        """
397
350
        self._check_not_locked()
398
 
        try:
399
 
            holder_info = self.peek()
400
 
        except LockCorrupt as e:
401
 
            # The lock info is corrupt.
402
 
            if ui.ui_factory.get_boolean(u"Break (corrupt %r)" % (self,)):
403
 
                self.force_break_corrupt(e.file_data)
404
 
            return
 
351
        holder_info = self.peek()
405
352
        if holder_info is not None:
406
 
            if ui.ui_factory.confirm_action(
407
 
                u"Break %(lock_info)s",
408
 
                'breezy.lockdir.break',
409
 
                    dict(lock_info=text_type(holder_info))):
410
 
                result = self.force_break(holder_info)
411
 
                ui.ui_factory.show_message(
412
 
                    "Broke lock %s" % result.lock_url)
 
353
            lock_info = '\n'.join(self._format_lock_info(holder_info))
 
354
            if bzrlib.ui.ui_factory.get_boolean("Break %s" % lock_info):
 
355
                self.force_break(holder_info)
413
356
 
414
357
    def force_break(self, dead_holder_info):
415
358
        """Release a lock held by another process.
418
361
        it still thinks it has the lock there will be two concurrent writers.
419
362
        In general the user's approval should be sought for lock breaks.
420
363
 
 
364
        dead_holder_info must be the result of a previous LockDir.peek() call;
 
365
        this is used to check that it's still held by the same process that
 
366
        the user decided was dead.  If this is not the current holder,
 
367
        LockBreakMismatch is raised.
 
368
 
421
369
        After the lock is broken it will not be held by any process.
422
370
        It is possible that another process may sneak in and take the
423
371
        lock before the breaking process acquires it.
424
 
 
425
 
        :param dead_holder_info:
426
 
            Must be the result of a previous LockDir.peek() call; this is used
427
 
            to check that it's still held by the same process that the user
428
 
            decided was dead.  If this is not the current holder,
429
 
            LockBreakMismatch is raised.
430
 
 
431
 
        :returns: LockResult for the broken lock.
432
372
        """
433
 
        if not isinstance(dead_holder_info, LockHeldInfo):
 
373
        if not isinstance(dead_holder_info, dict):
434
374
            raise ValueError("dead_holder_info: %r" % dead_holder_info)
435
375
        self._check_not_locked()
436
376
        current_info = self.peek()
454
394
                                 current_info.get('nonce'))
455
395
        for hook in self.hooks['lock_broken']:
456
396
            hook(result)
457
 
        return result
458
 
 
459
 
    def force_break_corrupt(self, corrupt_info_lines):
460
 
        """Release a lock that has been corrupted.
461
 
 
462
 
        This is very similar to force_break, it except it doesn't assume that
463
 
        self.peek() can work.
464
 
 
465
 
        :param corrupt_info_lines: the lines of the corrupted info file, used
466
 
            to check that the lock hasn't changed between reading the (corrupt)
467
 
            info file and calling force_break_corrupt.
468
 
        """
469
 
        # XXX: this copes with unparseable info files, but what about missing
470
 
        # info files?  Or missing lock dirs?
471
 
        self._check_not_locked()
472
 
        tmpname = '%s/broken.%s.tmp' % (self.path, rand_chars(20))
473
 
        self.transport.rename(self._held_dir, tmpname)
474
 
        # check that we actually broke the right lock, not someone else;
475
 
        # there's a small race window between checking it and doing the
476
 
        # rename.
477
 
        broken_info_path = tmpname + self.__INFO_NAME
478
 
        broken_content = self.transport.get_bytes(broken_info_path)
479
 
        broken_lines = osutils.split_lines(broken_content)
480
 
        if broken_lines != corrupt_info_lines:
481
 
            raise LockBreakMismatch(self, broken_lines, corrupt_info_lines)
482
 
        self.transport.delete(broken_info_path)
483
 
        self.transport.rmdir(tmpname)
484
 
        result = lock.LockResult(self.transport.abspath(self.path))
485
 
        for hook in self.hooks['lock_broken']:
486
 
            hook(result)
487
397
 
488
398
    def _check_not_locked(self):
489
399
        """If the lock is held by this instance, raise an error."""
515
425
 
516
426
        peek() reads the info file of the lock holder, if any.
517
427
        """
518
 
        return LockHeldInfo.from_info_file_bytes(
519
 
            self.transport.get_bytes(path))
 
428
        return self._parse_info(self.transport.get_bytes(path))
520
429
 
521
430
    def peek(self):
522
431
        """Check if the lock is held by anyone.
529
438
            info = self._read_info_file(self._held_info_path)
530
439
            self._trace("peek -> held")
531
440
            return info
532
 
        except NoSuchFile:
 
441
        except NoSuchFile, e:
533
442
            self._trace("peek -> not held")
534
443
 
535
444
    def _prepare_info(self):
536
445
        """Write information about a pending lock to a temporary file.
537
446
        """
 
447
        # XXX: is creating this here inefficient?
 
448
        config = bzrlib.config.GlobalConfig()
 
449
        try:
 
450
            user = config.username()
 
451
        except errors.NoWhoami:
 
452
            user = osutils.getuser_unicode()
 
453
        s = rio.Stanza(hostname=get_host_name(),
 
454
                   pid=str(os.getpid()),
 
455
                   start_time=str(int(time.time())),
 
456
                   nonce=self.nonce,
 
457
                   user=user,
 
458
                   )
 
459
        return s.to_string()
 
460
 
 
461
    def _parse_info(self, info_bytes):
 
462
        stanza = rio.read_stanza(osutils.split_lines(info_bytes))
 
463
        if stanza is None:
 
464
            # see bug 185013; we fairly often end up with the info file being
 
465
            # empty after an interruption; we could log a message here but
 
466
            # there may not be much we can say
 
467
            return {}
 
468
        else:
 
469
            return stanza.as_dict()
538
470
 
539
471
    def attempt_lock(self):
540
472
        """Take the lock; fail if it's already held.
549
481
            raise LockContention(self)
550
482
        result = self._attempt_lock()
551
483
        hook_result = lock.LockResult(self.transport.abspath(self.path),
552
 
                                      self.nonce)
 
484
                self.nonce)
553
485
        for hook in self.hooks['lock_acquired']:
554
486
            hook(hook_result)
555
487
        return result
556
488
 
557
 
    def lock_url_for_display(self):
558
 
        """Give a nicely-printable representation of the URL of this lock."""
559
 
        # As local lock urls are correct we display them.
560
 
        # We avoid displaying remote lock urls.
561
 
        lock_url = self.transport.abspath(self.path)
562
 
        if lock_url.startswith('file://'):
563
 
            lock_url = lock_url.split('.bzr/')[0]
564
 
        else:
565
 
            lock_url = ''
566
 
        return lock_url
567
 
 
568
489
    def wait_lock(self, timeout=None, poll=None, max_attempts=None):
569
490
        """Wait a certain period for a lock.
570
491
 
594
515
        deadline_str = None
595
516
        last_info = None
596
517
        attempt_count = 0
597
 
        lock_url = self.lock_url_for_display()
598
518
        while True:
599
519
            attempt_count += 1
600
520
            try:
611
531
            new_info = self.peek()
612
532
            if new_info is not None and new_info != last_info:
613
533
                if last_info is None:
614
 
                    start = gettext('Unable to obtain')
 
534
                    start = 'Unable to obtain'
615
535
                else:
616
 
                    start = gettext('Lock owner changed for')
 
536
                    start = 'Lock owner changed for'
617
537
                last_info = new_info
618
 
                msg = gettext('{0} lock {1} {2}.').format(start, lock_url,
619
 
                                                          new_info)
 
538
                formatted_info = self._format_lock_info(new_info)
620
539
                if deadline_str is None:
621
540
                    deadline_str = time.strftime('%H:%M:%S',
622
541
                                                 time.localtime(deadline))
 
542
                # As local lock urls are correct we display them.
 
543
                # We avoid displaying remote lock urls.
 
544
                lock_url = self.transport.abspath(self.path)
 
545
                if lock_url.startswith('file://'):
 
546
                    lock_url = lock_url.split('.bzr/')[0]
 
547
                else:
 
548
                    lock_url = ''
 
549
                user, hostname, pid, time_ago = formatted_info
 
550
                msg = ('%s lock %s '        # lock_url
 
551
                    'held by '              # start
 
552
                    '%s\n'                  # user
 
553
                    'at %s '                # hostname
 
554
                    '[process #%s], '       # pid
 
555
                    'acquired %s.')         # time ago
 
556
                msg_args = [start, lock_url, user, hostname, pid, time_ago]
623
557
                if timeout > 0:
624
 
                    msg += '\n' + gettext(
625
 
                        'Will continue to try until %s, unless '
626
 
                        'you press Ctrl-C.') % deadline_str
627
 
                msg += '\n' + gettext('See "brz help break-lock" for more.')
628
 
                self._report_function(msg)
 
558
                    msg += ('\nWill continue to try until %s, unless '
 
559
                        'you press Ctrl-C.')
 
560
                    msg_args.append(deadline_str)
 
561
                msg += '\nSee "bzr help break-lock" for more.'
 
562
                self._report_function(msg, *msg_args)
629
563
            if (max_attempts is not None) and (attempt_count >= max_attempts):
630
564
                self._trace("exceeded %d attempts")
631
565
                raise LockContention(self)
681
615
        # we can't rely on that remotely.  Once this is cleaned up,
682
616
        # reenable this warning to prevent it coming back in
683
617
        # -- mbp 20060303
684
 
        # warn("LockDir.lock_read falls back to write lock")
 
618
        ## warn("LockDir.lock_read falls back to write lock")
685
619
        if self._lock_held or self._fake_read_lock:
686
620
            raise LockContention(self)
687
621
        self._fake_read_lock = True
688
622
 
 
623
    def _format_lock_info(self, info):
 
624
        """Turn the contents of peek() into something for the user"""
 
625
        start_time = info.get('start_time')
 
626
        if start_time is None:
 
627
            time_ago = '(unknown)'
 
628
        else:
 
629
            time_ago = format_delta(time.time() - int(info['start_time']))
 
630
        user = info.get('user', '<unknown>')
 
631
        hostname = info.get('hostname', '<unknown>')
 
632
        pid = info.get('pid', '<unknown>')
 
633
        return [
 
634
            user,
 
635
            hostname,
 
636
            pid,
 
637
            time_ago,
 
638
            ]
 
639
 
689
640
    def validate_token(self, token):
690
641
        if token is not None:
691
642
            info = self.peek()
703
654
        if 'lock' not in debug.debug_flags:
704
655
            return
705
656
        mutter(str(self) + ": " + (format % args))
706
 
 
707
 
    def get_config(self):
708
 
        """Get the configuration that governs this lockdir."""
709
 
        # XXX: This really should also use the locationconfig at least, but
710
 
        # that seems a bit hard to hook up at the moment. -- mbp 20110329
711
 
        # FIXME: The above is still true ;) -- vila 20110811
712
 
        return config.GlobalStack()
713
 
 
714
 
 
715
 
class LockHeldInfo(object):
716
 
    """The information recorded about a held lock.
717
 
 
718
 
    This information is recorded into the lock when it's taken, and it can be
719
 
    read back by any process with access to the lockdir.  It can be used, for
720
 
    example, to tell the user who holds the lock, or to try to detect whether
721
 
    the lock holder is still alive.
722
 
 
723
 
    Prior to bzr 2.4 a simple dict was used instead of an object.
724
 
    """
725
 
 
726
 
    def __init__(self, info_dict):
727
 
        self.info_dict = info_dict
728
 
 
729
 
    def __repr__(self):
730
 
        """Return a debugging representation of this object."""
731
 
        return "%s(%r)" % (self.__class__.__name__, self.info_dict)
732
 
 
733
 
    def __unicode__(self):
734
 
        """Return a user-oriented description of this object."""
735
 
        d = self.to_readable_dict()
736
 
        return (gettext(
737
 
            u'held by %(user)s on %(hostname)s (process #%(pid)s), '
738
 
            u'acquired %(time_ago)s') % d)
739
 
 
740
 
    if PY3:
741
 
        __str__ = __unicode__
742
 
 
743
 
    def to_readable_dict(self):
744
 
        """Turn the holder info into a dict of human-readable attributes.
745
 
 
746
 
        For example, the start time is presented relative to the current time,
747
 
        rather than as seconds since the epoch.
748
 
 
749
 
        Returns a list of [user, hostname, pid, time_ago] all as readable
750
 
        strings.
751
 
        """
752
 
        start_time = self.info_dict.get('start_time')
753
 
        if start_time is None:
754
 
            time_ago = '(unknown)'
755
 
        else:
756
 
            time_ago = format_delta(
757
 
                time.time() - int(self.info_dict['start_time']))
758
 
        user = self.info_dict.get('user', '<unknown>')
759
 
        hostname = self.info_dict.get('hostname', '<unknown>')
760
 
        pid = self.info_dict.get('pid', '<unknown>')
761
 
        return dict(
762
 
            user=user,
763
 
            hostname=hostname,
764
 
            pid=pid,
765
 
            time_ago=time_ago)
766
 
 
767
 
    def get(self, field_name):
768
 
        """Return the contents of a field from the lock info, or None."""
769
 
        return self.info_dict.get(field_name)
770
 
 
771
 
    @classmethod
772
 
    def for_this_process(cls, extra_holder_info):
773
 
        """Return a new LockHeldInfo for a lock taken by this process.
774
 
        """
775
 
        info = dict(
776
 
            hostname=get_host_name(),
777
 
            pid=str(os.getpid()),
778
 
            nonce=rand_chars(20).encode('ascii'),
779
 
            start_time=str(int(time.time())),
780
 
            user=get_username_for_lock_info(),
781
 
            )
782
 
        if extra_holder_info is not None:
783
 
            info.update(extra_holder_info)
784
 
        return cls(info)
785
 
 
786
 
    def to_bytes(self):
787
 
        s = rio.Stanza(**self.info_dict)
788
 
        return s.to_string()
789
 
 
790
 
    @classmethod
791
 
    def from_info_file_bytes(cls, info_file_bytes):
792
 
        """Construct from the contents of the held file."""
793
 
        lines = osutils.split_lines(info_file_bytes)
794
 
        try:
795
 
            stanza = rio.read_stanza(lines)
796
 
        except ValueError as e:
797
 
            mutter('Corrupt lock info file: %r', lines)
798
 
            raise LockCorrupt("could not parse lock info file: " + str(e),
799
 
                              lines)
800
 
        if stanza is None:
801
 
            # see bug 185013; we fairly often end up with the info file being
802
 
            # empty after an interruption; we could log a message here but
803
 
            # there may not be much we can say
804
 
            return cls({})
805
 
        else:
806
 
            ret = stanza.as_dict()
807
 
            ret['nonce'] = ret['nonce'].encode('ascii')
808
 
            return cls(ret)
809
 
 
810
 
    def __hash__(self):
811
 
        return id(self)
812
 
 
813
 
    def __eq__(self, other):
814
 
        """Equality check for lock holders."""
815
 
        if type(self) != type(other):
816
 
            return False
817
 
        return self.info_dict == other.info_dict
818
 
 
819
 
    def __ne__(self, other):
820
 
        return not self == other
821
 
 
822
 
    def is_locked_by_this_process(self):
823
 
        """True if this process seems to be the current lock holder."""
824
 
        return (
825
 
            self.get('hostname') == get_host_name()
826
 
            and self.get('pid') == str(os.getpid())
827
 
            and self.get('user') == get_username_for_lock_info())
828
 
 
829
 
    def is_lock_holder_known_dead(self):
830
 
        """True if the lock holder process is known to be dead.
831
 
 
832
 
        False if it's either known to be still alive, or if we just can't tell.
833
 
 
834
 
        We can be fairly sure the lock holder is dead if it declared the same
835
 
        hostname and there is no process with the given pid alive.  If people
836
 
        have multiple machines with the same hostname this may cause trouble.
837
 
 
838
 
        This doesn't check whether the lock holder is in fact the same process
839
 
        calling this method.  (In that case it will return true.)
840
 
        """
841
 
        if self.get('hostname') != get_host_name():
842
 
            return False
843
 
        if self.get('hostname') == 'localhost':
844
 
            # Too ambiguous.
845
 
            return False
846
 
        if self.get('user') != get_username_for_lock_info():
847
 
            # Could well be another local process by a different user, but
848
 
            # just to be safe we won't conclude about this either.
849
 
            return False
850
 
        pid_str = self.info_dict.get('pid', None)
851
 
        if not pid_str:
852
 
            mutter("no pid recorded in %r" % (self, ))
853
 
            return False
854
 
        try:
855
 
            pid = int(pid_str)
856
 
        except ValueError:
857
 
            mutter("can't parse pid %r from %r"
858
 
                   % (pid_str, self))
859
 
            return False
860
 
        return osutils.is_local_pid_dead(pid)
861
 
 
862
 
 
863
 
def get_username_for_lock_info():
864
 
    """Get a username suitable for putting into a lock.
865
 
 
866
 
    It's ok if what's written here is not a proper email address as long
867
 
    as it gives some clue who the user is.
868
 
    """
869
 
    try:
870
 
        return config.GlobalStack().get('email')
871
 
    except errors.NoWhoami:
872
 
        return osutils.getuser_unicode()