/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/errors.py

merge in trunk and i18n-errors

Show diffs side-by-side

added added

removed removed

Lines of Context:
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
20
20
from bzrlib import (
21
21
    osutils,
22
22
    symbol_versioning,
 
23
    i18n,
23
24
    )
 
25
from bzrlib.i18n import gettext
24
26
from bzrlib.patches import (
25
27
    MalformedHunkHeader,
26
28
    MalformedLine,
54
56
    Base class for errors raised by bzrlib.
55
57
 
56
58
    :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.)
 
59
        should be displayed with a traceback; if False (or absent) this was
 
60
        probably a user or environment error and they don't need the gory
 
61
        details.  (That can be overridden by -Derror on the command line.)
60
62
 
61
63
    :cvar _fmt: Format string to display the error; this is expanded
62
 
    by the instance's dict.
 
64
        by the instance's dict.
63
65
    """
64
66
 
65
67
    internal_error = False
140
142
        """Return format string for this exception or None"""
141
143
        fmt = getattr(self, '_fmt', None)
142
144
        if fmt is not None:
143
 
            return fmt
 
145
            i18n.install()
 
146
            return gettext(fmt)
144
147
        fmt = getattr(self, '__doc__', None)
145
148
        if fmt is not None:
146
149
            symbol_versioning.warn("%s uses its docstring as a format, "
304
307
class RootMissing(InternalBzrError):
305
308
 
306
309
    _fmt = ("The root entry of a tree must be the first entry supplied to "
307
 
        "record_entry_contents.")
 
310
        "the commit builder.")
308
311
 
309
312
 
310
313
class NoPublicBranch(BzrError):
621
624
 
622
625
    _fmt = 'Unsupported protocol for url "%(path)s"%(extra)s'
623
626
 
624
 
    def __init__(self, url, extra):
 
627
    def __init__(self, url, extra=""):
625
628
        PathError.__init__(self, url, extra=extra)
626
629
 
627
630
 
680
683
 
681
684
    _fmt = 'Path "%(path)s" is not a child of path "%(base)s"%(extra)s'
682
685
 
683
 
    internal_error = True
 
686
    internal_error = False
684
687
 
685
688
    def __init__(self, path, base, extra=None):
686
689
        BzrError.__init__(self)
713
716
       self.bzrdir = bzrdir
714
717
       PathError.__init__(self, path=path)
715
718
 
 
719
    def __repr__(self):
 
720
        return '<%s %r>' % (self.__class__.__name__, self.__dict__)
 
721
 
716
722
    def _format(self):
717
723
        # XXX: Ideally self.detail would be a property, but Exceptions in
718
724
        # Python 2.4 have to be old-style classes so properties don't work.
723
729
                    self.bzrdir.open_repository()
724
730
                except NoRepositoryPresent:
725
731
                    self.detail = ''
 
732
                except Exception:
 
733
                    # Just ignore unexpected errors.  Raising arbitrary errors
 
734
                    # during str(err) can provoke strange bugs.  Concretely
 
735
                    # Launchpad's codehosting managed to raise NotBranchError
 
736
                    # here, and then get stuck in an infinite loop/recursion
 
737
                    # trying to str() that error.  All this error really cares
 
738
                    # about that there's no working repository there, and if
 
739
                    # open_repository() fails, there probably isn't.
 
740
                    self.detail = ''
726
741
                else:
727
742
                    self.detail = ': location is a repository'
728
743
            else:
782
797
 
783
798
    _fmt = 'File "%(path)s" is not in branch %(branch_base)s.'
784
799
 
 
800
    # use PathNotChild instead
 
801
    @symbol_versioning.deprecated_method(symbol_versioning.deprecated_in((2, 3, 0)))
785
802
    def __init__(self, branch, path):
786
803
        BzrError.__init__(self)
787
804
        self.branch = branch
850
867
        """Construct a new AlreadyVersionedError.
851
868
 
852
869
        :param path: This is the path which is versioned,
853
 
        which should be in a user friendly form.
 
870
            which should be in a user friendly form.
854
871
        :param context_info: If given, this is information about the context,
855
 
        which could explain why this is expected to not be versioned.
 
872
            which could explain why this is expected to not be versioned.
856
873
        """
857
874
        BzrError.__init__(self)
858
875
        self.path = path
871
888
        """Construct a new NotVersionedError.
872
889
 
873
890
        :param path: This is the path which is not versioned,
874
 
        which should be in a user friendly form.
 
891
            which should be in a user friendly form.
875
892
        :param context_info: If given, this is information about the context,
876
 
        which could explain why this is expected to be versioned.
 
893
            which could explain why this is expected to be versioned.
877
894
        """
878
895
        BzrError.__init__(self)
879
896
        self.path = path
947
964
    # original exception is available as e.original_error
948
965
    #
949
966
    # 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
 
967
    def __init__(self, msg):
 
968
        self.msg = msg
955
969
 
956
970
 
957
971
class LockActive(LockError):
1041
1055
class LockContention(LockError):
1042
1056
 
1043
1057
    _fmt = 'Could not acquire lock "%(lock)s": %(msg)s'
1044
 
    # TODO: show full url for lock, combining the transport and relative
1045
 
    # bits?
1046
1058
 
1047
1059
    internal_error = False
1048
1060
 
1075
1087
        self.target = target
1076
1088
 
1077
1089
 
 
1090
class LockCorrupt(LockError):
 
1091
 
 
1092
    _fmt = ("Lock is apparently held, but corrupted: %(corruption_info)s\n"
 
1093
            "Use 'bzr break-lock' to clear it")
 
1094
 
 
1095
    internal_error = False
 
1096
 
 
1097
    def __init__(self, corruption_info, file_data=None):
 
1098
        self.corruption_info = corruption_info
 
1099
        self.file_data = file_data
 
1100
 
 
1101
 
1078
1102
class LockNotHeld(LockError):
1079
1103
 
1080
1104
    _fmt = "Lock not held: %(lock)s"
1119
1143
        BzrError.__init__(self, files=files, files_str=files_str)
1120
1144
 
1121
1145
 
 
1146
class ExcludesUnsupported(BzrError):
 
1147
 
 
1148
    _fmt = ('Excluding paths during commit is not supported by '
 
1149
            'repository at %(repository)r.')
 
1150
 
 
1151
    def __init__(self, repository):
 
1152
        BzrError.__init__(self, repository=repository)
 
1153
 
 
1154
 
1122
1155
class BadCommitMessageEncoding(BzrError):
1123
1156
 
1124
1157
    _fmt = 'The specified commit message contains characters unsupported by '\
1180
1213
class InvalidRevisionSpec(BzrError):
1181
1214
 
1182
1215
    _fmt = ("Requested revision: '%(spec)s' does not exist in branch:"
1183
 
            " %(branch)s%(extra)s")
 
1216
            " %(branch_url)s%(extra)s")
1184
1217
 
1185
1218
    def __init__(self, spec, branch, extra=None):
1186
1219
        BzrError.__init__(self, branch=branch, spec=spec)
 
1220
        self.branch_url = getattr(branch, 'user_url', str(branch))
1187
1221
        if extra:
1188
1222
            self.extra = '\n' + str(extra)
1189
1223
        else:
1380
1414
 
1381
1415
class WeaveParentMismatch(WeaveError):
1382
1416
 
1383
 
    _fmt = "Parents are mismatched between two revisions. %(message)s"
 
1417
    _fmt = "Parents are mismatched between two revisions. %(msg)s"
1384
1418
 
1385
1419
 
1386
1420
class WeaveInvalidChecksum(WeaveError):
1387
1421
 
1388
 
    _fmt = "Text did not match it's checksum: %(message)s"
 
1422
    _fmt = "Text did not match its checksum: %(msg)s"
1389
1423
 
1390
1424
 
1391
1425
class WeaveTextDiffers(WeaveError):
1439
1473
 
1440
1474
class VersionedFileInvalidChecksum(VersionedFileError):
1441
1475
 
1442
 
    _fmt = "Text did not match its checksum: %(message)s"
 
1476
    _fmt = "Text did not match its checksum: %(msg)s"
1443
1477
 
1444
1478
 
1445
1479
class KnitError(InternalBzrError):
1684
1718
 
1685
1719
class InvalidHttpResponse(TransportError):
1686
1720
 
1687
 
    _fmt = "Invalid http response for %(path)s: %(msg)s"
 
1721
    _fmt = "Invalid http response for %(path)s: %(msg)s%(orig_error)s"
1688
1722
 
1689
1723
    def __init__(self, path, msg, orig_error=None):
1690
1724
        self.path = path
 
1725
        if orig_error is None:
 
1726
            orig_error = ''
 
1727
        else:
 
1728
            # This is reached for obscure and unusual errors so we want to
 
1729
            # preserve as much info as possible to ease debug.
 
1730
            orig_error = ': %r' % (orig_error,)
1691
1731
        TransportError.__init__(self, msg, orig_error=orig_error)
1692
1732
 
1693
1733
 
1700
1740
        InvalidHttpResponse.__init__(self, path, msg)
1701
1741
 
1702
1742
 
 
1743
class HttpBoundaryMissing(InvalidHttpResponse):
 
1744
    """A multipart response ends with no boundary marker.
 
1745
 
 
1746
    This is a special case caused by buggy proxies, described in
 
1747
    <https://bugs.launchpad.net/bzr/+bug/198646>.
 
1748
    """
 
1749
 
 
1750
    _fmt = "HTTP MIME Boundary missing for %(path)s: %(msg)s"
 
1751
 
 
1752
    def __init__(self, path, msg):
 
1753
        InvalidHttpResponse.__init__(self, path, msg)
 
1754
 
 
1755
 
1703
1756
class InvalidHttpContentType(InvalidHttpResponse):
1704
1757
 
1705
1758
    _fmt = 'Invalid http Content-type "%(ctype)s" for %(path)s: %(msg)s'
1733
1786
    _fmt = "Working tree has conflicts."
1734
1787
 
1735
1788
 
 
1789
class ConfigContentError(BzrError):
 
1790
 
 
1791
    _fmt = "Config file %(filename)s is not UTF-8 encoded\n"
 
1792
 
 
1793
    def __init__(self, filename):
 
1794
        BzrError.__init__(self)
 
1795
        self.filename = filename
 
1796
 
 
1797
 
1736
1798
class ParseConfigError(BzrError):
1737
1799
 
 
1800
    _fmt = "Error(s) parsing config file %(filename)s:\n%(errors)s"
 
1801
 
1738
1802
    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)
 
1803
        BzrError.__init__(self)
 
1804
        self.filename = filename
 
1805
        self.errors = '\n'.join(e.msg for e in errors)
 
1806
 
 
1807
 
 
1808
class ConfigOptionValueError(BzrError):
 
1809
 
 
1810
    _fmt = """Bad value "%(value)s" for option "%(name)s"."""
 
1811
 
 
1812
    def __init__(self, name, value):
 
1813
        BzrError.__init__(self, name=name, value=value)
1744
1814
 
1745
1815
 
1746
1816
class NoEmailInUsername(BzrError):
1754
1824
 
1755
1825
class SigningFailed(BzrError):
1756
1826
 
1757
 
    _fmt = 'Failed to gpg sign data with command "%(command_line)s"'
 
1827
    _fmt = 'Failed to GPG sign data with command "%(command_line)s"'
1758
1828
 
1759
1829
    def __init__(self, command_line):
1760
1830
        BzrError.__init__(self, command_line=command_line)
1761
1831
 
1762
1832
 
 
1833
class SignatureVerificationFailed(BzrError):
 
1834
 
 
1835
    _fmt = 'Failed to verify GPG signature data with error "%(error)s"'
 
1836
 
 
1837
    def __init__(self, error):
 
1838
        BzrError.__init__(self, error=error)
 
1839
 
 
1840
 
 
1841
class DependencyNotPresent(BzrError):
 
1842
 
 
1843
    _fmt = 'Unable to import library "%(library)s": %(error)s'
 
1844
 
 
1845
    def __init__(self, library, error):
 
1846
        BzrError.__init__(self, library=library, error=error)
 
1847
 
 
1848
 
 
1849
class GpgmeNotInstalled(DependencyNotPresent):
 
1850
 
 
1851
    _fmt = 'python-gpgme is not installed, it is needed to verify signatures'
 
1852
 
 
1853
    def __init__(self, error):
 
1854
        DependencyNotPresent.__init__(self, 'gpgme', error)
 
1855
 
 
1856
 
1763
1857
class WorkingTreeNotRevision(BzrError):
1764
1858
 
1765
1859
    _fmt = ("The working tree for %(basedir)s has changed since"
1925
2019
    _fmt = "Moving the root directory is not supported at this time"
1926
2020
 
1927
2021
 
 
2022
class TransformRenameFailed(BzrError):
 
2023
 
 
2024
    _fmt = "Failed to rename %(from_path)s to %(to_path)s: %(why)s"
 
2025
 
 
2026
    def __init__(self, from_path, to_path, why, errno):
 
2027
        self.from_path = from_path
 
2028
        self.to_path = to_path
 
2029
        self.why = why
 
2030
        self.errno = errno
 
2031
 
 
2032
 
1928
2033
class BzrMoveFailedError(BzrError):
1929
2034
 
1930
 
    _fmt = "Could not move %(from_path)s%(operator)s %(to_path)s%(extra)s"
 
2035
    _fmt = ("Could not move %(from_path)s%(operator)s %(to_path)s"
 
2036
        "%(_has_extra)s%(extra)s")
1931
2037
 
1932
2038
    def __init__(self, from_path='', to_path='', extra=None):
1933
2039
        from bzrlib.osutils import splitpath
1934
2040
        BzrError.__init__(self)
1935
2041
        if extra:
1936
 
            self.extra = ': ' + str(extra)
 
2042
            self.extra, self._has_extra = extra, ': '
1937
2043
        else:
1938
 
            self.extra = ''
 
2044
            self.extra = self._has_extra = ''
1939
2045
 
1940
2046
        has_from = len(from_path) > 0
1941
2047
        has_to = len(to_path) > 0
1962
2068
 
1963
2069
class BzrRenameFailedError(BzrMoveFailedError):
1964
2070
 
1965
 
    _fmt = "Could not rename %(from_path)s%(operator)s %(to_path)s%(extra)s"
 
2071
    _fmt = ("Could not rename %(from_path)s%(operator)s %(to_path)s"
 
2072
        "%(_has_extra)s%(extra)s")
1966
2073
 
1967
2074
    def __init__(self, from_path, to_path, extra=None):
1968
2075
        BzrMoveFailedError.__init__(self, from_path, to_path, extra)
1969
2076
 
 
2077
 
1970
2078
class BzrRemoveChangedFilesError(BzrError):
1971
2079
    """Used when user is trying to remove changed files."""
1972
2080
 
1975
2083
        "Use --keep to not delete them, or --force to delete them regardless.")
1976
2084
 
1977
2085
    def __init__(self, tree_delta):
 
2086
        symbol_versioning.warn(symbol_versioning.deprecated_in((2, 3, 0)) %
 
2087
            "BzrRemoveChangedFilesError", DeprecationWarning, stacklevel=2)
1978
2088
        BzrError.__init__(self)
1979
2089
        self.changes_as_text = tree_delta.get_changes_as_text()
1980
2090
        #self.paths_as_string = '\n'.join(changed_files)
1988
2098
 
1989
2099
class BzrBadParameterMissing(BzrBadParameter):
1990
2100
 
1991
 
    _fmt = "Parameter $(param)s is required but not present."
 
2101
    _fmt = "Parameter %(param)s is required but not present."
1992
2102
 
1993
2103
 
1994
2104
class BzrBadParameterUnicode(BzrBadParameter):
2002
2112
    _fmt = "Parameter %(param)s contains a newline."
2003
2113
 
2004
2114
 
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
2115
class ParamikoNotPresent(DependencyNotPresent):
2014
2116
 
2015
2117
    _fmt = "Unable to import paramiko (required for sftp support): %(error)s"
2618
2720
 
2619
2721
    This is distinct from ErrorFromSmartServer so that it is possible to
2620
2722
    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.
 
2723
 
 
2724
    - ErrorFromSmartServer was uncaught.  This is logic error in the client
 
2725
      and so should provoke a traceback to the user.
 
2726
    - ErrorFromSmartServer was caught but its error_tuple could not be
 
2727
      translated.  This is probably because the server sent us garbage, and
 
2728
      should not provoke a traceback.
2626
2729
    """
2627
2730
 
2628
2731
    _fmt = "Server sent an unexpected error: %(error_tuple)r"
2834
2937
        else:
2835
2938
            more = ' ' + more
2836
2939
        import bzrlib.urlutils as urlutils
2837
 
        display_url = urlutils.unescape_for_display(
2838
 
            tree.user_url, 'ascii')
 
2940
        user_url = getattr(tree, "user_url", None)
 
2941
        if user_url is None:
 
2942
            display_url = str(tree)
 
2943
        else:
 
2944
            display_url = urlutils.unescape_for_display(user_url, 'ascii')
2839
2945
        BzrError.__init__(self, tree=tree, display_url=display_url, more=more)
2840
2946
 
2841
2947
 
 
2948
class ShelvedChanges(UncommittedChanges):
 
2949
 
 
2950
    _fmt = ('Working tree "%(display_url)s" has shelved changes'
 
2951
            ' (See bzr shelve --list).%(more)s')
 
2952
 
 
2953
 
2842
2954
class MissingTemplateVariable(BzrError):
2843
2955
 
2844
2956
    _fmt = 'Variable {%(name)s} is not available.'
2913
3025
        self.user_encoding = osutils.get_user_encoding()
2914
3026
 
2915
3027
 
 
3028
class NoSuchConfig(BzrError):
 
3029
 
 
3030
    _fmt = ('The "%(config_id)s" configuration does not exist.')
 
3031
 
 
3032
    def __init__(self, config_id):
 
3033
        BzrError.__init__(self, config_id=config_id)
 
3034
 
 
3035
 
 
3036
class NoSuchConfigOption(BzrError):
 
3037
 
 
3038
    _fmt = ('The "%(option_name)s" configuration option does not exist.')
 
3039
 
 
3040
    def __init__(self, option_name):
 
3041
        BzrError.__init__(self, option_name=option_name)
 
3042
 
 
3043
 
2916
3044
class NoSuchAlias(BzrError):
2917
3045
 
2918
3046
    _fmt = ('The alias "%(alias_name)s" does not exist.')
3002
3130
    _fmt = "Shelf corrupt."
3003
3131
 
3004
3132
 
 
3133
class DecompressCorruption(BzrError):
 
3134
 
 
3135
    _fmt = "Corruption while decompressing repository file%(orig_error)s"
 
3136
 
 
3137
    def __init__(self, orig_error=None):
 
3138
        if orig_error is not None:
 
3139
            self.orig_error = ", %s" % (orig_error,)
 
3140
        else:
 
3141
            self.orig_error = ""
 
3142
        BzrError.__init__(self)
 
3143
 
 
3144
 
3005
3145
class NoSuchShelfId(BzrError):
3006
3146
 
3007
3147
    _fmt = 'No changes are shelved with id "%(shelf_id)d".'
3134
3274
    def __init__(self, bzrdir):
3135
3275
        self.bzrdir = bzrdir
3136
3276
 
 
3277
 
 
3278
class NoWhoami(BzrError):
 
3279
 
 
3280
    _fmt = ('Unable to determine your name.\n'
 
3281
        "Please, set your name with the 'whoami' command.\n"
 
3282
        'E.g. bzr whoami "Your Name <name@example.com>"')
 
3283
 
 
3284
 
 
3285
class InvalidPattern(BzrError):
 
3286
 
 
3287
    _fmt = ('Invalid pattern(s) found. %(msg)s')
 
3288
 
 
3289
    def __init__(self, msg):
 
3290
        self.msg = msg
 
3291
 
 
3292
 
 
3293
class RecursiveBind(BzrError):
 
3294
 
 
3295
    _fmt = ('Branch "%(branch_url)s" appears to be bound to itself. '
 
3296
        'Please use `bzr unbind` to fix.')
 
3297
 
 
3298
    def __init__(self, branch_url):
 
3299
        self.branch_url = branch_url
 
3300
 
 
3301
 
 
3302
# FIXME: I would prefer to define the config related exception classes in
 
3303
# config.py but the lazy import mechanism proscribes this -- vila 20101222
 
3304
class OptionExpansionLoop(BzrError):
 
3305
 
 
3306
    _fmt = 'Loop involving %(refs)r while expanding "%(string)s".'
 
3307
 
 
3308
    def __init__(self, string, refs):
 
3309
        self.string = string
 
3310
        self.refs = '->'.join(refs)
 
3311
 
 
3312
 
 
3313
class ExpandingUnknownOption(BzrError):
 
3314
 
 
3315
    _fmt = 'Option %(name)s is not defined while expanding "%(string)s".'
 
3316
 
 
3317
    def __init__(self, name, string):
 
3318
        self.name = name
 
3319
        self.string = string
 
3320
 
 
3321
 
 
3322
class NoCompatibleInter(BzrError):
 
3323
 
 
3324
    _fmt = ('No compatible object available for operations from %(source)r '
 
3325
            'to %(target)r.')
 
3326
 
 
3327
    def __init__(self, source, target):
 
3328
        self.source = source
 
3329
        self.target = target
 
3330
 
 
3331
 
 
3332
class HpssVfsRequestNotAllowed(BzrError):
 
3333
 
 
3334
    _fmt = ("VFS requests over the smart server are not allowed. Encountered: "
 
3335
            "%(method)s, %(arguments)s.")
 
3336
 
 
3337
    def __init__(self, method, arguments):
 
3338
        self.method = method
 
3339
        self.arguments = arguments