/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 breezy/lockdir.py

  • Committer: Jelmer Vernooij
  • Date: 2017-12-04 23:01:39 UTC
  • mto: This revision was merged to the branch mainline in revision 6839.
  • Revision ID: jelmer@jelmer.uk-20171204230139-1sc3c18ikwewdejm
Remove bytes_to_gzip; work with chunks instead.

Show diffs side-by-side

added added

removed removed

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