← 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: 2009-08-24 21:25:26 UTC
  • mfrom: (4641.1.1 integration)
  • Revision ID: pqm@pqm.ubuntu.com-20090824212526-5j41jw5zsciji66e
(robertc) Back out draft documentation change landed as 'selftest
        improvements'. (Robert Collins)

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/errors.py
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
 
62
61
    :cvar _fmt: Format string to display the error; this is expanded
63
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,
84
 
        not subject to expansion.
 
83
           not subject to expansion. 'msg' is used instead of 'message' because
 
84
           python evolved and, in 2.6, forbids the use of 'message'.
85
85
        """
86
86
        StandardError.__init__(self)
87
87
        if msg is not None:
102
102
            fmt = self._get_format_string()
103
103
            if fmt:
104
104
                d = dict(self.__dict__)
105
 
                # special case: python2.5 puts the 'message' attribute in a
106
 
                # slot, so it isn't seen in __dict__
107
 
                d['message'] = getattr(self, 'message', 'no message')
108
105
                s = fmt % d
109
106
                # __str__() should always return a 'str' object
110
107
                # never a 'unicode' object.
126
123
            # return a unicode object.
127
124
            u = unicode(u)
128
125
        return u
129
 
    
 
126
 
130
127
    def __str__(self):
131
128
        s = self._format()
132
129
        if isinstance(s, unicode):
136
133
            s = str(s)
137
134
        return s
138
135
 
 
136
    def __repr__(self):
 
137
        return '%s(%s)' % (self.__class__.__name__, str(self))
 
138
 
139
139
    def _get_format_string(self):
140
140
        """Return format string for this exception or None"""
141
141
        fmt = getattr(self, '_fmt', None)
154
154
               )
155
155
 
156
156
    def __eq__(self, other):
157
 
        if self.__class__ != other.__class__:
 
157
        if self.__class__ is not other.__class__:
158
158
            return NotImplemented
159
159
        return self.__dict__ == other.__dict__
160
160
 
204
204
 
205
205
 
206
206
class AlreadyBuilding(BzrError):
207
 
    
 
207
 
208
208
    _fmt = "The tree builder is already building a tree."
209
209
 
210
210
 
216
216
 
217
217
 
218
218
class BzrCheckError(InternalBzrError):
219
 
    
220
 
    _fmt = "Internal check failed: %(message)s"
221
 
 
222
 
    def __init__(self, message):
 
219
 
 
220
    _fmt = "Internal check failed: %(msg)s"
 
221
 
 
222
    def __init__(self, msg):
223
223
        BzrError.__init__(self)
224
 
        self.message = message
 
224
        self.msg = msg
225
225
 
226
226
 
227
227
class DirstateCorrupt(BzrError):
265
265
 
266
266
 
267
267
class InvalidEntryName(InternalBzrError):
268
 
    
 
268
 
269
269
    _fmt = "Invalid entry name: %(name)s"
270
270
 
271
271
    def __init__(self, name):
274
274
 
275
275
 
276
276
class InvalidRevisionNumber(BzrError):
277
 
    
 
277
 
278
278
    _fmt = "Invalid revision number %(revno)s"
279
279
 
280
280
    def __init__(self, revno):
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
 
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
705
    _fmt = 'Not a branch: "%(path)s".'
764
774
 
765
775
 
766
776
class UnknownFormatError(BzrError):
767
 
    
 
777
 
768
778
    _fmt = "Unknown %(kind)s format: %(format)r"
769
779
 
770
780
    def __init__(self, format, kind='branch'):
773
783
 
774
784
 
775
785
class IncompatibleFormat(BzrError):
776
 
    
 
786
 
777
787
    _fmt = "Format %(format)s is not compatible with .bzr version %(bzrdir)s."
778
788
 
779
789
    def __init__(self, format, bzrdir_format):
796
806
 
797
807
 
798
808
class IncompatibleRevision(BzrError):
799
 
    
 
809
 
800
810
    _fmt = "Revision is not compatible with %(repo_format)s"
801
811
 
802
812
    def __init__(self, repo_format):
1003
1013
 
1004
1014
class LockContention(LockError):
1005
1015
 
1006
 
    _fmt = 'Could not acquire lock "%(lock)s"'
 
1016
    _fmt = 'Could not acquire lock "%(lock)s": %(msg)s'
1007
1017
    # TODO: show full url for lock, combining the transport and relative
1008
1018
    # bits?
1009
1019
 
1010
1020
    internal_error = False
1011
1021
 
1012
 
    def __init__(self, lock):
 
1022
    def __init__(self, lock, msg=''):
1013
1023
        self.lock = lock
 
1024
        self.msg = msg
1014
1025
 
1015
1026
 
1016
1027
class LockBroken(LockError):
1130
1141
 
1131
1142
class NoSuchRevisionInTree(NoSuchRevision):
1132
1143
    """When using Tree.revision_tree, and the revision is not accessible."""
1133
 
    
 
1144
 
1134
1145
    _fmt = "The revision id {%(revision_id)s} is not present in the tree %(tree)s."
1135
1146
 
1136
1147
    def __init__(self, tree, revision_id):
1172
1183
class DivergedBranches(BzrError):
1173
1184
 
1174
1185
    _fmt = ("These branches have diverged."
1175
 
            " Use the merge command to reconcile them.")
 
1186
            " Use the missing command to see how.\n"
 
1187
            "Use the merge command to reconcile them.")
1176
1188
 
1177
1189
    def __init__(self, branch1, branch2):
1178
1190
        self.branch1 = branch1
1200
1212
 
1201
1213
 
1202
1214
class NoCommonAncestor(BzrError):
1203
 
    
 
1215
 
1204
1216
    _fmt = "Revisions have no common ancestor: %(revision_a)s %(revision_b)s"
1205
1217
 
1206
1218
    def __init__(self, revision_a, revision_b):
1226
1238
            not_ancestor_id=not_ancestor_id)
1227
1239
 
1228
1240
 
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
1241
class AmbiguousBase(BzrError):
1239
1242
 
1240
1243
    def __init__(self, bases):
1274
1277
        self.branch = branch
1275
1278
        self.master = master
1276
1279
 
1277
 
        
 
1280
 
1278
1281
class CommitToDoubleBoundBranch(BzrError):
1279
1282
 
1280
1283
    _fmt = ("Cannot commit to branch %(branch)s."
1310
1313
 
1311
1314
class WeaveError(BzrError):
1312
1315
 
1313
 
    _fmt = "Error in processing weave: %(message)s"
 
1316
    _fmt = "Error in processing weave: %(msg)s"
1314
1317
 
1315
 
    def __init__(self, message=None):
 
1318
    def __init__(self, msg=None):
1316
1319
        BzrError.__init__(self)
1317
 
        self.message = message
 
1320
        self.msg = msg
1318
1321
 
1319
1322
 
1320
1323
class WeaveRevisionAlreadyPresent(WeaveError):
1350
1353
class WeaveParentMismatch(WeaveError):
1351
1354
 
1352
1355
    _fmt = "Parents are mismatched between two revisions. %(message)s"
1353
 
    
 
1356
 
1354
1357
 
1355
1358
class WeaveInvalidChecksum(WeaveError):
1356
1359
 
1382
1385
 
1383
1386
 
1384
1387
class VersionedFileError(BzrError):
1385
 
    
 
1388
 
1386
1389
    _fmt = "Versioned file error"
1387
1390
 
1388
1391
 
1389
1392
class RevisionNotPresent(VersionedFileError):
1390
 
    
 
1393
 
1391
1394
    _fmt = 'Revision {%(revision_id)s} not present in "%(file_id)s".'
1392
1395
 
1393
1396
    def __init__(self, revision_id, file_id):
1397
1400
 
1398
1401
 
1399
1402
class RevisionAlreadyPresent(VersionedFileError):
1400
 
    
 
1403
 
1401
1404
    _fmt = 'Revision {%(revision_id)s} already present in "%(file_id)s".'
1402
1405
 
1403
1406
    def __init__(self, revision_id, file_id):
1412
1415
 
1413
1416
 
1414
1417
class KnitError(InternalBzrError):
1415
 
    
 
1418
 
1416
1419
    _fmt = "Knit error"
1417
1420
 
1418
1421
 
1426
1429
        self.how = how
1427
1430
 
1428
1431
 
 
1432
class SHA1KnitCorrupt(KnitCorrupt):
 
1433
 
 
1434
    _fmt = ("Knit %(filename)s corrupt: sha-1 of reconstructed text does not "
 
1435
        "match expected sha-1. key %(key)s expected sha %(expected)s actual "
 
1436
        "sha %(actual)s")
 
1437
 
 
1438
    def __init__(self, filename, actual, expected, key, content):
 
1439
        KnitError.__init__(self)
 
1440
        self.filename = filename
 
1441
        self.actual = actual
 
1442
        self.expected = expected
 
1443
        self.key = key
 
1444
        self.content = content
 
1445
 
 
1446
 
1429
1447
class KnitDataStreamIncompatible(KnitError):
1430
1448
    # Not raised anymore, as we can convert data streams.  In future we may
1431
1449
    # need it again for more exotic cases, so we're keeping it around for now.
1435
1453
    def __init__(self, stream_format, target_format):
1436
1454
        self.stream_format = stream_format
1437
1455
        self.target_format = target_format
1438
 
        
 
1456
 
1439
1457
 
1440
1458
class KnitDataStreamUnknown(KnitError):
1441
1459
    # Indicates a data stream we don't know how to handle.
1444
1462
 
1445
1463
    def __init__(self, stream_format):
1446
1464
        self.stream_format = stream_format
1447
 
        
 
1465
 
1448
1466
 
1449
1467
class KnitHeaderError(KnitError):
1450
1468
 
1460
1478
 
1461
1479
    Currently only 'fulltext' and 'line-delta' are supported.
1462
1480
    """
1463
 
    
 
1481
 
1464
1482
    _fmt = ("Knit index %(filename)s does not have a known method"
1465
1483
            " in options: %(options)r")
1466
1484
 
1470
1488
        self.options = options
1471
1489
 
1472
1490
 
 
1491
class RetryWithNewPacks(BzrError):
 
1492
    """Raised when we realize that the packs on disk have changed.
 
1493
 
 
1494
    This is meant as more of a signaling exception, to trap between where a
 
1495
    local error occurred and the code that can actually handle the error and
 
1496
    code that can retry appropriately.
 
1497
    """
 
1498
 
 
1499
    internal_error = True
 
1500
 
 
1501
    _fmt = ("Pack files have changed, reload and retry. context: %(context)s"
 
1502
            " %(orig_error)s")
 
1503
 
 
1504
    def __init__(self, context, reload_occurred, exc_info):
 
1505
        """create a new RetryWithNewPacks error.
 
1506
 
 
1507
        :param reload_occurred: Set to True if we know that the packs have
 
1508
            already been reloaded, and we are failing because of an in-memory
 
1509
            cache miss. If set to True then we will ignore if a reload says
 
1510
            nothing has changed, because we assume it has already reloaded. If
 
1511
            False, then a reload with nothing changed will force an error.
 
1512
        :param exc_info: The original exception traceback, so if there is a
 
1513
            problem we can raise the original error (value from sys.exc_info())
 
1514
        """
 
1515
        BzrError.__init__(self)
 
1516
        self.reload_occurred = reload_occurred
 
1517
        self.exc_info = exc_info
 
1518
        self.orig_error = exc_info[1]
 
1519
        # TODO: The global error handler should probably treat this by
 
1520
        #       raising/printing the original exception with a bit about
 
1521
        #       RetryWithNewPacks also not being caught
 
1522
 
 
1523
 
 
1524
class RetryAutopack(RetryWithNewPacks):
 
1525
    """Raised when we are autopacking and we find a missing file.
 
1526
 
 
1527
    Meant as a signaling exception, to tell the autopack code it should try
 
1528
    again.
 
1529
    """
 
1530
 
 
1531
    internal_error = True
 
1532
 
 
1533
    _fmt = ("Pack files have changed, reload and try autopack again."
 
1534
            " context: %(context)s %(orig_error)s")
 
1535
 
 
1536
 
1473
1537
class NoSuchExportFormat(BzrError):
1474
 
    
 
1538
 
1475
1539
    _fmt = "Export format %(format)r not supported"
1476
1540
 
1477
1541
    def __init__(self, format):
1480
1544
 
1481
1545
 
1482
1546
class TransportError(BzrError):
1483
 
    
 
1547
 
1484
1548
    _fmt = "Transport error: %(msg)s %(orig_error)s"
1485
1549
 
1486
1550
    def __init__(self, msg=None, orig_error=None):
1531
1595
 
1532
1596
class SmartMessageHandlerError(InternalBzrError):
1533
1597
 
1534
 
    _fmt = "The message handler raised an exception: %(exc_value)s."
 
1598
    _fmt = ("The message handler raised an exception:\n"
 
1599
            "%(traceback_text)s")
1535
1600
 
1536
1601
    def __init__(self, exc_info):
1537
 
        self.exc_type, self.exc_value, self.tb = exc_info
1538
 
        
 
1602
        import traceback
 
1603
        self.exc_type, self.exc_value, self.exc_tb = exc_info
 
1604
        self.exc_info = exc_info
 
1605
        traceback_strings = traceback.format_exception(
 
1606
                self.exc_type, self.exc_value, self.exc_tb)
 
1607
        self.traceback_text = ''.join(traceback_strings)
 
1608
 
1539
1609
 
1540
1610
# A set of semi-meaningful errors which can be thrown
1541
1611
class TransportNotPossible(TransportError):
1567
1637
            self.port = ':%s' % port
1568
1638
 
1569
1639
 
 
1640
# XXX: This is also used for unexpected end of file, which is different at the
 
1641
# TCP level from "connection reset".
1570
1642
class ConnectionReset(TransportError):
1571
1643
 
1572
1644
    _fmt = "Connection closed: %(msg)s %(orig_error)s"
1613
1685
 
1614
1686
    _fmt = '%(source)s is%(permanently)s redirected to %(target)s'
1615
1687
 
1616
 
    def __init__(self, source, target, is_permanent=False, qual_proto=None):
 
1688
    def __init__(self, source, target, is_permanent=False):
1617
1689
        self.source = source
1618
1690
        self.target = target
1619
1691
        if is_permanent:
1620
1692
            self.permanently = ' permanently'
1621
1693
        else:
1622
1694
            self.permanently = ''
1623
 
        self._qualified_proto = qual_proto
1624
1695
        TransportError.__init__(self)
1625
1696
 
1626
 
    def _requalify_url(self, url):
1627
 
        """Restore the qualified proto in front of the url"""
1628
 
        # When this exception is raised, source and target are in
1629
 
        # user readable format. But some transports may use a
1630
 
        # different proto (http+urllib:// will present http:// to
1631
 
        # the user. If a qualified proto is specified, the code
1632
 
        # trapping the exception can get the qualified urls to
1633
 
        # properly handle the redirection themself (creating a
1634
 
        # new transport object from the target url for example).
1635
 
        # But checking that the scheme of the original and
1636
 
        # redirected urls are the same can be tricky. (see the
1637
 
        # FIXME in BzrDir.open_from_transport for the unique use
1638
 
        # case so far).
1639
 
        if self._qualified_proto is None:
1640
 
            return url
1641
 
 
1642
 
        # The TODO related to NotBranchError mention that doing
1643
 
        # that kind of manipulation on the urls may not be the
1644
 
        # exception object job. On the other hand, this object is
1645
 
        # the interface between the code and the user so
1646
 
        # presenting the urls in different ways is indeed its
1647
 
        # job...
1648
 
        import urlparse
1649
 
        proto, netloc, path, query, fragment = urlparse.urlsplit(url)
1650
 
        return urlparse.urlunsplit((self._qualified_proto, netloc, path,
1651
 
                                   query, fragment))
1652
 
 
1653
 
    def get_source_url(self):
1654
 
        return self._requalify_url(self.source)
1655
 
 
1656
 
    def get_target_url(self):
1657
 
        return self._requalify_url(self.target)
1658
 
 
1659
1697
 
1660
1698
class TooManyRedirections(TransportError):
1661
1699
 
1673
1711
        if filename is None:
1674
1712
            filename = ""
1675
1713
        message = "Error(s) parsing config file %s:\n%s" % \
1676
 
            (filename, ('\n'.join(e.message for e in errors)))
 
1714
            (filename, ('\n'.join(e.msg for e in errors)))
1677
1715
        BzrError.__init__(self, message)
1678
1716
 
1679
1717
 
1696
1734
 
1697
1735
class WorkingTreeNotRevision(BzrError):
1698
1736
 
1699
 
    _fmt = ("The working tree for %(basedir)s has changed since" 
 
1737
    _fmt = ("The working tree for %(basedir)s has changed since"
1700
1738
            " the last commit, but weave merge requires that it be"
1701
1739
            " unchanged")
1702
1740
 
1864
1902
    _fmt = "Could not move %(from_path)s%(operator)s %(to_path)s%(extra)s"
1865
1903
 
1866
1904
    def __init__(self, from_path='', to_path='', extra=None):
 
1905
        from bzrlib.osutils import splitpath
1867
1906
        BzrError.__init__(self)
1868
1907
        if extra:
1869
1908
            self.extra = ': ' + str(extra)
1873
1912
        has_from = len(from_path) > 0
1874
1913
        has_to = len(to_path) > 0
1875
1914
        if has_from:
1876
 
            self.from_path = osutils.splitpath(from_path)[-1]
 
1915
            self.from_path = splitpath(from_path)[-1]
1877
1916
        else:
1878
1917
            self.from_path = ''
1879
1918
 
1880
1919
        if has_to:
1881
 
            self.to_path = osutils.splitpath(to_path)[-1]
 
1920
            self.to_path = splitpath(to_path)[-1]
1882
1921
        else:
1883
1922
            self.to_path = ''
1884
1923
 
1967
2006
 
1968
2007
class BadConversionTarget(BzrError):
1969
2008
 
1970
 
    _fmt = "Cannot convert to format %(format)s.  %(problem)s"
 
2009
    _fmt = "Cannot convert from format %(from_format)s to format %(format)s." \
 
2010
            "    %(problem)s"
1971
2011
 
1972
 
    def __init__(self, problem, format):
 
2012
    def __init__(self, problem, format, from_format=None):
1973
2013
        BzrError.__init__(self)
1974
2014
        self.problem = problem
1975
2015
        self.format = format
 
2016
        self.from_format = from_format or '(unspecified)'
1976
2017
 
1977
2018
 
1978
2019
class NoDiffFound(BzrError):
2015
2056
    _fmt = """This tree contains left-over files from a failed operation.
2016
2057
    Please examine %(limbo_dir)s to see if it contains any files you wish to
2017
2058
    keep, and delete it when you are done."""
2018
 
    
 
2059
 
2019
2060
    def __init__(self, limbo_dir):
2020
2061
       BzrError.__init__(self)
2021
2062
       self.limbo_dir = limbo_dir
2054
2095
 
2055
2096
class OutOfDateTree(BzrError):
2056
2097
 
2057
 
    _fmt = "Working tree is out of date, please run 'bzr update'."
 
2098
    _fmt = "Working tree is out of date, please run 'bzr update'.%(more)s"
2058
2099
 
2059
 
    def __init__(self, tree):
 
2100
    def __init__(self, tree, more=None):
 
2101
        if more is None:
 
2102
            more = ''
 
2103
        else:
 
2104
            more = ' ' + more
2060
2105
        BzrError.__init__(self)
2061
2106
        self.tree = tree
 
2107
        self.more = more
2062
2108
 
2063
2109
 
2064
2110
class PublicBranchOutOfDate(BzrError):
2118
2164
        self.reason = reason
2119
2165
 
2120
2166
 
 
2167
class InconsistentDeltaDelta(InconsistentDelta):
 
2168
    """Used when we get a delta that is not valid."""
 
2169
 
 
2170
    _fmt = ("An inconsistent delta was supplied: %(delta)r"
 
2171
            "\nreason: %(reason)s")
 
2172
 
 
2173
    def __init__(self, delta, reason):
 
2174
        BzrError.__init__(self)
 
2175
        self.delta = delta
 
2176
        self.reason = reason
 
2177
 
 
2178
 
2121
2179
class UpgradeRequired(BzrError):
2122
2180
 
2123
2181
    _fmt = "To use this feature you must upgrade your branch at %(path)s."
2132
2190
    _fmt = "To use this feature you must upgrade your repository at %(path)s."
2133
2191
 
2134
2192
 
 
2193
class RichRootUpgradeRequired(UpgradeRequired):
 
2194
 
 
2195
    _fmt = ("To use this feature you must upgrade your branch at %(path)s to"
 
2196
           " a format which supports rich roots.")
 
2197
 
 
2198
 
2135
2199
class LocalRequiresBoundBranch(BzrError):
2136
2200
 
2137
2201
    _fmt = "Cannot perform local-only commits on unbound branches."
2138
2202
 
2139
2203
 
2140
 
class MissingProgressBarFinish(BzrError):
2141
 
 
2142
 
    _fmt = "A nested progress bar was not 'finished' correctly."
2143
 
 
2144
 
 
2145
 
class InvalidProgressBarType(BzrError):
2146
 
 
2147
 
    _fmt = ("Environment variable BZR_PROGRESS_BAR='%(bar_type)s"
2148
 
            " is not a supported type Select one of: %(valid_types)s")
2149
 
 
2150
 
    def __init__(self, bar_type, valid_types):
2151
 
        BzrError.__init__(self, bar_type=bar_type, valid_types=valid_types)
2152
 
 
2153
 
 
2154
2204
class UnsupportedOperation(BzrError):
2155
2205
 
2156
2206
    _fmt = ("The method %(mname)s is not supported on"
2173
2223
 
2174
2224
 
2175
2225
class BinaryFile(BzrError):
2176
 
    
 
2226
 
2177
2227
    _fmt = "File is binary but should be text."
2178
2228
 
2179
2229
 
2199
2249
 
2200
2250
 
2201
2251
class NotABundle(BzrError):
2202
 
    
 
2252
 
2203
2253
    _fmt = "Not a bzr revision-bundle: %(text)r"
2204
2254
 
2205
2255
    def __init__(self, text):
2207
2257
        self.text = text
2208
2258
 
2209
2259
 
2210
 
class BadBundle(BzrError): 
2211
 
    
 
2260
class BadBundle(BzrError):
 
2261
 
2212
2262
    _fmt = "Bad bzr revision-bundle: %(text)r"
2213
2263
 
2214
2264
    def __init__(self, text):
2216
2266
        self.text = text
2217
2267
 
2218
2268
 
2219
 
class MalformedHeader(BadBundle): 
2220
 
    
 
2269
class MalformedHeader(BadBundle):
 
2270
 
2221
2271
    _fmt = "Malformed bzr revision-bundle header: %(text)r"
2222
2272
 
2223
2273
 
2224
 
class MalformedPatches(BadBundle): 
2225
 
    
 
2274
class MalformedPatches(BadBundle):
 
2275
 
2226
2276
    _fmt = "Malformed patches in bzr revision-bundle: %(text)r"
2227
2277
 
2228
2278
 
2229
 
class MalformedFooter(BadBundle): 
2230
 
    
 
2279
class MalformedFooter(BadBundle):
 
2280
 
2231
2281
    _fmt = "Malformed footer in bzr revision-bundle: %(text)r"
2232
2282
 
2233
2283
 
2234
2284
class UnsupportedEOLMarker(BadBundle):
2235
 
    
2236
 
    _fmt = "End of line marker was not \\n in bzr revision-bundle"    
 
2285
 
 
2286
    _fmt = "End of line marker was not \\n in bzr revision-bundle"
2237
2287
 
2238
2288
    def __init__(self):
2239
 
        # XXX: BadBundle's constructor assumes there's explanatory text, 
 
2289
        # XXX: BadBundle's constructor assumes there's explanatory text,
2240
2290
        # but for this there is not
2241
2291
        BzrError.__init__(self)
2242
2292
 
2243
2293
 
2244
2294
class IncompatibleBundleFormat(BzrError):
2245
 
    
 
2295
 
2246
2296
    _fmt = "Bundle format %(bundle_format)s is incompatible with %(other)s"
2247
2297
 
2248
2298
    def __init__(self, bundle_format, other):
2252
2302
 
2253
2303
 
2254
2304
class BadInventoryFormat(BzrError):
2255
 
    
 
2305
 
2256
2306
    _fmt = "Root class for inventory serialization errors"
2257
2307
 
2258
2308
 
2277
2327
        self.transport = transport
2278
2328
 
2279
2329
 
2280
 
class NoSmartServer(NotBranchError):
2281
 
 
2282
 
    _fmt = "No smart server available at %(url)s"
2283
 
 
2284
 
    @symbol_versioning.deprecated_method(symbol_versioning.one_four)
2285
 
    def __init__(self, url):
2286
 
        self.url = url
2287
 
 
2288
 
 
2289
2330
class UnknownSSH(BzrError):
2290
2331
 
2291
2332
    _fmt = "Unrecognised value for BZR_SSH environment variable: %(vendor)s"
2311
2352
        self.revision_id = revision_id
2312
2353
        self.ghost_revision_id = ghost_revision_id
2313
2354
 
2314
 
        
 
2355
 
2315
2356
class GhostRevisionUnusableHere(BzrError):
2316
2357
 
2317
2358
    _fmt = "Ghost revision {%(revision_id)s} cannot be used here."
2409
2450
 
2410
2451
 
2411
2452
class UnsupportedInventoryKind(BzrError):
2412
 
    
 
2453
 
2413
2454
    _fmt = """Unsupported entry kind %(kind)s"""
2414
2455
 
2415
2456
    def __init__(self, kind):
2427
2468
 
2428
2469
 
2429
2470
class SubsumeTargetNeedsUpgrade(BzrError):
2430
 
    
 
2471
 
2431
2472
    _fmt = """Subsume target %(other_tree)s needs to be upgraded."""
2432
2473
 
2433
2474
    def __init__(self, other_tree):
2461
2502
    def __init__(self, branch):
2462
2503
        self.branch = branch
2463
2504
 
2464
 
        
 
2505
 
2465
2506
class TagAlreadyExists(BzrError):
2466
2507
 
2467
2508
    _fmt = "Tag %(tag_name)s already exists."
2472
2513
 
2473
2514
class MalformedBugIdentifier(BzrError):
2474
2515
 
2475
 
    _fmt = "Did not understand bug identifier %(bug_id)s: %(reason)s"
 
2516
    _fmt = ('Did not understand bug identifier %(bug_id)s: %(reason)s. '
 
2517
            'See "bzr help bugs" for more information on this feature.')
2476
2518
 
2477
2519
    def __init__(self, bug_id, reason):
2478
2520
        self.bug_id = bug_id
2499
2541
        self.branch = branch
2500
2542
 
2501
2543
 
 
2544
class InvalidLineInBugsProperty(BzrError):
 
2545
 
 
2546
    _fmt = ("Invalid line in bugs property: '%(line)s'")
 
2547
 
 
2548
    def __init__(self, line):
 
2549
        self.line = line
 
2550
 
 
2551
 
 
2552
class InvalidBugStatus(BzrError):
 
2553
 
 
2554
    _fmt = ("Invalid bug status: '%(status)s'")
 
2555
 
 
2556
    def __init__(self, status):
 
2557
        self.status = status
 
2558
 
 
2559
 
2502
2560
class UnexpectedSmartServerResponse(BzrError):
2503
2561
 
2504
2562
    _fmt = "Could not understand response from smart server: %(response_tuple)r"
2550
2608
        """
2551
2609
        self.error_from_smart_server = error_from_smart_server
2552
2610
        self.error_tuple = error_from_smart_server.error_tuple
2553
 
        
 
2611
 
2554
2612
 
2555
2613
class ContainerError(BzrError):
2556
2614
    """Base class of container errors."""
2559
2617
class UnknownContainerFormatError(ContainerError):
2560
2618
 
2561
2619
    _fmt = "Unrecognised container format: %(container_format)r"
2562
 
    
 
2620
 
2563
2621
    def __init__(self, container_format):
2564
2622
        self.container_format = container_format
2565
2623
 
2629
2687
 
2630
2688
class NoMailAddressSpecified(BzrError):
2631
2689
 
2632
 
    _fmt = "No mail-to address specified."
 
2690
    _fmt = "No mail-to address (--mail-to) or output (-o) specified."
2633
2691
 
2634
2692
 
2635
2693
class UnknownMailClient(BzrError):
2715
2773
    _fmt = "'%(display_url)s' is already standalone."
2716
2774
 
2717
2775
 
 
2776
class AlreadyWithTrees(BzrDirError):
 
2777
 
 
2778
    _fmt = ("Shared repository '%(display_url)s' already creates "
 
2779
            "working trees.")
 
2780
 
 
2781
 
 
2782
class AlreadyWithNoTrees(BzrDirError):
 
2783
 
 
2784
    _fmt = ("Shared repository '%(display_url)s' already doesn't create "
 
2785
            "working trees.")
 
2786
 
 
2787
 
2718
2788
class ReconfigurationNotSupported(BzrDirError):
2719
2789
 
2720
2790
    _fmt = "Requested reconfiguration of '%(display_url)s' is not supported."
2727
2797
 
2728
2798
class UncommittedChanges(BzrError):
2729
2799
 
2730
 
    _fmt = 'Working tree "%(display_url)s" has uncommitted changes.'
 
2800
    _fmt = ('Working tree "%(display_url)s" has uncommitted changes'
 
2801
            ' (See bzr status).%(more)s')
2731
2802
 
2732
 
    def __init__(self, tree):
 
2803
    def __init__(self, tree, more=None):
 
2804
        if more is None:
 
2805
            more = ''
 
2806
        else:
 
2807
            more = ' ' + more
2733
2808
        import bzrlib.urlutils as urlutils
2734
2809
        display_url = urlutils.unescape_for_display(
2735
2810
            tree.bzrdir.root_transport.base, 'ascii')
2736
 
        BzrError.__init__(self, tree=tree, display_url=display_url)
 
2811
        BzrError.__init__(self, tree=tree, display_url=display_url, more=more)
2737
2812
 
2738
2813
 
2739
2814
class MissingTemplateVariable(BzrError):
2774
2849
 
2775
2850
 
2776
2851
class CommandAvailableInPlugin(StandardError):
2777
 
    
 
2852
 
2778
2853
    internal_error = False
2779
2854
 
2780
2855
    def __init__(self, cmd_name, plugin_metadata, provider):
2781
 
        
 
2856
 
2782
2857
        self.plugin_metadata = plugin_metadata
2783
2858
        self.cmd_name = cmd_name
2784
2859
        self.provider = provider
2785
2860
 
2786
2861
    def __str__(self):
2787
2862
 
2788
 
        _fmt = ('"%s" is not a standard bzr command. \n' 
 
2863
        _fmt = ('"%s" is not a standard bzr command. \n'
2789
2864
                'However, the following official plugin provides this command: %s\n'
2790
2865
                'You can install it by going to: %s'
2791
 
                % (self.cmd_name, self.plugin_metadata['name'], 
 
2866
                % (self.cmd_name, self.plugin_metadata['name'],
2792
2867
                    self.plugin_metadata['url']))
2793
2868
 
2794
2869
        return _fmt
2795
2870
 
2796
2871
 
2797
2872
class NoPluginAvailable(BzrError):
2798
 
    pass    
2799
 
 
2800
 
 
2801
 
class NotATerminal(BzrError):
2802
 
 
2803
 
    _fmt = 'Unable to ask for a password without real terminal.'
 
2873
    pass
2804
2874
 
2805
2875
 
2806
2876
class UnableEncodePath(BzrError):
2809
2879
            'user encoding %(user_encoding)s')
2810
2880
 
2811
2881
    def __init__(self, path, kind):
 
2882
        from bzrlib.osutils import get_user_encoding
2812
2883
        self.path = path
2813
2884
        self.kind = kind
2814
2885
        self.user_encoding = osutils.get_user_encoding()
2849
2920
    _fmt = 'Cannot bind address "%(host)s:%(port)i": %(orig_error)s.'
2850
2921
 
2851
2922
    def __init__(self, host, port, orig_error):
 
2923
        # nb: in python2.4 socket.error doesn't have a useful repr
2852
2924
        BzrError.__init__(self, host=host, port=port,
2853
 
            orig_error=orig_error[1])
 
2925
            orig_error=repr(orig_error.args))
2854
2926
 
2855
2927
 
2856
2928
class UnknownRules(BzrError):
2884
2956
    """A pre_change_branch_tip hook function may raise this to cleanly and
2885
2957
    explicitly abort a change to a branch tip.
2886
2958
    """
2887
 
    
 
2959
 
2888
2960
    _fmt = u"Tip change rejected: %(msg)s"
2889
2961
 
2890
2962
    def __init__(self, msg):
2891
2963
        self.msg = msg
2892
2964
 
 
2965
 
 
2966
class ShelfCorrupt(BzrError):
 
2967
 
 
2968
    _fmt = "Shelf corrupt."
 
2969
 
 
2970
 
 
2971
class NoSuchShelfId(BzrError):
 
2972
 
 
2973
    _fmt = 'No changes are shelved with id "%(shelf_id)d".'
 
2974
 
 
2975
    def __init__(self, shelf_id):
 
2976
        BzrError.__init__(self, shelf_id=shelf_id)
 
2977
 
 
2978
 
 
2979
class InvalidShelfId(BzrError):
 
2980
 
 
2981
    _fmt = '"%(invalid_id)s" is not a valid shelf id, try a number instead.'
 
2982
 
 
2983
    def __init__(self, invalid_id):
 
2984
        BzrError.__init__(self, invalid_id=invalid_id)
 
2985
 
 
2986
 
 
2987
class JailBreak(BzrError):
 
2988
 
 
2989
    _fmt = "An attempt to access a url outside the server jail was made: '%(url)s'."
 
2990
 
 
2991
    def __init__(self, url):
 
2992
        BzrError.__init__(self, url=url)
 
2993
 
 
2994
 
 
2995
class UserAbort(BzrError):
 
2996
 
 
2997
    _fmt = 'The user aborted the operation.'
 
2998
 
 
2999
 
 
3000
class MustHaveWorkingTree(BzrError):
 
3001
 
 
3002
    _fmt = ("Branching '%(url)s'(%(format)s) must create a working tree.")
 
3003
 
 
3004
    def __init__(self, format, url):
 
3005
        BzrError.__init__(self, format=format, url=url)
 
3006
 
 
3007
 
 
3008
class NoSuchView(BzrError):
 
3009
    """A view does not exist.
 
3010
    """
 
3011
 
 
3012
    _fmt = u"No such view: %(view_name)s."
 
3013
 
 
3014
    def __init__(self, view_name):
 
3015
        self.view_name = view_name
 
3016
 
 
3017
 
 
3018
class ViewsNotSupported(BzrError):
 
3019
    """Views are not supported by a tree format.
 
3020
    """
 
3021
 
 
3022
    _fmt = ("Views are not supported by %(tree)s;"
 
3023
            " use 'bzr upgrade' to change your tree to a later format.")
 
3024
 
 
3025
    def __init__(self, tree):
 
3026
        self.tree = tree
 
3027
 
 
3028
 
 
3029
class FileOutsideView(BzrError):
 
3030
 
 
3031
    _fmt = ('Specified file "%(file_name)s" is outside the current view: '
 
3032
            '%(view_str)s')
 
3033
 
 
3034
    def __init__(self, file_name, view_files):
 
3035
        self.file_name = file_name
 
3036
        self.view_str = ", ".join(view_files)
 
3037
 
 
3038
 
 
3039
class UnresumableWriteGroup(BzrError):
 
3040
 
 
3041
    _fmt = ("Repository %(repository)s cannot resume write group "
 
3042
            "%(write_groups)r: %(reason)s")
 
3043
 
 
3044
    internal_error = True
 
3045
 
 
3046
    def __init__(self, repository, write_groups, reason):
 
3047
        self.repository = repository
 
3048
        self.write_groups = write_groups
 
3049
        self.reason = reason
 
3050
 
 
3051
 
 
3052
class UnsuspendableWriteGroup(BzrError):
 
3053
 
 
3054
    _fmt = ("Repository %(repository)s cannot suspend a write group.")
 
3055
 
 
3056
    internal_error = True
 
3057
 
 
3058
    def __init__(self, repository):
 
3059
        self.repository = repository
 
3060
 
 
3061
 
 
3062
class LossyPushToSameVCS(BzrError):
 
3063
 
 
3064
    _fmt = ("Lossy push not possible between %(source_branch)r and "
 
3065
            "%(target_branch)r that are in the same VCS.")
 
3066
 
 
3067
    internal_error = True
 
3068
 
 
3069
    def __init__(self, source_branch, target_branch):
 
3070
        self.source_branch = source_branch
 
3071
        self.target_branch = target_branch