← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/errors.py

  • Committer: Vincent Ladeuil
  • Date: 2016-01-21 11:42:23 UTC
  • mto: This revision was merged to the branch mainline in revision 6610.
  • Revision ID: v.ladeuil+lp@free.fr-20160121114223-ngcvndi02ydiqs5z
Allow hyphens in option names to unbreak compatibility.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/errors.py
1
 
# Copyright (C) 2005, 2006, 2007, 2008 Canonical Ltd
 
1
# Copyright (C) 2005-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
17
17
"""Exceptions for bzr, and reporting of them.
18
18
"""
19
19
 
20
 
from bzrlib import (
21
 
    osutils,
22
 
    symbol_versioning,
23
 
    )
24
 
from bzrlib.patches import (
25
 
    MalformedHunkHeader,
26
 
    MalformedLine,
27
 
    MalformedPatchHeader,
28
 
    PatchConflict,
29
 
    PatchSyntax,
30
 
    )
31
 
 
 
20
from __future__ import absolute_import
32
21
 
33
22
# TODO: is there any value in providing the .args field used by standard
34
23
# python exceptions?   A list of values with no names seems less useful
54
43
    Base class for errors raised by bzrlib.
55
44
 
56
45
    :cvar internal_error: if True this was probably caused by a bzr bug and
57
 
    should be displayed with a traceback; if False (or absent) this was
58
 
    probably a user or environment error and they don't need the gory details.
59
 
    (That can be overridden by -Derror on the command line.)
 
46
        should be displayed with a traceback; if False (or absent) this was
 
47
        probably a user or environment error and they don't need the gory
 
48
        details.  (That can be overridden by -Derror on the command line.)
60
49
 
61
50
    :cvar _fmt: Format string to display the error; this is expanded
62
 
    by the instance's dict.
 
51
        by the instance's dict.
63
52
    """
64
53
 
65
54
    internal_error = False
106
95
                # __str__() should always return a 'str' object
107
96
                # never a 'unicode' object.
108
97
                return s
109
 
        except (AttributeError, TypeError, NameError, ValueError, KeyError), e:
110
 
            return 'Unprintable exception %s: dict=%r, fmt=%r, error=%r' \
111
 
                % (self.__class__.__name__,
112
 
                   self.__dict__,
113
 
                   getattr(self, '_fmt', None),
114
 
                   e)
 
98
        except Exception, e:
 
99
            pass # just bind to 'e' for formatting below
 
100
        else:
 
101
            e = None
 
102
        return 'Unprintable exception %s: dict=%r, fmt=%r, error=%r' \
 
103
            % (self.__class__.__name__,
 
104
               self.__dict__,
 
105
               getattr(self, '_fmt', None),
 
106
               e)
115
107
 
116
108
    def __unicode__(self):
117
109
        u = self._format()
140
132
        """Return format string for this exception or None"""
141
133
        fmt = getattr(self, '_fmt', None)
142
134
        if fmt is not None:
143
 
            return fmt
144
 
        fmt = getattr(self, '__doc__', None)
145
 
        if fmt is not None:
146
 
            symbol_versioning.warn("%s uses its docstring as a format, "
147
 
                    "it should use _fmt instead" % self.__class__.__name__,
148
 
                    DeprecationWarning)
149
 
            return fmt
150
 
        return 'Unprintable exception %s: dict=%r, fmt=%r' \
151
 
            % (self.__class__.__name__,
152
 
               self.__dict__,
153
 
               getattr(self, '_fmt', None),
154
 
               )
 
135
            from bzrlib.i18n import gettext
 
136
            return gettext(unicode(fmt)) # _fmt strings should be ascii
155
137
 
156
138
    def __eq__(self, other):
157
139
        if self.__class__ is not other.__class__:
170
152
    internal_error = True
171
153
 
172
154
 
173
 
class BzrNewError(BzrError):
174
 
    """Deprecated error base class."""
175
 
    # base classes should override the docstring with their human-
176
 
    # readable explanation
177
 
 
178
 
    def __init__(self, *args, **kwds):
179
 
        # XXX: Use the underlying BzrError to always generate the args
180
 
        # attribute if it doesn't exist.  We can't use super here, because
181
 
        # exceptions are old-style classes in python2.4 (but new in 2.5).
182
 
        # --bmc, 20060426
183
 
        symbol_versioning.warn('BzrNewError was deprecated in bzr 0.13; '
184
 
             'please convert %s to use BzrError instead'
185
 
             % self.__class__.__name__,
186
 
             DeprecationWarning,
187
 
             stacklevel=2)
188
 
        BzrError.__init__(self, *args)
189
 
        for key, value in kwds.items():
190
 
            setattr(self, key, value)
191
 
 
192
 
    def __str__(self):
193
 
        try:
194
 
            # __str__() should always return a 'str' object
195
 
            # never a 'unicode' object.
196
 
            s = self.__doc__ % self.__dict__
197
 
            if isinstance(s, unicode):
198
 
                return s.encode('utf8')
199
 
            return s
200
 
        except (TypeError, NameError, ValueError, KeyError), e:
201
 
            return 'Unprintable exception %s(%r): %r' \
202
 
                % (self.__class__.__name__,
203
 
                   self.__dict__, e)
204
 
 
205
 
 
206
155
class AlreadyBuilding(BzrError):
207
156
 
208
157
    _fmt = "The tree builder is already building a tree."
304
253
class RootMissing(InternalBzrError):
305
254
 
306
255
    _fmt = ("The root entry of a tree must be the first entry supplied to "
307
 
        "record_entry_contents.")
 
256
        "the commit builder.")
308
257
 
309
258
 
310
259
class NoPublicBranch(BzrError):
621
570
 
622
571
    _fmt = 'Unsupported protocol for url "%(path)s"%(extra)s'
623
572
 
624
 
    def __init__(self, url, extra):
 
573
    def __init__(self, url, extra=""):
625
574
        PathError.__init__(self, url, extra=extra)
626
575
 
627
576
 
680
629
 
681
630
    _fmt = 'Path "%(path)s" is not a child of path "%(base)s"%(extra)s'
682
631
 
683
 
    internal_error = True
 
632
    internal_error = False
684
633
 
685
634
    def __init__(self, path, base, extra=None):
686
635
        BzrError.__init__(self)
702
651
# TODO: Probably this behavior of should be a common superclass
703
652
class NotBranchError(PathError):
704
653
 
705
 
    _fmt = 'Not a branch: "%(path)s".'
 
654
    _fmt = 'Not a branch: "%(path)s"%(detail)s.'
706
655
 
707
 
    def __init__(self, path):
 
656
    def __init__(self, path, detail=None, bzrdir=None):
708
657
       import bzrlib.urlutils as urlutils
709
 
       self.path = urlutils.unescape_for_display(path, 'ascii')
 
658
       path = urlutils.unescape_for_display(path, 'ascii')
 
659
       if detail is not None:
 
660
           detail = ': ' + detail
 
661
       self.detail = detail
 
662
       self.bzrdir = bzrdir
 
663
       PathError.__init__(self, path=path)
 
664
 
 
665
    def __repr__(self):
 
666
        return '<%s %r>' % (self.__class__.__name__, self.__dict__)
 
667
 
 
668
    def _format(self):
 
669
        # XXX: Ideally self.detail would be a property, but Exceptions in
 
670
        # Python 2.4 have to be old-style classes so properties don't work.
 
671
        # Instead we override _format.
 
672
        if self.detail is None:
 
673
            if self.bzrdir is not None:
 
674
                try:
 
675
                    self.bzrdir.open_repository()
 
676
                except NoRepositoryPresent:
 
677
                    self.detail = ''
 
678
                except Exception:
 
679
                    # Just ignore unexpected errors.  Raising arbitrary errors
 
680
                    # during str(err) can provoke strange bugs.  Concretely
 
681
                    # Launchpad's codehosting managed to raise NotBranchError
 
682
                    # here, and then get stuck in an infinite loop/recursion
 
683
                    # trying to str() that error.  All this error really cares
 
684
                    # about that there's no working repository there, and if
 
685
                    # open_repository() fails, there probably isn't.
 
686
                    self.detail = ''
 
687
                else:
 
688
                    self.detail = ': location is a repository'
 
689
            else:
 
690
                self.detail = ''
 
691
        return PathError._format(self)
710
692
 
711
693
 
712
694
class NoSubmitBranch(PathError):
718
700
       self.path = urlutils.unescape_for_display(branch.base, 'ascii')
719
701
 
720
702
 
 
703
class AlreadyControlDirError(PathError):
 
704
 
 
705
    _fmt = 'A control directory already exists: "%(path)s".'
 
706
 
 
707
 
721
708
class AlreadyBranchError(PathError):
722
709
 
723
710
    _fmt = 'Already a branch: "%(path)s".'
724
711
 
725
712
 
 
713
class InvalidBranchName(PathError):
 
714
 
 
715
    _fmt = "Invalid branch name: %(name)s"
 
716
 
 
717
    def __init__(self, name):
 
718
        BzrError.__init__(self)
 
719
        self.name = name
 
720
 
 
721
 
 
722
class ParentBranchExists(AlreadyBranchError):
 
723
 
 
724
    _fmt = 'Parent branch already exists: "%(path)s".'
 
725
 
 
726
 
726
727
class BranchExistsWithoutWorkingTree(PathError):
727
728
 
728
729
    _fmt = 'Directory contains a branch, but no working tree \
757
758
        self.path = bzrdir.transport.clone('..').base
758
759
 
759
760
 
760
 
class FileInWrongBranch(BzrError):
761
 
 
762
 
    _fmt = 'File "%(path)s" is not in branch %(branch_base)s.'
763
 
 
764
 
    def __init__(self, branch, path):
765
 
        BzrError.__init__(self)
766
 
        self.branch = branch
767
 
        self.branch_base = branch.base
768
 
        self.path = path
769
 
 
770
 
 
771
761
class UnsupportedFormatError(BzrError):
772
762
 
773
763
    _fmt = "Unsupported branch format: %(format)s\nPlease run 'bzr upgrade'"
792
782
        self.bzrdir = bzrdir_format
793
783
 
794
784
 
 
785
class ParseFormatError(BzrError):
 
786
 
 
787
    _fmt = "Parse error on line %(lineno)d of %(format)s format: %(line)s"
 
788
 
 
789
    def __init__(self, format, lineno, line, text):
 
790
        BzrError.__init__(self)
 
791
        self.format = format
 
792
        self.lineno = lineno
 
793
        self.line = line
 
794
        self.text = text
 
795
 
 
796
 
795
797
class IncompatibleRepositories(BzrError):
796
798
    """Report an error that two repositories are not compatible.
797
799
 
829
831
        """Construct a new AlreadyVersionedError.
830
832
 
831
833
        :param path: This is the path which is versioned,
832
 
        which should be in a user friendly form.
 
834
            which should be in a user friendly form.
833
835
        :param context_info: If given, this is information about the context,
834
 
        which could explain why this is expected to not be versioned.
 
836
            which could explain why this is expected to not be versioned.
835
837
        """
836
838
        BzrError.__init__(self)
837
839
        self.path = path
850
852
        """Construct a new NotVersionedError.
851
853
 
852
854
        :param path: This is the path which is not versioned,
853
 
        which should be in a user friendly form.
 
855
            which should be in a user friendly form.
854
856
        :param context_info: If given, this is information about the context,
855
 
        which could explain why this is expected to be versioned.
 
857
            which could explain why this is expected to be versioned.
856
858
        """
857
859
        BzrError.__init__(self)
858
860
        self.path = path
926
928
    # original exception is available as e.original_error
927
929
    #
928
930
    # New code should prefer to raise specific subclasses
929
 
    def __init__(self, message):
930
 
        # Python 2.5 uses a slot for StandardError.message,
931
 
        # so use a different variable name.  We now work around this in
932
 
        # BzrError.__str__, but this member name is kept for compatability.
933
 
        self.msg = message
 
931
    def __init__(self, msg):
 
932
        self.msg = msg
934
933
 
935
934
 
936
935
class LockActive(LockError):
1020
1019
class LockContention(LockError):
1021
1020
 
1022
1021
    _fmt = 'Could not acquire lock "%(lock)s": %(msg)s'
1023
 
    # TODO: show full url for lock, combining the transport and relative
1024
 
    # bits?
1025
1022
 
1026
1023
    internal_error = False
1027
1024
 
1054
1051
        self.target = target
1055
1052
 
1056
1053
 
 
1054
class LockCorrupt(LockError):
 
1055
 
 
1056
    _fmt = ("Lock is apparently held, but corrupted: %(corruption_info)s\n"
 
1057
            "Use 'bzr break-lock' to clear it")
 
1058
 
 
1059
    internal_error = False
 
1060
 
 
1061
    def __init__(self, corruption_info, file_data=None):
 
1062
        self.corruption_info = corruption_info
 
1063
        self.file_data = file_data
 
1064
 
 
1065
 
1057
1066
class LockNotHeld(LockError):
1058
1067
 
1059
1068
    _fmt = "Lock not held: %(lock)s"
1098
1107
        BzrError.__init__(self, files=files, files_str=files_str)
1099
1108
 
1100
1109
 
 
1110
class ExcludesUnsupported(BzrError):
 
1111
 
 
1112
    _fmt = ('Excluding paths during commit is not supported by '
 
1113
            'repository at %(repository)r.')
 
1114
 
 
1115
    def __init__(self, repository):
 
1116
        BzrError.__init__(self, repository=repository)
 
1117
 
 
1118
 
1101
1119
class BadCommitMessageEncoding(BzrError):
1102
1120
 
1103
1121
    _fmt = 'The specified commit message contains characters unsupported by '\
1158
1176
 
1159
1177
class InvalidRevisionSpec(BzrError):
1160
1178
 
1161
 
    _fmt = ("Requested revision: %(spec)r does not exist in branch:"
1162
 
            " %(branch)s%(extra)s")
 
1179
    _fmt = ("Requested revision: '%(spec)s' does not exist in branch:"
 
1180
            " %(branch_url)s%(extra)s")
1163
1181
 
1164
1182
    def __init__(self, spec, branch, extra=None):
1165
1183
        BzrError.__init__(self, branch=branch, spec=spec)
 
1184
        self.branch_url = getattr(branch, 'user_url', str(branch))
1166
1185
        if extra:
1167
1186
            self.extra = '\n' + str(extra)
1168
1187
        else:
1169
1188
            self.extra = ''
1170
1189
 
1171
1190
 
1172
 
class HistoryMissing(BzrError):
1173
 
 
1174
 
    _fmt = "%(branch)s is missing %(object_type)s {%(object_id)s}"
1175
 
 
1176
 
 
1177
1191
class AppendRevisionsOnlyViolation(BzrError):
1178
1192
 
1179
1193
    _fmt = ('Operation denied because it would change the main history,'
1244
1258
            not_ancestor_id=not_ancestor_id)
1245
1259
 
1246
1260
 
1247
 
class AmbiguousBase(BzrError):
1248
 
 
1249
 
    def __init__(self, bases):
1250
 
        warn("BzrError AmbiguousBase has been deprecated as of bzrlib 0.8.",
1251
 
                DeprecationWarning)
1252
 
        msg = ("The correct base is unclear, because %s are all equally close"
1253
 
                % ", ".join(bases))
1254
 
        BzrError.__init__(self, msg)
1255
 
        self.bases = bases
1256
 
 
1257
 
 
1258
1261
class NoCommits(BranchError):
1259
1262
 
1260
1263
    _fmt = "Branch %(branch)s has no commits."
1276
1279
class BoundBranchOutOfDate(BzrError):
1277
1280
 
1278
1281
    _fmt = ("Bound branch %(branch)s is out of date with master branch"
1279
 
            " %(master)s.")
 
1282
            " %(master)s.%(extra_help)s")
1280
1283
 
1281
1284
    def __init__(self, branch, master):
1282
1285
        BzrError.__init__(self)
1283
1286
        self.branch = branch
1284
1287
        self.master = master
 
1288
        self.extra_help = ''
1285
1289
 
1286
1290
 
1287
1291
class CommitToDoubleBoundBranch(BzrError):
1358
1362
 
1359
1363
class WeaveParentMismatch(WeaveError):
1360
1364
 
1361
 
    _fmt = "Parents are mismatched between two revisions. %(message)s"
 
1365
    _fmt = "Parents are mismatched between two revisions. %(msg)s"
1362
1366
 
1363
1367
 
1364
1368
class WeaveInvalidChecksum(WeaveError):
1365
1369
 
1366
 
    _fmt = "Text did not match it's checksum: %(message)s"
 
1370
    _fmt = "Text did not match its checksum: %(msg)s"
1367
1371
 
1368
1372
 
1369
1373
class WeaveTextDiffers(WeaveError):
1417
1421
 
1418
1422
class VersionedFileInvalidChecksum(VersionedFileError):
1419
1423
 
1420
 
    _fmt = "Text did not match its checksum: %(message)s"
 
1424
    _fmt = "Text did not match its checksum: %(msg)s"
1421
1425
 
1422
1426
 
1423
1427
class KnitError(InternalBzrError):
1519
1523
            problem we can raise the original error (value from sys.exc_info())
1520
1524
        """
1521
1525
        BzrError.__init__(self)
 
1526
        self.context = context
1522
1527
        self.reload_occurred = reload_occurred
1523
1528
        self.exc_info = exc_info
1524
1529
        self.orig_error = exc_info[1]
1606
1611
 
1607
1612
    def __init__(self, exc_info):
1608
1613
        import traceback
 
1614
        # GZ 2010-08-10: Cycle with exc_tb/exc_info affects at least one test
1609
1615
        self.exc_type, self.exc_value, self.exc_tb = exc_info
1610
1616
        self.exc_info = exc_info
1611
1617
        traceback_strings = traceback.format_exception(
1650
1656
    _fmt = "Connection closed: %(msg)s %(orig_error)s"
1651
1657
 
1652
1658
 
 
1659
class ConnectionTimeout(ConnectionError):
 
1660
 
 
1661
    _fmt = "Connection Timeout: %(msg)s%(orig_error)s"
 
1662
 
 
1663
 
1653
1664
class InvalidRange(TransportError):
1654
1665
 
1655
1666
    _fmt = "Invalid range access in %(path)s at %(offset)s: %(msg)s"
1662
1673
 
1663
1674
class InvalidHttpResponse(TransportError):
1664
1675
 
1665
 
    _fmt = "Invalid http response for %(path)s: %(msg)s"
 
1676
    _fmt = "Invalid http response for %(path)s: %(msg)s%(orig_error)s"
1666
1677
 
1667
1678
    def __init__(self, path, msg, orig_error=None):
1668
1679
        self.path = path
 
1680
        if orig_error is None:
 
1681
            orig_error = ''
 
1682
        else:
 
1683
            # This is reached for obscure and unusual errors so we want to
 
1684
            # preserve as much info as possible to ease debug.
 
1685
            orig_error = ': %r' % (orig_error,)
1669
1686
        TransportError.__init__(self, msg, orig_error=orig_error)
1670
1687
 
1671
1688
 
 
1689
class CertificateError(TransportError):
 
1690
 
 
1691
    _fmt = "Certificate error: %(error)s"
 
1692
 
 
1693
    def __init__(self, error):
 
1694
        self.error = error
 
1695
 
 
1696
 
1672
1697
class InvalidHttpRange(InvalidHttpResponse):
1673
1698
 
1674
1699
    _fmt = "Invalid http range %(range)r for %(path)s: %(msg)s"
1678
1703
        InvalidHttpResponse.__init__(self, path, msg)
1679
1704
 
1680
1705
 
 
1706
class HttpBoundaryMissing(InvalidHttpResponse):
 
1707
    """A multipart response ends with no boundary marker.
 
1708
 
 
1709
    This is a special case caused by buggy proxies, described in
 
1710
    <https://bugs.launchpad.net/bzr/+bug/198646>.
 
1711
    """
 
1712
 
 
1713
    _fmt = "HTTP MIME Boundary missing for %(path)s: %(msg)s"
 
1714
 
 
1715
    def __init__(self, path, msg):
 
1716
        InvalidHttpResponse.__init__(self, path, msg)
 
1717
 
 
1718
 
1681
1719
class InvalidHttpContentType(InvalidHttpResponse):
1682
1720
 
1683
1721
    _fmt = 'Invalid http Content-type "%(ctype)s" for %(path)s: %(msg)s'
1711
1749
    _fmt = "Working tree has conflicts."
1712
1750
 
1713
1751
 
 
1752
class ConfigContentError(BzrError):
 
1753
 
 
1754
    _fmt = "Config file %(filename)s is not UTF-8 encoded\n"
 
1755
 
 
1756
    def __init__(self, filename):
 
1757
        BzrError.__init__(self)
 
1758
        self.filename = filename
 
1759
 
 
1760
 
1714
1761
class ParseConfigError(BzrError):
1715
1762
 
 
1763
    _fmt = "Error(s) parsing config file %(filename)s:\n%(errors)s"
 
1764
 
1716
1765
    def __init__(self, errors, filename):
1717
 
        if filename is None:
1718
 
            filename = ""
1719
 
        message = "Error(s) parsing config file %s:\n%s" % \
1720
 
            (filename, ('\n'.join(e.msg for e in errors)))
1721
 
        BzrError.__init__(self, message)
 
1766
        BzrError.__init__(self)
 
1767
        self.filename = filename
 
1768
        self.errors = '\n'.join(e.msg for e in errors)
 
1769
 
 
1770
 
 
1771
class ConfigOptionValueError(BzrError):
 
1772
 
 
1773
    _fmt = ('Bad value "%(value)s" for option "%(name)s".\n'
 
1774
            'See ``bzr help %(name)s``')
 
1775
 
 
1776
    def __init__(self, name, value):
 
1777
        BzrError.__init__(self, name=name, value=value)
1722
1778
 
1723
1779
 
1724
1780
class NoEmailInUsername(BzrError):
1732
1788
 
1733
1789
class SigningFailed(BzrError):
1734
1790
 
1735
 
    _fmt = 'Failed to gpg sign data with command "%(command_line)s"'
 
1791
    _fmt = 'Failed to GPG sign data with command "%(command_line)s"'
1736
1792
 
1737
1793
    def __init__(self, command_line):
1738
1794
        BzrError.__init__(self, command_line=command_line)
1739
1795
 
1740
1796
 
 
1797
class SignatureVerificationFailed(BzrError):
 
1798
 
 
1799
    _fmt = 'Failed to verify GPG signature data with error "%(error)s"'
 
1800
 
 
1801
    def __init__(self, error):
 
1802
        BzrError.__init__(self, error=error)
 
1803
 
 
1804
 
 
1805
class DependencyNotPresent(BzrError):
 
1806
 
 
1807
    _fmt = 'Unable to import library "%(library)s": %(error)s'
 
1808
 
 
1809
    def __init__(self, library, error):
 
1810
        BzrError.__init__(self, library=library, error=error)
 
1811
 
 
1812
 
 
1813
class GpgmeNotInstalled(DependencyNotPresent):
 
1814
 
 
1815
    _fmt = 'python-gpgme is not installed, it is needed to verify signatures'
 
1816
 
 
1817
    def __init__(self, error):
 
1818
        DependencyNotPresent.__init__(self, 'gpgme', error)
 
1819
 
 
1820
 
1741
1821
class WorkingTreeNotRevision(BzrError):
1742
1822
 
1743
1823
    _fmt = ("The working tree for %(basedir)s has changed since"
1859
1939
        self.prefix = prefix
1860
1940
 
1861
1941
 
1862
 
class MalformedTransform(BzrError):
 
1942
class MalformedTransform(InternalBzrError):
1863
1943
 
1864
1944
    _fmt = "Tree transform is malformed %(conflicts)r"
1865
1945
 
1903
1983
    _fmt = "Moving the root directory is not supported at this time"
1904
1984
 
1905
1985
 
 
1986
class TransformRenameFailed(BzrError):
 
1987
 
 
1988
    _fmt = "Failed to rename %(from_path)s to %(to_path)s: %(why)s"
 
1989
 
 
1990
    def __init__(self, from_path, to_path, why, errno):
 
1991
        self.from_path = from_path
 
1992
        self.to_path = to_path
 
1993
        self.why = why
 
1994
        self.errno = errno
 
1995
 
 
1996
 
1906
1997
class BzrMoveFailedError(BzrError):
1907
1998
 
1908
 
    _fmt = "Could not move %(from_path)s%(operator)s %(to_path)s%(extra)s"
 
1999
    _fmt = ("Could not move %(from_path)s%(operator)s %(to_path)s"
 
2000
        "%(_has_extra)s%(extra)s")
1909
2001
 
1910
2002
    def __init__(self, from_path='', to_path='', extra=None):
1911
2003
        from bzrlib.osutils import splitpath
1912
2004
        BzrError.__init__(self)
1913
2005
        if extra:
1914
 
            self.extra = ': ' + str(extra)
 
2006
            self.extra, self._has_extra = extra, ': '
1915
2007
        else:
1916
 
            self.extra = ''
 
2008
            self.extra = self._has_extra = ''
1917
2009
 
1918
2010
        has_from = len(from_path) > 0
1919
2011
        has_to = len(to_path) > 0
1940
2032
 
1941
2033
class BzrRenameFailedError(BzrMoveFailedError):
1942
2034
 
1943
 
    _fmt = "Could not rename %(from_path)s%(operator)s %(to_path)s%(extra)s"
 
2035
    _fmt = ("Could not rename %(from_path)s%(operator)s %(to_path)s"
 
2036
        "%(_has_extra)s%(extra)s")
1944
2037
 
1945
2038
    def __init__(self, from_path, to_path, extra=None):
1946
2039
        BzrMoveFailedError.__init__(self, from_path, to_path, extra)
1947
2040
 
1948
 
class BzrRemoveChangedFilesError(BzrError):
1949
 
    """Used when user is trying to remove changed files."""
1950
 
 
1951
 
    _fmt = ("Can't safely remove modified or unknown files:\n"
1952
 
        "%(changes_as_text)s"
1953
 
        "Use --keep to not delete them, or --force to delete them regardless.")
1954
 
 
1955
 
    def __init__(self, tree_delta):
1956
 
        BzrError.__init__(self)
1957
 
        self.changes_as_text = tree_delta.get_changes_as_text()
1958
 
        #self.paths_as_string = '\n'.join(changed_files)
1959
 
        #self.paths_as_string = '\n'.join([quotefn(p) for p in changed_files])
1960
 
 
1961
2041
 
1962
2042
class BzrBadParameterNotString(BzrBadParameter):
1963
2043
 
1966
2046
 
1967
2047
class BzrBadParameterMissing(BzrBadParameter):
1968
2048
 
1969
 
    _fmt = "Parameter $(param)s is required but not present."
 
2049
    _fmt = "Parameter %(param)s is required but not present."
1970
2050
 
1971
2051
 
1972
2052
class BzrBadParameterUnicode(BzrBadParameter):
1980
2060
    _fmt = "Parameter %(param)s contains a newline."
1981
2061
 
1982
2062
 
1983
 
class DependencyNotPresent(BzrError):
1984
 
 
1985
 
    _fmt = 'Unable to import library "%(library)s": %(error)s'
1986
 
 
1987
 
    def __init__(self, library, error):
1988
 
        BzrError.__init__(self, library=library, error=error)
1989
 
 
1990
 
 
1991
2063
class ParamikoNotPresent(DependencyNotPresent):
1992
2064
 
1993
2065
    _fmt = "Unable to import paramiko (required for sftp support): %(error)s"
2154
2226
 
2155
2227
    def __init__(self, repo):
2156
2228
        BzrError.__init__(self)
2157
 
        self.repo_path = repo.bzrdir.root_transport.base
 
2229
        self.repo_path = repo.user_url
2158
2230
 
2159
2231
 
2160
2232
class InconsistentDelta(BzrError):
2228
2300
    """
2229
2301
 
2230
2302
 
 
2303
class GhostTagsNotSupported(BzrError):
 
2304
 
 
2305
    _fmt = "Ghost tags not supported by format %(format)r."
 
2306
 
 
2307
    def __init__(self, format):
 
2308
        self.format = format
 
2309
 
 
2310
 
2231
2311
class BinaryFile(BzrError):
2232
2312
 
2233
2313
    _fmt = "File is binary but should be text."
2596
2676
 
2597
2677
    This is distinct from ErrorFromSmartServer so that it is possible to
2598
2678
    distinguish between the following two cases:
2599
 
      - ErrorFromSmartServer was uncaught.  This is logic error in the client
2600
 
        and so should provoke a traceback to the user.
2601
 
      - ErrorFromSmartServer was caught but its error_tuple could not be
2602
 
        translated.  This is probably because the server sent us garbage, and
2603
 
        should not provoke a traceback.
 
2679
 
 
2680
    - ErrorFromSmartServer was uncaught.  This is logic error in the client
 
2681
      and so should provoke a traceback to the user.
 
2682
    - ErrorFromSmartServer was caught but its error_tuple could not be
 
2683
      translated.  This is probably because the server sent us garbage, and
 
2684
      should not provoke a traceback.
2604
2685
    """
2605
2686
 
2606
2687
    _fmt = "Server sent an unexpected error: %(error_tuple)r"
2662
2743
    _fmt = "Container has multiple records with the same name: %(name)s"
2663
2744
 
2664
2745
    def __init__(self, name):
2665
 
        self.name = name
 
2746
        self.name = name.decode("utf-8")
2666
2747
 
2667
2748
 
2668
2749
class NoDestinationAddress(InternalBzrError):
2696
2777
    _fmt = "No mail-to address (--mail-to) or output (-o) specified."
2697
2778
 
2698
2779
 
2699
 
class UnknownMailClient(BzrError):
2700
 
 
2701
 
    _fmt = "Unknown mail client: %(mail_client)s"
2702
 
 
2703
 
    def __init__(self, mail_client):
2704
 
        BzrError.__init__(self, mail_client=mail_client)
2705
 
 
2706
 
 
2707
2780
class MailClientNotFound(BzrError):
2708
2781
 
2709
2782
    _fmt = "Unable to find mail client with the following names:"\
2732
2805
 
2733
2806
    def __init__(self, bzrdir):
2734
2807
        import bzrlib.urlutils as urlutils
2735
 
        display_url = urlutils.unescape_for_display(bzrdir.root_transport.base,
 
2808
        display_url = urlutils.unescape_for_display(bzrdir.user_url,
2736
2809
                                                    'ascii')
2737
2810
        BzrError.__init__(self, bzrdir=bzrdir, display_url=display_url)
2738
2811
 
2812
2885
        else:
2813
2886
            more = ' ' + more
2814
2887
        import bzrlib.urlutils as urlutils
2815
 
        display_url = urlutils.unescape_for_display(
2816
 
            tree.bzrdir.root_transport.base, 'ascii')
 
2888
        user_url = getattr(tree, "user_url", None)
 
2889
        if user_url is None:
 
2890
            display_url = str(tree)
 
2891
        else:
 
2892
            display_url = urlutils.unescape_for_display(user_url, 'ascii')
2817
2893
        BzrError.__init__(self, tree=tree, display_url=display_url, more=more)
2818
2894
 
2819
2895
 
 
2896
class StoringUncommittedNotSupported(BzrError):
 
2897
 
 
2898
    _fmt = ('Branch "%(display_url)s" does not support storing uncommitted'
 
2899
            ' changes.')
 
2900
 
 
2901
    def __init__(self, branch):
 
2902
        import bzrlib.urlutils as urlutils
 
2903
        user_url = getattr(branch, "user_url", None)
 
2904
        if user_url is None:
 
2905
            display_url = str(branch)
 
2906
        else:
 
2907
            display_url = urlutils.unescape_for_display(user_url, 'ascii')
 
2908
        BzrError.__init__(self, branch=branch, display_url=display_url)
 
2909
 
 
2910
 
 
2911
class ShelvedChanges(UncommittedChanges):
 
2912
 
 
2913
    _fmt = ('Working tree "%(display_url)s" has shelved changes'
 
2914
            ' (See bzr shelve --list).%(more)s')
 
2915
 
 
2916
 
2820
2917
class MissingTemplateVariable(BzrError):
2821
2918
 
2822
2919
    _fmt = 'Variable {%(name)s} is not available.'
2888
2985
        from bzrlib.osutils import get_user_encoding
2889
2986
        self.path = path
2890
2987
        self.kind = kind
2891
 
        self.user_encoding = osutils.get_user_encoding()
 
2988
        self.user_encoding = get_user_encoding()
 
2989
 
 
2990
 
 
2991
class NoSuchConfig(BzrError):
 
2992
 
 
2993
    _fmt = ('The "%(config_id)s" configuration does not exist.')
 
2994
 
 
2995
    def __init__(self, config_id):
 
2996
        BzrError.__init__(self, config_id=config_id)
 
2997
 
 
2998
 
 
2999
class NoSuchConfigOption(BzrError):
 
3000
 
 
3001
    _fmt = ('The "%(option_name)s" configuration option does not exist.')
 
3002
 
 
3003
    def __init__(self, option_name):
 
3004
        BzrError.__init__(self, option_name=option_name)
2892
3005
 
2893
3006
 
2894
3007
class NoSuchAlias(BzrError):
2939
3052
        BzrError.__init__(self, unknowns_str=", ".join(unknowns))
2940
3053
 
2941
3054
 
2942
 
class HookFailed(BzrError):
2943
 
    """Raised when a pre_change_branch_tip hook function fails anything other
2944
 
    than TipChangeRejected.
2945
 
    """
2946
 
 
2947
 
    _fmt = ("Hook '%(hook_name)s' during %(hook_stage)s failed:\n"
2948
 
            "%(traceback_text)s%(exc_value)s")
2949
 
 
2950
 
    def __init__(self, hook_stage, hook_name, exc_info):
2951
 
        import traceback
2952
 
        self.hook_stage = hook_stage
2953
 
        self.hook_name = hook_name
2954
 
        self.exc_info = exc_info
2955
 
        self.exc_type = exc_info[0]
2956
 
        self.exc_value = exc_info[1]
2957
 
        self.exc_tb = exc_info[2]
2958
 
        self.traceback_text = ''.join(traceback.format_tb(self.exc_tb))
2959
 
 
2960
 
 
2961
3055
class TipChangeRejected(BzrError):
2962
3056
    """A pre_change_branch_tip hook function may raise this to cleanly and
2963
3057
    explicitly abort a change to a branch tip.
2974
3068
    _fmt = "Shelf corrupt."
2975
3069
 
2976
3070
 
 
3071
class DecompressCorruption(BzrError):
 
3072
 
 
3073
    _fmt = "Corruption while decompressing repository file%(orig_error)s"
 
3074
 
 
3075
    def __init__(self, orig_error=None):
 
3076
        if orig_error is not None:
 
3077
            self.orig_error = ", %s" % (orig_error,)
 
3078
        else:
 
3079
            self.orig_error = ""
 
3080
        BzrError.__init__(self)
 
3081
 
 
3082
 
2977
3083
class NoSuchShelfId(BzrError):
2978
3084
 
2979
3085
    _fmt = 'No changes are shelved with id "%(shelf_id)d".'
3087
3193
    def __init__(self, source_branch, target_branch):
3088
3194
        self.source_branch = source_branch
3089
3195
        self.target_branch = target_branch
 
3196
 
 
3197
 
 
3198
class FileTimestampUnavailable(BzrError):
 
3199
 
 
3200
    _fmt = "The filestamp for %(path)s is not available."
 
3201
 
 
3202
    internal_error = True
 
3203
 
 
3204
    def __init__(self, path):
 
3205
        self.path = path
 
3206
 
 
3207
 
 
3208
class NoColocatedBranchSupport(BzrError):
 
3209
 
 
3210
    _fmt = ("%(bzrdir)r does not support co-located branches.")
 
3211
 
 
3212
    def __init__(self, bzrdir):
 
3213
        self.bzrdir = bzrdir
 
3214
 
 
3215
 
 
3216
class NoWhoami(BzrError):
 
3217
 
 
3218
    _fmt = ('Unable to determine your name.\n'
 
3219
        "Please, set your name with the 'whoami' command.\n"
 
3220
        'E.g. bzr whoami "Your Name <name@example.com>"')
 
3221
 
 
3222
 
 
3223
class InvalidPattern(BzrError):
 
3224
 
 
3225
    _fmt = ('Invalid pattern(s) found. %(msg)s')
 
3226
 
 
3227
    def __init__(self, msg):
 
3228
        self.msg = msg
 
3229
 
 
3230
 
 
3231
class RecursiveBind(BzrError):
 
3232
 
 
3233
    _fmt = ('Branch "%(branch_url)s" appears to be bound to itself. '
 
3234
        'Please use `bzr unbind` to fix.')
 
3235
 
 
3236
    def __init__(self, branch_url):
 
3237
        self.branch_url = branch_url
 
3238
 
 
3239
 
 
3240
# FIXME: I would prefer to define the config related exception classes in
 
3241
# config.py but the lazy import mechanism proscribes this -- vila 20101222
 
3242
class OptionExpansionLoop(BzrError):
 
3243
 
 
3244
    _fmt = 'Loop involving %(refs)r while expanding "%(string)s".'
 
3245
 
 
3246
    def __init__(self, string, refs):
 
3247
        self.string = string
 
3248
        self.refs = '->'.join(refs)
 
3249
 
 
3250
 
 
3251
class ExpandingUnknownOption(BzrError):
 
3252
 
 
3253
    _fmt = 'Option "%(name)s" is not defined while expanding "%(string)s".'
 
3254
 
 
3255
    def __init__(self, name, string):
 
3256
        self.name = name
 
3257
        self.string = string
 
3258
 
 
3259
 
 
3260
class IllegalOptionName(BzrError):
 
3261
 
 
3262
    _fmt = 'Option "%(name)s" is not allowed.'
 
3263
 
 
3264
    def __init__(self, name):
 
3265
        self.name = name
 
3266
 
 
3267
 
 
3268
class NoCompatibleInter(BzrError):
 
3269
 
 
3270
    _fmt = ('No compatible object available for operations from %(source)r '
 
3271
            'to %(target)r.')
 
3272
 
 
3273
    def __init__(self, source, target):
 
3274
        self.source = source
 
3275
        self.target = target
 
3276
 
 
3277
 
 
3278
class HpssVfsRequestNotAllowed(BzrError):
 
3279
 
 
3280
    _fmt = ("VFS requests over the smart server are not allowed. Encountered: "
 
3281
            "%(method)s, %(arguments)s.")
 
3282
 
 
3283
    def __init__(self, method, arguments):
 
3284
        self.method = method
 
3285
        self.arguments = arguments
 
3286
 
 
3287
 
 
3288
class UnsupportedKindChange(BzrError):
 
3289
 
 
3290
    _fmt = ("Kind change from %(from_kind)s to %(to_kind)s for "
 
3291
            "%(path)s not supported by format %(format)r")
 
3292
 
 
3293
    def __init__(self, path, from_kind, to_kind, format):
 
3294
        self.path = path
 
3295
        self.from_kind = from_kind
 
3296
        self.to_kind = to_kind
 
3297
        self.format = format
 
3298
 
 
3299
 
 
3300
class MissingFeature(BzrError):
 
3301
 
 
3302
    _fmt = ("Missing feature %(feature)s not provided by this "
 
3303
            "version of Bazaar or any plugin.")
 
3304
 
 
3305
    def __init__(self, feature):
 
3306
        self.feature = feature
 
3307
 
 
3308
 
 
3309
class PatchSyntax(BzrError):
 
3310
    """Base class for patch syntax errors."""
 
3311
 
 
3312
 
 
3313
class BinaryFiles(BzrError):
 
3314
 
 
3315
    _fmt = 'Binary files section encountered.'
 
3316
 
 
3317
    def __init__(self, orig_name, mod_name):
 
3318
        self.orig_name = orig_name
 
3319
        self.mod_name = mod_name
 
3320
 
 
3321
 
 
3322
class MalformedPatchHeader(PatchSyntax):
 
3323
 
 
3324
    _fmt = "Malformed patch header.  %(desc)s\n%(line)r"
 
3325
 
 
3326
    def __init__(self, desc, line):
 
3327
        self.desc = desc
 
3328
        self.line = line
 
3329
 
 
3330
 
 
3331
class MalformedHunkHeader(PatchSyntax):
 
3332
 
 
3333
    _fmt = "Malformed hunk header.  %(desc)s\n%(line)r"
 
3334
 
 
3335
    def __init__(self, desc, line):
 
3336
        self.desc = desc
 
3337
        self.line = line
 
3338
 
 
3339
 
 
3340
class MalformedLine(PatchSyntax):
 
3341
 
 
3342
    _fmt = "Malformed line.  %(desc)s\n%(line)r"
 
3343
 
 
3344
    def __init__(self, desc, line):
 
3345
        self.desc = desc
 
3346
        self.line = line
 
3347
 
 
3348
 
 
3349
class PatchConflict(BzrError):
 
3350
 
 
3351
    _fmt = ('Text contents mismatch at line %(line_no)d.  Original has '
 
3352
            '"%(orig_line)s", but patch says it should be "%(patch_line)s"')
 
3353
 
 
3354
    def __init__(self, line_no, orig_line, patch_line):
 
3355
        self.line_no = line_no
 
3356
        self.orig_line = orig_line.rstrip('\n')
 
3357
        self.patch_line = patch_line.rstrip('\n')
 
3358
 
 
3359
 
 
3360
class FeatureAlreadyRegistered(BzrError):
 
3361
 
 
3362
    _fmt = 'The feature %(feature)s has already been registered.'
 
3363
 
 
3364
    def __init__(self, feature):
 
3365
        self.feature = feature
 
3366
 
 
3367
 
 
3368
class ChangesAlreadyStored(BzrCommandError):
 
3369
 
 
3370
    _fmt = ('Cannot store uncommitted changes because this branch already'
 
3371
            ' stores uncommitted changes.')