/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: 2020-04-05 19:11:34 UTC
  • mto: (7490.7.16 work)
  • mto: This revision was merged to the branch mainline in revision 7501.
  • Revision ID: jelmer@jelmer.uk-20200405191134-0aebh8ikiwygxma5
Populate the .gitignore file.

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,
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
 
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
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,
 
175
                 dir_modebits=0o755, 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 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
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.
251
273
        self._trace("after locking, info=%r", info)
252
274
        if info is None:
253
275
            raise LockFailed(self, "lock was renamed into place, but "
254
 
                "now is missing!")
 
276
                             "now is missing!")
255
277
        if info.get('nonce') != self.nonce:
256
278
            self._trace("rename succeeded, "
257
 
                "but lock is still held by someone else")
 
279
                        "but lock is still held by someone else")
258
280
            raise LockContention(self)
259
281
        self._lock_held = True
260
282
        self._trace("... lock succeeded after %dms",
261
 
                (time.time() - start_time) * 1000)
 
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:
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
329
376
                # within it.
330
 
                #
331
 
                # Maybe this should be broader to allow for ftp servers with
332
 
                # non-specific error messages?
333
377
                self._trace("doing recursive deletion of non-empty directory "
334
 
                        "%s", tmpname)
 
378
                            "%s", tmpname)
335
379
                self.transport.delete_tree(tmpname)
336
380
            self._trace("... unlock succeeded after %dms",
337
 
                    (time.time() - start_time) * 1000)
 
381
                        (time.time() - start_time) * 1000)
338
382
            result = lock.LockResult(self.transport.abspath(self.path),
339
383
                                     old_nonce)
340
384
            for hook in self.hooks['lock_released']:
343
387
    def break_lock(self):
344
388
        """Break a lock not held by this instance of LockDir.
345
389
 
346
 
        This is a UI centric function: it uses the bzrlib.ui.ui_factory to
 
390
        This is a UI centric function: it uses the ui.ui_factory to
347
391
        prompt for input if a lock is detected and there is any doubt about
348
 
        it possibly being still active.
 
392
        it possibly being still active.  force_break is the non-interactive
 
393
        version.
 
394
 
 
395
        :returns: LockResult for the broken lock.
349
396
        """
350
397
        self._check_not_locked()
351
 
        holder_info = self.peek()
 
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
352
405
        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)
 
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)
356
413
 
357
414
    def force_break(self, dead_holder_info):
358
415
        """Release a lock held by another process.
361
418
        it still thinks it has the lock there will be two concurrent writers.
362
419
        In general the user's approval should be sought for lock breaks.
363
420
 
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
421
        After the lock is broken it will not be held by any process.
370
422
        It is possible that another process may sneak in and take the
371
423
        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.
372
432
        """
373
 
        if not isinstance(dead_holder_info, dict):
 
433
        if not isinstance(dead_holder_info, LockHeldInfo):
374
434
            raise ValueError("dead_holder_info: %r" % dead_holder_info)
375
435
        self._check_not_locked()
376
436
        current_info = self.peek()
394
454
                                 current_info.get('nonce'))
395
455
        for hook in self.hooks['lock_broken']:
396
456
            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)
397
487
 
398
488
    def _check_not_locked(self):
399
489
        """If the lock is held by this instance, raise an error."""
425
515
 
426
516
        peek() reads the info file of the lock holder, if any.
427
517
        """
428
 
        return self._parse_info(self.transport.get_bytes(path))
 
518
        return LockHeldInfo.from_info_file_bytes(
 
519
            self.transport.get_bytes(path))
429
520
 
430
521
    def peek(self):
431
522
        """Check if the lock is held by anyone.
438
529
            info = self._read_info_file(self._held_info_path)
439
530
            self._trace("peek -> held")
440
531
            return info
441
 
        except NoSuchFile, e:
 
532
        except NoSuchFile:
442
533
            self._trace("peek -> not held")
443
534
 
444
535
    def _prepare_info(self):
445
536
        """Write information about a pending lock to a temporary file.
446
537
        """
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
538
 
471
539
    def attempt_lock(self):
472
540
        """Take the lock; fail if it's already held.
481
549
            raise LockContention(self)
482
550
        result = self._attempt_lock()
483
551
        hook_result = lock.LockResult(self.transport.abspath(self.path),
484
 
                self.nonce)
 
552
                                      self.nonce)
485
553
        for hook in self.hooks['lock_acquired']:
486
554
            hook(hook_result)
487
555
        return result
488
556
 
 
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
 
489
568
    def wait_lock(self, timeout=None, poll=None, max_attempts=None):
490
569
        """Wait a certain period for a lock.
491
570
 
515
594
        deadline_str = None
516
595
        last_info = None
517
596
        attempt_count = 0
 
597
        lock_url = self.lock_url_for_display()
518
598
        while True:
519
599
            attempt_count += 1
520
600
            try:
531
611
            new_info = self.peek()
532
612
            if new_info is not None and new_info != last_info:
533
613
                if last_info is None:
534
 
                    start = 'Unable to obtain'
 
614
                    start = gettext('Unable to obtain')
535
615
                else:
536
 
                    start = 'Lock owner changed for'
 
616
                    start = gettext('Lock owner changed for')
537
617
                last_info = new_info
538
 
                formatted_info = self._format_lock_info(new_info)
 
618
                msg = gettext('{0} lock {1} {2}.').format(start, lock_url,
 
619
                                                          new_info)
539
620
                if deadline_str is None:
540
621
                    deadline_str = time.strftime('%H:%M:%S',
541
622
                                                 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
 
 
 
623
                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)
560
629
            if (max_attempts is not None) and (attempt_count >= max_attempts):
561
630
                self._trace("exceeded %d attempts")
562
631
                raise LockContention(self)
564
633
                self._trace("waiting %ss", poll)
565
634
                time.sleep(poll)
566
635
            else:
 
636
                # As timeout is always 0 for remote locks
 
637
                # this block is applicable only for local
 
638
                # lock contention
567
639
                self._trace("timeout after waiting %ss", timeout)
568
 
                raise LockContention(self)
 
640
                raise LockContention('(local)', lock_url)
569
641
 
570
642
    def leave_in_place(self):
571
643
        self._locked_via_token = True
609
681
        # we can't rely on that remotely.  Once this is cleaned up,
610
682
        # reenable this warning to prevent it coming back in
611
683
        # -- mbp 20060303
612
 
        ## warn("LockDir.lock_read falls back to write lock")
 
684
        # warn("LockDir.lock_read falls back to write lock")
613
685
        if self._lock_held or self._fake_read_lock:
614
686
            raise LockContention(self)
615
687
        self._fake_read_lock = True
616
688
 
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
689
    def validate_token(self, token):
633
690
        if token is not None:
634
691
            info = self.peek()
646
703
        if 'lock' not in debug.debug_flags:
647
704
            return
648
705
        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()