/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

  • Committer: Canonical.com Patch Queue Manager
  • Date: 2009-04-09 20:23:07 UTC
  • mfrom: (4265.1.4 bbc-merge)
  • Revision ID: pqm@pqm.ubuntu.com-20090409202307-n0depb16qepoe21o
(jam) Change _fetch_uses_deltas = False for CHK repos until we can
        write a better fix.

Show diffs side-by-side

added added

removed removed

Lines of Context:
1
 
# Copyright (C) 2005-2011 Canonical Ltd
 
1
# Copyright (C) 2005, 2006, 2007, 2008 Canonical Ltd
2
2
#
3
3
# This program is free software; you can redistribute it and/or modify
4
4
# it under the terms of the GNU General Public License as published by
636
636
        self.url = url
637
637
 
638
638
 
639
 
class UnstackableLocationError(BzrError):
640
 
 
641
 
    _fmt = "The branch '%(branch_url)s' cannot be stacked on '%(target_url)s'."
642
 
 
643
 
    def __init__(self, branch_url, target_url):
644
 
        BzrError.__init__(self)
645
 
        self.branch_url = branch_url
646
 
        self.target_url = target_url
647
 
 
648
 
 
649
639
class UnstackableRepositoryFormat(BzrError):
650
640
 
651
641
    _fmt = ("The repository '%(url)s'(%(format)s) is not a stackable format. "
680
670
 
681
671
    _fmt = 'Path "%(path)s" is not a child of path "%(base)s"%(extra)s'
682
672
 
683
 
    internal_error = False
 
673
    internal_error = True
684
674
 
685
675
    def __init__(self, path, base, extra=None):
686
676
        BzrError.__init__(self)
702
692
# TODO: Probably this behavior of should be a common superclass
703
693
class NotBranchError(PathError):
704
694
 
705
 
    _fmt = 'Not a branch: "%(path)s"%(detail)s.'
 
695
    _fmt = 'Not a branch: "%(path)s".'
706
696
 
707
 
    def __init__(self, path, detail=None, bzrdir=None):
 
697
    def __init__(self, path):
708
698
       import bzrlib.urlutils as urlutils
709
 
       path = urlutils.unescape_for_display(path, 'ascii')
710
 
       if detail is not None:
711
 
           detail = ': ' + detail
712
 
       self.detail = detail
713
 
       self.bzrdir = bzrdir
714
 
       PathError.__init__(self, path=path)
715
 
 
716
 
    def __repr__(self):
717
 
        return '<%s %r>' % (self.__class__.__name__, self.__dict__)
718
 
 
719
 
    def _format(self):
720
 
        # XXX: Ideally self.detail would be a property, but Exceptions in
721
 
        # Python 2.4 have to be old-style classes so properties don't work.
722
 
        # Instead we override _format.
723
 
        if self.detail is None:
724
 
            if self.bzrdir is not None:
725
 
                try:
726
 
                    self.bzrdir.open_repository()
727
 
                except NoRepositoryPresent:
728
 
                    self.detail = ''
729
 
                except Exception:
730
 
                    # Just ignore unexpected errors.  Raising arbitrary errors
731
 
                    # during str(err) can provoke strange bugs.  Concretely
732
 
                    # Launchpad's codehosting managed to raise NotBranchError
733
 
                    # here, and then get stuck in an infinite loop/recursion
734
 
                    # trying to str() that error.  All this error really cares
735
 
                    # about that there's no working repository there, and if
736
 
                    # open_repository() fails, there probably isn't.
737
 
                    self.detail = ''
738
 
                else:
739
 
                    self.detail = ': location is a repository'
740
 
            else:
741
 
                self.detail = ''
742
 
        return PathError._format(self)
 
699
       self.path = urlutils.unescape_for_display(path, 'ascii')
743
700
 
744
701
 
745
702
class NoSubmitBranch(PathError):
794
751
 
795
752
    _fmt = 'File "%(path)s" is not in branch %(branch_base)s.'
796
753
 
797
 
    # use PathNotChild instead
798
 
    @symbol_versioning.deprecated_method(symbol_versioning.deprecated_in((2, 3, 0)))
799
754
    def __init__(self, branch, path):
800
755
        BzrError.__init__(self)
801
756
        self.branch = branch
828
783
 
829
784
 
830
785
class IncompatibleRepositories(BzrError):
831
 
    """Report an error that two repositories are not compatible.
832
 
 
833
 
    Note that the source and target repositories are permitted to be strings:
834
 
    this exception is thrown from the smart server and may refer to a
835
 
    repository the client hasn't opened.
836
 
    """
837
786
 
838
787
    _fmt = "%(target)s\n" \
839
788
            "is not compatible with\n" \
961
910
    # original exception is available as e.original_error
962
911
    #
963
912
    # New code should prefer to raise specific subclasses
964
 
    def __init__(self, msg):
965
 
        self.msg = msg
 
913
    def __init__(self, message):
 
914
        # Python 2.5 uses a slot for StandardError.message,
 
915
        # so use a different variable name.  We now work around this in
 
916
        # BzrError.__str__, but this member name is kept for compatability.
 
917
        self.msg = message
966
918
 
967
919
 
968
920
class LockActive(LockError):
1052
1004
class LockContention(LockError):
1053
1005
 
1054
1006
    _fmt = 'Could not acquire lock "%(lock)s": %(msg)s'
 
1007
    # TODO: show full url for lock, combining the transport and relative
 
1008
    # bits?
1055
1009
 
1056
1010
    internal_error = False
1057
1011
 
1084
1038
        self.target = target
1085
1039
 
1086
1040
 
1087
 
class LockCorrupt(LockError):
1088
 
 
1089
 
    _fmt = ("Lock is apparently held, but corrupted: %(corruption_info)s\n"
1090
 
            "Use 'bzr break-lock' to clear it")
1091
 
 
1092
 
    internal_error = False
1093
 
 
1094
 
    def __init__(self, corruption_info, file_data=None):
1095
 
        self.corruption_info = corruption_info
1096
 
        self.file_data = file_data
1097
 
 
1098
 
 
1099
1041
class LockNotHeld(LockError):
1100
1042
 
1101
1043
    _fmt = "Lock not held: %(lock)s"
1200
1142
 
1201
1143
class InvalidRevisionSpec(BzrError):
1202
1144
 
1203
 
    _fmt = ("Requested revision: '%(spec)s' does not exist in branch:"
1204
 
            " %(branch_url)s%(extra)s")
 
1145
    _fmt = ("Requested revision: %(spec)r does not exist in branch:"
 
1146
            " %(branch)s%(extra)s")
1205
1147
 
1206
1148
    def __init__(self, spec, branch, extra=None):
1207
1149
        BzrError.__init__(self, branch=branch, spec=spec)
1208
 
        self.branch_url = getattr(branch, 'user_url', str(branch))
1209
1150
        if extra:
1210
1151
            self.extra = '\n' + str(extra)
1211
1152
        else:
1232
1173
class DivergedBranches(BzrError):
1233
1174
 
1234
1175
    _fmt = ("These branches have diverged."
1235
 
            " Use the missing command to see how.\n"
1236
 
            "Use the merge command to reconcile them.")
 
1176
            " Use the merge command to reconcile them.")
1237
1177
 
1238
1178
    def __init__(self, branch1, branch2):
1239
1179
        self.branch1 = branch1
1287
1227
            not_ancestor_id=not_ancestor_id)
1288
1228
 
1289
1229
 
 
1230
class InstallFailed(BzrError):
 
1231
 
 
1232
    def __init__(self, revisions):
 
1233
        revision_str = ", ".join(str(r) for r in revisions)
 
1234
        msg = "Could not install revisions:\n%s" % revision_str
 
1235
        BzrError.__init__(self, msg)
 
1236
        self.revisions = revisions
 
1237
 
 
1238
 
1290
1239
class AmbiguousBase(BzrError):
1291
1240
 
1292
1241
    def __init__(self, bases):
1293
 
        symbol_versioning.warn("BzrError AmbiguousBase has been deprecated "
1294
 
            "as of bzrlib 0.8.", DeprecationWarning, stacklevel=2)
 
1242
        warn("BzrError AmbiguousBase has been deprecated as of bzrlib 0.8.",
 
1243
                DeprecationWarning)
1295
1244
        msg = ("The correct base is unclear, because %s are all equally close"
1296
1245
                % ", ".join(bases))
1297
1246
        BzrError.__init__(self, msg)
1319
1268
class BoundBranchOutOfDate(BzrError):
1320
1269
 
1321
1270
    _fmt = ("Bound branch %(branch)s is out of date with master branch"
1322
 
            " %(master)s.%(extra_help)s")
 
1271
            " %(master)s.")
1323
1272
 
1324
1273
    def __init__(self, branch, master):
1325
1274
        BzrError.__init__(self)
1326
1275
        self.branch = branch
1327
1276
        self.master = master
1328
 
        self.extra_help = ''
1329
1277
 
1330
1278
 
1331
1279
class CommitToDoubleBoundBranch(BzrError):
1402
1350
 
1403
1351
class WeaveParentMismatch(WeaveError):
1404
1352
 
1405
 
    _fmt = "Parents are mismatched between two revisions. %(msg)s"
 
1353
    _fmt = "Parents are mismatched between two revisions. %(message)s"
1406
1354
 
1407
1355
 
1408
1356
class WeaveInvalidChecksum(WeaveError):
1409
1357
 
1410
 
    _fmt = "Text did not match its checksum: %(msg)s"
 
1358
    _fmt = "Text did not match it's checksum: %(message)s"
1411
1359
 
1412
1360
 
1413
1361
class WeaveTextDiffers(WeaveError):
1461
1409
 
1462
1410
class VersionedFileInvalidChecksum(VersionedFileError):
1463
1411
 
1464
 
    _fmt = "Text did not match its checksum: %(msg)s"
 
1412
    _fmt = "Text did not match its checksum: %(message)s"
1465
1413
 
1466
1414
 
1467
1415
class KnitError(InternalBzrError):
1947
1895
    _fmt = "Moving the root directory is not supported at this time"
1948
1896
 
1949
1897
 
1950
 
class TransformRenameFailed(BzrError):
1951
 
 
1952
 
    _fmt = "Failed to rename %(from_path)s to %(to_path)s: %(why)s"
1953
 
 
1954
 
    def __init__(self, from_path, to_path, why, errno):
1955
 
        self.from_path = from_path
1956
 
        self.to_path = to_path
1957
 
        self.why = why
1958
 
        self.errno = errno
1959
 
 
1960
 
 
1961
1898
class BzrMoveFailedError(BzrError):
1962
1899
 
1963
 
    _fmt = ("Could not move %(from_path)s%(operator)s %(to_path)s"
1964
 
        "%(_has_extra)s%(extra)s")
 
1900
    _fmt = "Could not move %(from_path)s%(operator)s %(to_path)s%(extra)s"
1965
1901
 
1966
1902
    def __init__(self, from_path='', to_path='', extra=None):
1967
1903
        from bzrlib.osutils import splitpath
1968
1904
        BzrError.__init__(self)
1969
1905
        if extra:
1970
 
            self.extra, self._has_extra = extra, ': '
 
1906
            self.extra = ': ' + str(extra)
1971
1907
        else:
1972
 
            self.extra = self._has_extra = ''
 
1908
            self.extra = ''
1973
1909
 
1974
1910
        has_from = len(from_path) > 0
1975
1911
        has_to = len(to_path) > 0
1996
1932
 
1997
1933
class BzrRenameFailedError(BzrMoveFailedError):
1998
1934
 
1999
 
    _fmt = ("Could not rename %(from_path)s%(operator)s %(to_path)s"
2000
 
        "%(_has_extra)s%(extra)s")
 
1935
    _fmt = "Could not rename %(from_path)s%(operator)s %(to_path)s%(extra)s"
2001
1936
 
2002
1937
    def __init__(self, from_path, to_path, extra=None):
2003
1938
        BzrMoveFailedError.__init__(self, from_path, to_path, extra)
2004
1939
 
2005
 
 
2006
1940
class BzrRemoveChangedFilesError(BzrError):
2007
1941
    """Used when user is trying to remove changed files."""
2008
1942
 
2011
1945
        "Use --keep to not delete them, or --force to delete them regardless.")
2012
1946
 
2013
1947
    def __init__(self, tree_delta):
2014
 
        symbol_versioning.warn(symbol_versioning.deprecated_in((2, 3, 0)) %
2015
 
            "BzrRemoveChangedFilesError", DeprecationWarning, stacklevel=2)
2016
1948
        BzrError.__init__(self)
2017
1949
        self.changes_as_text = tree_delta.get_changes_as_text()
2018
1950
        #self.paths_as_string = '\n'.join(changed_files)
2026
1958
 
2027
1959
class BzrBadParameterMissing(BzrBadParameter):
2028
1960
 
2029
 
    _fmt = "Parameter %(param)s is required but not present."
 
1961
    _fmt = "Parameter $(param)s is required but not present."
2030
1962
 
2031
1963
 
2032
1964
class BzrBadParameterUnicode(BzrBadParameter):
2072
2004
 
2073
2005
class BadConversionTarget(BzrError):
2074
2006
 
2075
 
    _fmt = "Cannot convert from format %(from_format)s to format %(format)s." \
2076
 
            "    %(problem)s"
 
2007
    _fmt = "Cannot convert to format %(format)s.  %(problem)s"
2077
2008
 
2078
 
    def __init__(self, problem, format, from_format=None):
 
2009
    def __init__(self, problem, format):
2079
2010
        BzrError.__init__(self)
2080
2011
        self.problem = problem
2081
2012
        self.format = format
2082
 
        self.from_format = from_format or '(unspecified)'
2083
2013
 
2084
2014
 
2085
2015
class NoDiffFound(BzrError):
2161
2091
 
2162
2092
class OutOfDateTree(BzrError):
2163
2093
 
2164
 
    _fmt = "Working tree is out of date, please run 'bzr update'.%(more)s"
 
2094
    _fmt = "Working tree is out of date, please run 'bzr update'."
2165
2095
 
2166
 
    def __init__(self, tree, more=None):
2167
 
        if more is None:
2168
 
            more = ''
2169
 
        else:
2170
 
            more = ' ' + more
 
2096
    def __init__(self, tree):
2171
2097
        BzrError.__init__(self)
2172
2098
        self.tree = tree
2173
 
        self.more = more
2174
2099
 
2175
2100
 
2176
2101
class PublicBranchOutOfDate(BzrError):
2214
2139
 
2215
2140
    def __init__(self, repo):
2216
2141
        BzrError.__init__(self)
2217
 
        self.repo_path = repo.user_url
 
2142
        self.repo_path = repo.bzrdir.root_transport.base
2218
2143
 
2219
2144
 
2220
2145
class InconsistentDelta(BzrError):
2230
2155
        self.reason = reason
2231
2156
 
2232
2157
 
2233
 
class InconsistentDeltaDelta(InconsistentDelta):
2234
 
    """Used when we get a delta that is not valid."""
2235
 
 
2236
 
    _fmt = ("An inconsistent delta was supplied: %(delta)r"
2237
 
            "\nreason: %(reason)s")
2238
 
 
2239
 
    def __init__(self, delta, reason):
2240
 
        BzrError.__init__(self)
2241
 
        self.delta = delta
2242
 
        self.reason = reason
2243
 
 
2244
 
 
2245
2158
class UpgradeRequired(BzrError):
2246
2159
 
2247
2160
    _fmt = "To use this feature you must upgrade your branch at %(path)s."
2256
2169
    _fmt = "To use this feature you must upgrade your repository at %(path)s."
2257
2170
 
2258
2171
 
2259
 
class RichRootUpgradeRequired(UpgradeRequired):
2260
 
 
2261
 
    _fmt = ("To use this feature you must upgrade your branch at %(path)s to"
2262
 
           " a format which supports rich roots.")
2263
 
 
2264
 
 
2265
2172
class LocalRequiresBoundBranch(BzrError):
2266
2173
 
2267
2174
    _fmt = "Cannot perform local-only commits on unbound branches."
2268
2175
 
2269
2176
 
 
2177
class InvalidProgressBarType(BzrError):
 
2178
 
 
2179
    _fmt = ("Environment variable BZR_PROGRESS_BAR='%(bar_type)s"
 
2180
            " is not a supported type Select one of: %(valid_types)s")
 
2181
 
 
2182
    def __init__(self, bar_type, valid_types):
 
2183
        BzrError.__init__(self, bar_type=bar_type, valid_types=valid_types)
 
2184
 
 
2185
 
2270
2186
class UnsupportedOperation(BzrError):
2271
2187
 
2272
2188
    _fmt = ("The method %(mname)s is not supported on"
2792
2708
 
2793
2709
    def __init__(self, bzrdir):
2794
2710
        import bzrlib.urlutils as urlutils
2795
 
        display_url = urlutils.unescape_for_display(bzrdir.user_url,
 
2711
        display_url = urlutils.unescape_for_display(bzrdir.root_transport.base,
2796
2712
                                                    'ascii')
2797
2713
        BzrError.__init__(self, bzrdir=bzrdir, display_url=display_url)
2798
2714
 
2863
2779
 
2864
2780
class UncommittedChanges(BzrError):
2865
2781
 
2866
 
    _fmt = ('Working tree "%(display_url)s" has uncommitted changes'
2867
 
            ' (See bzr status).%(more)s')
 
2782
    _fmt = 'Working tree "%(display_url)s" has uncommitted changes.'
2868
2783
 
2869
 
    def __init__(self, tree, more=None):
2870
 
        if more is None:
2871
 
            more = ''
2872
 
        else:
2873
 
            more = ' ' + more
 
2784
    def __init__(self, tree):
2874
2785
        import bzrlib.urlutils as urlutils
2875
 
        user_url = getattr(tree, "user_url", None)
2876
 
        if user_url is None:
2877
 
            display_url = str(tree)
2878
 
        else:
2879
 
            display_url = urlutils.unescape_for_display(user_url, 'ascii')
2880
 
        BzrError.__init__(self, tree=tree, display_url=display_url, more=more)
2881
 
 
2882
 
 
2883
 
class ShelvedChanges(UncommittedChanges):
2884
 
 
2885
 
    _fmt = ('Working tree "%(display_url)s" has shelved changes'
2886
 
            ' (See bzr shelve --list).%(more)s')
 
2786
        display_url = urlutils.unescape_for_display(
 
2787
            tree.bzrdir.root_transport.base, 'ascii')
 
2788
        BzrError.__init__(self, tree=tree, display_url=display_url)
2887
2789
 
2888
2790
 
2889
2791
class MissingTemplateVariable(BzrError):
2960
2862
        self.user_encoding = osutils.get_user_encoding()
2961
2863
 
2962
2864
 
2963
 
class NoSuchConfig(BzrError):
2964
 
 
2965
 
    _fmt = ('The "%(config_id)s" configuration does not exist.')
2966
 
 
2967
 
    def __init__(self, config_id):
2968
 
        BzrError.__init__(self, config_id=config_id)
2969
 
 
2970
 
 
2971
 
class NoSuchConfigOption(BzrError):
2972
 
 
2973
 
    _fmt = ('The "%(option_name)s" configuration option does not exist.')
2974
 
 
2975
 
    def __init__(self, option_name):
2976
 
        BzrError.__init__(self, option_name=option_name)
2977
 
 
2978
 
 
2979
2865
class NoSuchAlias(BzrError):
2980
2866
 
2981
2867
    _fmt = ('The alias "%(alias_name)s" does not exist.')
3011
2897
    _fmt = 'Cannot bind address "%(host)s:%(port)i": %(orig_error)s.'
3012
2898
 
3013
2899
    def __init__(self, host, port, orig_error):
3014
 
        # nb: in python2.4 socket.error doesn't have a useful repr
3015
2900
        BzrError.__init__(self, host=host, port=port,
3016
 
            orig_error=repr(orig_error.args))
 
2901
            orig_error=orig_error[1])
3017
2902
 
3018
2903
 
3019
2904
class UnknownRules(BzrError):
3027
2912
class HookFailed(BzrError):
3028
2913
    """Raised when a pre_change_branch_tip hook function fails anything other
3029
2914
    than TipChangeRejected.
3030
 
 
3031
 
    Note that this exception is no longer raised, and the import is only left
3032
 
    to be nice to code which might catch it in a plugin.
3033
2915
    """
3034
2916
 
3035
2917
    _fmt = ("Hook '%(hook_name)s' during %(hook_stage)s failed:\n"
3036
2918
            "%(traceback_text)s%(exc_value)s")
3037
2919
 
3038
 
    def __init__(self, hook_stage, hook_name, exc_info, warn=True):
3039
 
        if warn:
3040
 
            symbol_versioning.warn("BzrError HookFailed has been deprecated "
3041
 
                "as of bzrlib 2.1.", DeprecationWarning, stacklevel=2)
 
2920
    def __init__(self, hook_stage, hook_name, exc_info):
3042
2921
        import traceback
3043
2922
        self.hook_stage = hook_stage
3044
2923
        self.hook_name = hook_name
3081
2960
        BzrError.__init__(self, invalid_id=invalid_id)
3082
2961
 
3083
2962
 
3084
 
class JailBreak(BzrError):
3085
 
 
3086
 
    _fmt = "An attempt to access a url outside the server jail was made: '%(url)s'."
3087
 
 
3088
 
    def __init__(self, url):
3089
 
        BzrError.__init__(self, url=url)
3090
 
 
3091
 
 
3092
2963
class UserAbort(BzrError):
3093
2964
 
3094
2965
    _fmt = 'The user aborted the operation.'
3154
3025
 
3155
3026
    def __init__(self, repository):
3156
3027
        self.repository = repository
3157
 
 
3158
 
 
3159
 
class LossyPushToSameVCS(BzrError):
3160
 
 
3161
 
    _fmt = ("Lossy push not possible between %(source_branch)r and "
3162
 
            "%(target_branch)r that are in the same VCS.")
3163
 
 
3164
 
    internal_error = True
3165
 
 
3166
 
    def __init__(self, source_branch, target_branch):
3167
 
        self.source_branch = source_branch
3168
 
        self.target_branch = target_branch
3169
 
 
3170
 
 
3171
 
class NoRoundtrippingSupport(BzrError):
3172
 
 
3173
 
    _fmt = ("Roundtripping is not supported between %(source_branch)r and "
3174
 
            "%(target_branch)r.")
3175
 
 
3176
 
    internal_error = True
3177
 
 
3178
 
    def __init__(self, source_branch, target_branch):
3179
 
        self.source_branch = source_branch
3180
 
        self.target_branch = target_branch
3181
 
 
3182
 
 
3183
 
class FileTimestampUnavailable(BzrError):
3184
 
 
3185
 
    _fmt = "The filestamp for %(path)s is not available."
3186
 
 
3187
 
    internal_error = True
3188
 
 
3189
 
    def __init__(self, path):
3190
 
        self.path = path
3191
 
 
3192
 
 
3193
 
class NoColocatedBranchSupport(BzrError):
3194
 
 
3195
 
    _fmt = ("%(bzrdir)r does not support co-located branches.")
3196
 
 
3197
 
    def __init__(self, bzrdir):
3198
 
        self.bzrdir = bzrdir
3199
 
 
3200
 
 
3201
 
class NoWhoami(BzrError):
3202
 
 
3203
 
    _fmt = ('Unable to determine your name.\n'
3204
 
        "Please, set your name with the 'whoami' command.\n"
3205
 
        'E.g. bzr whoami "Your Name <name@example.com>"')
3206
 
 
3207
 
 
3208
 
class InvalidPattern(BzrError):
3209
 
 
3210
 
    _fmt = ('Invalid pattern(s) found. %(msg)s')
3211
 
 
3212
 
    def __init__(self, msg):
3213
 
        self.msg = msg
3214
 
 
3215
 
 
3216
 
class RecursiveBind(BzrError):
3217
 
 
3218
 
    _fmt = ('Branch "%(branch_url)s" appears to be bound to itself. '
3219
 
        'Please use `bzr unbind` to fix.')
3220
 
 
3221
 
    def __init__(self, branch_url):
3222
 
        self.branch_url = branch_url
3223