/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: Martin Pool
  • Date: 2009-07-27 06:28:35 UTC
  • mto: This revision was merged to the branch mainline in revision 4587.
  • Revision ID: mbp@sourcefrog.net-20090727062835-o66p8it658tq1sma
Add CountedLock.get_physical_lock_status

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, 2007, 2008 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
 
    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
 
113
    )
 
114
import bzrlib.config
 
115
from bzrlib.errors import (
 
116
        DirectoryNotEmpty,
 
117
        FileExists,
 
118
        LockBreakMismatch,
 
119
        LockBroken,
 
120
        LockContention,
 
121
        LockFailed,
 
122
        LockNotHeld,
 
123
        NoSuchFile,
 
124
        PathError,
 
125
        ResourceBusy,
 
126
        TransportError,
 
127
        )
 
128
from bzrlib.trace import mutter, note
 
129
from bzrlib.osutils import format_delta, rand_chars, get_host_name
 
130
import bzrlib.ui
147
131
 
 
132
from bzrlib.lazy_import import lazy_import
 
133
lazy_import(globals(), """
 
134
from bzrlib import rio
 
135
""")
148
136
 
149
137
# XXX: At the moment there is no consideration of thread safety on LockDir
150
138
# objects.  This should perhaps be updated - e.g. if two threads try to take a
161
149
# files/dirs created.
162
150
 
163
151
 
164
 
_DEFAULT_TIMEOUT_SECONDS = 30
 
152
_DEFAULT_TIMEOUT_SECONDS = 300
165
153
_DEFAULT_POLL_SECONDS = 1.0
166
154
 
167
155
 
171
159
 
172
160
    __INFO_NAME = '/info'
173
161
 
174
 
    def __init__(self, transport, path, file_modebits=0o644,
175
 
                 dir_modebits=0o755, extra_holder_info=None):
 
162
    def __init__(self, transport, path, file_modebits=0644, dir_modebits=0755):
176
163
        """Create a new LockDir object.
177
164
 
178
165
        The LockDir is initially unlocked - this just creates the object.
181
168
 
182
169
        :param path: Path to the lock within the base directory of the
183
170
            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
171
        """
189
172
        self.transport = transport
190
173
        self.path = path
195
178
        self._held_info_path = self._held_dir + self.__INFO_NAME
196
179
        self._file_modebits = file_modebits
197
180
        self._dir_modebits = dir_modebits
 
181
 
198
182
        self._report_function = note
199
 
        self.extra_holder_info = extra_holder_info
200
 
        self._warned_about_lock_holder = None
201
183
 
202
184
    def __repr__(self):
203
185
        return '%s(%s%s)' % (self.__class__.__name__,
215
197
        self._trace("create lock directory")
216
198
        try:
217
199
            self.transport.mkdir(self.path, mode=mode)
218
 
        except (TransportError, PathError) as e:
 
200
        except (TransportError, PathError), e:
219
201
            raise LockFailed(self, e)
220
202
 
 
203
 
221
204
    def _attempt_lock(self):
222
205
        """Make the pending directory and attempt to rename into place.
223
206
 
230
213
 
231
214
        :returns: The nonce of the lock, if it was successfully acquired.
232
215
 
233
 
        :raises LockContention: If the lock is held by someone else.  The
234
 
            exception contains the info of the current holder of the lock.
 
216
        :raises LockContention: If the lock is held by someone else.  The exception
 
217
            contains the info of the current holder of the lock.
235
218
        """
236
219
        self._trace("lock_write...")
237
220
        start_time = time.time()
238
221
        try:
239
222
            tmpname = self._create_pending_dir()
240
 
        except (errors.TransportError, PathError) as e:
 
223
        except (errors.TransportError, PathError), e:
241
224
            self._trace("... failed to create pending dir, %s", e)
242
225
            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
 
226
        try:
 
227
            self.transport.rename(tmpname, self._held_dir)
 
228
        except (errors.TransportError, PathError, DirectoryNotEmpty,
 
229
                FileExists, ResourceBusy), e:
 
230
            self._trace("... contention, %s", e)
 
231
            self._remove_pending_dir(tmpname)
 
232
            raise LockContention(self)
 
233
        except Exception, e:
 
234
            self._trace("... lock failed, %s", e)
 
235
            self._remove_pending_dir(tmpname)
 
236
            raise
261
237
        # We must check we really got the lock, because Launchpad's sftp
262
238
        # server at one time had a bug were the rename would successfully
263
239
        # move the new directory into the existing directory, which was
264
240
        # incorrect.  It's possible some other servers or filesystems will
265
241
        # have a similar bug allowing someone to think they got the lock
266
242
        # when it's already held.
267
 
        #
268
 
        # See <https://bugs.launchpad.net/bzr/+bug/498378> for one case.
269
 
        #
270
 
        # Strictly the check is unnecessary and a waste of time for most
271
 
        # people, but probably worth trapping if something is wrong.
272
243
        info = self.peek()
273
244
        self._trace("after locking, info=%r", info)
274
 
        if info is None:
275
 
            raise LockFailed(self, "lock was renamed into place, but "
276
 
                             "now is missing!")
277
 
        if info.get('nonce') != self.nonce:
 
245
        if info['nonce'] != self.nonce:
278
246
            self._trace("rename succeeded, "
279
 
                        "but lock is still held by someone else")
 
247
                "but lock is still held by someone else")
280
248
            raise LockContention(self)
281
249
        self._lock_held = True
282
250
        self._trace("... lock succeeded after %dms",
283
 
                    (time.time() - start_time) * 1000)
 
251
                (time.time() - start_time) * 1000)
284
252
        return self.nonce
285
253
 
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
254
    def _remove_pending_dir(self, tmpname):
312
255
        """Remove the pending directory
313
256
 
318
261
        try:
319
262
            self.transport.delete(tmpname + self.__INFO_NAME)
320
263
            self.transport.rmdir(tmpname)
321
 
        except PathError as e:
322
 
            note(gettext("error removing pending lock: %s"), e)
 
264
        except PathError, e:
 
265
            note("error removing pending lock: %s", e)
323
266
 
324
267
    def _create_pending_dir(self):
325
268
        tmpname = '%s/%s.tmp' % (self.path, rand_chars(10))
333
276
            self.create(mode=self._dir_modebits)
334
277
            # After creating the lock directory, try again
335
278
            self.transport.mkdir(tmpname)
336
 
        info = LockHeldInfo.for_this_process(self.extra_holder_info)
337
 
        self.nonce = info.get('nonce')
 
279
        self.nonce = rand_chars(20)
 
280
        info_bytes = self._prepare_info()
338
281
        # We use put_file_non_atomic because we just created a new unique
339
282
        # directory so we don't have to worry about files existing there.
340
283
        # We'll rename the whole directory into place to get atomic
341
284
        # properties
342
285
        self.transport.put_bytes_non_atomic(tmpname + self.__INFO_NAME,
343
 
                                            info.to_bytes())
 
286
                                            info_bytes)
344
287
        return tmpname
345
288
 
346
 
    @only_raises(LockNotHeld, LockBroken)
347
289
    def unlock(self):
348
290
        """Release a held lock
349
291
        """
369
311
            self.transport.delete(tmpname + self.__INFO_NAME)
370
312
            try:
371
313
                self.transport.rmdir(tmpname)
372
 
            except DirectoryNotEmpty:
 
314
            except DirectoryNotEmpty, e:
373
315
                # There might have been junk left over by a rename that moved
374
316
                # another locker within the 'held' directory.  do a slower
375
317
                # deletion where we list the directory and remove everything
376
318
                # within it.
 
319
                #
 
320
                # Maybe this should be broader to allow for ftp servers with
 
321
                # non-specific error messages?
377
322
                self._trace("doing recursive deletion of non-empty directory "
378
 
                            "%s", tmpname)
 
323
                        "%s", tmpname)
379
324
                self.transport.delete_tree(tmpname)
380
325
            self._trace("... unlock succeeded after %dms",
381
 
                        (time.time() - start_time) * 1000)
 
326
                    (time.time() - start_time) * 1000)
382
327
            result = lock.LockResult(self.transport.abspath(self.path),
383
328
                                     old_nonce)
384
329
            for hook in self.hooks['lock_released']:
387
332
    def break_lock(self):
388
333
        """Break a lock not held by this instance of LockDir.
389
334
 
390
 
        This is a UI centric function: it uses the ui.ui_factory to
 
335
        This is a UI centric function: it uses the bzrlib.ui.ui_factory to
391
336
        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.
 
337
        it possibly being still active.
396
338
        """
397
339
        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
 
340
        holder_info = self.peek()
405
341
        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)
 
342
            lock_info = '\n'.join(self._format_lock_info(holder_info))
 
343
            if bzrlib.ui.ui_factory.get_boolean("Break %s" % lock_info):
 
344
                self.force_break(holder_info)
413
345
 
414
346
    def force_break(self, dead_holder_info):
415
347
        """Release a lock held by another process.
418
350
        it still thinks it has the lock there will be two concurrent writers.
419
351
        In general the user's approval should be sought for lock breaks.
420
352
 
 
353
        dead_holder_info must be the result of a previous LockDir.peek() call;
 
354
        this is used to check that it's still held by the same process that
 
355
        the user decided was dead.  If this is not the current holder,
 
356
        LockBreakMismatch is raised.
 
357
 
421
358
        After the lock is broken it will not be held by any process.
422
359
        It is possible that another process may sneak in and take the
423
360
        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
361
        """
433
 
        if not isinstance(dead_holder_info, LockHeldInfo):
 
362
        if not isinstance(dead_holder_info, dict):
434
363
            raise ValueError("dead_holder_info: %r" % dead_holder_info)
435
364
        self._check_not_locked()
436
365
        current_info = self.peek()
454
383
                                 current_info.get('nonce'))
455
384
        for hook in self.hooks['lock_broken']:
456
385
            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
386
 
488
387
    def _check_not_locked(self):
489
388
        """If the lock is held by this instance, raise an error."""
515
414
 
516
415
        peek() reads the info file of the lock holder, if any.
517
416
        """
518
 
        return LockHeldInfo.from_info_file_bytes(
519
 
            self.transport.get_bytes(path))
 
417
        return self._parse_info(self.transport.get(path))
520
418
 
521
419
    def peek(self):
522
420
        """Check if the lock is held by anyone.
523
421
 
524
 
        If it is held, this returns the lock info structure as a dict
 
422
        If it is held, this returns the lock info structure as a rio Stanza,
525
423
        which contains some information about the current lock holder.
526
424
        Otherwise returns None.
527
425
        """
529
427
            info = self._read_info_file(self._held_info_path)
530
428
            self._trace("peek -> held")
531
429
            return info
532
 
        except NoSuchFile:
 
430
        except NoSuchFile, e:
533
431
            self._trace("peek -> not held")
534
432
 
535
433
    def _prepare_info(self):
536
434
        """Write information about a pending lock to a temporary file.
537
435
        """
 
436
        # XXX: is creating this here inefficient?
 
437
        config = bzrlib.config.GlobalConfig()
 
438
        try:
 
439
            user = config.user_email()
 
440
        except errors.NoEmailInUsername:
 
441
            user = config.username()
 
442
        s = rio.Stanza(hostname=get_host_name(),
 
443
                   pid=str(os.getpid()),
 
444
                   start_time=str(int(time.time())),
 
445
                   nonce=self.nonce,
 
446
                   user=user,
 
447
                   )
 
448
        return s.to_string()
 
449
 
 
450
    def _parse_info(self, info_file):
 
451
        return rio.read_stanza(info_file.readlines()).as_dict()
538
452
 
539
453
    def attempt_lock(self):
540
454
        """Take the lock; fail if it's already held.
549
463
            raise LockContention(self)
550
464
        result = self._attempt_lock()
551
465
        hook_result = lock.LockResult(self.transport.abspath(self.path),
552
 
                                      self.nonce)
 
466
                self.nonce)
553
467
        for hook in self.hooks['lock_acquired']:
554
468
            hook(hook_result)
555
469
        return result
556
470
 
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
471
    def wait_lock(self, timeout=None, poll=None, max_attempts=None):
569
472
        """Wait a certain period for a lock.
570
473
 
594
497
        deadline_str = None
595
498
        last_info = None
596
499
        attempt_count = 0
597
 
        lock_url = self.lock_url_for_display()
598
500
        while True:
599
501
            attempt_count += 1
600
502
            try:
611
513
            new_info = self.peek()
612
514
            if new_info is not None and new_info != last_info:
613
515
                if last_info is None:
614
 
                    start = gettext('Unable to obtain')
 
516
                    start = 'Unable to obtain'
615
517
                else:
616
 
                    start = gettext('Lock owner changed for')
 
518
                    start = 'Lock owner changed for'
617
519
                last_info = new_info
618
 
                msg = gettext('{0} lock {1} {2}.').format(start, lock_url,
619
 
                                                          new_info)
 
520
                formatted_info = self._format_lock_info(new_info)
620
521
                if deadline_str is None:
621
522
                    deadline_str = time.strftime('%H:%M:%S',
622
523
                                                 time.localtime(deadline))
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)
 
524
                lock_url = self.transport.abspath(self.path)
 
525
                self._report_function('%s %s\n'
 
526
                                      '%s\n' # held by
 
527
                                      '%s\n' # locked ... ago
 
528
                                      'Will continue to try until %s, unless '
 
529
                                      'you press Ctrl-C\n'
 
530
                                      'If you\'re sure that it\'s not being '
 
531
                                      'modified, use bzr break-lock %s',
 
532
                                      start,
 
533
                                      formatted_info[0],
 
534
                                      formatted_info[1],
 
535
                                      formatted_info[2],
 
536
                                      deadline_str,
 
537
                                      lock_url)
 
538
 
629
539
            if (max_attempts is not None) and (attempt_count >= max_attempts):
630
540
                self._trace("exceeded %d attempts")
631
541
                raise LockContention(self)
633
543
                self._trace("waiting %ss", poll)
634
544
                time.sleep(poll)
635
545
            else:
636
 
                # As timeout is always 0 for remote locks
637
 
                # this block is applicable only for local
638
 
                # lock contention
639
546
                self._trace("timeout after waiting %ss", timeout)
640
 
                raise LockContention('(local)', lock_url)
 
547
                raise LockContention(self)
641
548
 
642
549
    def leave_in_place(self):
643
550
        self._locked_via_token = True
681
588
        # we can't rely on that remotely.  Once this is cleaned up,
682
589
        # reenable this warning to prevent it coming back in
683
590
        # -- mbp 20060303
684
 
        # warn("LockDir.lock_read falls back to write lock")
 
591
        ## warn("LockDir.lock_read falls back to write lock")
685
592
        if self._lock_held or self._fake_read_lock:
686
593
            raise LockContention(self)
687
594
        self._fake_read_lock = True
688
595
 
 
596
    def _format_lock_info(self, info):
 
597
        """Turn the contents of peek() into something for the user"""
 
598
        lock_url = self.transport.abspath(self.path)
 
599
        delta = time.time() - int(info['start_time'])
 
600
        return [
 
601
            'lock %s' % (lock_url,),
 
602
            'held by %(user)s on host %(hostname)s [process #%(pid)s]' % info,
 
603
            'locked %s' % (format_delta(delta),),
 
604
            ]
 
605
 
689
606
    def validate_token(self, token):
690
607
        if token is not None:
691
608
            info = self.peek()
703
620
        if 'lock' not in debug.debug_flags:
704
621
            return
705
622
        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()