← 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: 2014-02-07 10:20:38 UTC
  • mto: This revision was merged to the branch mainline in revision 6590.
  • Revision ID: v.ladeuil+lp@free.fr-20140207102038-17sgslnv35no6bsu
https://launchpad.net/bugs/1269886
Fix test failure on recent Ubuntu Trusty versions without weakening the test itself.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/errors.py
1
 
# Copyright (C) 2005-2010 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)
713
662
       self.bzrdir = bzrdir
714
663
       PathError.__init__(self, path=path)
715
664
 
 
665
    def __repr__(self):
 
666
        return '<%s %r>' % (self.__class__.__name__, self.__dict__)
 
667
 
716
668
    def _format(self):
717
669
        # XXX: Ideally self.detail would be a property, but Exceptions in
718
670
        # Python 2.4 have to be old-style classes so properties don't work.
723
675
                    self.bzrdir.open_repository()
724
676
                except NoRepositoryPresent:
725
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 = ''
726
687
                else:
727
688
                    self.detail = ': location is a repository'
728
689
            else:
739
700
       self.path = urlutils.unescape_for_display(branch.base, 'ascii')
740
701
 
741
702
 
 
703
class AlreadyControlDirError(PathError):
 
704
 
 
705
    _fmt = 'A control directory already exists: "%(path)s".'
 
706
 
 
707
 
742
708
class AlreadyBranchError(PathError):
743
709
 
744
710
    _fmt = 'Already a branch: "%(path)s".'
745
711
 
746
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
 
747
727
class BranchExistsWithoutWorkingTree(PathError):
748
728
 
749
729
    _fmt = 'Directory contains a branch, but no working tree \
778
758
        self.path = bzrdir.transport.clone('..').base
779
759
 
780
760
 
781
 
class FileInWrongBranch(BzrError):
782
 
 
783
 
    _fmt = 'File "%(path)s" is not in branch %(branch_base)s.'
784
 
 
785
 
    def __init__(self, branch, path):
786
 
        BzrError.__init__(self)
787
 
        self.branch = branch
788
 
        self.branch_base = branch.base
789
 
        self.path = path
790
 
 
791
 
 
792
761
class UnsupportedFormatError(BzrError):
793
762
 
794
763
    _fmt = "Unsupported branch format: %(format)s\nPlease run 'bzr upgrade'"
813
782
        self.bzrdir = bzrdir_format
814
783
 
815
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
 
816
797
class IncompatibleRepositories(BzrError):
817
798
    """Report an error that two repositories are not compatible.
818
799
 
850
831
        """Construct a new AlreadyVersionedError.
851
832
 
852
833
        :param path: This is the path which is versioned,
853
 
        which should be in a user friendly form.
 
834
            which should be in a user friendly form.
854
835
        :param context_info: If given, this is information about the context,
855
 
        which could explain why this is expected to not be versioned.
 
836
            which could explain why this is expected to not be versioned.
856
837
        """
857
838
        BzrError.__init__(self)
858
839
        self.path = path
871
852
        """Construct a new NotVersionedError.
872
853
 
873
854
        :param path: This is the path which is not versioned,
874
 
        which should be in a user friendly form.
 
855
            which should be in a user friendly form.
875
856
        :param context_info: If given, this is information about the context,
876
 
        which could explain why this is expected to be versioned.
 
857
            which could explain why this is expected to be versioned.
877
858
        """
878
859
        BzrError.__init__(self)
879
860
        self.path = path
947
928
    # original exception is available as e.original_error
948
929
    #
949
930
    # New code should prefer to raise specific subclasses
950
 
    def __init__(self, message):
951
 
        # Python 2.5 uses a slot for StandardError.message,
952
 
        # so use a different variable name.  We now work around this in
953
 
        # BzrError.__str__, but this member name is kept for compatability.
954
 
        self.msg = message
 
931
    def __init__(self, msg):
 
932
        self.msg = msg
955
933
 
956
934
 
957
935
class LockActive(LockError):
1041
1019
class LockContention(LockError):
1042
1020
 
1043
1021
    _fmt = 'Could not acquire lock "%(lock)s": %(msg)s'
1044
 
    # TODO: show full url for lock, combining the transport and relative
1045
 
    # bits?
1046
1022
 
1047
1023
    internal_error = False
1048
1024
 
1075
1051
        self.target = target
1076
1052
 
1077
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
 
1078
1066
class LockNotHeld(LockError):
1079
1067
 
1080
1068
    _fmt = "Lock not held: %(lock)s"
1119
1107
        BzrError.__init__(self, files=files, files_str=files_str)
1120
1108
 
1121
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
 
1122
1119
class BadCommitMessageEncoding(BzrError):
1123
1120
 
1124
1121
    _fmt = 'The specified commit message contains characters unsupported by '\
1180
1177
class InvalidRevisionSpec(BzrError):
1181
1178
 
1182
1179
    _fmt = ("Requested revision: '%(spec)s' does not exist in branch:"
1183
 
            " %(branch)s%(extra)s")
 
1180
            " %(branch_url)s%(extra)s")
1184
1181
 
1185
1182
    def __init__(self, spec, branch, extra=None):
1186
1183
        BzrError.__init__(self, branch=branch, spec=spec)
 
1184
        self.branch_url = getattr(branch, 'user_url', str(branch))
1187
1185
        if extra:
1188
1186
            self.extra = '\n' + str(extra)
1189
1187
        else:
1190
1188
            self.extra = ''
1191
1189
 
1192
1190
 
1193
 
class HistoryMissing(BzrError):
1194
 
 
1195
 
    _fmt = "%(branch)s is missing %(object_type)s {%(object_id)s}"
1196
 
 
1197
 
 
1198
1191
class AppendRevisionsOnlyViolation(BzrError):
1199
1192
 
1200
1193
    _fmt = ('Operation denied because it would change the main history,'
1265
1258
            not_ancestor_id=not_ancestor_id)
1266
1259
 
1267
1260
 
1268
 
class AmbiguousBase(BzrError):
1269
 
 
1270
 
    def __init__(self, bases):
1271
 
        symbol_versioning.warn("BzrError AmbiguousBase has been deprecated "
1272
 
            "as of bzrlib 0.8.", DeprecationWarning, stacklevel=2)
1273
 
        msg = ("The correct base is unclear, because %s are all equally close"
1274
 
                % ", ".join(bases))
1275
 
        BzrError.__init__(self, msg)
1276
 
        self.bases = bases
1277
 
 
1278
 
 
1279
1261
class NoCommits(BranchError):
1280
1262
 
1281
1263
    _fmt = "Branch %(branch)s has no commits."
1380
1362
 
1381
1363
class WeaveParentMismatch(WeaveError):
1382
1364
 
1383
 
    _fmt = "Parents are mismatched between two revisions. %(message)s"
 
1365
    _fmt = "Parents are mismatched between two revisions. %(msg)s"
1384
1366
 
1385
1367
 
1386
1368
class WeaveInvalidChecksum(WeaveError):
1387
1369
 
1388
 
    _fmt = "Text did not match it's checksum: %(message)s"
 
1370
    _fmt = "Text did not match its checksum: %(msg)s"
1389
1371
 
1390
1372
 
1391
1373
class WeaveTextDiffers(WeaveError):
1439
1421
 
1440
1422
class VersionedFileInvalidChecksum(VersionedFileError):
1441
1423
 
1442
 
    _fmt = "Text did not match its checksum: %(message)s"
 
1424
    _fmt = "Text did not match its checksum: %(msg)s"
1443
1425
 
1444
1426
 
1445
1427
class KnitError(InternalBzrError):
1541
1523
            problem we can raise the original error (value from sys.exc_info())
1542
1524
        """
1543
1525
        BzrError.__init__(self)
 
1526
        self.context = context
1544
1527
        self.reload_occurred = reload_occurred
1545
1528
        self.exc_info = exc_info
1546
1529
        self.orig_error = exc_info[1]
1628
1611
 
1629
1612
    def __init__(self, exc_info):
1630
1613
        import traceback
 
1614
        # GZ 2010-08-10: Cycle with exc_tb/exc_info affects at least one test
1631
1615
        self.exc_type, self.exc_value, self.exc_tb = exc_info
1632
1616
        self.exc_info = exc_info
1633
1617
        traceback_strings = traceback.format_exception(
1672
1656
    _fmt = "Connection closed: %(msg)s %(orig_error)s"
1673
1657
 
1674
1658
 
 
1659
class ConnectionTimeout(ConnectionError):
 
1660
 
 
1661
    _fmt = "Connection Timeout: %(msg)s%(orig_error)s"
 
1662
 
 
1663
 
1675
1664
class InvalidRange(TransportError):
1676
1665
 
1677
1666
    _fmt = "Invalid range access in %(path)s at %(offset)s: %(msg)s"
1684
1673
 
1685
1674
class InvalidHttpResponse(TransportError):
1686
1675
 
1687
 
    _fmt = "Invalid http response for %(path)s: %(msg)s"
 
1676
    _fmt = "Invalid http response for %(path)s: %(msg)s%(orig_error)s"
1688
1677
 
1689
1678
    def __init__(self, path, msg, orig_error=None):
1690
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,)
1691
1686
        TransportError.__init__(self, msg, orig_error=orig_error)
1692
1687
 
1693
1688
 
 
1689
class CertificateError(TransportError):
 
1690
 
 
1691
    _fmt = "Certificate error: %(error)s"
 
1692
 
 
1693
    def __init__(self, error):
 
1694
        self.error = error
 
1695
 
 
1696
 
1694
1697
class InvalidHttpRange(InvalidHttpResponse):
1695
1698
 
1696
1699
    _fmt = "Invalid http range %(range)r for %(path)s: %(msg)s"
1700
1703
        InvalidHttpResponse.__init__(self, path, msg)
1701
1704
 
1702
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
 
1703
1719
class InvalidHttpContentType(InvalidHttpResponse):
1704
1720
 
1705
1721
    _fmt = 'Invalid http Content-type "%(ctype)s" for %(path)s: %(msg)s'
1733
1749
    _fmt = "Working tree has conflicts."
1734
1750
 
1735
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
 
1736
1761
class ParseConfigError(BzrError):
1737
1762
 
 
1763
    _fmt = "Error(s) parsing config file %(filename)s:\n%(errors)s"
 
1764
 
1738
1765
    def __init__(self, errors, filename):
1739
 
        if filename is None:
1740
 
            filename = ""
1741
 
        message = "Error(s) parsing config file %s:\n%s" % \
1742
 
            (filename, ('\n'.join(e.msg for e in errors)))
1743
 
        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)
1744
1778
 
1745
1779
 
1746
1780
class NoEmailInUsername(BzrError):
1754
1788
 
1755
1789
class SigningFailed(BzrError):
1756
1790
 
1757
 
    _fmt = 'Failed to gpg sign data with command "%(command_line)s"'
 
1791
    _fmt = 'Failed to GPG sign data with command "%(command_line)s"'
1758
1792
 
1759
1793
    def __init__(self, command_line):
1760
1794
        BzrError.__init__(self, command_line=command_line)
1761
1795
 
1762
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
 
1763
1821
class WorkingTreeNotRevision(BzrError):
1764
1822
 
1765
1823
    _fmt = ("The working tree for %(basedir)s has changed since"
1881
1939
        self.prefix = prefix
1882
1940
 
1883
1941
 
1884
 
class MalformedTransform(BzrError):
 
1942
class MalformedTransform(InternalBzrError):
1885
1943
 
1886
1944
    _fmt = "Tree transform is malformed %(conflicts)r"
1887
1945
 
1925
1983
    _fmt = "Moving the root directory is not supported at this time"
1926
1984
 
1927
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
 
1928
1997
class BzrMoveFailedError(BzrError):
1929
1998
 
1930
 
    _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")
1931
2001
 
1932
2002
    def __init__(self, from_path='', to_path='', extra=None):
1933
2003
        from bzrlib.osutils import splitpath
1934
2004
        BzrError.__init__(self)
1935
2005
        if extra:
1936
 
            self.extra = ': ' + str(extra)
 
2006
            self.extra, self._has_extra = extra, ': '
1937
2007
        else:
1938
 
            self.extra = ''
 
2008
            self.extra = self._has_extra = ''
1939
2009
 
1940
2010
        has_from = len(from_path) > 0
1941
2011
        has_to = len(to_path) > 0
1962
2032
 
1963
2033
class BzrRenameFailedError(BzrMoveFailedError):
1964
2034
 
1965
 
    _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")
1966
2037
 
1967
2038
    def __init__(self, from_path, to_path, extra=None):
1968
2039
        BzrMoveFailedError.__init__(self, from_path, to_path, extra)
1969
2040
 
1970
 
class BzrRemoveChangedFilesError(BzrError):
1971
 
    """Used when user is trying to remove changed files."""
1972
 
 
1973
 
    _fmt = ("Can't safely remove modified or unknown files:\n"
1974
 
        "%(changes_as_text)s"
1975
 
        "Use --keep to not delete them, or --force to delete them regardless.")
1976
 
 
1977
 
    def __init__(self, tree_delta):
1978
 
        BzrError.__init__(self)
1979
 
        self.changes_as_text = tree_delta.get_changes_as_text()
1980
 
        #self.paths_as_string = '\n'.join(changed_files)
1981
 
        #self.paths_as_string = '\n'.join([quotefn(p) for p in changed_files])
1982
 
 
1983
2041
 
1984
2042
class BzrBadParameterNotString(BzrBadParameter):
1985
2043
 
1988
2046
 
1989
2047
class BzrBadParameterMissing(BzrBadParameter):
1990
2048
 
1991
 
    _fmt = "Parameter $(param)s is required but not present."
 
2049
    _fmt = "Parameter %(param)s is required but not present."
1992
2050
 
1993
2051
 
1994
2052
class BzrBadParameterUnicode(BzrBadParameter):
2002
2060
    _fmt = "Parameter %(param)s contains a newline."
2003
2061
 
2004
2062
 
2005
 
class DependencyNotPresent(BzrError):
2006
 
 
2007
 
    _fmt = 'Unable to import library "%(library)s": %(error)s'
2008
 
 
2009
 
    def __init__(self, library, error):
2010
 
        BzrError.__init__(self, library=library, error=error)
2011
 
 
2012
 
 
2013
2063
class ParamikoNotPresent(DependencyNotPresent):
2014
2064
 
2015
2065
    _fmt = "Unable to import paramiko (required for sftp support): %(error)s"
2250
2300
    """
2251
2301
 
2252
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
 
2253
2311
class BinaryFile(BzrError):
2254
2312
 
2255
2313
    _fmt = "File is binary but should be text."
2618
2676
 
2619
2677
    This is distinct from ErrorFromSmartServer so that it is possible to
2620
2678
    distinguish between the following two cases:
2621
 
      - ErrorFromSmartServer was uncaught.  This is logic error in the client
2622
 
        and so should provoke a traceback to the user.
2623
 
      - ErrorFromSmartServer was caught but its error_tuple could not be
2624
 
        translated.  This is probably because the server sent us garbage, and
2625
 
        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.
2626
2685
    """
2627
2686
 
2628
2687
    _fmt = "Server sent an unexpected error: %(error_tuple)r"
2684
2743
    _fmt = "Container has multiple records with the same name: %(name)s"
2685
2744
 
2686
2745
    def __init__(self, name):
2687
 
        self.name = name
 
2746
        self.name = name.decode("utf-8")
2688
2747
 
2689
2748
 
2690
2749
class NoDestinationAddress(InternalBzrError):
2718
2777
    _fmt = "No mail-to address (--mail-to) or output (-o) specified."
2719
2778
 
2720
2779
 
2721
 
class UnknownMailClient(BzrError):
2722
 
 
2723
 
    _fmt = "Unknown mail client: %(mail_client)s"
2724
 
 
2725
 
    def __init__(self, mail_client):
2726
 
        BzrError.__init__(self, mail_client=mail_client)
2727
 
 
2728
 
 
2729
2780
class MailClientNotFound(BzrError):
2730
2781
 
2731
2782
    _fmt = "Unable to find mail client with the following names:"\
2834
2885
        else:
2835
2886
            more = ' ' + more
2836
2887
        import bzrlib.urlutils as urlutils
2837
 
        display_url = urlutils.unescape_for_display(
2838
 
            tree.user_url, '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')
2839
2893
        BzrError.__init__(self, tree=tree, display_url=display_url, more=more)
2840
2894
 
2841
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
 
2842
2917
class MissingTemplateVariable(BzrError):
2843
2918
 
2844
2919
    _fmt = 'Variable {%(name)s} is not available.'
2910
2985
        from bzrlib.osutils import get_user_encoding
2911
2986
        self.path = path
2912
2987
        self.kind = kind
2913
 
        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)
2914
3005
 
2915
3006
 
2916
3007
class NoSuchAlias(BzrError):
2961
3052
        BzrError.__init__(self, unknowns_str=", ".join(unknowns))
2962
3053
 
2963
3054
 
2964
 
class HookFailed(BzrError):
2965
 
    """Raised when a pre_change_branch_tip hook function fails anything other
2966
 
    than TipChangeRejected.
2967
 
 
2968
 
    Note that this exception is no longer raised, and the import is only left
2969
 
    to be nice to code which might catch it in a plugin.
2970
 
    """
2971
 
 
2972
 
    _fmt = ("Hook '%(hook_name)s' during %(hook_stage)s failed:\n"
2973
 
            "%(traceback_text)s%(exc_value)s")
2974
 
 
2975
 
    def __init__(self, hook_stage, hook_name, exc_info, warn=True):
2976
 
        if warn:
2977
 
            symbol_versioning.warn("BzrError HookFailed has been deprecated "
2978
 
                "as of bzrlib 2.1.", DeprecationWarning, stacklevel=2)
2979
 
        import traceback
2980
 
        self.hook_stage = hook_stage
2981
 
        self.hook_name = hook_name
2982
 
        self.exc_info = exc_info
2983
 
        self.exc_type = exc_info[0]
2984
 
        self.exc_value = exc_info[1]
2985
 
        self.exc_tb = exc_info[2]
2986
 
        self.traceback_text = ''.join(traceback.format_tb(self.exc_tb))
2987
 
 
2988
 
 
2989
3055
class TipChangeRejected(BzrError):
2990
3056
    """A pre_change_branch_tip hook function may raise this to cleanly and
2991
3057
    explicitly abort a change to a branch tip.
3002
3068
    _fmt = "Shelf corrupt."
3003
3069
 
3004
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
 
3005
3083
class NoSuchShelfId(BzrError):
3006
3084
 
3007
3085
    _fmt = 'No changes are shelved with id "%(shelf_id)d".'
3134
3212
    def __init__(self, bzrdir):
3135
3213
        self.bzrdir = bzrdir
3136
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.')