← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/errors.py

Fix up inter_changes with dirstate both C and python.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/errors.py
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
12
12
#
13
13
# You should have received a copy of the GNU General Public License
14
14
# along with this program; if not, write to the Free Software
15
 
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
16
16
 
17
17
"""Exceptions for bzr, and reporting of them.
18
18
"""
19
19
 
 
20
 
20
21
from bzrlib import (
21
22
    osutils,
22
23
    symbol_versioning,
31
32
 
32
33
 
33
34
# TODO: is there any value in providing the .args field used by standard
34
 
# python exceptions?   A list of values with no names seems less useful
 
35
# python exceptions?   A list of values with no names seems less useful 
35
36
# to me.
36
37
 
37
 
# TODO: Perhaps convert the exception to a string at the moment it's
 
38
# TODO: Perhaps convert the exception to a string at the moment it's 
38
39
# constructed to make sure it will succeed.  But that says nothing about
39
40
# exceptions that are never raised.
40
41
 
54
55
    Base class for errors raised by bzrlib.
55
56
 
56
57
    :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
59
 
        details.  (That can be overridden by -Derror on the command line.)
 
58
    should be displayed with a traceback; if False (or absent) this was
 
59
    probably a user or environment error and they don't need the gory details.
 
60
    (That can be overridden by -Derror on the command line.)
60
61
 
61
62
    :cvar _fmt: Format string to display the error; this is expanded
62
 
        by the instance's dict.
 
63
    by the instance's dict.
63
64
    """
64
 
 
 
65
    
65
66
    internal_error = False
66
67
 
67
68
    def __init__(self, msg=None, **kwds):
72
73
        arguments can be given.  The first is for generic "user" errors which
73
74
        are not intended to be caught and so do not need a specific subclass.
74
75
        The second case is for use with subclasses that provide a _fmt format
75
 
        string to print the arguments.
 
76
        string to print the arguments.  
76
77
 
77
 
        Keyword arguments are taken as parameters to the error, which can
78
 
        be inserted into the format string template.  It's recommended
79
 
        that subclasses override the __init__ method to require specific
 
78
        Keyword arguments are taken as parameters to the error, which can 
 
79
        be inserted into the format string template.  It's recommended 
 
80
        that subclasses override the __init__ method to require specific 
80
81
        parameters.
81
82
 
82
83
        :param msg: If given, this is the literal complete text for the error,
83
 
           not subject to expansion. 'msg' is used instead of 'message' because
84
 
           python evolved and, in 2.6, forbids the use of 'message'.
 
84
        not subject to expansion.
85
85
        """
86
86
        StandardError.__init__(self)
87
87
        if msg is not None:
102
102
            fmt = self._get_format_string()
103
103
            if fmt:
104
104
                d = dict(self.__dict__)
 
105
                # special case: python2.5 puts the 'message' attribute in a
 
106
                # slot, so it isn't seen in __dict__
 
107
                d['message'] = getattr(self, 'message', 'no message')
105
108
                s = fmt % d
106
109
                # __str__() should always return a 'str' object
107
110
                # never a 'unicode' object.
123
126
            # return a unicode object.
124
127
            u = unicode(u)
125
128
        return u
126
 
 
 
129
    
127
130
    def __str__(self):
128
131
        s = self._format()
129
132
        if isinstance(s, unicode):
133
136
            s = str(s)
134
137
        return s
135
138
 
136
 
    def __repr__(self):
137
 
        return '%s(%s)' % (self.__class__.__name__, str(self))
138
 
 
139
139
    def _get_format_string(self):
140
140
        """Return format string for this exception or None"""
141
141
        fmt = getattr(self, '_fmt', None)
154
154
               )
155
155
 
156
156
    def __eq__(self, other):
157
 
        if self.__class__ is not other.__class__:
 
157
        if self.__class__ != other.__class__:
158
158
            return NotImplemented
159
159
        return self.__dict__ == other.__dict__
160
160
 
204
204
 
205
205
 
206
206
class AlreadyBuilding(BzrError):
207
 
 
 
207
    
208
208
    _fmt = "The tree builder is already building a tree."
209
209
 
210
210
 
216
216
 
217
217
 
218
218
class BzrCheckError(InternalBzrError):
219
 
 
220
 
    _fmt = "Internal check failed: %(msg)s"
221
 
 
222
 
    def __init__(self, msg):
 
219
    
 
220
    _fmt = "Internal check failed: %(message)s"
 
221
 
 
222
    def __init__(self, message):
223
223
        BzrError.__init__(self)
224
 
        self.msg = msg
 
224
        self.message = message
225
225
 
226
226
 
227
227
class DirstateCorrupt(BzrError):
265
265
 
266
266
 
267
267
class InvalidEntryName(InternalBzrError):
268
 
 
 
268
    
269
269
    _fmt = "Invalid entry name: %(name)s"
270
270
 
271
271
    def __init__(self, name):
274
274
 
275
275
 
276
276
class InvalidRevisionNumber(BzrError):
277
 
 
 
277
    
278
278
    _fmt = "Invalid revision number %(revno)s"
279
279
 
280
280
    def __init__(self, revno):
304
304
class RootMissing(InternalBzrError):
305
305
 
306
306
    _fmt = ("The root entry of a tree must be the first entry supplied to "
307
 
        "the commit builder.")
 
307
        "record_entry_contents.")
308
308
 
309
309
 
310
310
class NoPublicBranch(BzrError):
329
329
class NoSuchId(BzrError):
330
330
 
331
331
    _fmt = 'The file id "%(file_id)s" is not present in the tree %(tree)s.'
332
 
 
 
332
    
333
333
    def __init__(self, tree, file_id):
334
334
        BzrError.__init__(self)
335
335
        self.file_id = file_id
362
362
class NoWorkingTree(BzrError):
363
363
 
364
364
    _fmt = 'No WorkingTree exists for "%(base)s".'
365
 
 
 
365
    
366
366
    def __init__(self, base):
367
367
        BzrError.__init__(self)
368
368
        self.base = base
477
477
    def __init__(self, name, value):
478
478
        BzrError.__init__(self, name=name, value=value)
479
479
 
480
 
 
 
480
    
481
481
class StrictCommitFailed(BzrError):
482
482
 
483
483
    _fmt = "Commit refused because there are unknown files in the tree"
486
486
# XXX: Should be unified with TransportError; they seem to represent the
487
487
# same thing
488
488
# RBC 20060929: I think that unifiying with TransportError would be a mistake
489
 
# - this is finer than a TransportError - and more useful as such. It
 
489
# - this is finer than a TransportError - and more useful as such. It 
490
490
# differentiates between 'transport has failed' and 'operation on a transport
491
491
# has failed.'
492
492
class PathError(BzrError):
493
 
 
 
493
    
494
494
    _fmt = "Generic path error: %(path)r%(extra)s)"
495
495
 
496
496
    def __init__(self, path, extra=None):
550
550
 
551
551
 
552
552
class ReadingCompleted(InternalBzrError):
553
 
 
 
553
    
554
554
    _fmt = ("The MediumRequest '%(request)s' has already had finish_reading "
555
555
            "called upon it - the request has been completed and no more "
556
556
            "data may be read.")
621
621
 
622
622
    _fmt = 'Unsupported protocol for url "%(path)s"%(extra)s'
623
623
 
624
 
    def __init__(self, url, extra=""):
 
624
    def __init__(self, url, extra):
625
625
        PathError.__init__(self, url, extra=extra)
626
626
 
627
627
 
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. "
658
648
 
659
649
 
660
650
class ReadError(PathError):
661
 
 
 
651
    
662
652
    _fmt = """Error reading from %(path)r."""
663
653
 
664
654
 
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)
699
689
 
700
690
# TODO: This is given a URL; we try to unescape it but doing that from inside
701
691
# the exception object is a bit undesirable.
702
 
# TODO: Probably this behavior of should be a common superclass
 
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
809
764
 
810
765
 
811
766
class UnknownFormatError(BzrError):
812
 
 
 
767
    
813
768
    _fmt = "Unknown %(kind)s format: %(format)r"
814
769
 
815
770
    def __init__(self, format, kind='branch'):
818
773
 
819
774
 
820
775
class IncompatibleFormat(BzrError):
821
 
 
 
776
    
822
777
    _fmt = "Format %(format)s is not compatible with .bzr version %(bzrdir)s."
823
778
 
824
779
    def __init__(self, format, bzrdir_format):
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" \
847
796
 
848
797
 
849
798
class IncompatibleRevision(BzrError):
850
 
 
 
799
    
851
800
    _fmt = "Revision is not compatible with %(repo_format)s"
852
801
 
853
802
    def __init__(self, repo_format):
864
813
        """Construct a new AlreadyVersionedError.
865
814
 
866
815
        :param path: This is the path which is versioned,
867
 
            which should be in a user friendly form.
 
816
        which should be in a user friendly form.
868
817
        :param context_info: If given, this is information about the context,
869
 
            which could explain why this is expected to not be versioned.
 
818
        which could explain why this is expected to not be versioned.
870
819
        """
871
820
        BzrError.__init__(self)
872
821
        self.path = path
885
834
        """Construct a new NotVersionedError.
886
835
 
887
836
        :param path: This is the path which is not versioned,
888
 
            which should be in a user friendly form.
 
837
        which should be in a user friendly form.
889
838
        :param context_info: If given, this is information about the context,
890
 
            which could explain why this is expected to be versioned.
 
839
        which could explain why this is expected to be versioned.
891
840
        """
892
841
        BzrError.__init__(self)
893
842
        self.path = path
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):
1051
1003
 
1052
1004
class LockContention(LockError):
1053
1005
 
1054
 
    _fmt = 'Could not acquire lock "%(lock)s": %(msg)s'
 
1006
    _fmt = 'Could not acquire lock "%(lock)s"'
 
1007
    # TODO: show full url for lock, combining the transport and relative
 
1008
    # bits?
1055
1009
 
1056
1010
    internal_error = False
1057
1011
 
1058
 
    def __init__(self, lock, msg=''):
 
1012
    def __init__(self, lock):
1059
1013
        self.lock = lock
1060
 
        self.msg = msg
1061
1014
 
1062
1015
 
1063
1016
class LockBroken(LockError):
1084
1037
        self.target = target
1085
1038
 
1086
1039
 
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
1040
class LockNotHeld(LockError):
1100
1041
 
1101
1042
    _fmt = "Lock not held: %(lock)s"
1140
1081
        BzrError.__init__(self, files=files, files_str=files_str)
1141
1082
 
1142
1083
 
1143
 
class ExcludesUnsupported(BzrError):
1144
 
 
1145
 
    _fmt = ('Excluding paths during commit is not supported by '
1146
 
            'repository at %(repository)r.')
1147
 
 
1148
 
    def __init__(self, repository):
1149
 
        BzrError.__init__(self, repository=repository)
1150
 
 
1151
 
 
1152
1084
class BadCommitMessageEncoding(BzrError):
1153
1085
 
1154
1086
    _fmt = 'The specified commit message contains characters unsupported by '\
1198
1130
 
1199
1131
class NoSuchRevisionInTree(NoSuchRevision):
1200
1132
    """When using Tree.revision_tree, and the revision is not accessible."""
1201
 
 
 
1133
    
1202
1134
    _fmt = "The revision id {%(revision_id)s} is not present in the tree %(tree)s."
1203
1135
 
1204
1136
    def __init__(self, tree, revision_id):
1209
1141
 
1210
1142
class InvalidRevisionSpec(BzrError):
1211
1143
 
1212
 
    _fmt = ("Requested revision: '%(spec)s' does not exist in branch:"
1213
 
            " %(branch_url)s%(extra)s")
 
1144
    _fmt = ("Requested revision: %(spec)r does not exist in branch:"
 
1145
            " %(branch)s%(extra)s")
1214
1146
 
1215
1147
    def __init__(self, spec, branch, extra=None):
1216
1148
        BzrError.__init__(self, branch=branch, spec=spec)
1217
 
        self.branch_url = getattr(branch, 'user_url', str(branch))
1218
1149
        if extra:
1219
1150
            self.extra = '\n' + str(extra)
1220
1151
        else:
1241
1172
class DivergedBranches(BzrError):
1242
1173
 
1243
1174
    _fmt = ("These branches have diverged."
1244
 
            " Use the missing command to see how.\n"
1245
 
            "Use the merge command to reconcile them.")
 
1175
            " Use the merge command to reconcile them.")
1246
1176
 
1247
1177
    def __init__(self, branch1, branch2):
1248
1178
        self.branch1 = branch1
1270
1200
 
1271
1201
 
1272
1202
class NoCommonAncestor(BzrError):
1273
 
 
 
1203
    
1274
1204
    _fmt = "Revisions have no common ancestor: %(revision_a)s %(revision_b)s"
1275
1205
 
1276
1206
    def __init__(self, revision_a, revision_b):
1296
1226
            not_ancestor_id=not_ancestor_id)
1297
1227
 
1298
1228
 
 
1229
class InstallFailed(BzrError):
 
1230
 
 
1231
    def __init__(self, revisions):
 
1232
        revision_str = ", ".join(str(r) for r in revisions)
 
1233
        msg = "Could not install revisions:\n%s" % revision_str
 
1234
        BzrError.__init__(self, msg)
 
1235
        self.revisions = revisions
 
1236
 
 
1237
 
1299
1238
class AmbiguousBase(BzrError):
1300
1239
 
1301
1240
    def __init__(self, bases):
1302
 
        symbol_versioning.warn("BzrError AmbiguousBase has been deprecated "
1303
 
            "as of bzrlib 0.8.", DeprecationWarning, stacklevel=2)
 
1241
        warn("BzrError AmbiguousBase has been deprecated as of bzrlib 0.8.",
 
1242
                DeprecationWarning)
1304
1243
        msg = ("The correct base is unclear, because %s are all equally close"
1305
1244
                % ", ".join(bases))
1306
1245
        BzrError.__init__(self, msg)
1328
1267
class BoundBranchOutOfDate(BzrError):
1329
1268
 
1330
1269
    _fmt = ("Bound branch %(branch)s is out of date with master branch"
1331
 
            " %(master)s.%(extra_help)s")
 
1270
            " %(master)s.")
1332
1271
 
1333
1272
    def __init__(self, branch, master):
1334
1273
        BzrError.__init__(self)
1335
1274
        self.branch = branch
1336
1275
        self.master = master
1337
 
        self.extra_help = ''
1338
 
 
1339
 
 
 
1276
 
 
1277
        
1340
1278
class CommitToDoubleBoundBranch(BzrError):
1341
1279
 
1342
1280
    _fmt = ("Cannot commit to branch %(branch)s."
1372
1310
 
1373
1311
class WeaveError(BzrError):
1374
1312
 
1375
 
    _fmt = "Error in processing weave: %(msg)s"
 
1313
    _fmt = "Error in processing weave: %(message)s"
1376
1314
 
1377
 
    def __init__(self, msg=None):
 
1315
    def __init__(self, message=None):
1378
1316
        BzrError.__init__(self)
1379
 
        self.msg = msg
 
1317
        self.message = message
1380
1318
 
1381
1319
 
1382
1320
class WeaveRevisionAlreadyPresent(WeaveError):
1411
1349
 
1412
1350
class WeaveParentMismatch(WeaveError):
1413
1351
 
1414
 
    _fmt = "Parents are mismatched between two revisions. %(msg)s"
1415
 
 
 
1352
    _fmt = "Parents are mismatched between two revisions. %(message)s"
 
1353
    
1416
1354
 
1417
1355
class WeaveInvalidChecksum(WeaveError):
1418
1356
 
1419
 
    _fmt = "Text did not match its checksum: %(msg)s"
 
1357
    _fmt = "Text did not match it's checksum: %(message)s"
1420
1358
 
1421
1359
 
1422
1360
class WeaveTextDiffers(WeaveError):
1444
1382
 
1445
1383
 
1446
1384
class VersionedFileError(BzrError):
1447
 
 
 
1385
    
1448
1386
    _fmt = "Versioned file error"
1449
1387
 
1450
1388
 
1451
1389
class RevisionNotPresent(VersionedFileError):
1452
 
 
 
1390
    
1453
1391
    _fmt = 'Revision {%(revision_id)s} not present in "%(file_id)s".'
1454
1392
 
1455
1393
    def __init__(self, revision_id, file_id):
1459
1397
 
1460
1398
 
1461
1399
class RevisionAlreadyPresent(VersionedFileError):
1462
 
 
 
1400
    
1463
1401
    _fmt = 'Revision {%(revision_id)s} already present in "%(file_id)s".'
1464
1402
 
1465
1403
    def __init__(self, revision_id, file_id):
1470
1408
 
1471
1409
class VersionedFileInvalidChecksum(VersionedFileError):
1472
1410
 
1473
 
    _fmt = "Text did not match its checksum: %(msg)s"
 
1411
    _fmt = "Text did not match its checksum: %(message)s"
1474
1412
 
1475
1413
 
1476
1414
class KnitError(InternalBzrError):
1477
 
 
 
1415
    
1478
1416
    _fmt = "Knit error"
1479
1417
 
1480
1418
 
1488
1426
        self.how = how
1489
1427
 
1490
1428
 
1491
 
class SHA1KnitCorrupt(KnitCorrupt):
1492
 
 
1493
 
    _fmt = ("Knit %(filename)s corrupt: sha-1 of reconstructed text does not "
1494
 
        "match expected sha-1. key %(key)s expected sha %(expected)s actual "
1495
 
        "sha %(actual)s")
1496
 
 
1497
 
    def __init__(self, filename, actual, expected, key, content):
1498
 
        KnitError.__init__(self)
1499
 
        self.filename = filename
1500
 
        self.actual = actual
1501
 
        self.expected = expected
1502
 
        self.key = key
1503
 
        self.content = content
1504
 
 
1505
 
 
1506
1429
class KnitDataStreamIncompatible(KnitError):
1507
1430
    # Not raised anymore, as we can convert data streams.  In future we may
1508
1431
    # need it again for more exotic cases, so we're keeping it around for now.
1512
1435
    def __init__(self, stream_format, target_format):
1513
1436
        self.stream_format = stream_format
1514
1437
        self.target_format = target_format
1515
 
 
 
1438
        
1516
1439
 
1517
1440
class KnitDataStreamUnknown(KnitError):
1518
1441
    # Indicates a data stream we don't know how to handle.
1521
1444
 
1522
1445
    def __init__(self, stream_format):
1523
1446
        self.stream_format = stream_format
1524
 
 
 
1447
        
1525
1448
 
1526
1449
class KnitHeaderError(KnitError):
1527
1450
 
1537
1460
 
1538
1461
    Currently only 'fulltext' and 'line-delta' are supported.
1539
1462
    """
1540
 
 
 
1463
    
1541
1464
    _fmt = ("Knit index %(filename)s does not have a known method"
1542
1465
            " in options: %(options)r")
1543
1466
 
1547
1470
        self.options = options
1548
1471
 
1549
1472
 
1550
 
class RetryWithNewPacks(BzrError):
1551
 
    """Raised when we realize that the packs on disk have changed.
1552
 
 
1553
 
    This is meant as more of a signaling exception, to trap between where a
1554
 
    local error occurred and the code that can actually handle the error and
1555
 
    code that can retry appropriately.
1556
 
    """
1557
 
 
1558
 
    internal_error = True
1559
 
 
1560
 
    _fmt = ("Pack files have changed, reload and retry. context: %(context)s"
1561
 
            " %(orig_error)s")
1562
 
 
1563
 
    def __init__(self, context, reload_occurred, exc_info):
1564
 
        """create a new RetryWithNewPacks error.
1565
 
 
1566
 
        :param reload_occurred: Set to True if we know that the packs have
1567
 
            already been reloaded, and we are failing because of an in-memory
1568
 
            cache miss. If set to True then we will ignore if a reload says
1569
 
            nothing has changed, because we assume it has already reloaded. If
1570
 
            False, then a reload with nothing changed will force an error.
1571
 
        :param exc_info: The original exception traceback, so if there is a
1572
 
            problem we can raise the original error (value from sys.exc_info())
1573
 
        """
1574
 
        BzrError.__init__(self)
1575
 
        self.reload_occurred = reload_occurred
1576
 
        self.exc_info = exc_info
1577
 
        self.orig_error = exc_info[1]
1578
 
        # TODO: The global error handler should probably treat this by
1579
 
        #       raising/printing the original exception with a bit about
1580
 
        #       RetryWithNewPacks also not being caught
1581
 
 
1582
 
 
1583
 
class RetryAutopack(RetryWithNewPacks):
1584
 
    """Raised when we are autopacking and we find a missing file.
1585
 
 
1586
 
    Meant as a signaling exception, to tell the autopack code it should try
1587
 
    again.
1588
 
    """
1589
 
 
1590
 
    internal_error = True
1591
 
 
1592
 
    _fmt = ("Pack files have changed, reload and try autopack again."
1593
 
            " context: %(context)s %(orig_error)s")
1594
 
 
1595
 
 
1596
1473
class NoSuchExportFormat(BzrError):
1597
 
 
 
1474
    
1598
1475
    _fmt = "Export format %(format)r not supported"
1599
1476
 
1600
1477
    def __init__(self, format):
1603
1480
 
1604
1481
 
1605
1482
class TransportError(BzrError):
1606
 
 
 
1483
    
1607
1484
    _fmt = "Transport error: %(msg)s %(orig_error)s"
1608
1485
 
1609
1486
    def __init__(self, msg=None, orig_error=None):
1654
1531
 
1655
1532
class SmartMessageHandlerError(InternalBzrError):
1656
1533
 
1657
 
    _fmt = ("The message handler raised an exception:\n"
1658
 
            "%(traceback_text)s")
 
1534
    _fmt = "The message handler raised an exception: %(exc_value)s."
1659
1535
 
1660
1536
    def __init__(self, exc_info):
1661
 
        import traceback
1662
 
        self.exc_type, self.exc_value, self.exc_tb = exc_info
1663
 
        self.exc_info = exc_info
1664
 
        traceback_strings = traceback.format_exception(
1665
 
                self.exc_type, self.exc_value, self.exc_tb)
1666
 
        self.traceback_text = ''.join(traceback_strings)
1667
 
 
 
1537
        self.exc_type, self.exc_value, self.tb = exc_info
 
1538
        
1668
1539
 
1669
1540
# A set of semi-meaningful errors which can be thrown
1670
1541
class TransportNotPossible(TransportError):
1696
1567
            self.port = ':%s' % port
1697
1568
 
1698
1569
 
1699
 
# XXX: This is also used for unexpected end of file, which is different at the
1700
 
# TCP level from "connection reset".
1701
1570
class ConnectionReset(TransportError):
1702
1571
 
1703
1572
    _fmt = "Connection closed: %(msg)s %(orig_error)s"
1715
1584
 
1716
1585
class InvalidHttpResponse(TransportError):
1717
1586
 
1718
 
    _fmt = "Invalid http response for %(path)s: %(msg)s%(orig_error)s"
 
1587
    _fmt = "Invalid http response for %(path)s: %(msg)s"
1719
1588
 
1720
1589
    def __init__(self, path, msg, orig_error=None):
1721
1590
        self.path = path
1722
 
        if orig_error is None:
1723
 
            orig_error = ''
1724
 
        else:
1725
 
            # This is reached for obscure and unusual errors so we want to
1726
 
            # preserve as much info as possible to ease debug.
1727
 
            orig_error = ': %r' % (orig_error,)
1728
1591
        TransportError.__init__(self, msg, orig_error=orig_error)
1729
1592
 
1730
1593
 
1737
1600
        InvalidHttpResponse.__init__(self, path, msg)
1738
1601
 
1739
1602
 
1740
 
class HttpBoundaryMissing(InvalidHttpResponse):
1741
 
    """A multipart response ends with no boundary marker.
1742
 
 
1743
 
    This is a special case caused by buggy proxies, described in
1744
 
    <https://bugs.launchpad.net/bzr/+bug/198646>.
1745
 
    """
1746
 
 
1747
 
    _fmt = "HTTP MIME Boundary missing for %(path)s: %(msg)s"
1748
 
 
1749
 
    def __init__(self, path, msg):
1750
 
        InvalidHttpResponse.__init__(self, path, msg)
1751
 
 
1752
 
 
1753
1603
class InvalidHttpContentType(InvalidHttpResponse):
1754
1604
 
1755
1605
    _fmt = 'Invalid http Content-type "%(ctype)s" for %(path)s: %(msg)s'
1763
1613
 
1764
1614
    _fmt = '%(source)s is%(permanently)s redirected to %(target)s'
1765
1615
 
1766
 
    def __init__(self, source, target, is_permanent=False):
 
1616
    def __init__(self, source, target, is_permanent=False, qual_proto=None):
1767
1617
        self.source = source
1768
1618
        self.target = target
1769
1619
        if is_permanent:
1770
1620
            self.permanently = ' permanently'
1771
1621
        else:
1772
1622
            self.permanently = ''
 
1623
        self._qualified_proto = qual_proto
1773
1624
        TransportError.__init__(self)
1774
1625
 
 
1626
    def _requalify_url(self, url):
 
1627
        """Restore the qualified proto in front of the url"""
 
1628
        # When this exception is raised, source and target are in
 
1629
        # user readable format. But some transports may use a
 
1630
        # different proto (http+urllib:// will present http:// to
 
1631
        # the user. If a qualified proto is specified, the code
 
1632
        # trapping the exception can get the qualified urls to
 
1633
        # properly handle the redirection themself (creating a
 
1634
        # new transport object from the target url for example).
 
1635
        # But checking that the scheme of the original and
 
1636
        # redirected urls are the same can be tricky. (see the
 
1637
        # FIXME in BzrDir.open_from_transport for the unique use
 
1638
        # case so far).
 
1639
        if self._qualified_proto is None:
 
1640
            return url
 
1641
 
 
1642
        # The TODO related to NotBranchError mention that doing
 
1643
        # that kind of manipulation on the urls may not be the
 
1644
        # exception object job. On the other hand, this object is
 
1645
        # the interface between the code and the user so
 
1646
        # presenting the urls in different ways is indeed its
 
1647
        # job...
 
1648
        import urlparse
 
1649
        proto, netloc, path, query, fragment = urlparse.urlsplit(url)
 
1650
        return urlparse.urlunsplit((self._qualified_proto, netloc, path,
 
1651
                                   query, fragment))
 
1652
 
 
1653
    def get_source_url(self):
 
1654
        return self._requalify_url(self.source)
 
1655
 
 
1656
    def get_target_url(self):
 
1657
        return self._requalify_url(self.target)
 
1658
 
1775
1659
 
1776
1660
class TooManyRedirections(TransportError):
1777
1661
 
1783
1667
    _fmt = "Working tree has conflicts."
1784
1668
 
1785
1669
 
1786
 
class ConfigContentError(BzrError):
1787
 
 
1788
 
    _fmt = "Config file %(filename)s is not UTF-8 encoded\n"
1789
 
 
1790
 
    def __init__(self, filename):
1791
 
        BzrError.__init__(self)
1792
 
        self.filename = filename
1793
 
 
1794
 
 
1795
1670
class ParseConfigError(BzrError):
1796
1671
 
1797
 
    _fmt = "Error(s) parsing config file %(filename)s:\n%(errors)s"
1798
 
 
1799
1672
    def __init__(self, errors, filename):
1800
 
        BzrError.__init__(self)
1801
 
        self.filename = filename
1802
 
        self.errors = '\n'.join(e.msg for e in errors)
1803
 
 
1804
 
 
1805
 
class ConfigOptionValueError(BzrError):
1806
 
 
1807
 
    _fmt = """Bad value "%(value)s" for option "%(name)s"."""
1808
 
 
1809
 
    def __init__(self, name, value):
1810
 
        BzrError.__init__(self, name=name, value=value)
 
1673
        if filename is None:
 
1674
            filename = ""
 
1675
        message = "Error(s) parsing config file %s:\n%s" % \
 
1676
            (filename, ('\n'.join(e.message for e in errors)))
 
1677
        BzrError.__init__(self, message)
1811
1678
 
1812
1679
 
1813
1680
class NoEmailInUsername(BzrError):
1821
1688
 
1822
1689
class SigningFailed(BzrError):
1823
1690
 
1824
 
    _fmt = 'Failed to GPG sign data with command "%(command_line)s"'
 
1691
    _fmt = 'Failed to gpg sign data with command "%(command_line)s"'
1825
1692
 
1826
1693
    def __init__(self, command_line):
1827
1694
        BzrError.__init__(self, command_line=command_line)
1828
1695
 
1829
1696
 
1830
 
class SignatureVerificationFailed(BzrError):
1831
 
 
1832
 
    _fmt = 'Failed to verify GPG signature data with error "%(error)s"'
1833
 
 
1834
 
    def __init__(self, error):
1835
 
        BzrError.__init__(self, error=error)
1836
 
 
1837
 
 
1838
 
class DependencyNotPresent(BzrError):
1839
 
 
1840
 
    _fmt = 'Unable to import library "%(library)s": %(error)s'
1841
 
 
1842
 
    def __init__(self, library, error):
1843
 
        BzrError.__init__(self, library=library, error=error)
1844
 
 
1845
 
 
1846
 
class GpgmeNotInstalled(DependencyNotPresent):
1847
 
 
1848
 
    _fmt = 'python-gpgme is not installed, it is needed to verify signatures'
1849
 
 
1850
 
    def __init__(self, error):
1851
 
        DependencyNotPresent.__init__(self, 'gpgme', error)
1852
 
 
1853
 
 
1854
1697
class WorkingTreeNotRevision(BzrError):
1855
1698
 
1856
 
    _fmt = ("The working tree for %(basedir)s has changed since"
 
1699
    _fmt = ("The working tree for %(basedir)s has changed since" 
1857
1700
            " the last commit, but weave merge requires that it be"
1858
1701
            " unchanged")
1859
1702
 
2016
1859
    _fmt = "Moving the root directory is not supported at this time"
2017
1860
 
2018
1861
 
2019
 
class TransformRenameFailed(BzrError):
2020
 
 
2021
 
    _fmt = "Failed to rename %(from_path)s to %(to_path)s: %(why)s"
2022
 
 
2023
 
    def __init__(self, from_path, to_path, why, errno):
2024
 
        self.from_path = from_path
2025
 
        self.to_path = to_path
2026
 
        self.why = why
2027
 
        self.errno = errno
2028
 
 
2029
 
 
2030
1862
class BzrMoveFailedError(BzrError):
2031
1863
 
2032
 
    _fmt = ("Could not move %(from_path)s%(operator)s %(to_path)s"
2033
 
        "%(_has_extra)s%(extra)s")
 
1864
    _fmt = "Could not move %(from_path)s%(operator)s %(to_path)s%(extra)s"
2034
1865
 
2035
1866
    def __init__(self, from_path='', to_path='', extra=None):
2036
 
        from bzrlib.osutils import splitpath
2037
1867
        BzrError.__init__(self)
2038
1868
        if extra:
2039
 
            self.extra, self._has_extra = extra, ': '
 
1869
            self.extra = ': ' + str(extra)
2040
1870
        else:
2041
 
            self.extra = self._has_extra = ''
 
1871
            self.extra = ''
2042
1872
 
2043
1873
        has_from = len(from_path) > 0
2044
1874
        has_to = len(to_path) > 0
2045
1875
        if has_from:
2046
 
            self.from_path = splitpath(from_path)[-1]
 
1876
            self.from_path = osutils.splitpath(from_path)[-1]
2047
1877
        else:
2048
1878
            self.from_path = ''
2049
1879
 
2050
1880
        if has_to:
2051
 
            self.to_path = splitpath(to_path)[-1]
 
1881
            self.to_path = osutils.splitpath(to_path)[-1]
2052
1882
        else:
2053
1883
            self.to_path = ''
2054
1884
 
2065
1895
 
2066
1896
class BzrRenameFailedError(BzrMoveFailedError):
2067
1897
 
2068
 
    _fmt = ("Could not rename %(from_path)s%(operator)s %(to_path)s"
2069
 
        "%(_has_extra)s%(extra)s")
 
1898
    _fmt = "Could not rename %(from_path)s%(operator)s %(to_path)s%(extra)s"
2070
1899
 
2071
1900
    def __init__(self, from_path, to_path, extra=None):
2072
1901
        BzrMoveFailedError.__init__(self, from_path, to_path, extra)
2073
1902
 
2074
 
 
2075
1903
class BzrRemoveChangedFilesError(BzrError):
2076
1904
    """Used when user is trying to remove changed files."""
2077
1905
 
2080
1908
        "Use --keep to not delete them, or --force to delete them regardless.")
2081
1909
 
2082
1910
    def __init__(self, tree_delta):
2083
 
        symbol_versioning.warn(symbol_versioning.deprecated_in((2, 3, 0)) %
2084
 
            "BzrRemoveChangedFilesError", DeprecationWarning, stacklevel=2)
2085
1911
        BzrError.__init__(self)
2086
1912
        self.changes_as_text = tree_delta.get_changes_as_text()
2087
1913
        #self.paths_as_string = '\n'.join(changed_files)
2095
1921
 
2096
1922
class BzrBadParameterMissing(BzrBadParameter):
2097
1923
 
2098
 
    _fmt = "Parameter %(param)s is required but not present."
 
1924
    _fmt = "Parameter $(param)s is required but not present."
2099
1925
 
2100
1926
 
2101
1927
class BzrBadParameterUnicode(BzrBadParameter):
2109
1935
    _fmt = "Parameter %(param)s contains a newline."
2110
1936
 
2111
1937
 
 
1938
class DependencyNotPresent(BzrError):
 
1939
 
 
1940
    _fmt = 'Unable to import library "%(library)s": %(error)s'
 
1941
 
 
1942
    def __init__(self, library, error):
 
1943
        BzrError.__init__(self, library=library, error=error)
 
1944
 
 
1945
 
2112
1946
class ParamikoNotPresent(DependencyNotPresent):
2113
1947
 
2114
1948
    _fmt = "Unable to import paramiko (required for sftp support): %(error)s"
2133
1967
 
2134
1968
class BadConversionTarget(BzrError):
2135
1969
 
2136
 
    _fmt = "Cannot convert from format %(from_format)s to format %(format)s." \
2137
 
            "    %(problem)s"
 
1970
    _fmt = "Cannot convert to format %(format)s.  %(problem)s"
2138
1971
 
2139
 
    def __init__(self, problem, format, from_format=None):
 
1972
    def __init__(self, problem, format):
2140
1973
        BzrError.__init__(self)
2141
1974
        self.problem = problem
2142
1975
        self.format = format
2143
 
        self.from_format = from_format or '(unspecified)'
2144
1976
 
2145
1977
 
2146
1978
class NoDiffFound(BzrError):
2183
2015
    _fmt = """This tree contains left-over files from a failed operation.
2184
2016
    Please examine %(limbo_dir)s to see if it contains any files you wish to
2185
2017
    keep, and delete it when you are done."""
2186
 
 
 
2018
    
2187
2019
    def __init__(self, limbo_dir):
2188
2020
       BzrError.__init__(self)
2189
2021
       self.limbo_dir = limbo_dir
2222
2054
 
2223
2055
class OutOfDateTree(BzrError):
2224
2056
 
2225
 
    _fmt = "Working tree is out of date, please run 'bzr update'.%(more)s"
 
2057
    _fmt = "Working tree is out of date, please run 'bzr update'."
2226
2058
 
2227
 
    def __init__(self, tree, more=None):
2228
 
        if more is None:
2229
 
            more = ''
2230
 
        else:
2231
 
            more = ' ' + more
 
2059
    def __init__(self, tree):
2232
2060
        BzrError.__init__(self)
2233
2061
        self.tree = tree
2234
 
        self.more = more
2235
2062
 
2236
2063
 
2237
2064
class PublicBranchOutOfDate(BzrError):
2275
2102
 
2276
2103
    def __init__(self, repo):
2277
2104
        BzrError.__init__(self)
2278
 
        self.repo_path = repo.user_url
 
2105
        self.repo_path = repo.bzrdir.root_transport.base
2279
2106
 
2280
2107
 
2281
2108
class InconsistentDelta(BzrError):
2291
2118
        self.reason = reason
2292
2119
 
2293
2120
 
2294
 
class InconsistentDeltaDelta(InconsistentDelta):
2295
 
    """Used when we get a delta that is not valid."""
2296
 
 
2297
 
    _fmt = ("An inconsistent delta was supplied: %(delta)r"
2298
 
            "\nreason: %(reason)s")
2299
 
 
2300
 
    def __init__(self, delta, reason):
2301
 
        BzrError.__init__(self)
2302
 
        self.delta = delta
2303
 
        self.reason = reason
2304
 
 
2305
 
 
2306
2121
class UpgradeRequired(BzrError):
2307
2122
 
2308
2123
    _fmt = "To use this feature you must upgrade your branch at %(path)s."
2317
2132
    _fmt = "To use this feature you must upgrade your repository at %(path)s."
2318
2133
 
2319
2134
 
2320
 
class RichRootUpgradeRequired(UpgradeRequired):
2321
 
 
2322
 
    _fmt = ("To use this feature you must upgrade your branch at %(path)s to"
2323
 
           " a format which supports rich roots.")
2324
 
 
2325
 
 
2326
2135
class LocalRequiresBoundBranch(BzrError):
2327
2136
 
2328
2137
    _fmt = "Cannot perform local-only commits on unbound branches."
2329
2138
 
2330
2139
 
 
2140
class MissingProgressBarFinish(BzrError):
 
2141
 
 
2142
    _fmt = "A nested progress bar was not 'finished' correctly."
 
2143
 
 
2144
 
 
2145
class InvalidProgressBarType(BzrError):
 
2146
 
 
2147
    _fmt = ("Environment variable BZR_PROGRESS_BAR='%(bar_type)s"
 
2148
            " is not a supported type Select one of: %(valid_types)s")
 
2149
 
 
2150
    def __init__(self, bar_type, valid_types):
 
2151
        BzrError.__init__(self, bar_type=bar_type, valid_types=valid_types)
 
2152
 
 
2153
 
2331
2154
class UnsupportedOperation(BzrError):
2332
2155
 
2333
2156
    _fmt = ("The method %(mname)s is not supported on"
2350
2173
 
2351
2174
 
2352
2175
class BinaryFile(BzrError):
2353
 
 
 
2176
    
2354
2177
    _fmt = "File is binary but should be text."
2355
2178
 
2356
2179
 
2376
2199
 
2377
2200
 
2378
2201
class NotABundle(BzrError):
2379
 
 
 
2202
    
2380
2203
    _fmt = "Not a bzr revision-bundle: %(text)r"
2381
2204
 
2382
2205
    def __init__(self, text):
2384
2207
        self.text = text
2385
2208
 
2386
2209
 
2387
 
class BadBundle(BzrError):
2388
 
 
 
2210
class BadBundle(BzrError): 
 
2211
    
2389
2212
    _fmt = "Bad bzr revision-bundle: %(text)r"
2390
2213
 
2391
2214
    def __init__(self, text):
2393
2216
        self.text = text
2394
2217
 
2395
2218
 
2396
 
class MalformedHeader(BadBundle):
2397
 
 
 
2219
class MalformedHeader(BadBundle): 
 
2220
    
2398
2221
    _fmt = "Malformed bzr revision-bundle header: %(text)r"
2399
2222
 
2400
2223
 
2401
 
class MalformedPatches(BadBundle):
2402
 
 
 
2224
class MalformedPatches(BadBundle): 
 
2225
    
2403
2226
    _fmt = "Malformed patches in bzr revision-bundle: %(text)r"
2404
2227
 
2405
2228
 
2406
 
class MalformedFooter(BadBundle):
2407
 
 
 
2229
class MalformedFooter(BadBundle): 
 
2230
    
2408
2231
    _fmt = "Malformed footer in bzr revision-bundle: %(text)r"
2409
2232
 
2410
2233
 
2411
2234
class UnsupportedEOLMarker(BadBundle):
2412
 
 
2413
 
    _fmt = "End of line marker was not \\n in bzr revision-bundle"
 
2235
    
 
2236
    _fmt = "End of line marker was not \\n in bzr revision-bundle"    
2414
2237
 
2415
2238
    def __init__(self):
2416
 
        # XXX: BadBundle's constructor assumes there's explanatory text,
 
2239
        # XXX: BadBundle's constructor assumes there's explanatory text, 
2417
2240
        # but for this there is not
2418
2241
        BzrError.__init__(self)
2419
2242
 
2420
2243
 
2421
2244
class IncompatibleBundleFormat(BzrError):
2422
 
 
 
2245
    
2423
2246
    _fmt = "Bundle format %(bundle_format)s is incompatible with %(other)s"
2424
2247
 
2425
2248
    def __init__(self, bundle_format, other):
2429
2252
 
2430
2253
 
2431
2254
class BadInventoryFormat(BzrError):
2432
 
 
 
2255
    
2433
2256
    _fmt = "Root class for inventory serialization errors"
2434
2257
 
2435
2258
 
2454
2277
        self.transport = transport
2455
2278
 
2456
2279
 
 
2280
class NoSmartServer(NotBranchError):
 
2281
 
 
2282
    _fmt = "No smart server available at %(url)s"
 
2283
 
 
2284
    @symbol_versioning.deprecated_method(symbol_versioning.one_four)
 
2285
    def __init__(self, url):
 
2286
        self.url = url
 
2287
 
 
2288
 
2457
2289
class UnknownSSH(BzrError):
2458
2290
 
2459
2291
    _fmt = "Unrecognised value for BZR_SSH environment variable: %(vendor)s"
2479
2311
        self.revision_id = revision_id
2480
2312
        self.ghost_revision_id = ghost_revision_id
2481
2313
 
2482
 
 
 
2314
        
2483
2315
class GhostRevisionUnusableHere(BzrError):
2484
2316
 
2485
2317
    _fmt = "Ghost revision {%(revision_id)s} cannot be used here."
2577
2409
 
2578
2410
 
2579
2411
class UnsupportedInventoryKind(BzrError):
2580
 
 
 
2412
    
2581
2413
    _fmt = """Unsupported entry kind %(kind)s"""
2582
2414
 
2583
2415
    def __init__(self, kind):
2595
2427
 
2596
2428
 
2597
2429
class SubsumeTargetNeedsUpgrade(BzrError):
2598
 
 
 
2430
    
2599
2431
    _fmt = """Subsume target %(other_tree)s needs to be upgraded."""
2600
2432
 
2601
2433
    def __init__(self, other_tree):
2629
2461
    def __init__(self, branch):
2630
2462
        self.branch = branch
2631
2463
 
2632
 
 
 
2464
        
2633
2465
class TagAlreadyExists(BzrError):
2634
2466
 
2635
2467
    _fmt = "Tag %(tag_name)s already exists."
2640
2472
 
2641
2473
class MalformedBugIdentifier(BzrError):
2642
2474
 
2643
 
    _fmt = ('Did not understand bug identifier %(bug_id)s: %(reason)s. '
2644
 
            'See "bzr help bugs" for more information on this feature.')
 
2475
    _fmt = "Did not understand bug identifier %(bug_id)s: %(reason)s"
2645
2476
 
2646
2477
    def __init__(self, bug_id, reason):
2647
2478
        self.bug_id = bug_id
2668
2499
        self.branch = branch
2669
2500
 
2670
2501
 
2671
 
class InvalidLineInBugsProperty(BzrError):
2672
 
 
2673
 
    _fmt = ("Invalid line in bugs property: '%(line)s'")
2674
 
 
2675
 
    def __init__(self, line):
2676
 
        self.line = line
2677
 
 
2678
 
 
2679
 
class InvalidBugStatus(BzrError):
2680
 
 
2681
 
    _fmt = ("Invalid bug status: '%(status)s'")
2682
 
 
2683
 
    def __init__(self, status):
2684
 
        self.status = status
2685
 
 
2686
 
 
2687
2502
class UnexpectedSmartServerResponse(BzrError):
2688
2503
 
2689
2504
    _fmt = "Could not understand response from smart server: %(response_tuple)r"
2717
2532
 
2718
2533
    This is distinct from ErrorFromSmartServer so that it is possible to
2719
2534
    distinguish between the following two cases:
2720
 
 
2721
 
    - ErrorFromSmartServer was uncaught.  This is logic error in the client
2722
 
      and so should provoke a traceback to the user.
2723
 
    - ErrorFromSmartServer was caught but its error_tuple could not be
2724
 
      translated.  This is probably because the server sent us garbage, and
2725
 
      should not provoke a traceback.
 
2535
      - ErrorFromSmartServer was uncaught.  This is logic error in the client
 
2536
        and so should provoke a traceback to the user.
 
2537
      - ErrorFromSmartServer was caught but its error_tuple could not be
 
2538
        translated.  This is probably because the server sent us garbage, and
 
2539
        should not provoke a traceback.
2726
2540
    """
2727
2541
 
2728
2542
    _fmt = "Server sent an unexpected error: %(error_tuple)r"
2736
2550
        """
2737
2551
        self.error_from_smart_server = error_from_smart_server
2738
2552
        self.error_tuple = error_from_smart_server.error_tuple
2739
 
 
 
2553
        
2740
2554
 
2741
2555
class ContainerError(BzrError):
2742
2556
    """Base class of container errors."""
2745
2559
class UnknownContainerFormatError(ContainerError):
2746
2560
 
2747
2561
    _fmt = "Unrecognised container format: %(container_format)r"
2748
 
 
 
2562
    
2749
2563
    def __init__(self, container_format):
2750
2564
        self.container_format = container_format
2751
2565
 
2815
2629
 
2816
2630
class NoMailAddressSpecified(BzrError):
2817
2631
 
2818
 
    _fmt = "No mail-to address (--mail-to) or output (-o) specified."
 
2632
    _fmt = "No mail-to address specified."
2819
2633
 
2820
2634
 
2821
2635
class UnknownMailClient(BzrError):
2854
2668
 
2855
2669
    def __init__(self, bzrdir):
2856
2670
        import bzrlib.urlutils as urlutils
2857
 
        display_url = urlutils.unescape_for_display(bzrdir.user_url,
 
2671
        display_url = urlutils.unescape_for_display(bzrdir.root_transport.base,
2858
2672
                                                    'ascii')
2859
2673
        BzrError.__init__(self, bzrdir=bzrdir, display_url=display_url)
2860
2674
 
2901
2715
    _fmt = "'%(display_url)s' is already standalone."
2902
2716
 
2903
2717
 
2904
 
class AlreadyWithTrees(BzrDirError):
2905
 
 
2906
 
    _fmt = ("Shared repository '%(display_url)s' already creates "
2907
 
            "working trees.")
2908
 
 
2909
 
 
2910
 
class AlreadyWithNoTrees(BzrDirError):
2911
 
 
2912
 
    _fmt = ("Shared repository '%(display_url)s' already doesn't create "
2913
 
            "working trees.")
2914
 
 
2915
 
 
2916
2718
class ReconfigurationNotSupported(BzrDirError):
2917
2719
 
2918
2720
    _fmt = "Requested reconfiguration of '%(display_url)s' is not supported."
2925
2727
 
2926
2728
class UncommittedChanges(BzrError):
2927
2729
 
2928
 
    _fmt = ('Working tree "%(display_url)s" has uncommitted changes'
2929
 
            ' (See bzr status).%(more)s')
 
2730
    _fmt = 'Working tree "%(display_url)s" has uncommitted changes.'
2930
2731
 
2931
 
    def __init__(self, tree, more=None):
2932
 
        if more is None:
2933
 
            more = ''
2934
 
        else:
2935
 
            more = ' ' + more
 
2732
    def __init__(self, tree):
2936
2733
        import bzrlib.urlutils as urlutils
2937
 
        user_url = getattr(tree, "user_url", None)
2938
 
        if user_url is None:
2939
 
            display_url = str(tree)
2940
 
        else:
2941
 
            display_url = urlutils.unescape_for_display(user_url, 'ascii')
2942
 
        BzrError.__init__(self, tree=tree, display_url=display_url, more=more)
2943
 
 
2944
 
 
2945
 
class ShelvedChanges(UncommittedChanges):
2946
 
 
2947
 
    _fmt = ('Working tree "%(display_url)s" has shelved changes'
2948
 
            ' (See bzr shelve --list).%(more)s')
 
2734
        display_url = urlutils.unescape_for_display(
 
2735
            tree.bzrdir.root_transport.base, 'ascii')
 
2736
        BzrError.__init__(self, tree=tree, display_url=display_url)
2949
2737
 
2950
2738
 
2951
2739
class MissingTemplateVariable(BzrError):
2986
2774
 
2987
2775
 
2988
2776
class CommandAvailableInPlugin(StandardError):
2989
 
 
 
2777
    
2990
2778
    internal_error = False
2991
2779
 
2992
2780
    def __init__(self, cmd_name, plugin_metadata, provider):
2993
 
 
 
2781
        
2994
2782
        self.plugin_metadata = plugin_metadata
2995
2783
        self.cmd_name = cmd_name
2996
2784
        self.provider = provider
2997
2785
 
2998
2786
    def __str__(self):
2999
2787
 
3000
 
        _fmt = ('"%s" is not a standard bzr command. \n'
 
2788
        _fmt = ('"%s" is not a standard bzr command. \n' 
3001
2789
                'However, the following official plugin provides this command: %s\n'
3002
2790
                'You can install it by going to: %s'
3003
 
                % (self.cmd_name, self.plugin_metadata['name'],
 
2791
                % (self.cmd_name, self.plugin_metadata['name'], 
3004
2792
                    self.plugin_metadata['url']))
3005
2793
 
3006
2794
        return _fmt
3007
2795
 
3008
2796
 
3009
2797
class NoPluginAvailable(BzrError):
3010
 
    pass
 
2798
    pass    
 
2799
 
 
2800
 
 
2801
class NotATerminal(BzrError):
 
2802
 
 
2803
    _fmt = 'Unable to ask for a password without real terminal.'
3011
2804
 
3012
2805
 
3013
2806
class UnableEncodePath(BzrError):
3016
2809
            'user encoding %(user_encoding)s')
3017
2810
 
3018
2811
    def __init__(self, path, kind):
3019
 
        from bzrlib.osutils import get_user_encoding
3020
2812
        self.path = path
3021
2813
        self.kind = kind
3022
2814
        self.user_encoding = osutils.get_user_encoding()
3023
2815
 
3024
2816
 
3025
 
class NoSuchConfig(BzrError):
3026
 
 
3027
 
    _fmt = ('The "%(config_id)s" configuration does not exist.')
3028
 
 
3029
 
    def __init__(self, config_id):
3030
 
        BzrError.__init__(self, config_id=config_id)
3031
 
 
3032
 
 
3033
 
class NoSuchConfigOption(BzrError):
3034
 
 
3035
 
    _fmt = ('The "%(option_name)s" configuration option does not exist.')
3036
 
 
3037
 
    def __init__(self, option_name):
3038
 
        BzrError.__init__(self, option_name=option_name)
3039
 
 
3040
 
 
3041
2817
class NoSuchAlias(BzrError):
3042
2818
 
3043
2819
    _fmt = ('The alias "%(alias_name)s" does not exist.')
3073
2849
    _fmt = 'Cannot bind address "%(host)s:%(port)i": %(orig_error)s.'
3074
2850
 
3075
2851
    def __init__(self, host, port, orig_error):
3076
 
        # nb: in python2.4 socket.error doesn't have a useful repr
3077
2852
        BzrError.__init__(self, host=host, port=port,
3078
 
            orig_error=repr(orig_error.args))
 
2853
            orig_error=orig_error[1])
3079
2854
 
3080
2855
 
3081
2856
class UnknownRules(BzrError):
3089
2864
class HookFailed(BzrError):
3090
2865
    """Raised when a pre_change_branch_tip hook function fails anything other
3091
2866
    than TipChangeRejected.
3092
 
 
3093
 
    Note that this exception is no longer raised, and the import is only left
3094
 
    to be nice to code which might catch it in a plugin.
3095
2867
    """
3096
2868
 
3097
2869
    _fmt = ("Hook '%(hook_name)s' during %(hook_stage)s failed:\n"
3098
2870
            "%(traceback_text)s%(exc_value)s")
3099
2871
 
3100
 
    def __init__(self, hook_stage, hook_name, exc_info, warn=True):
3101
 
        if warn:
3102
 
            symbol_versioning.warn("BzrError HookFailed has been deprecated "
3103
 
                "as of bzrlib 2.1.", DeprecationWarning, stacklevel=2)
 
2872
    def __init__(self, hook_stage, hook_name, exc_info):
3104
2873
        import traceback
3105
2874
        self.hook_stage = hook_stage
3106
2875
        self.hook_name = hook_name
3115
2884
    """A pre_change_branch_tip hook function may raise this to cleanly and
3116
2885
    explicitly abort a change to a branch tip.
3117
2886
    """
3118
 
 
 
2887
    
3119
2888
    _fmt = u"Tip change rejected: %(msg)s"
3120
2889
 
3121
2890
    def __init__(self, msg):
3122
2891
        self.msg = msg
3123
2892
 
3124
 
 
3125
 
class ShelfCorrupt(BzrError):
3126
 
 
3127
 
    _fmt = "Shelf corrupt."
3128
 
 
3129
 
 
3130
 
class DecompressCorruption(BzrError):
3131
 
 
3132
 
    _fmt = "Corruption while decompressing repository file%(orig_error)s"
3133
 
 
3134
 
    def __init__(self, orig_error=None):
3135
 
        if orig_error is not None:
3136
 
            self.orig_error = ", %s" % (orig_error,)
3137
 
        else:
3138
 
            self.orig_error = ""
3139
 
        BzrError.__init__(self)
3140
 
 
3141
 
 
3142
 
class NoSuchShelfId(BzrError):
3143
 
 
3144
 
    _fmt = 'No changes are shelved with id "%(shelf_id)d".'
3145
 
 
3146
 
    def __init__(self, shelf_id):
3147
 
        BzrError.__init__(self, shelf_id=shelf_id)
3148
 
 
3149
 
 
3150
 
class InvalidShelfId(BzrError):
3151
 
 
3152
 
    _fmt = '"%(invalid_id)s" is not a valid shelf id, try a number instead.'
3153
 
 
3154
 
    def __init__(self, invalid_id):
3155
 
        BzrError.__init__(self, invalid_id=invalid_id)
3156
 
 
3157
 
 
3158
 
class JailBreak(BzrError):
3159
 
 
3160
 
    _fmt = "An attempt to access a url outside the server jail was made: '%(url)s'."
3161
 
 
3162
 
    def __init__(self, url):
3163
 
        BzrError.__init__(self, url=url)
3164
 
 
3165
 
 
3166
 
class UserAbort(BzrError):
3167
 
 
3168
 
    _fmt = 'The user aborted the operation.'
3169
 
 
3170
 
 
3171
 
class MustHaveWorkingTree(BzrError):
3172
 
 
3173
 
    _fmt = ("Branching '%(url)s'(%(format)s) must create a working tree.")
3174
 
 
3175
 
    def __init__(self, format, url):
3176
 
        BzrError.__init__(self, format=format, url=url)
3177
 
 
3178
 
 
3179
 
class NoSuchView(BzrError):
3180
 
    """A view does not exist.
3181
 
    """
3182
 
 
3183
 
    _fmt = u"No such view: %(view_name)s."
3184
 
 
3185
 
    def __init__(self, view_name):
3186
 
        self.view_name = view_name
3187
 
 
3188
 
 
3189
 
class ViewsNotSupported(BzrError):
3190
 
    """Views are not supported by a tree format.
3191
 
    """
3192
 
 
3193
 
    _fmt = ("Views are not supported by %(tree)s;"
3194
 
            " use 'bzr upgrade' to change your tree to a later format.")
3195
 
 
3196
 
    def __init__(self, tree):
3197
 
        self.tree = tree
3198
 
 
3199
 
 
3200
 
class FileOutsideView(BzrError):
3201
 
 
3202
 
    _fmt = ('Specified file "%(file_name)s" is outside the current view: '
3203
 
            '%(view_str)s')
3204
 
 
3205
 
    def __init__(self, file_name, view_files):
3206
 
        self.file_name = file_name
3207
 
        self.view_str = ", ".join(view_files)
3208
 
 
3209
 
 
3210
 
class UnresumableWriteGroup(BzrError):
3211
 
 
3212
 
    _fmt = ("Repository %(repository)s cannot resume write group "
3213
 
            "%(write_groups)r: %(reason)s")
3214
 
 
3215
 
    internal_error = True
3216
 
 
3217
 
    def __init__(self, repository, write_groups, reason):
3218
 
        self.repository = repository
3219
 
        self.write_groups = write_groups
3220
 
        self.reason = reason
3221
 
 
3222
 
 
3223
 
class UnsuspendableWriteGroup(BzrError):
3224
 
 
3225
 
    _fmt = ("Repository %(repository)s cannot suspend a write group.")
3226
 
 
3227
 
    internal_error = True
3228
 
 
3229
 
    def __init__(self, repository):
3230
 
        self.repository = repository
3231
 
 
3232
 
 
3233
 
class LossyPushToSameVCS(BzrError):
3234
 
 
3235
 
    _fmt = ("Lossy push not possible between %(source_branch)r and "
3236
 
            "%(target_branch)r that are in the same VCS.")
3237
 
 
3238
 
    internal_error = True
3239
 
 
3240
 
    def __init__(self, source_branch, target_branch):
3241
 
        self.source_branch = source_branch
3242
 
        self.target_branch = target_branch
3243
 
 
3244
 
 
3245
 
class NoRoundtrippingSupport(BzrError):
3246
 
 
3247
 
    _fmt = ("Roundtripping is not supported between %(source_branch)r and "
3248
 
            "%(target_branch)r.")
3249
 
 
3250
 
    internal_error = True
3251
 
 
3252
 
    def __init__(self, source_branch, target_branch):
3253
 
        self.source_branch = source_branch
3254
 
        self.target_branch = target_branch
3255
 
 
3256
 
 
3257
 
class FileTimestampUnavailable(BzrError):
3258
 
 
3259
 
    _fmt = "The filestamp for %(path)s is not available."
3260
 
 
3261
 
    internal_error = True
3262
 
 
3263
 
    def __init__(self, path):
3264
 
        self.path = path
3265
 
 
3266
 
 
3267
 
class NoColocatedBranchSupport(BzrError):
3268
 
 
3269
 
    _fmt = ("%(bzrdir)r does not support co-located branches.")
3270
 
 
3271
 
    def __init__(self, bzrdir):
3272
 
        self.bzrdir = bzrdir
3273
 
 
3274
 
 
3275
 
class NoWhoami(BzrError):
3276
 
 
3277
 
    _fmt = ('Unable to determine your name.\n'
3278
 
        "Please, set your name with the 'whoami' command.\n"
3279
 
        'E.g. bzr whoami "Your Name <name@example.com>"')
3280
 
 
3281
 
 
3282
 
class InvalidPattern(BzrError):
3283
 
 
3284
 
    _fmt = ('Invalid pattern(s) found. %(msg)s')
3285
 
 
3286
 
    def __init__(self, msg):
3287
 
        self.msg = msg
3288
 
 
3289
 
 
3290
 
class RecursiveBind(BzrError):
3291
 
 
3292
 
    _fmt = ('Branch "%(branch_url)s" appears to be bound to itself. '
3293
 
        'Please use `bzr unbind` to fix.')
3294
 
 
3295
 
    def __init__(self, branch_url):
3296
 
        self.branch_url = branch_url
3297
 
 
3298
 
 
3299
 
# FIXME: I would prefer to define the config related exception classes in
3300
 
# config.py but the lazy import mechanism proscribes this -- vila 20101222
3301
 
class OptionExpansionLoop(BzrError):
3302
 
 
3303
 
    _fmt = 'Loop involving %(refs)r while expanding "%(string)s".'
3304
 
 
3305
 
    def __init__(self, string, refs):
3306
 
        self.string = string
3307
 
        self.refs = '->'.join(refs)
3308
 
 
3309
 
 
3310
 
class ExpandingUnknownOption(BzrError):
3311
 
 
3312
 
    _fmt = 'Option %(name)s is not defined while expanding "%(string)s".'
3313
 
 
3314
 
    def __init__(self, name, string):
3315
 
        self.name = name
3316
 
        self.string = string
3317
 
 
3318
 
 
3319
 
class NoCompatibleInter(BzrError):
3320
 
 
3321
 
    _fmt = ('No compatible object available for operations from %(source)r '
3322
 
            'to %(target)r.')
3323
 
 
3324
 
    def __init__(self, source, target):
3325
 
        self.source = source
3326
 
        self.target = target