/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: Andrew Bennetts
  • Date: 2009-07-23 07:37:05 UTC
  • mto: This revision was merged to the branch mainline in revision 4573.
  • Revision ID: andrew.bennetts@canonical.com-20090723073705-l9shzmc4ix74zv18
Handle failures more gracefully.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/lockdir.py
1
 
# Copyright (C) 2006-2010 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
110
110
    debug,
111
111
    errors,
112
112
    lock,
113
 
    osutils,
114
113
    )
115
114
import bzrlib.config
116
 
from bzrlib.decorators import only_raises
117
115
from bzrlib.errors import (
118
116
        DirectoryNotEmpty,
119
117
        FileExists,
183
181
 
184
182
        self._report_function = note
185
183
 
 
184
    def _url(self):
 
185
        try:
 
186
            url = self.transport.external_url()
 
187
        except errors.InProcessTransport:
 
188
            url = self.transport.base
 
189
        return url
 
190
 
186
191
    def __repr__(self):
187
192
        return '%s(%s%s)' % (self.__class__.__name__,
188
 
                             self.transport.base,
189
 
                             self.path)
 
193
                             self._url(), self.path)
190
194
 
191
195
    is_held = property(lambda self: self._lock_held)
192
196
 
242
246
        # incorrect.  It's possible some other servers or filesystems will
243
247
        # have a similar bug allowing someone to think they got the lock
244
248
        # when it's already held.
245
 
        #
246
 
        # See <https://bugs.edge.launchpad.net/bzr/+bug/498378> for one case.
247
 
        #
248
 
        # Strictly the check is unnecessary and a waste of time for most
249
 
        # people, but probably worth trapping if something is wrong.
250
249
        info = self.peek()
251
250
        self._trace("after locking, info=%r", info)
252
 
        if info is None:
253
 
            raise LockFailed(self, "lock was renamed into place, but "
254
 
                "now is missing!")
255
 
        if info.get('nonce') != self.nonce:
 
251
        if info['nonce'] != self.nonce:
256
252
            self._trace("rename succeeded, "
257
253
                "but lock is still held by someone else")
258
254
            raise LockContention(self)
296
292
                                            info_bytes)
297
293
        return tmpname
298
294
 
299
 
    @only_raises(LockNotHeld, LockBroken)
300
295
    def unlock(self):
301
296
        """Release a held lock
302
297
        """
304
299
            self._fake_read_lock = False
305
300
            return
306
301
        if not self._lock_held:
307
 
            return lock.cant_unlock_not_held(self)
 
302
            raise LockNotHeld(self)
308
303
        if self._locked_via_token:
309
304
            self._locked_via_token = False
310
305
            self._lock_held = False
425
420
 
426
421
        peek() reads the info file of the lock holder, if any.
427
422
        """
428
 
        return self._parse_info(self.transport.get_bytes(path))
 
423
        return self._parse_info(self.transport.get(path))
429
424
 
430
425
    def peek(self):
431
426
        """Check if the lock is held by anyone.
432
427
 
433
 
        If it is held, this returns the lock info structure as a dict
 
428
        If it is held, this returns the lock info structure as a rio Stanza,
434
429
        which contains some information about the current lock holder.
435
430
        Otherwise returns None.
436
431
        """
458
453
                   )
459
454
        return s.to_string()
460
455
 
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()
 
456
    def _parse_info(self, info_file):
 
457
        return rio.read_stanza(info_file.readlines()).as_dict()
470
458
 
471
459
    def attempt_lock(self):
472
460
        """Take the lock; fail if it's already held.
539
527
                if deadline_str is None:
540
528
                    deadline_str = time.strftime('%H:%M:%S',
541
529
                                                 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.
 
530
                lock_url = self._url()
547
531
                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
 
                    )
 
532
                                      '%s\n' # held by
 
533
                                      '%s\n' # locked ... ago
 
534
                                      'Will continue to try until %s, unless '
 
535
                                      'you press Ctrl-C\n'
 
536
                                      'If you\'re sure that it\'s not being '
 
537
                                      'modified, use bzr break-lock %s',
 
538
                                      start,
 
539
                                      formatted_info[0],
 
540
                                      formatted_info[1],
 
541
                                      formatted_info[2],
 
542
                                      deadline_str,
 
543
                                      lock_url)
559
544
 
560
545
            if (max_attempts is not None) and (attempt_count >= max_attempts):
561
546
                self._trace("exceeded %d attempts")
617
602
    def _format_lock_info(self, info):
618
603
        """Turn the contents of peek() into something for the user"""
619
604
        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']))
 
605
        delta = time.time() - int(info['start_time'])
625
606
        return [
626
607
            '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,),
 
608
            'held by %(user)s on host %(hostname)s [process #%(pid)s]' % info,
 
609
            'locked %s' % (format_delta(delta),),
630
610
            ]
631
611
 
632
612
    def validate_token(self, token):