← 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: 2010-09-01 08:02:42 UTC
  • mfrom: (5390.3.3 faster-revert-593560)
  • Revision ID: pqm@pqm.ubuntu.com-20100901080242-esg62ody4frwmy66
(spiv) Avoid repeatedly calling self.target.all_file_ids() in
 InterTree.iter_changes. (Andrew Bennetts)

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-2010 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
"""
31
31
 
32
32
 
33
33
# 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 
 
34
# python exceptions?   A list of values with no names seems less useful
35
35
# to me.
36
36
 
37
 
# 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
38
38
# constructed to make sure it will succeed.  But that says nothing about
39
39
# exceptions that are never raised.
40
40
 
61
61
    :cvar _fmt: Format string to display the error; this is expanded
62
62
    by the instance's dict.
63
63
    """
64
 
    
 
64
 
65
65
    internal_error = False
66
66
 
67
67
    def __init__(self, msg=None, **kwds):
72
72
        arguments can be given.  The first is for generic "user" errors which
73
73
        are not intended to be caught and so do not need a specific subclass.
74
74
        The second case is for use with subclasses that provide a _fmt format
75
 
        string to print the arguments.  
 
75
        string to print the arguments.
76
76
 
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 
 
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
80
80
        parameters.
81
81
 
82
82
        :param msg: If given, this is the literal complete text for the error,
154
154
               )
155
155
 
156
156
    def __eq__(self, other):
157
 
        if self.__class__ != other.__class__:
 
157
        if self.__class__ is not other.__class__:
158
158
            return NotImplemented
159
159
        return self.__dict__ == other.__dict__
160
160
 
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):
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.")
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
 
639
649
class UnstackableRepositoryFormat(BzrError):
640
650
 
641
651
    _fmt = ("The repository '%(url)s'(%(format)s) is not a stackable format. "
648
658
 
649
659
 
650
660
class ReadError(PathError):
651
 
    
 
661
 
652
662
    _fmt = """Error reading from %(path)r."""
653
663
 
654
664
 
670
680
 
671
681
    _fmt = 'Path "%(path)s" is not a child of path "%(base)s"%(extra)s'
672
682
 
673
 
    internal_error = True
 
683
    internal_error = False
674
684
 
675
685
    def __init__(self, path, base, extra=None):
676
686
        BzrError.__init__(self)
689
699
 
690
700
# TODO: This is given a URL; we try to unescape it but doing that from inside
691
701
# the exception object is a bit undesirable.
692
 
# TODO: Probably this behavior of should be a common superclass 
 
702
# TODO: Probably this behavior of should be a common superclass
693
703
class NotBranchError(PathError):
694
704
 
695
 
    _fmt = 'Not a branch: "%(path)s".'
 
705
    _fmt = 'Not a branch: "%(path)s"%(detail)s.'
696
706
 
697
 
    def __init__(self, path):
 
707
    def __init__(self, path, detail=None, bzrdir=None):
698
708
       import bzrlib.urlutils as urlutils
699
 
       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 _format(self):
 
717
        # XXX: Ideally self.detail would be a property, but Exceptions in
 
718
        # Python 2.4 have to be old-style classes so properties don't work.
 
719
        # Instead we override _format.
 
720
        if self.detail is None:
 
721
            if self.bzrdir is not None:
 
722
                try:
 
723
                    self.bzrdir.open_repository()
 
724
                except NoRepositoryPresent:
 
725
                    self.detail = ''
 
726
                else:
 
727
                    self.detail = ': location is a repository'
 
728
            else:
 
729
                self.detail = ''
 
730
        return PathError._format(self)
700
731
 
701
732
 
702
733
class NoSubmitBranch(PathError):
751
782
 
752
783
    _fmt = 'File "%(path)s" is not in branch %(branch_base)s.'
753
784
 
 
785
    # use PathNotChild instead
 
786
    @symbol_versioning.deprecated_method(symbol_versioning.deprecated_in((2, 3, 0)))
754
787
    def __init__(self, branch, path):
755
788
        BzrError.__init__(self)
756
789
        self.branch = branch
764
797
 
765
798
 
766
799
class UnknownFormatError(BzrError):
767
 
    
 
800
 
768
801
    _fmt = "Unknown %(kind)s format: %(format)r"
769
802
 
770
803
    def __init__(self, format, kind='branch'):
773
806
 
774
807
 
775
808
class IncompatibleFormat(BzrError):
776
 
    
 
809
 
777
810
    _fmt = "Format %(format)s is not compatible with .bzr version %(bzrdir)s."
778
811
 
779
812
    def __init__(self, format, bzrdir_format):
783
816
 
784
817
 
785
818
class IncompatibleRepositories(BzrError):
 
819
    """Report an error that two repositories are not compatible.
 
820
 
 
821
    Note that the source and target repositories are permitted to be strings:
 
822
    this exception is thrown from the smart server and may refer to a
 
823
    repository the client hasn't opened.
 
824
    """
786
825
 
787
826
    _fmt = "%(target)s\n" \
788
827
            "is not compatible with\n" \
796
835
 
797
836
 
798
837
class IncompatibleRevision(BzrError):
799
 
    
 
838
 
800
839
    _fmt = "Revision is not compatible with %(repo_format)s"
801
840
 
802
841
    def __init__(self, repo_format):
910
949
    # original exception is available as e.original_error
911
950
    #
912
951
    # New code should prefer to raise specific subclasses
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
 
952
    def __init__(self, msg):
 
953
        self.msg = msg
918
954
 
919
955
 
920
956
class LockActive(LockError):
1003
1039
 
1004
1040
class LockContention(LockError):
1005
1041
 
1006
 
    _fmt = 'Could not acquire lock "%(lock)s"'
1007
 
    # TODO: show full url for lock, combining the transport and relative
1008
 
    # bits?
 
1042
    _fmt = 'Could not acquire lock "%(lock)s": %(msg)s'
1009
1043
 
1010
1044
    internal_error = False
1011
1045
 
1012
 
    def __init__(self, lock):
 
1046
    def __init__(self, lock, msg=''):
1013
1047
        self.lock = lock
 
1048
        self.msg = msg
1014
1049
 
1015
1050
 
1016
1051
class LockBroken(LockError):
1130
1165
 
1131
1166
class NoSuchRevisionInTree(NoSuchRevision):
1132
1167
    """When using Tree.revision_tree, and the revision is not accessible."""
1133
 
    
 
1168
 
1134
1169
    _fmt = "The revision id {%(revision_id)s} is not present in the tree %(tree)s."
1135
1170
 
1136
1171
    def __init__(self, tree, revision_id):
1141
1176
 
1142
1177
class InvalidRevisionSpec(BzrError):
1143
1178
 
1144
 
    _fmt = ("Requested revision: %(spec)r does not exist in branch:"
1145
 
            " %(branch)s%(extra)s")
 
1179
    _fmt = ("Requested revision: '%(spec)s' does not exist in branch:"
 
1180
            " %(branch_url)s%(extra)s")
1146
1181
 
1147
1182
    def __init__(self, spec, branch, extra=None):
1148
1183
        BzrError.__init__(self, branch=branch, spec=spec)
 
1184
        self.branch_url = getattr(branch, 'user_url', str(branch))
1149
1185
        if extra:
1150
1186
            self.extra = '\n' + str(extra)
1151
1187
        else:
1172
1208
class DivergedBranches(BzrError):
1173
1209
 
1174
1210
    _fmt = ("These branches have diverged."
1175
 
            " Use the merge command to reconcile them.")
 
1211
            " Use the missing command to see how.\n"
 
1212
            "Use the merge command to reconcile them.")
1176
1213
 
1177
1214
    def __init__(self, branch1, branch2):
1178
1215
        self.branch1 = branch1
1200
1237
 
1201
1238
 
1202
1239
class NoCommonAncestor(BzrError):
1203
 
    
 
1240
 
1204
1241
    _fmt = "Revisions have no common ancestor: %(revision_a)s %(revision_b)s"
1205
1242
 
1206
1243
    def __init__(self, revision_a, revision_b):
1226
1263
            not_ancestor_id=not_ancestor_id)
1227
1264
 
1228
1265
 
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
 
 
1238
1266
class AmbiguousBase(BzrError):
1239
1267
 
1240
1268
    def __init__(self, bases):
1241
 
        warn("BzrError AmbiguousBase has been deprecated as of bzrlib 0.8.",
1242
 
                DeprecationWarning)
 
1269
        symbol_versioning.warn("BzrError AmbiguousBase has been deprecated "
 
1270
            "as of bzrlib 0.8.", DeprecationWarning, stacklevel=2)
1243
1271
        msg = ("The correct base is unclear, because %s are all equally close"
1244
1272
                % ", ".join(bases))
1245
1273
        BzrError.__init__(self, msg)
1267
1295
class BoundBranchOutOfDate(BzrError):
1268
1296
 
1269
1297
    _fmt = ("Bound branch %(branch)s is out of date with master branch"
1270
 
            " %(master)s.")
 
1298
            " %(master)s.%(extra_help)s")
1271
1299
 
1272
1300
    def __init__(self, branch, master):
1273
1301
        BzrError.__init__(self)
1274
1302
        self.branch = branch
1275
1303
        self.master = master
1276
 
 
1277
 
        
 
1304
        self.extra_help = ''
 
1305
 
 
1306
 
1278
1307
class CommitToDoubleBoundBranch(BzrError):
1279
1308
 
1280
1309
    _fmt = ("Cannot commit to branch %(branch)s."
1349
1378
 
1350
1379
class WeaveParentMismatch(WeaveError):
1351
1380
 
1352
 
    _fmt = "Parents are mismatched between two revisions. %(message)s"
1353
 
    
 
1381
    _fmt = "Parents are mismatched between two revisions. %(msg)s"
 
1382
 
1354
1383
 
1355
1384
class WeaveInvalidChecksum(WeaveError):
1356
1385
 
1357
 
    _fmt = "Text did not match it's checksum: %(message)s"
 
1386
    _fmt = "Text did not match it's checksum: %(msg)s"
1358
1387
 
1359
1388
 
1360
1389
class WeaveTextDiffers(WeaveError):
1382
1411
 
1383
1412
 
1384
1413
class VersionedFileError(BzrError):
1385
 
    
 
1414
 
1386
1415
    _fmt = "Versioned file error"
1387
1416
 
1388
1417
 
1389
1418
class RevisionNotPresent(VersionedFileError):
1390
 
    
 
1419
 
1391
1420
    _fmt = 'Revision {%(revision_id)s} not present in "%(file_id)s".'
1392
1421
 
1393
1422
    def __init__(self, revision_id, file_id):
1397
1426
 
1398
1427
 
1399
1428
class RevisionAlreadyPresent(VersionedFileError):
1400
 
    
 
1429
 
1401
1430
    _fmt = 'Revision {%(revision_id)s} already present in "%(file_id)s".'
1402
1431
 
1403
1432
    def __init__(self, revision_id, file_id):
1408
1437
 
1409
1438
class VersionedFileInvalidChecksum(VersionedFileError):
1410
1439
 
1411
 
    _fmt = "Text did not match its checksum: %(message)s"
 
1440
    _fmt = "Text did not match its checksum: %(msg)s"
1412
1441
 
1413
1442
 
1414
1443
class KnitError(InternalBzrError):
1415
 
    
 
1444
 
1416
1445
    _fmt = "Knit error"
1417
1446
 
1418
1447
 
1450
1479
    def __init__(self, stream_format, target_format):
1451
1480
        self.stream_format = stream_format
1452
1481
        self.target_format = target_format
1453
 
        
 
1482
 
1454
1483
 
1455
1484
class KnitDataStreamUnknown(KnitError):
1456
1485
    # Indicates a data stream we don't know how to handle.
1459
1488
 
1460
1489
    def __init__(self, stream_format):
1461
1490
        self.stream_format = stream_format
1462
 
        
 
1491
 
1463
1492
 
1464
1493
class KnitHeaderError(KnitError):
1465
1494
 
1475
1504
 
1476
1505
    Currently only 'fulltext' and 'line-delta' are supported.
1477
1506
    """
1478
 
    
 
1507
 
1479
1508
    _fmt = ("Knit index %(filename)s does not have a known method"
1480
1509
            " in options: %(options)r")
1481
1510
 
1532
1561
 
1533
1562
 
1534
1563
class NoSuchExportFormat(BzrError):
1535
 
    
 
1564
 
1536
1565
    _fmt = "Export format %(format)r not supported"
1537
1566
 
1538
1567
    def __init__(self, format):
1541
1570
 
1542
1571
 
1543
1572
class TransportError(BzrError):
1544
 
    
 
1573
 
1545
1574
    _fmt = "Transport error: %(msg)s %(orig_error)s"
1546
1575
 
1547
1576
    def __init__(self, msg=None, orig_error=None):
1634
1663
            self.port = ':%s' % port
1635
1664
 
1636
1665
 
 
1666
# XXX: This is also used for unexpected end of file, which is different at the
 
1667
# TCP level from "connection reset".
1637
1668
class ConnectionReset(TransportError):
1638
1669
 
1639
1670
    _fmt = "Connection closed: %(msg)s %(orig_error)s"
1729
1760
 
1730
1761
class WorkingTreeNotRevision(BzrError):
1731
1762
 
1732
 
    _fmt = ("The working tree for %(basedir)s has changed since" 
 
1763
    _fmt = ("The working tree for %(basedir)s has changed since"
1733
1764
            " the last commit, but weave merge requires that it be"
1734
1765
            " unchanged")
1735
1766
 
1892
1923
    _fmt = "Moving the root directory is not supported at this time"
1893
1924
 
1894
1925
 
 
1926
class TransformRenameFailed(BzrError):
 
1927
 
 
1928
    _fmt = "Failed to rename %(from_path)s to %(to_path)s: %(why)s"
 
1929
 
 
1930
    def __init__(self, from_path, to_path, why, errno):
 
1931
        self.from_path = from_path
 
1932
        self.to_path = to_path
 
1933
        self.why = why
 
1934
        self.errno = errno
 
1935
 
 
1936
 
1895
1937
class BzrMoveFailedError(BzrError):
1896
1938
 
1897
1939
    _fmt = "Could not move %(from_path)s%(operator)s %(to_path)s%(extra)s"
1942
1984
        "Use --keep to not delete them, or --force to delete them regardless.")
1943
1985
 
1944
1986
    def __init__(self, tree_delta):
 
1987
        symbol_versioning.warn(symbol_versioning.deprecated_in((2, 3, 0)) %
 
1988
            "BzrRemoveChangedFilesError", DeprecationWarning, stacklevel=2)
1945
1989
        BzrError.__init__(self)
1946
1990
        self.changes_as_text = tree_delta.get_changes_as_text()
1947
1991
        #self.paths_as_string = '\n'.join(changed_files)
2001
2045
 
2002
2046
class BadConversionTarget(BzrError):
2003
2047
 
2004
 
    _fmt = "Cannot convert to format %(format)s.  %(problem)s"
 
2048
    _fmt = "Cannot convert from format %(from_format)s to format %(format)s." \
 
2049
            "    %(problem)s"
2005
2050
 
2006
 
    def __init__(self, problem, format):
 
2051
    def __init__(self, problem, format, from_format=None):
2007
2052
        BzrError.__init__(self)
2008
2053
        self.problem = problem
2009
2054
        self.format = format
 
2055
        self.from_format = from_format or '(unspecified)'
2010
2056
 
2011
2057
 
2012
2058
class NoDiffFound(BzrError):
2049
2095
    _fmt = """This tree contains left-over files from a failed operation.
2050
2096
    Please examine %(limbo_dir)s to see if it contains any files you wish to
2051
2097
    keep, and delete it when you are done."""
2052
 
    
 
2098
 
2053
2099
    def __init__(self, limbo_dir):
2054
2100
       BzrError.__init__(self)
2055
2101
       self.limbo_dir = limbo_dir
2088
2134
 
2089
2135
class OutOfDateTree(BzrError):
2090
2136
 
2091
 
    _fmt = "Working tree is out of date, please run 'bzr update'."
 
2137
    _fmt = "Working tree is out of date, please run 'bzr update'.%(more)s"
2092
2138
 
2093
 
    def __init__(self, tree):
 
2139
    def __init__(self, tree, more=None):
 
2140
        if more is None:
 
2141
            more = ''
 
2142
        else:
 
2143
            more = ' ' + more
2094
2144
        BzrError.__init__(self)
2095
2145
        self.tree = tree
 
2146
        self.more = more
2096
2147
 
2097
2148
 
2098
2149
class PublicBranchOutOfDate(BzrError):
2136
2187
 
2137
2188
    def __init__(self, repo):
2138
2189
        BzrError.__init__(self)
2139
 
        self.repo_path = repo.bzrdir.root_transport.base
 
2190
        self.repo_path = repo.user_url
2140
2191
 
2141
2192
 
2142
2193
class InconsistentDelta(BzrError):
2152
2203
        self.reason = reason
2153
2204
 
2154
2205
 
 
2206
class InconsistentDeltaDelta(InconsistentDelta):
 
2207
    """Used when we get a delta that is not valid."""
 
2208
 
 
2209
    _fmt = ("An inconsistent delta was supplied: %(delta)r"
 
2210
            "\nreason: %(reason)s")
 
2211
 
 
2212
    def __init__(self, delta, reason):
 
2213
        BzrError.__init__(self)
 
2214
        self.delta = delta
 
2215
        self.reason = reason
 
2216
 
 
2217
 
2155
2218
class UpgradeRequired(BzrError):
2156
2219
 
2157
2220
    _fmt = "To use this feature you must upgrade your branch at %(path)s."
2166
2229
    _fmt = "To use this feature you must upgrade your repository at %(path)s."
2167
2230
 
2168
2231
 
 
2232
class RichRootUpgradeRequired(UpgradeRequired):
 
2233
 
 
2234
    _fmt = ("To use this feature you must upgrade your branch at %(path)s to"
 
2235
           " a format which supports rich roots.")
 
2236
 
 
2237
 
2169
2238
class LocalRequiresBoundBranch(BzrError):
2170
2239
 
2171
2240
    _fmt = "Cannot perform local-only commits on unbound branches."
2172
2241
 
2173
2242
 
2174
 
class InvalidProgressBarType(BzrError):
2175
 
 
2176
 
    _fmt = ("Environment variable BZR_PROGRESS_BAR='%(bar_type)s"
2177
 
            " is not a supported type Select one of: %(valid_types)s")
2178
 
 
2179
 
    def __init__(self, bar_type, valid_types):
2180
 
        BzrError.__init__(self, bar_type=bar_type, valid_types=valid_types)
2181
 
 
2182
 
 
2183
2243
class UnsupportedOperation(BzrError):
2184
2244
 
2185
2245
    _fmt = ("The method %(mname)s is not supported on"
2202
2262
 
2203
2263
 
2204
2264
class BinaryFile(BzrError):
2205
 
    
 
2265
 
2206
2266
    _fmt = "File is binary but should be text."
2207
2267
 
2208
2268
 
2228
2288
 
2229
2289
 
2230
2290
class NotABundle(BzrError):
2231
 
    
 
2291
 
2232
2292
    _fmt = "Not a bzr revision-bundle: %(text)r"
2233
2293
 
2234
2294
    def __init__(self, text):
2236
2296
        self.text = text
2237
2297
 
2238
2298
 
2239
 
class BadBundle(BzrError): 
2240
 
    
 
2299
class BadBundle(BzrError):
 
2300
 
2241
2301
    _fmt = "Bad bzr revision-bundle: %(text)r"
2242
2302
 
2243
2303
    def __init__(self, text):
2245
2305
        self.text = text
2246
2306
 
2247
2307
 
2248
 
class MalformedHeader(BadBundle): 
2249
 
    
 
2308
class MalformedHeader(BadBundle):
 
2309
 
2250
2310
    _fmt = "Malformed bzr revision-bundle header: %(text)r"
2251
2311
 
2252
2312
 
2253
 
class MalformedPatches(BadBundle): 
2254
 
    
 
2313
class MalformedPatches(BadBundle):
 
2314
 
2255
2315
    _fmt = "Malformed patches in bzr revision-bundle: %(text)r"
2256
2316
 
2257
2317
 
2258
 
class MalformedFooter(BadBundle): 
2259
 
    
 
2318
class MalformedFooter(BadBundle):
 
2319
 
2260
2320
    _fmt = "Malformed footer in bzr revision-bundle: %(text)r"
2261
2321
 
2262
2322
 
2263
2323
class UnsupportedEOLMarker(BadBundle):
2264
 
    
2265
 
    _fmt = "End of line marker was not \\n in bzr revision-bundle"    
 
2324
 
 
2325
    _fmt = "End of line marker was not \\n in bzr revision-bundle"
2266
2326
 
2267
2327
    def __init__(self):
2268
 
        # XXX: BadBundle's constructor assumes there's explanatory text, 
 
2328
        # XXX: BadBundle's constructor assumes there's explanatory text,
2269
2329
        # but for this there is not
2270
2330
        BzrError.__init__(self)
2271
2331
 
2272
2332
 
2273
2333
class IncompatibleBundleFormat(BzrError):
2274
 
    
 
2334
 
2275
2335
    _fmt = "Bundle format %(bundle_format)s is incompatible with %(other)s"
2276
2336
 
2277
2337
    def __init__(self, bundle_format, other):
2281
2341
 
2282
2342
 
2283
2343
class BadInventoryFormat(BzrError):
2284
 
    
 
2344
 
2285
2345
    _fmt = "Root class for inventory serialization errors"
2286
2346
 
2287
2347
 
2306
2366
        self.transport = transport
2307
2367
 
2308
2368
 
2309
 
class NoSmartServer(NotBranchError):
2310
 
 
2311
 
    _fmt = "No smart server available at %(url)s"
2312
 
 
2313
 
    @symbol_versioning.deprecated_method(symbol_versioning.one_four)
2314
 
    def __init__(self, url):
2315
 
        self.url = url
2316
 
 
2317
 
 
2318
2369
class UnknownSSH(BzrError):
2319
2370
 
2320
2371
    _fmt = "Unrecognised value for BZR_SSH environment variable: %(vendor)s"
2340
2391
        self.revision_id = revision_id
2341
2392
        self.ghost_revision_id = ghost_revision_id
2342
2393
 
2343
 
        
 
2394
 
2344
2395
class GhostRevisionUnusableHere(BzrError):
2345
2396
 
2346
2397
    _fmt = "Ghost revision {%(revision_id)s} cannot be used here."
2438
2489
 
2439
2490
 
2440
2491
class UnsupportedInventoryKind(BzrError):
2441
 
    
 
2492
 
2442
2493
    _fmt = """Unsupported entry kind %(kind)s"""
2443
2494
 
2444
2495
    def __init__(self, kind):
2456
2507
 
2457
2508
 
2458
2509
class SubsumeTargetNeedsUpgrade(BzrError):
2459
 
    
 
2510
 
2460
2511
    _fmt = """Subsume target %(other_tree)s needs to be upgraded."""
2461
2512
 
2462
2513
    def __init__(self, other_tree):
2490
2541
    def __init__(self, branch):
2491
2542
        self.branch = branch
2492
2543
 
2493
 
        
 
2544
 
2494
2545
class TagAlreadyExists(BzrError):
2495
2546
 
2496
2547
    _fmt = "Tag %(tag_name)s already exists."
2501
2552
 
2502
2553
class MalformedBugIdentifier(BzrError):
2503
2554
 
2504
 
    _fmt = "Did not understand bug identifier %(bug_id)s: %(reason)s"
 
2555
    _fmt = ('Did not understand bug identifier %(bug_id)s: %(reason)s. '
 
2556
            'See "bzr help bugs" for more information on this feature.')
2505
2557
 
2506
2558
    def __init__(self, bug_id, reason):
2507
2559
        self.bug_id = bug_id
2528
2580
        self.branch = branch
2529
2581
 
2530
2582
 
 
2583
class InvalidLineInBugsProperty(BzrError):
 
2584
 
 
2585
    _fmt = ("Invalid line in bugs property: '%(line)s'")
 
2586
 
 
2587
    def __init__(self, line):
 
2588
        self.line = line
 
2589
 
 
2590
 
 
2591
class InvalidBugStatus(BzrError):
 
2592
 
 
2593
    _fmt = ("Invalid bug status: '%(status)s'")
 
2594
 
 
2595
    def __init__(self, status):
 
2596
        self.status = status
 
2597
 
 
2598
 
2531
2599
class UnexpectedSmartServerResponse(BzrError):
2532
2600
 
2533
2601
    _fmt = "Could not understand response from smart server: %(response_tuple)r"
2579
2647
        """
2580
2648
        self.error_from_smart_server = error_from_smart_server
2581
2649
        self.error_tuple = error_from_smart_server.error_tuple
2582
 
        
 
2650
 
2583
2651
 
2584
2652
class ContainerError(BzrError):
2585
2653
    """Base class of container errors."""
2588
2656
class UnknownContainerFormatError(ContainerError):
2589
2657
 
2590
2658
    _fmt = "Unrecognised container format: %(container_format)r"
2591
 
    
 
2659
 
2592
2660
    def __init__(self, container_format):
2593
2661
        self.container_format = container_format
2594
2662
 
2697
2765
 
2698
2766
    def __init__(self, bzrdir):
2699
2767
        import bzrlib.urlutils as urlutils
2700
 
        display_url = urlutils.unescape_for_display(bzrdir.root_transport.base,
 
2768
        display_url = urlutils.unescape_for_display(bzrdir.user_url,
2701
2769
                                                    'ascii')
2702
2770
        BzrError.__init__(self, bzrdir=bzrdir, display_url=display_url)
2703
2771
 
2768
2836
 
2769
2837
class UncommittedChanges(BzrError):
2770
2838
 
2771
 
    _fmt = 'Working tree "%(display_url)s" has uncommitted changes.'
 
2839
    _fmt = ('Working tree "%(display_url)s" has uncommitted changes'
 
2840
            ' (See bzr status).%(more)s')
2772
2841
 
2773
 
    def __init__(self, tree):
 
2842
    def __init__(self, tree, more=None):
 
2843
        if more is None:
 
2844
            more = ''
 
2845
        else:
 
2846
            more = ' ' + more
2774
2847
        import bzrlib.urlutils as urlutils
2775
 
        display_url = urlutils.unescape_for_display(
2776
 
            tree.bzrdir.root_transport.base, 'ascii')
2777
 
        BzrError.__init__(self, tree=tree, display_url=display_url)
 
2848
        user_url = getattr(tree, "user_url", None)
 
2849
        if user_url is None:
 
2850
            display_url = str(tree)
 
2851
        else:
 
2852
            display_url = urlutils.unescape_for_display(user_url, 'ascii')
 
2853
        BzrError.__init__(self, tree=tree, display_url=display_url, more=more)
 
2854
 
 
2855
 
 
2856
class ShelvedChanges(UncommittedChanges):
 
2857
 
 
2858
    _fmt = ('Working tree "%(display_url)s" has shelved changes'
 
2859
            ' (See bzr shelve --list).%(more)s')
2778
2860
 
2779
2861
 
2780
2862
class MissingTemplateVariable(BzrError):
2815
2897
 
2816
2898
 
2817
2899
class CommandAvailableInPlugin(StandardError):
2818
 
    
 
2900
 
2819
2901
    internal_error = False
2820
2902
 
2821
2903
    def __init__(self, cmd_name, plugin_metadata, provider):
2822
 
        
 
2904
 
2823
2905
        self.plugin_metadata = plugin_metadata
2824
2906
        self.cmd_name = cmd_name
2825
2907
        self.provider = provider
2826
2908
 
2827
2909
    def __str__(self):
2828
2910
 
2829
 
        _fmt = ('"%s" is not a standard bzr command. \n' 
 
2911
        _fmt = ('"%s" is not a standard bzr command. \n'
2830
2912
                'However, the following official plugin provides this command: %s\n'
2831
2913
                'You can install it by going to: %s'
2832
 
                % (self.cmd_name, self.plugin_metadata['name'], 
 
2914
                % (self.cmd_name, self.plugin_metadata['name'],
2833
2915
                    self.plugin_metadata['url']))
2834
2916
 
2835
2917
        return _fmt
2836
2918
 
2837
2919
 
2838
2920
class NoPluginAvailable(BzrError):
2839
 
    pass    
2840
 
 
2841
 
 
2842
 
class NotATerminal(BzrError):
2843
 
 
2844
 
    _fmt = 'Unable to ask for a password without real terminal.'
 
2921
    pass
2845
2922
 
2846
2923
 
2847
2924
class UnableEncodePath(BzrError):
2891
2968
    _fmt = 'Cannot bind address "%(host)s:%(port)i": %(orig_error)s.'
2892
2969
 
2893
2970
    def __init__(self, host, port, orig_error):
 
2971
        # nb: in python2.4 socket.error doesn't have a useful repr
2894
2972
        BzrError.__init__(self, host=host, port=port,
2895
 
            orig_error=orig_error[1])
 
2973
            orig_error=repr(orig_error.args))
2896
2974
 
2897
2975
 
2898
2976
class UnknownRules(BzrError):
2906
2984
class HookFailed(BzrError):
2907
2985
    """Raised when a pre_change_branch_tip hook function fails anything other
2908
2986
    than TipChangeRejected.
 
2987
 
 
2988
    Note that this exception is no longer raised, and the import is only left
 
2989
    to be nice to code which might catch it in a plugin.
2909
2990
    """
2910
2991
 
2911
2992
    _fmt = ("Hook '%(hook_name)s' during %(hook_stage)s failed:\n"
2912
2993
            "%(traceback_text)s%(exc_value)s")
2913
2994
 
2914
 
    def __init__(self, hook_stage, hook_name, exc_info):
 
2995
    def __init__(self, hook_stage, hook_name, exc_info, warn=True):
 
2996
        if warn:
 
2997
            symbol_versioning.warn("BzrError HookFailed has been deprecated "
 
2998
                "as of bzrlib 2.1.", DeprecationWarning, stacklevel=2)
2915
2999
        import traceback
2916
3000
        self.hook_stage = hook_stage
2917
3001
        self.hook_name = hook_name
2926
3010
    """A pre_change_branch_tip hook function may raise this to cleanly and
2927
3011
    explicitly abort a change to a branch tip.
2928
3012
    """
2929
 
    
 
3013
 
2930
3014
    _fmt = u"Tip change rejected: %(msg)s"
2931
3015
 
2932
3016
    def __init__(self, msg):
2954
3038
        BzrError.__init__(self, invalid_id=invalid_id)
2955
3039
 
2956
3040
 
 
3041
class JailBreak(BzrError):
 
3042
 
 
3043
    _fmt = "An attempt to access a url outside the server jail was made: '%(url)s'."
 
3044
 
 
3045
    def __init__(self, url):
 
3046
        BzrError.__init__(self, url=url)
 
3047
 
 
3048
 
2957
3049
class UserAbort(BzrError):
2958
3050
 
2959
3051
    _fmt = 'The user aborted the operation.'
2965
3057
 
2966
3058
    def __init__(self, format, url):
2967
3059
        BzrError.__init__(self, format=format, url=url)
 
3060
 
 
3061
 
 
3062
class NoSuchView(BzrError):
 
3063
    """A view does not exist.
 
3064
    """
 
3065
 
 
3066
    _fmt = u"No such view: %(view_name)s."
 
3067
 
 
3068
    def __init__(self, view_name):
 
3069
        self.view_name = view_name
 
3070
 
 
3071
 
 
3072
class ViewsNotSupported(BzrError):
 
3073
    """Views are not supported by a tree format.
 
3074
    """
 
3075
 
 
3076
    _fmt = ("Views are not supported by %(tree)s;"
 
3077
            " use 'bzr upgrade' to change your tree to a later format.")
 
3078
 
 
3079
    def __init__(self, tree):
 
3080
        self.tree = tree
 
3081
 
 
3082
 
 
3083
class FileOutsideView(BzrError):
 
3084
 
 
3085
    _fmt = ('Specified file "%(file_name)s" is outside the current view: '
 
3086
            '%(view_str)s')
 
3087
 
 
3088
    def __init__(self, file_name, view_files):
 
3089
        self.file_name = file_name
 
3090
        self.view_str = ", ".join(view_files)
 
3091
 
 
3092
 
 
3093
class UnresumableWriteGroup(BzrError):
 
3094
 
 
3095
    _fmt = ("Repository %(repository)s cannot resume write group "
 
3096
            "%(write_groups)r: %(reason)s")
 
3097
 
 
3098
    internal_error = True
 
3099
 
 
3100
    def __init__(self, repository, write_groups, reason):
 
3101
        self.repository = repository
 
3102
        self.write_groups = write_groups
 
3103
        self.reason = reason
 
3104
 
 
3105
 
 
3106
class UnsuspendableWriteGroup(BzrError):
 
3107
 
 
3108
    _fmt = ("Repository %(repository)s cannot suspend a write group.")
 
3109
 
 
3110
    internal_error = True
 
3111
 
 
3112
    def __init__(self, repository):
 
3113
        self.repository = repository
 
3114
 
 
3115
 
 
3116
class LossyPushToSameVCS(BzrError):
 
3117
 
 
3118
    _fmt = ("Lossy push not possible between %(source_branch)r and "
 
3119
            "%(target_branch)r that are in the same VCS.")
 
3120
 
 
3121
    internal_error = True
 
3122
 
 
3123
    def __init__(self, source_branch, target_branch):
 
3124
        self.source_branch = source_branch
 
3125
        self.target_branch = target_branch
 
3126
 
 
3127
 
 
3128
class NoRoundtrippingSupport(BzrError):
 
3129
 
 
3130
    _fmt = ("Roundtripping is not supported between %(source_branch)r and "
 
3131
            "%(target_branch)r.")
 
3132
 
 
3133
    internal_error = True
 
3134
 
 
3135
    def __init__(self, source_branch, target_branch):
 
3136
        self.source_branch = source_branch
 
3137
        self.target_branch = target_branch
 
3138
 
 
3139
 
 
3140
class FileTimestampUnavailable(BzrError):
 
3141
 
 
3142
    _fmt = "The filestamp for %(path)s is not available."
 
3143
 
 
3144
    internal_error = True
 
3145
 
 
3146
    def __init__(self, path):
 
3147
        self.path = path
 
3148
 
 
3149
 
 
3150
class NoColocatedBranchSupport(BzrError):
 
3151
 
 
3152
    _fmt = ("%(bzrdir)r does not support co-located branches.")
 
3153
 
 
3154
    def __init__(self, bzrdir):
 
3155
        self.bzrdir = bzrdir
 
3156
 
 
3157
 
 
3158
class NoWhoami(BzrError):
 
3159
 
 
3160
    _fmt = ('Unable to determine your name.\n'
 
3161
        "Please, set your name with the 'whoami' command.\n"
 
3162
        'E.g. bzr whoami "Your Name <name@example.com>"')
 
3163
 
 
3164
 
 
3165
class InvalidPattern(BzrError):
 
3166
 
 
3167
    _fmt = ('Invalid pattern(s) found. %(msg)s')
 
3168
 
 
3169
    def __init__(self, msg):
 
3170
        self.msg = msg
 
3171
 
 
3172
 
 
3173
class RecursiveBind(BzrError):
 
3174
 
 
3175
    _fmt = ('Branch "%(branch_url)s" appears to be bound to itself. '
 
3176
        'Please use `bzr unbind` to fix.')
 
3177
 
 
3178
    def __init__(self, branch_url):
 
3179
        self.branch_url = branch_url
 
3180