~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/errors.py

  • Committer: Vincent Ladeuil
  • Date: 2010-02-10 15:46:03 UTC
  • mfrom: (4985.3.21 update)
  • mto: This revision was merged to the branch mainline in revision 5021.
  • Revision ID: v.ladeuil+lp@free.fr-20100210154603-k4no1gvfuqpzrw7p
Update performs two merges in a more logical order but stop on conflicts

Show diffs side-by-side

added added

removed removed

Lines of Context:
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
 
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):
764
795
 
765
796
 
766
797
class UnknownFormatError(BzrError):
767
 
    
 
798
 
768
799
    _fmt = "Unknown %(kind)s format: %(format)r"
769
800
 
770
801
    def __init__(self, format, kind='branch'):
773
804
 
774
805
 
775
806
class IncompatibleFormat(BzrError):
776
 
    
 
807
 
777
808
    _fmt = "Format %(format)s is not compatible with .bzr version %(bzrdir)s."
778
809
 
779
810
    def __init__(self, format, bzrdir_format):
783
814
 
784
815
 
785
816
class IncompatibleRepositories(BzrError):
 
817
    """Report an error that two repositories are not compatible.
 
818
 
 
819
    Note that the source and target repositories are permitted to be strings:
 
820
    this exception is thrown from the smart server and may refer to a
 
821
    repository the client hasn't opened.
 
822
    """
786
823
 
787
824
    _fmt = "%(target)s\n" \
788
825
            "is not compatible with\n" \
796
833
 
797
834
 
798
835
class IncompatibleRevision(BzrError):
799
 
    
 
836
 
800
837
    _fmt = "Revision is not compatible with %(repo_format)s"
801
838
 
802
839
    def __init__(self, repo_format):
1003
1040
 
1004
1041
class LockContention(LockError):
1005
1042
 
1006
 
    _fmt = 'Could not acquire lock "%(lock)s"'
 
1043
    _fmt = 'Could not acquire lock "%(lock)s": %(msg)s'
1007
1044
    # TODO: show full url for lock, combining the transport and relative
1008
1045
    # bits?
1009
1046
 
1010
1047
    internal_error = False
1011
1048
 
1012
 
    def __init__(self, lock):
 
1049
    def __init__(self, lock, msg=''):
1013
1050
        self.lock = lock
 
1051
        self.msg = msg
1014
1052
 
1015
1053
 
1016
1054
class LockBroken(LockError):
1130
1168
 
1131
1169
class NoSuchRevisionInTree(NoSuchRevision):
1132
1170
    """When using Tree.revision_tree, and the revision is not accessible."""
1133
 
    
 
1171
 
1134
1172
    _fmt = "The revision id {%(revision_id)s} is not present in the tree %(tree)s."
1135
1173
 
1136
1174
    def __init__(self, tree, revision_id):
1172
1210
class DivergedBranches(BzrError):
1173
1211
 
1174
1212
    _fmt = ("These branches have diverged."
1175
 
            " Use the merge command to reconcile them.")
 
1213
            " Use the missing command to see how.\n"
 
1214
            "Use the merge command to reconcile them.")
1176
1215
 
1177
1216
    def __init__(self, branch1, branch2):
1178
1217
        self.branch1 = branch1
1200
1239
 
1201
1240
 
1202
1241
class NoCommonAncestor(BzrError):
1203
 
    
 
1242
 
1204
1243
    _fmt = "Revisions have no common ancestor: %(revision_a)s %(revision_b)s"
1205
1244
 
1206
1245
    def __init__(self, revision_a, revision_b):
1226
1265
            not_ancestor_id=not_ancestor_id)
1227
1266
 
1228
1267
 
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
1268
class AmbiguousBase(BzrError):
1239
1269
 
1240
1270
    def __init__(self, bases):
1241
 
        warn("BzrError AmbiguousBase has been deprecated as of bzrlib 0.8.",
1242
 
                DeprecationWarning)
 
1271
        symbol_versioning.warn("BzrError AmbiguousBase has been deprecated "
 
1272
            "as of bzrlib 0.8.", DeprecationWarning, stacklevel=2)
1243
1273
        msg = ("The correct base is unclear, because %s are all equally close"
1244
1274
                % ", ".join(bases))
1245
1275
        BzrError.__init__(self, msg)
1274
1304
        self.branch = branch
1275
1305
        self.master = master
1276
1306
 
1277
 
        
 
1307
 
1278
1308
class CommitToDoubleBoundBranch(BzrError):
1279
1309
 
1280
1310
    _fmt = ("Cannot commit to branch %(branch)s."
1350
1380
class WeaveParentMismatch(WeaveError):
1351
1381
 
1352
1382
    _fmt = "Parents are mismatched between two revisions. %(message)s"
1353
 
    
 
1383
 
1354
1384
 
1355
1385
class WeaveInvalidChecksum(WeaveError):
1356
1386
 
1382
1412
 
1383
1413
 
1384
1414
class VersionedFileError(BzrError):
1385
 
    
 
1415
 
1386
1416
    _fmt = "Versioned file error"
1387
1417
 
1388
1418
 
1389
1419
class RevisionNotPresent(VersionedFileError):
1390
 
    
 
1420
 
1391
1421
    _fmt = 'Revision {%(revision_id)s} not present in "%(file_id)s".'
1392
1422
 
1393
1423
    def __init__(self, revision_id, file_id):
1397
1427
 
1398
1428
 
1399
1429
class RevisionAlreadyPresent(VersionedFileError):
1400
 
    
 
1430
 
1401
1431
    _fmt = 'Revision {%(revision_id)s} already present in "%(file_id)s".'
1402
1432
 
1403
1433
    def __init__(self, revision_id, file_id):
1412
1442
 
1413
1443
 
1414
1444
class KnitError(InternalBzrError):
1415
 
    
 
1445
 
1416
1446
    _fmt = "Knit error"
1417
1447
 
1418
1448
 
1450
1480
    def __init__(self, stream_format, target_format):
1451
1481
        self.stream_format = stream_format
1452
1482
        self.target_format = target_format
1453
 
        
 
1483
 
1454
1484
 
1455
1485
class KnitDataStreamUnknown(KnitError):
1456
1486
    # Indicates a data stream we don't know how to handle.
1459
1489
 
1460
1490
    def __init__(self, stream_format):
1461
1491
        self.stream_format = stream_format
1462
 
        
 
1492
 
1463
1493
 
1464
1494
class KnitHeaderError(KnitError):
1465
1495
 
1475
1505
 
1476
1506
    Currently only 'fulltext' and 'line-delta' are supported.
1477
1507
    """
1478
 
    
 
1508
 
1479
1509
    _fmt = ("Knit index %(filename)s does not have a known method"
1480
1510
            " in options: %(options)r")
1481
1511
 
1532
1562
 
1533
1563
 
1534
1564
class NoSuchExportFormat(BzrError):
1535
 
    
 
1565
 
1536
1566
    _fmt = "Export format %(format)r not supported"
1537
1567
 
1538
1568
    def __init__(self, format):
1541
1571
 
1542
1572
 
1543
1573
class TransportError(BzrError):
1544
 
    
 
1574
 
1545
1575
    _fmt = "Transport error: %(msg)s %(orig_error)s"
1546
1576
 
1547
1577
    def __init__(self, msg=None, orig_error=None):
1634
1664
            self.port = ':%s' % port
1635
1665
 
1636
1666
 
 
1667
# XXX: This is also used for unexpected end of file, which is different at the
 
1668
# TCP level from "connection reset".
1637
1669
class ConnectionReset(TransportError):
1638
1670
 
1639
1671
    _fmt = "Connection closed: %(msg)s %(orig_error)s"
1729
1761
 
1730
1762
class WorkingTreeNotRevision(BzrError):
1731
1763
 
1732
 
    _fmt = ("The working tree for %(basedir)s has changed since" 
 
1764
    _fmt = ("The working tree for %(basedir)s has changed since"
1733
1765
            " the last commit, but weave merge requires that it be"
1734
1766
            " unchanged")
1735
1767
 
2001
2033
 
2002
2034
class BadConversionTarget(BzrError):
2003
2035
 
2004
 
    _fmt = "Cannot convert to format %(format)s.  %(problem)s"
 
2036
    _fmt = "Cannot convert from format %(from_format)s to format %(format)s." \
 
2037
            "    %(problem)s"
2005
2038
 
2006
 
    def __init__(self, problem, format):
 
2039
    def __init__(self, problem, format, from_format=None):
2007
2040
        BzrError.__init__(self)
2008
2041
        self.problem = problem
2009
2042
        self.format = format
 
2043
        self.from_format = from_format or '(unspecified)'
2010
2044
 
2011
2045
 
2012
2046
class NoDiffFound(BzrError):
2049
2083
    _fmt = """This tree contains left-over files from a failed operation.
2050
2084
    Please examine %(limbo_dir)s to see if it contains any files you wish to
2051
2085
    keep, and delete it when you are done."""
2052
 
    
 
2086
 
2053
2087
    def __init__(self, limbo_dir):
2054
2088
       BzrError.__init__(self)
2055
2089
       self.limbo_dir = limbo_dir
2088
2122
 
2089
2123
class OutOfDateTree(BzrError):
2090
2124
 
2091
 
    _fmt = "Working tree is out of date, please run 'bzr update'."
 
2125
    _fmt = "Working tree is out of date, please run 'bzr update'.%(more)s"
2092
2126
 
2093
 
    def __init__(self, tree):
 
2127
    def __init__(self, tree, more=None):
 
2128
        if more is None:
 
2129
            more = ''
 
2130
        else:
 
2131
            more = ' ' + more
2094
2132
        BzrError.__init__(self)
2095
2133
        self.tree = tree
 
2134
        self.more = more
2096
2135
 
2097
2136
 
2098
2137
class PublicBranchOutOfDate(BzrError):
2152
2191
        self.reason = reason
2153
2192
 
2154
2193
 
 
2194
class InconsistentDeltaDelta(InconsistentDelta):
 
2195
    """Used when we get a delta that is not valid."""
 
2196
 
 
2197
    _fmt = ("An inconsistent delta was supplied: %(delta)r"
 
2198
            "\nreason: %(reason)s")
 
2199
 
 
2200
    def __init__(self, delta, reason):
 
2201
        BzrError.__init__(self)
 
2202
        self.delta = delta
 
2203
        self.reason = reason
 
2204
 
 
2205
 
2155
2206
class UpgradeRequired(BzrError):
2156
2207
 
2157
2208
    _fmt = "To use this feature you must upgrade your branch at %(path)s."
2166
2217
    _fmt = "To use this feature you must upgrade your repository at %(path)s."
2167
2218
 
2168
2219
 
 
2220
class RichRootUpgradeRequired(UpgradeRequired):
 
2221
 
 
2222
    _fmt = ("To use this feature you must upgrade your branch at %(path)s to"
 
2223
           " a format which supports rich roots.")
 
2224
 
 
2225
 
2169
2226
class LocalRequiresBoundBranch(BzrError):
2170
2227
 
2171
2228
    _fmt = "Cannot perform local-only commits on unbound branches."
2172
2229
 
2173
2230
 
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
2231
class UnsupportedOperation(BzrError):
2184
2232
 
2185
2233
    _fmt = ("The method %(mname)s is not supported on"
2202
2250
 
2203
2251
 
2204
2252
class BinaryFile(BzrError):
2205
 
    
 
2253
 
2206
2254
    _fmt = "File is binary but should be text."
2207
2255
 
2208
2256
 
2228
2276
 
2229
2277
 
2230
2278
class NotABundle(BzrError):
2231
 
    
 
2279
 
2232
2280
    _fmt = "Not a bzr revision-bundle: %(text)r"
2233
2281
 
2234
2282
    def __init__(self, text):
2236
2284
        self.text = text
2237
2285
 
2238
2286
 
2239
 
class BadBundle(BzrError): 
2240
 
    
 
2287
class BadBundle(BzrError):
 
2288
 
2241
2289
    _fmt = "Bad bzr revision-bundle: %(text)r"
2242
2290
 
2243
2291
    def __init__(self, text):
2245
2293
        self.text = text
2246
2294
 
2247
2295
 
2248
 
class MalformedHeader(BadBundle): 
2249
 
    
 
2296
class MalformedHeader(BadBundle):
 
2297
 
2250
2298
    _fmt = "Malformed bzr revision-bundle header: %(text)r"
2251
2299
 
2252
2300
 
2253
 
class MalformedPatches(BadBundle): 
2254
 
    
 
2301
class MalformedPatches(BadBundle):
 
2302
 
2255
2303
    _fmt = "Malformed patches in bzr revision-bundle: %(text)r"
2256
2304
 
2257
2305
 
2258
 
class MalformedFooter(BadBundle): 
2259
 
    
 
2306
class MalformedFooter(BadBundle):
 
2307
 
2260
2308
    _fmt = "Malformed footer in bzr revision-bundle: %(text)r"
2261
2309
 
2262
2310
 
2263
2311
class UnsupportedEOLMarker(BadBundle):
2264
 
    
2265
 
    _fmt = "End of line marker was not \\n in bzr revision-bundle"    
 
2312
 
 
2313
    _fmt = "End of line marker was not \\n in bzr revision-bundle"
2266
2314
 
2267
2315
    def __init__(self):
2268
 
        # XXX: BadBundle's constructor assumes there's explanatory text, 
 
2316
        # XXX: BadBundle's constructor assumes there's explanatory text,
2269
2317
        # but for this there is not
2270
2318
        BzrError.__init__(self)
2271
2319
 
2272
2320
 
2273
2321
class IncompatibleBundleFormat(BzrError):
2274
 
    
 
2322
 
2275
2323
    _fmt = "Bundle format %(bundle_format)s is incompatible with %(other)s"
2276
2324
 
2277
2325
    def __init__(self, bundle_format, other):
2281
2329
 
2282
2330
 
2283
2331
class BadInventoryFormat(BzrError):
2284
 
    
 
2332
 
2285
2333
    _fmt = "Root class for inventory serialization errors"
2286
2334
 
2287
2335
 
2306
2354
        self.transport = transport
2307
2355
 
2308
2356
 
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
2357
class UnknownSSH(BzrError):
2319
2358
 
2320
2359
    _fmt = "Unrecognised value for BZR_SSH environment variable: %(vendor)s"
2340
2379
        self.revision_id = revision_id
2341
2380
        self.ghost_revision_id = ghost_revision_id
2342
2381
 
2343
 
        
 
2382
 
2344
2383
class GhostRevisionUnusableHere(BzrError):
2345
2384
 
2346
2385
    _fmt = "Ghost revision {%(revision_id)s} cannot be used here."
2438
2477
 
2439
2478
 
2440
2479
class UnsupportedInventoryKind(BzrError):
2441
 
    
 
2480
 
2442
2481
    _fmt = """Unsupported entry kind %(kind)s"""
2443
2482
 
2444
2483
    def __init__(self, kind):
2456
2495
 
2457
2496
 
2458
2497
class SubsumeTargetNeedsUpgrade(BzrError):
2459
 
    
 
2498
 
2460
2499
    _fmt = """Subsume target %(other_tree)s needs to be upgraded."""
2461
2500
 
2462
2501
    def __init__(self, other_tree):
2490
2529
    def __init__(self, branch):
2491
2530
        self.branch = branch
2492
2531
 
2493
 
        
 
2532
 
2494
2533
class TagAlreadyExists(BzrError):
2495
2534
 
2496
2535
    _fmt = "Tag %(tag_name)s already exists."
2501
2540
 
2502
2541
class MalformedBugIdentifier(BzrError):
2503
2542
 
2504
 
    _fmt = "Did not understand bug identifier %(bug_id)s: %(reason)s"
 
2543
    _fmt = ('Did not understand bug identifier %(bug_id)s: %(reason)s. '
 
2544
            'See "bzr help bugs" for more information on this feature.')
2505
2545
 
2506
2546
    def __init__(self, bug_id, reason):
2507
2547
        self.bug_id = bug_id
2528
2568
        self.branch = branch
2529
2569
 
2530
2570
 
 
2571
class InvalidLineInBugsProperty(BzrError):
 
2572
 
 
2573
    _fmt = ("Invalid line in bugs property: '%(line)s'")
 
2574
 
 
2575
    def __init__(self, line):
 
2576
        self.line = line
 
2577
 
 
2578
 
 
2579
class InvalidBugStatus(BzrError):
 
2580
 
 
2581
    _fmt = ("Invalid bug status: '%(status)s'")
 
2582
 
 
2583
    def __init__(self, status):
 
2584
        self.status = status
 
2585
 
 
2586
 
2531
2587
class UnexpectedSmartServerResponse(BzrError):
2532
2588
 
2533
2589
    _fmt = "Could not understand response from smart server: %(response_tuple)r"
2579
2635
        """
2580
2636
        self.error_from_smart_server = error_from_smart_server
2581
2637
        self.error_tuple = error_from_smart_server.error_tuple
2582
 
        
 
2638
 
2583
2639
 
2584
2640
class ContainerError(BzrError):
2585
2641
    """Base class of container errors."""
2588
2644
class UnknownContainerFormatError(ContainerError):
2589
2645
 
2590
2646
    _fmt = "Unrecognised container format: %(container_format)r"
2591
 
    
 
2647
 
2592
2648
    def __init__(self, container_format):
2593
2649
        self.container_format = container_format
2594
2650
 
2658
2714
 
2659
2715
class NoMailAddressSpecified(BzrError):
2660
2716
 
2661
 
    _fmt = "No mail-to address specified."
 
2717
    _fmt = "No mail-to address (--mail-to) or output (-o) specified."
2662
2718
 
2663
2719
 
2664
2720
class UnknownMailClient(BzrError):
2744
2800
    _fmt = "'%(display_url)s' is already standalone."
2745
2801
 
2746
2802
 
 
2803
class AlreadyWithTrees(BzrDirError):
 
2804
 
 
2805
    _fmt = ("Shared repository '%(display_url)s' already creates "
 
2806
            "working trees.")
 
2807
 
 
2808
 
 
2809
class AlreadyWithNoTrees(BzrDirError):
 
2810
 
 
2811
    _fmt = ("Shared repository '%(display_url)s' already doesn't create "
 
2812
            "working trees.")
 
2813
 
 
2814
 
2747
2815
class ReconfigurationNotSupported(BzrDirError):
2748
2816
 
2749
2817
    _fmt = "Requested reconfiguration of '%(display_url)s' is not supported."
2756
2824
 
2757
2825
class UncommittedChanges(BzrError):
2758
2826
 
2759
 
    _fmt = 'Working tree "%(display_url)s" has uncommitted changes.'
 
2827
    _fmt = ('Working tree "%(display_url)s" has uncommitted changes'
 
2828
            ' (See bzr status).%(more)s')
2760
2829
 
2761
 
    def __init__(self, tree):
 
2830
    def __init__(self, tree, more=None):
 
2831
        if more is None:
 
2832
            more = ''
 
2833
        else:
 
2834
            more = ' ' + more
2762
2835
        import bzrlib.urlutils as urlutils
2763
2836
        display_url = urlutils.unescape_for_display(
2764
2837
            tree.bzrdir.root_transport.base, 'ascii')
2765
 
        BzrError.__init__(self, tree=tree, display_url=display_url)
 
2838
        BzrError.__init__(self, tree=tree, display_url=display_url, more=more)
2766
2839
 
2767
2840
 
2768
2841
class MissingTemplateVariable(BzrError):
2803
2876
 
2804
2877
 
2805
2878
class CommandAvailableInPlugin(StandardError):
2806
 
    
 
2879
 
2807
2880
    internal_error = False
2808
2881
 
2809
2882
    def __init__(self, cmd_name, plugin_metadata, provider):
2810
 
        
 
2883
 
2811
2884
        self.plugin_metadata = plugin_metadata
2812
2885
        self.cmd_name = cmd_name
2813
2886
        self.provider = provider
2814
2887
 
2815
2888
    def __str__(self):
2816
2889
 
2817
 
        _fmt = ('"%s" is not a standard bzr command. \n' 
 
2890
        _fmt = ('"%s" is not a standard bzr command. \n'
2818
2891
                'However, the following official plugin provides this command: %s\n'
2819
2892
                'You can install it by going to: %s'
2820
 
                % (self.cmd_name, self.plugin_metadata['name'], 
 
2893
                % (self.cmd_name, self.plugin_metadata['name'],
2821
2894
                    self.plugin_metadata['url']))
2822
2895
 
2823
2896
        return _fmt
2824
2897
 
2825
2898
 
2826
2899
class NoPluginAvailable(BzrError):
2827
 
    pass    
2828
 
 
2829
 
 
2830
 
class NotATerminal(BzrError):
2831
 
 
2832
 
    _fmt = 'Unable to ask for a password without real terminal.'
 
2900
    pass
2833
2901
 
2834
2902
 
2835
2903
class UnableEncodePath(BzrError):
2879
2947
    _fmt = 'Cannot bind address "%(host)s:%(port)i": %(orig_error)s.'
2880
2948
 
2881
2949
    def __init__(self, host, port, orig_error):
 
2950
        # nb: in python2.4 socket.error doesn't have a useful repr
2882
2951
        BzrError.__init__(self, host=host, port=port,
2883
 
            orig_error=orig_error[1])
 
2952
            orig_error=repr(orig_error.args))
2884
2953
 
2885
2954
 
2886
2955
class UnknownRules(BzrError):
2894
2963
class HookFailed(BzrError):
2895
2964
    """Raised when a pre_change_branch_tip hook function fails anything other
2896
2965
    than TipChangeRejected.
 
2966
 
 
2967
    Note that this exception is no longer raised, and the import is only left
 
2968
    to be nice to code which might catch it in a plugin.
2897
2969
    """
2898
2970
 
2899
2971
    _fmt = ("Hook '%(hook_name)s' during %(hook_stage)s failed:\n"
2900
2972
            "%(traceback_text)s%(exc_value)s")
2901
2973
 
2902
 
    def __init__(self, hook_stage, hook_name, exc_info):
 
2974
    def __init__(self, hook_stage, hook_name, exc_info, warn=True):
 
2975
        if warn:
 
2976
            symbol_versioning.warn("BzrError HookFailed has been deprecated "
 
2977
                "as of bzrlib 2.1.", DeprecationWarning, stacklevel=2)
2903
2978
        import traceback
2904
2979
        self.hook_stage = hook_stage
2905
2980
        self.hook_name = hook_name
2914
2989
    """A pre_change_branch_tip hook function may raise this to cleanly and
2915
2990
    explicitly abort a change to a branch tip.
2916
2991
    """
2917
 
    
 
2992
 
2918
2993
    _fmt = u"Tip change rejected: %(msg)s"
2919
2994
 
2920
2995
    def __init__(self, msg):
2934
3009
        BzrError.__init__(self, shelf_id=shelf_id)
2935
3010
 
2936
3011
 
 
3012
class InvalidShelfId(BzrError):
 
3013
 
 
3014
    _fmt = '"%(invalid_id)s" is not a valid shelf id, try a number instead.'
 
3015
 
 
3016
    def __init__(self, invalid_id):
 
3017
        BzrError.__init__(self, invalid_id=invalid_id)
 
3018
 
 
3019
 
 
3020
class JailBreak(BzrError):
 
3021
 
 
3022
    _fmt = "An attempt to access a url outside the server jail was made: '%(url)s'."
 
3023
 
 
3024
    def __init__(self, url):
 
3025
        BzrError.__init__(self, url=url)
 
3026
 
 
3027
 
2937
3028
class UserAbort(BzrError):
2938
3029
 
2939
3030
    _fmt = 'The user aborted the operation.'
 
3031
 
 
3032
 
 
3033
class MustHaveWorkingTree(BzrError):
 
3034
 
 
3035
    _fmt = ("Branching '%(url)s'(%(format)s) must create a working tree.")
 
3036
 
 
3037
    def __init__(self, format, url):
 
3038
        BzrError.__init__(self, format=format, url=url)
 
3039
 
 
3040
 
 
3041
class NoSuchView(BzrError):
 
3042
    """A view does not exist.
 
3043
    """
 
3044
 
 
3045
    _fmt = u"No such view: %(view_name)s."
 
3046
 
 
3047
    def __init__(self, view_name):
 
3048
        self.view_name = view_name
 
3049
 
 
3050
 
 
3051
class ViewsNotSupported(BzrError):
 
3052
    """Views are not supported by a tree format.
 
3053
    """
 
3054
 
 
3055
    _fmt = ("Views are not supported by %(tree)s;"
 
3056
            " use 'bzr upgrade' to change your tree to a later format.")
 
3057
 
 
3058
    def __init__(self, tree):
 
3059
        self.tree = tree
 
3060
 
 
3061
 
 
3062
class FileOutsideView(BzrError):
 
3063
 
 
3064
    _fmt = ('Specified file "%(file_name)s" is outside the current view: '
 
3065
            '%(view_str)s')
 
3066
 
 
3067
    def __init__(self, file_name, view_files):
 
3068
        self.file_name = file_name
 
3069
        self.view_str = ", ".join(view_files)
 
3070
 
 
3071
 
 
3072
class UnresumableWriteGroup(BzrError):
 
3073
 
 
3074
    _fmt = ("Repository %(repository)s cannot resume write group "
 
3075
            "%(write_groups)r: %(reason)s")
 
3076
 
 
3077
    internal_error = True
 
3078
 
 
3079
    def __init__(self, repository, write_groups, reason):
 
3080
        self.repository = repository
 
3081
        self.write_groups = write_groups
 
3082
        self.reason = reason
 
3083
 
 
3084
 
 
3085
class UnsuspendableWriteGroup(BzrError):
 
3086
 
 
3087
    _fmt = ("Repository %(repository)s cannot suspend a write group.")
 
3088
 
 
3089
    internal_error = True
 
3090
 
 
3091
    def __init__(self, repository):
 
3092
        self.repository = repository
 
3093
 
 
3094
 
 
3095
class LossyPushToSameVCS(BzrError):
 
3096
 
 
3097
    _fmt = ("Lossy push not possible between %(source_branch)r and "
 
3098
            "%(target_branch)r that are in the same VCS.")
 
3099
 
 
3100
    internal_error = True
 
3101
 
 
3102
    def __init__(self, source_branch, target_branch):
 
3103
        self.source_branch = source_branch
 
3104
        self.target_branch = target_branch
 
3105
 
 
3106
 
 
3107
class NoRoundtrippingSupport(BzrError):
 
3108
 
 
3109
    _fmt = ("Roundtripping is not supported between %(source_branch)r and "
 
3110
            "%(target_branch)r.")
 
3111
 
 
3112
    internal_error = True
 
3113
 
 
3114
    def __init__(self, source_branch, target_branch):
 
3115
        self.source_branch = source_branch
 
3116
        self.target_branch = target_branch
 
3117
 
 
3118
 
 
3119
class FileTimestampUnavailable(BzrError):
 
3120
 
 
3121
    _fmt = "The filestamp for %(path)s is not available."
 
3122
 
 
3123
    internal_error = True
 
3124
 
 
3125
    def __init__(self, path):
 
3126
        self.path = path