← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/errors.py

  • Committer: Canonical.com Patch Queue Manager
  • Date: 2011-08-17 18:13:57 UTC
  • mfrom: (5268.7.29 transport-segments)
  • Revision ID: pqm@pqm.ubuntu.com-20110817181357-y5q5eth1hk8bl3om
(jelmer) Allow specifying the colocated branch to use in the branch URL,
 and retrieving the branch name using ControlDir._get_selected_branch.
 (Jelmer Vernooij)

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/errors.py
1
 
# Copyright (C) 2005, 2006, 2007, 2008 Canonical Ltd
 
1
# Copyright (C) 2005-2011 Canonical Ltd
2
2
#
3
3
# This program is free software; you can redistribute it and/or modify
4
4
# it under the terms of the GNU General Public License as published by
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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
16
16
 
17
17
"""Exceptions for bzr, and reporting of them.
18
18
"""
19
19
 
20
 
 
21
20
from bzrlib import (
22
21
    osutils,
23
22
    symbol_versioning,
32
31
 
33
32
 
34
33
# TODO: is there any value in providing the .args field used by standard
35
 
# python exceptions?   A list of values with no names seems less useful 
 
34
# python exceptions?   A list of values with no names seems less useful
36
35
# to me.
37
36
 
38
 
# TODO: Perhaps convert the exception to a string at the moment it's 
 
37
# TODO: Perhaps convert the exception to a string at the moment it's
39
38
# constructed to make sure it will succeed.  But that says nothing about
40
39
# exceptions that are never raised.
41
40
 
55
54
    Base class for errors raised by bzrlib.
56
55
 
57
56
    :cvar internal_error: if True this was probably caused by a bzr bug and
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.)
 
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.)
61
60
 
62
61
    :cvar _fmt: Format string to display the error; this is expanded
63
 
    by the instance's dict.
 
62
        by the instance's dict.
64
63
    """
65
 
    
 
64
 
66
65
    internal_error = False
67
66
 
68
67
    def __init__(self, msg=None, **kwds):
73
72
        arguments can be given.  The first is for generic "user" errors which
74
73
        are not intended to be caught and so do not need a specific subclass.
75
74
        The second case is for use with subclasses that provide a _fmt format
76
 
        string to print the arguments.  
 
75
        string to print the arguments.
77
76
 
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 
 
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
81
80
        parameters.
82
81
 
83
82
        :param msg: If given, this is the literal complete text for the error,
134
133
            s = str(s)
135
134
        return s
136
135
 
 
136
    def __repr__(self):
 
137
        return '%s(%s)' % (self.__class__.__name__, str(self))
 
138
 
137
139
    def _get_format_string(self):
138
140
        """Return format string for this exception or None"""
139
141
        fmt = getattr(self, '_fmt', None)
152
154
               )
153
155
 
154
156
    def __eq__(self, other):
155
 
        if self.__class__ != other.__class__:
 
157
        if self.__class__ is not other.__class__:
156
158
            return NotImplemented
157
159
        return self.__dict__ == other.__dict__
158
160
 
263
265
 
264
266
 
265
267
class InvalidEntryName(InternalBzrError):
266
 
    
 
268
 
267
269
    _fmt = "Invalid entry name: %(name)s"
268
270
 
269
271
    def __init__(self, name):
272
274
 
273
275
 
274
276
class InvalidRevisionNumber(BzrError):
275
 
    
 
277
 
276
278
    _fmt = "Invalid revision number %(revno)s"
277
279
 
278
280
    def __init__(self, revno):
302
304
class RootMissing(InternalBzrError):
303
305
 
304
306
    _fmt = ("The root entry of a tree must be the first entry supplied to "
305
 
        "record_entry_contents.")
 
307
        "the commit builder.")
306
308
 
307
309
 
308
310
class NoPublicBranch(BzrError):
327
329
class NoSuchId(BzrError):
328
330
 
329
331
    _fmt = 'The file id "%(file_id)s" is not present in the tree %(tree)s.'
330
 
    
 
332
 
331
333
    def __init__(self, tree, file_id):
332
334
        BzrError.__init__(self)
333
335
        self.file_id = file_id
360
362
class NoWorkingTree(BzrError):
361
363
 
362
364
    _fmt = 'No WorkingTree exists for "%(base)s".'
363
 
    
 
365
 
364
366
    def __init__(self, base):
365
367
        BzrError.__init__(self)
366
368
        self.base = base
475
477
    def __init__(self, name, value):
476
478
        BzrError.__init__(self, name=name, value=value)
477
479
 
478
 
    
 
480
 
479
481
class StrictCommitFailed(BzrError):
480
482
 
481
483
    _fmt = "Commit refused because there are unknown files in the tree"
484
486
# XXX: Should be unified with TransportError; they seem to represent the
485
487
# same thing
486
488
# RBC 20060929: I think that unifiying with TransportError would be a mistake
487
 
# - 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
488
490
# differentiates between 'transport has failed' and 'operation on a transport
489
491
# has failed.'
490
492
class PathError(BzrError):
491
 
    
 
493
 
492
494
    _fmt = "Generic path error: %(path)r%(extra)s)"
493
495
 
494
496
    def __init__(self, path, extra=None):
548
550
 
549
551
 
550
552
class ReadingCompleted(InternalBzrError):
551
 
    
 
553
 
552
554
    _fmt = ("The MediumRequest '%(request)s' has already had finish_reading "
553
555
            "called upon it - the request has been completed and no more "
554
556
            "data may be read.")
619
621
 
620
622
    _fmt = 'Unsupported protocol for url "%(path)s"%(extra)s'
621
623
 
622
 
    def __init__(self, url, extra):
 
624
    def __init__(self, url, extra=""):
623
625
        PathError.__init__(self, url, extra=extra)
624
626
 
625
627
 
634
636
        self.url = url
635
637
 
636
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
 
637
649
class UnstackableRepositoryFormat(BzrError):
638
650
 
639
651
    _fmt = ("The repository '%(url)s'(%(format)s) is not a stackable format. "
646
658
 
647
659
 
648
660
class ReadError(PathError):
649
 
    
 
661
 
650
662
    _fmt = """Error reading from %(path)r."""
651
663
 
652
664
 
668
680
 
669
681
    _fmt = 'Path "%(path)s" is not a child of path "%(base)s"%(extra)s'
670
682
 
671
 
    internal_error = True
 
683
    internal_error = False
672
684
 
673
685
    def __init__(self, path, base, extra=None):
674
686
        BzrError.__init__(self)
687
699
 
688
700
# TODO: This is given a URL; we try to unescape it but doing that from inside
689
701
# the exception object is a bit undesirable.
690
 
# TODO: Probably this behavior of should be a common superclass 
 
702
# TODO: Probably this behavior of should be a common superclass
691
703
class NotBranchError(PathError):
692
704
 
693
 
    _fmt = 'Not a branch: "%(path)s".'
 
705
    _fmt = 'Not a branch: "%(path)s"%(detail)s.'
694
706
 
695
 
    def __init__(self, path):
 
707
    def __init__(self, path, detail=None, bzrdir=None):
696
708
       import bzrlib.urlutils as urlutils
697
 
       self.path = urlutils.unescape_for_display(path, 'ascii')
 
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)
698
743
 
699
744
 
700
745
class NoSubmitBranch(PathError):
749
794
 
750
795
    _fmt = 'File "%(path)s" is not in branch %(branch_base)s.'
751
796
 
 
797
    # use PathNotChild instead
 
798
    @symbol_versioning.deprecated_method(symbol_versioning.deprecated_in((2, 3, 0)))
752
799
    def __init__(self, branch, path):
753
800
        BzrError.__init__(self)
754
801
        self.branch = branch
762
809
 
763
810
 
764
811
class UnknownFormatError(BzrError):
765
 
    
 
812
 
766
813
    _fmt = "Unknown %(kind)s format: %(format)r"
767
814
 
768
815
    def __init__(self, format, kind='branch'):
771
818
 
772
819
 
773
820
class IncompatibleFormat(BzrError):
774
 
    
 
821
 
775
822
    _fmt = "Format %(format)s is not compatible with .bzr version %(bzrdir)s."
776
823
 
777
824
    def __init__(self, format, bzrdir_format):
781
828
 
782
829
 
783
830
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
    """
784
837
 
785
838
    _fmt = "%(target)s\n" \
786
839
            "is not compatible with\n" \
794
847
 
795
848
 
796
849
class IncompatibleRevision(BzrError):
797
 
    
 
850
 
798
851
    _fmt = "Revision is not compatible with %(repo_format)s"
799
852
 
800
853
    def __init__(self, repo_format):
811
864
        """Construct a new AlreadyVersionedError.
812
865
 
813
866
        :param path: This is the path which is versioned,
814
 
        which should be in a user friendly form.
 
867
            which should be in a user friendly form.
815
868
        :param context_info: If given, this is information about the context,
816
 
        which could explain why this is expected to not be versioned.
 
869
            which could explain why this is expected to not be versioned.
817
870
        """
818
871
        BzrError.__init__(self)
819
872
        self.path = path
832
885
        """Construct a new NotVersionedError.
833
886
 
834
887
        :param path: This is the path which is not versioned,
835
 
        which should be in a user friendly form.
 
888
            which should be in a user friendly form.
836
889
        :param context_info: If given, this is information about the context,
837
 
        which could explain why this is expected to be versioned.
 
890
            which could explain why this is expected to be versioned.
838
891
        """
839
892
        BzrError.__init__(self)
840
893
        self.path = path
908
961
    # original exception is available as e.original_error
909
962
    #
910
963
    # New code should prefer to raise specific subclasses
911
 
    def __init__(self, message):
912
 
        # Python 2.5 uses a slot for StandardError.message,
913
 
        # so use a different variable name.  We now work around this in
914
 
        # BzrError.__str__, but this member name is kept for compatability.
915
 
        self.msg = message
 
964
    def __init__(self, msg):
 
965
        self.msg = msg
916
966
 
917
967
 
918
968
class LockActive(LockError):
1001
1051
 
1002
1052
class LockContention(LockError):
1003
1053
 
1004
 
    _fmt = 'Could not acquire lock "%(lock)s"'
1005
 
    # TODO: show full url for lock, combining the transport and relative
1006
 
    # bits?
 
1054
    _fmt = 'Could not acquire lock "%(lock)s": %(msg)s'
1007
1055
 
1008
1056
    internal_error = False
1009
1057
 
1010
 
    def __init__(self, lock):
 
1058
    def __init__(self, lock, msg=''):
1011
1059
        self.lock = lock
 
1060
        self.msg = msg
1012
1061
 
1013
1062
 
1014
1063
class LockBroken(LockError):
1035
1084
        self.target = target
1036
1085
 
1037
1086
 
 
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
 
1038
1099
class LockNotHeld(LockError):
1039
1100
 
1040
1101
    _fmt = "Lock not held: %(lock)s"
1079
1140
        BzrError.__init__(self, files=files, files_str=files_str)
1080
1141
 
1081
1142
 
 
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
 
1082
1152
class BadCommitMessageEncoding(BzrError):
1083
1153
 
1084
1154
    _fmt = 'The specified commit message contains characters unsupported by '\
1128
1198
 
1129
1199
class NoSuchRevisionInTree(NoSuchRevision):
1130
1200
    """When using Tree.revision_tree, and the revision is not accessible."""
1131
 
    
 
1201
 
1132
1202
    _fmt = "The revision id {%(revision_id)s} is not present in the tree %(tree)s."
1133
1203
 
1134
1204
    def __init__(self, tree, revision_id):
1139
1209
 
1140
1210
class InvalidRevisionSpec(BzrError):
1141
1211
 
1142
 
    _fmt = ("Requested revision: %(spec)r does not exist in branch:"
1143
 
            " %(branch)s%(extra)s")
 
1212
    _fmt = ("Requested revision: '%(spec)s' does not exist in branch:"
 
1213
            " %(branch_url)s%(extra)s")
1144
1214
 
1145
1215
    def __init__(self, spec, branch, extra=None):
1146
1216
        BzrError.__init__(self, branch=branch, spec=spec)
 
1217
        self.branch_url = getattr(branch, 'user_url', str(branch))
1147
1218
        if extra:
1148
1219
            self.extra = '\n' + str(extra)
1149
1220
        else:
1170
1241
class DivergedBranches(BzrError):
1171
1242
 
1172
1243
    _fmt = ("These branches have diverged."
1173
 
            " Use the merge command to reconcile them.")
 
1244
            " Use the missing command to see how.\n"
 
1245
            "Use the merge command to reconcile them.")
1174
1246
 
1175
1247
    def __init__(self, branch1, branch2):
1176
1248
        self.branch1 = branch1
1198
1270
 
1199
1271
 
1200
1272
class NoCommonAncestor(BzrError):
1201
 
    
 
1273
 
1202
1274
    _fmt = "Revisions have no common ancestor: %(revision_a)s %(revision_b)s"
1203
1275
 
1204
1276
    def __init__(self, revision_a, revision_b):
1224
1296
            not_ancestor_id=not_ancestor_id)
1225
1297
 
1226
1298
 
1227
 
class InstallFailed(BzrError):
1228
 
 
1229
 
    def __init__(self, revisions):
1230
 
        revision_str = ", ".join(str(r) for r in revisions)
1231
 
        msg = "Could not install revisions:\n%s" % revision_str
1232
 
        BzrError.__init__(self, msg)
1233
 
        self.revisions = revisions
1234
 
 
1235
 
 
1236
1299
class AmbiguousBase(BzrError):
1237
1300
 
1238
1301
    def __init__(self, bases):
1239
 
        warn("BzrError AmbiguousBase has been deprecated as of bzrlib 0.8.",
1240
 
                DeprecationWarning)
 
1302
        symbol_versioning.warn("BzrError AmbiguousBase has been deprecated "
 
1303
            "as of bzrlib 0.8.", DeprecationWarning, stacklevel=2)
1241
1304
        msg = ("The correct base is unclear, because %s are all equally close"
1242
1305
                % ", ".join(bases))
1243
1306
        BzrError.__init__(self, msg)
1265
1328
class BoundBranchOutOfDate(BzrError):
1266
1329
 
1267
1330
    _fmt = ("Bound branch %(branch)s is out of date with master branch"
1268
 
            " %(master)s.")
 
1331
            " %(master)s.%(extra_help)s")
1269
1332
 
1270
1333
    def __init__(self, branch, master):
1271
1334
        BzrError.__init__(self)
1272
1335
        self.branch = branch
1273
1336
        self.master = master
1274
 
 
1275
 
        
 
1337
        self.extra_help = ''
 
1338
 
 
1339
 
1276
1340
class CommitToDoubleBoundBranch(BzrError):
1277
1341
 
1278
1342
    _fmt = ("Cannot commit to branch %(branch)s."
1347
1411
 
1348
1412
class WeaveParentMismatch(WeaveError):
1349
1413
 
1350
 
    _fmt = "Parents are mismatched between two revisions. %(message)s"
1351
 
    
 
1414
    _fmt = "Parents are mismatched between two revisions. %(msg)s"
 
1415
 
1352
1416
 
1353
1417
class WeaveInvalidChecksum(WeaveError):
1354
1418
 
1355
 
    _fmt = "Text did not match it's checksum: %(message)s"
 
1419
    _fmt = "Text did not match its checksum: %(msg)s"
1356
1420
 
1357
1421
 
1358
1422
class WeaveTextDiffers(WeaveError):
1380
1444
 
1381
1445
 
1382
1446
class VersionedFileError(BzrError):
1383
 
    
 
1447
 
1384
1448
    _fmt = "Versioned file error"
1385
1449
 
1386
1450
 
1387
1451
class RevisionNotPresent(VersionedFileError):
1388
 
    
 
1452
 
1389
1453
    _fmt = 'Revision {%(revision_id)s} not present in "%(file_id)s".'
1390
1454
 
1391
1455
    def __init__(self, revision_id, file_id):
1395
1459
 
1396
1460
 
1397
1461
class RevisionAlreadyPresent(VersionedFileError):
1398
 
    
 
1462
 
1399
1463
    _fmt = 'Revision {%(revision_id)s} already present in "%(file_id)s".'
1400
1464
 
1401
1465
    def __init__(self, revision_id, file_id):
1406
1470
 
1407
1471
class VersionedFileInvalidChecksum(VersionedFileError):
1408
1472
 
1409
 
    _fmt = "Text did not match its checksum: %(message)s"
 
1473
    _fmt = "Text did not match its checksum: %(msg)s"
1410
1474
 
1411
1475
 
1412
1476
class KnitError(InternalBzrError):
1413
 
    
 
1477
 
1414
1478
    _fmt = "Knit error"
1415
1479
 
1416
1480
 
1424
1488
        self.how = how
1425
1489
 
1426
1490
 
 
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
 
1427
1506
class KnitDataStreamIncompatible(KnitError):
1428
1507
    # Not raised anymore, as we can convert data streams.  In future we may
1429
1508
    # need it again for more exotic cases, so we're keeping it around for now.
1433
1512
    def __init__(self, stream_format, target_format):
1434
1513
        self.stream_format = stream_format
1435
1514
        self.target_format = target_format
1436
 
        
 
1515
 
1437
1516
 
1438
1517
class KnitDataStreamUnknown(KnitError):
1439
1518
    # Indicates a data stream we don't know how to handle.
1442
1521
 
1443
1522
    def __init__(self, stream_format):
1444
1523
        self.stream_format = stream_format
1445
 
        
 
1524
 
1446
1525
 
1447
1526
class KnitHeaderError(KnitError):
1448
1527
 
1458
1537
 
1459
1538
    Currently only 'fulltext' and 'line-delta' are supported.
1460
1539
    """
1461
 
    
 
1540
 
1462
1541
    _fmt = ("Knit index %(filename)s does not have a known method"
1463
1542
            " in options: %(options)r")
1464
1543
 
1468
1547
        self.options = options
1469
1548
 
1470
1549
 
 
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
 
1471
1596
class NoSuchExportFormat(BzrError):
1472
 
    
 
1597
 
1473
1598
    _fmt = "Export format %(format)r not supported"
1474
1599
 
1475
1600
    def __init__(self, format):
1478
1603
 
1479
1604
 
1480
1605
class TransportError(BzrError):
1481
 
    
 
1606
 
1482
1607
    _fmt = "Transport error: %(msg)s %(orig_error)s"
1483
1608
 
1484
1609
    def __init__(self, msg=None, orig_error=None):
1529
1654
 
1530
1655
class SmartMessageHandlerError(InternalBzrError):
1531
1656
 
1532
 
    _fmt = "The message handler raised an exception: %(exc_value)s."
 
1657
    _fmt = ("The message handler raised an exception:\n"
 
1658
            "%(traceback_text)s")
1533
1659
 
1534
1660
    def __init__(self, exc_info):
1535
 
        self.exc_type, self.exc_value, self.tb = exc_info
1536
 
        
 
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
1668
 
1538
1669
# A set of semi-meaningful errors which can be thrown
1539
1670
class TransportNotPossible(TransportError):
1565
1696
            self.port = ':%s' % port
1566
1697
 
1567
1698
 
 
1699
# XXX: This is also used for unexpected end of file, which is different at the
 
1700
# TCP level from "connection reset".
1568
1701
class ConnectionReset(TransportError):
1569
1702
 
1570
1703
    _fmt = "Connection closed: %(msg)s %(orig_error)s"
1582
1715
 
1583
1716
class InvalidHttpResponse(TransportError):
1584
1717
 
1585
 
    _fmt = "Invalid http response for %(path)s: %(msg)s"
 
1718
    _fmt = "Invalid http response for %(path)s: %(msg)s%(orig_error)s"
1586
1719
 
1587
1720
    def __init__(self, path, msg, orig_error=None):
1588
1721
        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,)
1589
1728
        TransportError.__init__(self, msg, orig_error=orig_error)
1590
1729
 
1591
1730
 
1598
1737
        InvalidHttpResponse.__init__(self, path, msg)
1599
1738
 
1600
1739
 
 
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
 
1601
1753
class InvalidHttpContentType(InvalidHttpResponse):
1602
1754
 
1603
1755
    _fmt = 'Invalid http Content-type "%(ctype)s" for %(path)s: %(msg)s'
1611
1763
 
1612
1764
    _fmt = '%(source)s is%(permanently)s redirected to %(target)s'
1613
1765
 
1614
 
    def __init__(self, source, target, is_permanent=False, qual_proto=None):
 
1766
    def __init__(self, source, target, is_permanent=False):
1615
1767
        self.source = source
1616
1768
        self.target = target
1617
1769
        if is_permanent:
1618
1770
            self.permanently = ' permanently'
1619
1771
        else:
1620
1772
            self.permanently = ''
1621
 
        self._qualified_proto = qual_proto
1622
1773
        TransportError.__init__(self)
1623
1774
 
1624
 
    def _requalify_url(self, url):
1625
 
        """Restore the qualified proto in front of the url"""
1626
 
        # When this exception is raised, source and target are in
1627
 
        # user readable format. But some transports may use a
1628
 
        # different proto (http+urllib:// will present http:// to
1629
 
        # the user. If a qualified proto is specified, the code
1630
 
        # trapping the exception can get the qualified urls to
1631
 
        # properly handle the redirection themself (creating a
1632
 
        # new transport object from the target url for example).
1633
 
        # But checking that the scheme of the original and
1634
 
        # redirected urls are the same can be tricky. (see the
1635
 
        # FIXME in BzrDir.open_from_transport for the unique use
1636
 
        # case so far).
1637
 
        if self._qualified_proto is None:
1638
 
            return url
1639
 
 
1640
 
        # The TODO related to NotBranchError mention that doing
1641
 
        # that kind of manipulation on the urls may not be the
1642
 
        # exception object job. On the other hand, this object is
1643
 
        # the interface between the code and the user so
1644
 
        # presenting the urls in different ways is indeed its
1645
 
        # job...
1646
 
        import urlparse
1647
 
        proto, netloc, path, query, fragment = urlparse.urlsplit(url)
1648
 
        return urlparse.urlunsplit((self._qualified_proto, netloc, path,
1649
 
                                   query, fragment))
1650
 
 
1651
 
    def get_source_url(self):
1652
 
        return self._requalify_url(self.source)
1653
 
 
1654
 
    def get_target_url(self):
1655
 
        return self._requalify_url(self.target)
1656
 
 
1657
1775
 
1658
1776
class TooManyRedirections(TransportError):
1659
1777
 
1665
1783
    _fmt = "Working tree has conflicts."
1666
1784
 
1667
1785
 
 
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
 
1668
1795
class ParseConfigError(BzrError):
1669
1796
 
 
1797
    _fmt = "Error(s) parsing config file %(filename)s:\n%(errors)s"
 
1798
 
1670
1799
    def __init__(self, errors, filename):
1671
 
        if filename is None:
1672
 
            filename = ""
1673
 
        message = "Error(s) parsing config file %s:\n%s" % \
1674
 
            (filename, ('\n'.join(e.msg for e in errors)))
1675
 
        BzrError.__init__(self, message)
 
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)
1676
1811
 
1677
1812
 
1678
1813
class NoEmailInUsername(BzrError):
1686
1821
 
1687
1822
class SigningFailed(BzrError):
1688
1823
 
1689
 
    _fmt = 'Failed to gpg sign data with command "%(command_line)s"'
 
1824
    _fmt = 'Failed to GPG sign data with command "%(command_line)s"'
1690
1825
 
1691
1826
    def __init__(self, command_line):
1692
1827
        BzrError.__init__(self, command_line=command_line)
1693
1828
 
1694
1829
 
 
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
 
1695
1854
class WorkingTreeNotRevision(BzrError):
1696
1855
 
1697
 
    _fmt = ("The working tree for %(basedir)s has changed since" 
 
1856
    _fmt = ("The working tree for %(basedir)s has changed since"
1698
1857
            " the last commit, but weave merge requires that it be"
1699
1858
            " unchanged")
1700
1859
 
1857
2016
    _fmt = "Moving the root directory is not supported at this time"
1858
2017
 
1859
2018
 
 
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
 
1860
2030
class BzrMoveFailedError(BzrError):
1861
2031
 
1862
 
    _fmt = "Could not move %(from_path)s%(operator)s %(to_path)s%(extra)s"
 
2032
    _fmt = ("Could not move %(from_path)s%(operator)s %(to_path)s"
 
2033
        "%(_has_extra)s%(extra)s")
1863
2034
 
1864
2035
    def __init__(self, from_path='', to_path='', extra=None):
1865
2036
        from bzrlib.osutils import splitpath
1866
2037
        BzrError.__init__(self)
1867
2038
        if extra:
1868
 
            self.extra = ': ' + str(extra)
 
2039
            self.extra, self._has_extra = extra, ': '
1869
2040
        else:
1870
 
            self.extra = ''
 
2041
            self.extra = self._has_extra = ''
1871
2042
 
1872
2043
        has_from = len(from_path) > 0
1873
2044
        has_to = len(to_path) > 0
1894
2065
 
1895
2066
class BzrRenameFailedError(BzrMoveFailedError):
1896
2067
 
1897
 
    _fmt = "Could not rename %(from_path)s%(operator)s %(to_path)s%(extra)s"
 
2068
    _fmt = ("Could not rename %(from_path)s%(operator)s %(to_path)s"
 
2069
        "%(_has_extra)s%(extra)s")
1898
2070
 
1899
2071
    def __init__(self, from_path, to_path, extra=None):
1900
2072
        BzrMoveFailedError.__init__(self, from_path, to_path, extra)
1901
2073
 
 
2074
 
1902
2075
class BzrRemoveChangedFilesError(BzrError):
1903
2076
    """Used when user is trying to remove changed files."""
1904
2077
 
1907
2080
        "Use --keep to not delete them, or --force to delete them regardless.")
1908
2081
 
1909
2082
    def __init__(self, tree_delta):
 
2083
        symbol_versioning.warn(symbol_versioning.deprecated_in((2, 3, 0)) %
 
2084
            "BzrRemoveChangedFilesError", DeprecationWarning, stacklevel=2)
1910
2085
        BzrError.__init__(self)
1911
2086
        self.changes_as_text = tree_delta.get_changes_as_text()
1912
2087
        #self.paths_as_string = '\n'.join(changed_files)
1920
2095
 
1921
2096
class BzrBadParameterMissing(BzrBadParameter):
1922
2097
 
1923
 
    _fmt = "Parameter $(param)s is required but not present."
 
2098
    _fmt = "Parameter %(param)s is required but not present."
1924
2099
 
1925
2100
 
1926
2101
class BzrBadParameterUnicode(BzrBadParameter):
1934
2109
    _fmt = "Parameter %(param)s contains a newline."
1935
2110
 
1936
2111
 
1937
 
class DependencyNotPresent(BzrError):
1938
 
 
1939
 
    _fmt = 'Unable to import library "%(library)s": %(error)s'
1940
 
 
1941
 
    def __init__(self, library, error):
1942
 
        BzrError.__init__(self, library=library, error=error)
1943
 
 
1944
 
 
1945
2112
class ParamikoNotPresent(DependencyNotPresent):
1946
2113
 
1947
2114
    _fmt = "Unable to import paramiko (required for sftp support): %(error)s"
1966
2133
 
1967
2134
class BadConversionTarget(BzrError):
1968
2135
 
1969
 
    _fmt = "Cannot convert to format %(format)s.  %(problem)s"
 
2136
    _fmt = "Cannot convert from format %(from_format)s to format %(format)s." \
 
2137
            "    %(problem)s"
1970
2138
 
1971
 
    def __init__(self, problem, format):
 
2139
    def __init__(self, problem, format, from_format=None):
1972
2140
        BzrError.__init__(self)
1973
2141
        self.problem = problem
1974
2142
        self.format = format
 
2143
        self.from_format = from_format or '(unspecified)'
1975
2144
 
1976
2145
 
1977
2146
class NoDiffFound(BzrError):
2014
2183
    _fmt = """This tree contains left-over files from a failed operation.
2015
2184
    Please examine %(limbo_dir)s to see if it contains any files you wish to
2016
2185
    keep, and delete it when you are done."""
2017
 
    
 
2186
 
2018
2187
    def __init__(self, limbo_dir):
2019
2188
       BzrError.__init__(self)
2020
2189
       self.limbo_dir = limbo_dir
2053
2222
 
2054
2223
class OutOfDateTree(BzrError):
2055
2224
 
2056
 
    _fmt = "Working tree is out of date, please run 'bzr update'."
 
2225
    _fmt = "Working tree is out of date, please run 'bzr update'.%(more)s"
2057
2226
 
2058
 
    def __init__(self, tree):
 
2227
    def __init__(self, tree, more=None):
 
2228
        if more is None:
 
2229
            more = ''
 
2230
        else:
 
2231
            more = ' ' + more
2059
2232
        BzrError.__init__(self)
2060
2233
        self.tree = tree
 
2234
        self.more = more
2061
2235
 
2062
2236
 
2063
2237
class PublicBranchOutOfDate(BzrError):
2101
2275
 
2102
2276
    def __init__(self, repo):
2103
2277
        BzrError.__init__(self)
2104
 
        self.repo_path = repo.bzrdir.root_transport.base
 
2278
        self.repo_path = repo.user_url
2105
2279
 
2106
2280
 
2107
2281
class InconsistentDelta(BzrError):
2117
2291
        self.reason = reason
2118
2292
 
2119
2293
 
 
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
 
2120
2306
class UpgradeRequired(BzrError):
2121
2307
 
2122
2308
    _fmt = "To use this feature you must upgrade your branch at %(path)s."
2131
2317
    _fmt = "To use this feature you must upgrade your repository at %(path)s."
2132
2318
 
2133
2319
 
 
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
 
2134
2326
class LocalRequiresBoundBranch(BzrError):
2135
2327
 
2136
2328
    _fmt = "Cannot perform local-only commits on unbound branches."
2137
2329
 
2138
2330
 
2139
 
class MissingProgressBarFinish(BzrError):
2140
 
 
2141
 
    _fmt = "A nested progress bar was not 'finished' correctly."
2142
 
 
2143
 
 
2144
 
class InvalidProgressBarType(BzrError):
2145
 
 
2146
 
    _fmt = ("Environment variable BZR_PROGRESS_BAR='%(bar_type)s"
2147
 
            " is not a supported type Select one of: %(valid_types)s")
2148
 
 
2149
 
    def __init__(self, bar_type, valid_types):
2150
 
        BzrError.__init__(self, bar_type=bar_type, valid_types=valid_types)
2151
 
 
2152
 
 
2153
2331
class UnsupportedOperation(BzrError):
2154
2332
 
2155
2333
    _fmt = ("The method %(mname)s is not supported on"
2172
2350
 
2173
2351
 
2174
2352
class BinaryFile(BzrError):
2175
 
    
 
2353
 
2176
2354
    _fmt = "File is binary but should be text."
2177
2355
 
2178
2356
 
2198
2376
 
2199
2377
 
2200
2378
class NotABundle(BzrError):
2201
 
    
 
2379
 
2202
2380
    _fmt = "Not a bzr revision-bundle: %(text)r"
2203
2381
 
2204
2382
    def __init__(self, text):
2206
2384
        self.text = text
2207
2385
 
2208
2386
 
2209
 
class BadBundle(BzrError): 
2210
 
    
 
2387
class BadBundle(BzrError):
 
2388
 
2211
2389
    _fmt = "Bad bzr revision-bundle: %(text)r"
2212
2390
 
2213
2391
    def __init__(self, text):
2215
2393
        self.text = text
2216
2394
 
2217
2395
 
2218
 
class MalformedHeader(BadBundle): 
2219
 
    
 
2396
class MalformedHeader(BadBundle):
 
2397
 
2220
2398
    _fmt = "Malformed bzr revision-bundle header: %(text)r"
2221
2399
 
2222
2400
 
2223
 
class MalformedPatches(BadBundle): 
2224
 
    
 
2401
class MalformedPatches(BadBundle):
 
2402
 
2225
2403
    _fmt = "Malformed patches in bzr revision-bundle: %(text)r"
2226
2404
 
2227
2405
 
2228
 
class MalformedFooter(BadBundle): 
2229
 
    
 
2406
class MalformedFooter(BadBundle):
 
2407
 
2230
2408
    _fmt = "Malformed footer in bzr revision-bundle: %(text)r"
2231
2409
 
2232
2410
 
2233
2411
class UnsupportedEOLMarker(BadBundle):
2234
 
    
2235
 
    _fmt = "End of line marker was not \\n in bzr revision-bundle"    
 
2412
 
 
2413
    _fmt = "End of line marker was not \\n in bzr revision-bundle"
2236
2414
 
2237
2415
    def __init__(self):
2238
 
        # XXX: BadBundle's constructor assumes there's explanatory text, 
 
2416
        # XXX: BadBundle's constructor assumes there's explanatory text,
2239
2417
        # but for this there is not
2240
2418
        BzrError.__init__(self)
2241
2419
 
2242
2420
 
2243
2421
class IncompatibleBundleFormat(BzrError):
2244
 
    
 
2422
 
2245
2423
    _fmt = "Bundle format %(bundle_format)s is incompatible with %(other)s"
2246
2424
 
2247
2425
    def __init__(self, bundle_format, other):
2251
2429
 
2252
2430
 
2253
2431
class BadInventoryFormat(BzrError):
2254
 
    
 
2432
 
2255
2433
    _fmt = "Root class for inventory serialization errors"
2256
2434
 
2257
2435
 
2276
2454
        self.transport = transport
2277
2455
 
2278
2456
 
2279
 
class NoSmartServer(NotBranchError):
2280
 
 
2281
 
    _fmt = "No smart server available at %(url)s"
2282
 
 
2283
 
    @symbol_versioning.deprecated_method(symbol_versioning.one_four)
2284
 
    def __init__(self, url):
2285
 
        self.url = url
2286
 
 
2287
 
 
2288
2457
class UnknownSSH(BzrError):
2289
2458
 
2290
2459
    _fmt = "Unrecognised value for BZR_SSH environment variable: %(vendor)s"
2310
2479
        self.revision_id = revision_id
2311
2480
        self.ghost_revision_id = ghost_revision_id
2312
2481
 
2313
 
        
 
2482
 
2314
2483
class GhostRevisionUnusableHere(BzrError):
2315
2484
 
2316
2485
    _fmt = "Ghost revision {%(revision_id)s} cannot be used here."
2408
2577
 
2409
2578
 
2410
2579
class UnsupportedInventoryKind(BzrError):
2411
 
    
 
2580
 
2412
2581
    _fmt = """Unsupported entry kind %(kind)s"""
2413
2582
 
2414
2583
    def __init__(self, kind):
2426
2595
 
2427
2596
 
2428
2597
class SubsumeTargetNeedsUpgrade(BzrError):
2429
 
    
 
2598
 
2430
2599
    _fmt = """Subsume target %(other_tree)s needs to be upgraded."""
2431
2600
 
2432
2601
    def __init__(self, other_tree):
2460
2629
    def __init__(self, branch):
2461
2630
        self.branch = branch
2462
2631
 
2463
 
        
 
2632
 
2464
2633
class TagAlreadyExists(BzrError):
2465
2634
 
2466
2635
    _fmt = "Tag %(tag_name)s already exists."
2471
2640
 
2472
2641
class MalformedBugIdentifier(BzrError):
2473
2642
 
2474
 
    _fmt = "Did not understand bug identifier %(bug_id)s: %(reason)s"
 
2643
    _fmt = ('Did not understand bug identifier %(bug_id)s: %(reason)s. '
 
2644
            'See "bzr help bugs" for more information on this feature.')
2475
2645
 
2476
2646
    def __init__(self, bug_id, reason):
2477
2647
        self.bug_id = bug_id
2498
2668
        self.branch = branch
2499
2669
 
2500
2670
 
 
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
 
2501
2687
class UnexpectedSmartServerResponse(BzrError):
2502
2688
 
2503
2689
    _fmt = "Could not understand response from smart server: %(response_tuple)r"
2531
2717
 
2532
2718
    This is distinct from ErrorFromSmartServer so that it is possible to
2533
2719
    distinguish between the following two cases:
2534
 
      - ErrorFromSmartServer was uncaught.  This is logic error in the client
2535
 
        and so should provoke a traceback to the user.
2536
 
      - ErrorFromSmartServer was caught but its error_tuple could not be
2537
 
        translated.  This is probably because the server sent us garbage, and
2538
 
        should not provoke a traceback.
 
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.
2539
2726
    """
2540
2727
 
2541
2728
    _fmt = "Server sent an unexpected error: %(error_tuple)r"
2549
2736
        """
2550
2737
        self.error_from_smart_server = error_from_smart_server
2551
2738
        self.error_tuple = error_from_smart_server.error_tuple
2552
 
        
 
2739
 
2553
2740
 
2554
2741
class ContainerError(BzrError):
2555
2742
    """Base class of container errors."""
2558
2745
class UnknownContainerFormatError(ContainerError):
2559
2746
 
2560
2747
    _fmt = "Unrecognised container format: %(container_format)r"
2561
 
    
 
2748
 
2562
2749
    def __init__(self, container_format):
2563
2750
        self.container_format = container_format
2564
2751
 
2628
2815
 
2629
2816
class NoMailAddressSpecified(BzrError):
2630
2817
 
2631
 
    _fmt = "No mail-to address specified."
 
2818
    _fmt = "No mail-to address (--mail-to) or output (-o) specified."
2632
2819
 
2633
2820
 
2634
2821
class UnknownMailClient(BzrError):
2667
2854
 
2668
2855
    def __init__(self, bzrdir):
2669
2856
        import bzrlib.urlutils as urlutils
2670
 
        display_url = urlutils.unescape_for_display(bzrdir.root_transport.base,
 
2857
        display_url = urlutils.unescape_for_display(bzrdir.user_url,
2671
2858
                                                    'ascii')
2672
2859
        BzrError.__init__(self, bzrdir=bzrdir, display_url=display_url)
2673
2860
 
2714
2901
    _fmt = "'%(display_url)s' is already standalone."
2715
2902
 
2716
2903
 
 
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
 
2717
2916
class ReconfigurationNotSupported(BzrDirError):
2718
2917
 
2719
2918
    _fmt = "Requested reconfiguration of '%(display_url)s' is not supported."
2726
2925
 
2727
2926
class UncommittedChanges(BzrError):
2728
2927
 
2729
 
    _fmt = 'Working tree "%(display_url)s" has uncommitted changes.'
 
2928
    _fmt = ('Working tree "%(display_url)s" has uncommitted changes'
 
2929
            ' (See bzr status).%(more)s')
2730
2930
 
2731
 
    def __init__(self, tree):
 
2931
    def __init__(self, tree, more=None):
 
2932
        if more is None:
 
2933
            more = ''
 
2934
        else:
 
2935
            more = ' ' + more
2732
2936
        import bzrlib.urlutils as urlutils
2733
 
        display_url = urlutils.unescape_for_display(
2734
 
            tree.bzrdir.root_transport.base, 'ascii')
2735
 
        BzrError.__init__(self, tree=tree, display_url=display_url)
 
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')
2736
2949
 
2737
2950
 
2738
2951
class MissingTemplateVariable(BzrError):
2773
2986
 
2774
2987
 
2775
2988
class CommandAvailableInPlugin(StandardError):
2776
 
    
 
2989
 
2777
2990
    internal_error = False
2778
2991
 
2779
2992
    def __init__(self, cmd_name, plugin_metadata, provider):
2780
 
        
 
2993
 
2781
2994
        self.plugin_metadata = plugin_metadata
2782
2995
        self.cmd_name = cmd_name
2783
2996
        self.provider = provider
2784
2997
 
2785
2998
    def __str__(self):
2786
2999
 
2787
 
        _fmt = ('"%s" is not a standard bzr command. \n' 
 
3000
        _fmt = ('"%s" is not a standard bzr command. \n'
2788
3001
                'However, the following official plugin provides this command: %s\n'
2789
3002
                'You can install it by going to: %s'
2790
 
                % (self.cmd_name, self.plugin_metadata['name'], 
 
3003
                % (self.cmd_name, self.plugin_metadata['name'],
2791
3004
                    self.plugin_metadata['url']))
2792
3005
 
2793
3006
        return _fmt
2794
3007
 
2795
3008
 
2796
3009
class NoPluginAvailable(BzrError):
2797
 
    pass    
2798
 
 
2799
 
 
2800
 
class NotATerminal(BzrError):
2801
 
 
2802
 
    _fmt = 'Unable to ask for a password without real terminal.'
 
3010
    pass
2803
3011
 
2804
3012
 
2805
3013
class UnableEncodePath(BzrError):
2814
3022
        self.user_encoding = osutils.get_user_encoding()
2815
3023
 
2816
3024
 
 
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
 
2817
3041
class NoSuchAlias(BzrError):
2818
3042
 
2819
3043
    _fmt = ('The alias "%(alias_name)s" does not exist.')
2849
3073
    _fmt = 'Cannot bind address "%(host)s:%(port)i": %(orig_error)s.'
2850
3074
 
2851
3075
    def __init__(self, host, port, orig_error):
 
3076
        # nb: in python2.4 socket.error doesn't have a useful repr
2852
3077
        BzrError.__init__(self, host=host, port=port,
2853
 
            orig_error=orig_error[1])
 
3078
            orig_error=repr(orig_error.args))
2854
3079
 
2855
3080
 
2856
3081
class UnknownRules(BzrError):
2864
3089
class HookFailed(BzrError):
2865
3090
    """Raised when a pre_change_branch_tip hook function fails anything other
2866
3091
    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.
2867
3095
    """
2868
3096
 
2869
3097
    _fmt = ("Hook '%(hook_name)s' during %(hook_stage)s failed:\n"
2870
3098
            "%(traceback_text)s%(exc_value)s")
2871
3099
 
2872
 
    def __init__(self, hook_stage, hook_name, exc_info):
 
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)
2873
3104
        import traceback
2874
3105
        self.hook_stage = hook_stage
2875
3106
        self.hook_name = hook_name
2884
3115
    """A pre_change_branch_tip hook function may raise this to cleanly and
2885
3116
    explicitly abort a change to a branch tip.
2886
3117
    """
2887
 
    
 
3118
 
2888
3119
    _fmt = u"Tip change rejected: %(msg)s"
2889
3120
 
2890
3121
    def __init__(self, msg):
2891
3122
        self.msg = msg
2892
3123
 
 
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