← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/errors.py

  • Committer: Andrew Bennetts
  • Date: 2010-01-12 03:53:21 UTC
  • mfrom: (4948 +trunk)
  • mto: This revision was merged to the branch mainline in revision 4964.
  • Revision ID: andrew.bennetts@canonical.com-20100112035321-hofpz5p10224ryj3
Merge lp:bzr, resolving conflicts.

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
"""
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
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):
783
793
 
784
794
 
785
795
class IncompatibleRepositories(BzrError):
 
796
    """Report an error that two repositories are not compatible.
 
797
 
 
798
    Note that the source and target repositories are permitted to be strings:
 
799
    this exception is thrown from the smart server and may refer to a
 
800
    repository the client hasn't opened.
 
801
    """
786
802
 
787
803
    _fmt = "%(target)s\n" \
788
804
            "is not compatible with\n" \
796
812
 
797
813
 
798
814
class IncompatibleRevision(BzrError):
799
 
    
 
815
 
800
816
    _fmt = "Revision is not compatible with %(repo_format)s"
801
817
 
802
818
    def __init__(self, repo_format):
1003
1019
 
1004
1020
class LockContention(LockError):
1005
1021
 
1006
 
    _fmt = 'Could not acquire lock "%(lock)s"'
 
1022
    _fmt = 'Could not acquire lock "%(lock)s": %(msg)s'
1007
1023
    # TODO: show full url for lock, combining the transport and relative
1008
1024
    # bits?
1009
1025
 
1010
1026
    internal_error = False
1011
1027
 
1012
 
    def __init__(self, lock):
 
1028
    def __init__(self, lock, msg=''):
1013
1029
        self.lock = lock
 
1030
        self.msg = msg
1014
1031
 
1015
1032
 
1016
1033
class LockBroken(LockError):
1130
1147
 
1131
1148
class NoSuchRevisionInTree(NoSuchRevision):
1132
1149
    """When using Tree.revision_tree, and the revision is not accessible."""
1133
 
    
 
1150
 
1134
1151
    _fmt = "The revision id {%(revision_id)s} is not present in the tree %(tree)s."
1135
1152
 
1136
1153
    def __init__(self, tree, revision_id):
1172
1189
class DivergedBranches(BzrError):
1173
1190
 
1174
1191
    _fmt = ("These branches have diverged."
1175
 
            " Use the merge command to reconcile them.")
 
1192
            " Use the missing command to see how.\n"
 
1193
            "Use the merge command to reconcile them.")
1176
1194
 
1177
1195
    def __init__(self, branch1, branch2):
1178
1196
        self.branch1 = branch1
1200
1218
 
1201
1219
 
1202
1220
class NoCommonAncestor(BzrError):
1203
 
    
 
1221
 
1204
1222
    _fmt = "Revisions have no common ancestor: %(revision_a)s %(revision_b)s"
1205
1223
 
1206
1224
    def __init__(self, revision_a, revision_b):
1226
1244
            not_ancestor_id=not_ancestor_id)
1227
1245
 
1228
1246
 
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
1247
class AmbiguousBase(BzrError):
1239
1248
 
1240
1249
    def __init__(self, bases):
1241
 
        warn("BzrError AmbiguousBase has been deprecated as of bzrlib 0.8.",
1242
 
                DeprecationWarning)
 
1250
        symbol_versioning.warn("BzrError AmbiguousBase has been deprecated "
 
1251
            "as of bzrlib 0.8.", DeprecationWarning, stacklevel=2)
1243
1252
        msg = ("The correct base is unclear, because %s are all equally close"
1244
1253
                % ", ".join(bases))
1245
1254
        BzrError.__init__(self, msg)
1274
1283
        self.branch = branch
1275
1284
        self.master = master
1276
1285
 
1277
 
        
 
1286
 
1278
1287
class CommitToDoubleBoundBranch(BzrError):
1279
1288
 
1280
1289
    _fmt = ("Cannot commit to branch %(branch)s."
1350
1359
class WeaveParentMismatch(WeaveError):
1351
1360
 
1352
1361
    _fmt = "Parents are mismatched between two revisions. %(message)s"
1353
 
    
 
1362
 
1354
1363
 
1355
1364
class WeaveInvalidChecksum(WeaveError):
1356
1365
 
1382
1391
 
1383
1392
 
1384
1393
class VersionedFileError(BzrError):
1385
 
    
 
1394
 
1386
1395
    _fmt = "Versioned file error"
1387
1396
 
1388
1397
 
1389
1398
class RevisionNotPresent(VersionedFileError):
1390
 
    
 
1399
 
1391
1400
    _fmt = 'Revision {%(revision_id)s} not present in "%(file_id)s".'
1392
1401
 
1393
1402
    def __init__(self, revision_id, file_id):
1397
1406
 
1398
1407
 
1399
1408
class RevisionAlreadyPresent(VersionedFileError):
1400
 
    
 
1409
 
1401
1410
    _fmt = 'Revision {%(revision_id)s} already present in "%(file_id)s".'
1402
1411
 
1403
1412
    def __init__(self, revision_id, file_id):
1412
1421
 
1413
1422
 
1414
1423
class KnitError(InternalBzrError):
1415
 
    
 
1424
 
1416
1425
    _fmt = "Knit error"
1417
1426
 
1418
1427
 
1450
1459
    def __init__(self, stream_format, target_format):
1451
1460
        self.stream_format = stream_format
1452
1461
        self.target_format = target_format
1453
 
        
 
1462
 
1454
1463
 
1455
1464
class KnitDataStreamUnknown(KnitError):
1456
1465
    # Indicates a data stream we don't know how to handle.
1459
1468
 
1460
1469
    def __init__(self, stream_format):
1461
1470
        self.stream_format = stream_format
1462
 
        
 
1471
 
1463
1472
 
1464
1473
class KnitHeaderError(KnitError):
1465
1474
 
1475
1484
 
1476
1485
    Currently only 'fulltext' and 'line-delta' are supported.
1477
1486
    """
1478
 
    
 
1487
 
1479
1488
    _fmt = ("Knit index %(filename)s does not have a known method"
1480
1489
            " in options: %(options)r")
1481
1490
 
1532
1541
 
1533
1542
 
1534
1543
class NoSuchExportFormat(BzrError):
1535
 
    
 
1544
 
1536
1545
    _fmt = "Export format %(format)r not supported"
1537
1546
 
1538
1547
    def __init__(self, format):
1541
1550
 
1542
1551
 
1543
1552
class TransportError(BzrError):
1544
 
    
 
1553
 
1545
1554
    _fmt = "Transport error: %(msg)s %(orig_error)s"
1546
1555
 
1547
1556
    def __init__(self, msg=None, orig_error=None):
1634
1643
            self.port = ':%s' % port
1635
1644
 
1636
1645
 
 
1646
# XXX: This is also used for unexpected end of file, which is different at the
 
1647
# TCP level from "connection reset".
1637
1648
class ConnectionReset(TransportError):
1638
1649
 
1639
1650
    _fmt = "Connection closed: %(msg)s %(orig_error)s"
1729
1740
 
1730
1741
class WorkingTreeNotRevision(BzrError):
1731
1742
 
1732
 
    _fmt = ("The working tree for %(basedir)s has changed since" 
 
1743
    _fmt = ("The working tree for %(basedir)s has changed since"
1733
1744
            " the last commit, but weave merge requires that it be"
1734
1745
            " unchanged")
1735
1746
 
2001
2012
 
2002
2013
class BadConversionTarget(BzrError):
2003
2014
 
2004
 
    _fmt = "Cannot convert to format %(format)s.  %(problem)s"
 
2015
    _fmt = "Cannot convert from format %(from_format)s to format %(format)s." \
 
2016
            "    %(problem)s"
2005
2017
 
2006
 
    def __init__(self, problem, format):
 
2018
    def __init__(self, problem, format, from_format=None):
2007
2019
        BzrError.__init__(self)
2008
2020
        self.problem = problem
2009
2021
        self.format = format
 
2022
        self.from_format = from_format or '(unspecified)'
2010
2023
 
2011
2024
 
2012
2025
class NoDiffFound(BzrError):
2049
2062
    _fmt = """This tree contains left-over files from a failed operation.
2050
2063
    Please examine %(limbo_dir)s to see if it contains any files you wish to
2051
2064
    keep, and delete it when you are done."""
2052
 
    
 
2065
 
2053
2066
    def __init__(self, limbo_dir):
2054
2067
       BzrError.__init__(self)
2055
2068
       self.limbo_dir = limbo_dir
2088
2101
 
2089
2102
class OutOfDateTree(BzrError):
2090
2103
 
2091
 
    _fmt = "Working tree is out of date, please run 'bzr update'."
 
2104
    _fmt = "Working tree is out of date, please run 'bzr update'.%(more)s"
2092
2105
 
2093
 
    def __init__(self, tree):
 
2106
    def __init__(self, tree, more=None):
 
2107
        if more is None:
 
2108
            more = ''
 
2109
        else:
 
2110
            more = ' ' + more
2094
2111
        BzrError.__init__(self)
2095
2112
        self.tree = tree
 
2113
        self.more = more
2096
2114
 
2097
2115
 
2098
2116
class PublicBranchOutOfDate(BzrError):
2152
2170
        self.reason = reason
2153
2171
 
2154
2172
 
 
2173
class InconsistentDeltaDelta(InconsistentDelta):
 
2174
    """Used when we get a delta that is not valid."""
 
2175
 
 
2176
    _fmt = ("An inconsistent delta was supplied: %(delta)r"
 
2177
            "\nreason: %(reason)s")
 
2178
 
 
2179
    def __init__(self, delta, reason):
 
2180
        BzrError.__init__(self)
 
2181
        self.delta = delta
 
2182
        self.reason = reason
 
2183
 
 
2184
 
2155
2185
class UpgradeRequired(BzrError):
2156
2186
 
2157
2187
    _fmt = "To use this feature you must upgrade your branch at %(path)s."
2166
2196
    _fmt = "To use this feature you must upgrade your repository at %(path)s."
2167
2197
 
2168
2198
 
 
2199
class RichRootUpgradeRequired(UpgradeRequired):
 
2200
 
 
2201
    _fmt = ("To use this feature you must upgrade your branch at %(path)s to"
 
2202
           " a format which supports rich roots.")
 
2203
 
 
2204
 
2169
2205
class LocalRequiresBoundBranch(BzrError):
2170
2206
 
2171
2207
    _fmt = "Cannot perform local-only commits on unbound branches."
2172
2208
 
2173
2209
 
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
2210
class UnsupportedOperation(BzrError):
2184
2211
 
2185
2212
    _fmt = ("The method %(mname)s is not supported on"
2202
2229
 
2203
2230
 
2204
2231
class BinaryFile(BzrError):
2205
 
    
 
2232
 
2206
2233
    _fmt = "File is binary but should be text."
2207
2234
 
2208
2235
 
2228
2255
 
2229
2256
 
2230
2257
class NotABundle(BzrError):
2231
 
    
 
2258
 
2232
2259
    _fmt = "Not a bzr revision-bundle: %(text)r"
2233
2260
 
2234
2261
    def __init__(self, text):
2236
2263
        self.text = text
2237
2264
 
2238
2265
 
2239
 
class BadBundle(BzrError): 
2240
 
    
 
2266
class BadBundle(BzrError):
 
2267
 
2241
2268
    _fmt = "Bad bzr revision-bundle: %(text)r"
2242
2269
 
2243
2270
    def __init__(self, text):
2245
2272
        self.text = text
2246
2273
 
2247
2274
 
2248
 
class MalformedHeader(BadBundle): 
2249
 
    
 
2275
class MalformedHeader(BadBundle):
 
2276
 
2250
2277
    _fmt = "Malformed bzr revision-bundle header: %(text)r"
2251
2278
 
2252
2279
 
2253
 
class MalformedPatches(BadBundle): 
2254
 
    
 
2280
class MalformedPatches(BadBundle):
 
2281
 
2255
2282
    _fmt = "Malformed patches in bzr revision-bundle: %(text)r"
2256
2283
 
2257
2284
 
2258
 
class MalformedFooter(BadBundle): 
2259
 
    
 
2285
class MalformedFooter(BadBundle):
 
2286
 
2260
2287
    _fmt = "Malformed footer in bzr revision-bundle: %(text)r"
2261
2288
 
2262
2289
 
2263
2290
class UnsupportedEOLMarker(BadBundle):
2264
 
    
2265
 
    _fmt = "End of line marker was not \\n in bzr revision-bundle"    
 
2291
 
 
2292
    _fmt = "End of line marker was not \\n in bzr revision-bundle"
2266
2293
 
2267
2294
    def __init__(self):
2268
 
        # XXX: BadBundle's constructor assumes there's explanatory text, 
 
2295
        # XXX: BadBundle's constructor assumes there's explanatory text,
2269
2296
        # but for this there is not
2270
2297
        BzrError.__init__(self)
2271
2298
 
2272
2299
 
2273
2300
class IncompatibleBundleFormat(BzrError):
2274
 
    
 
2301
 
2275
2302
    _fmt = "Bundle format %(bundle_format)s is incompatible with %(other)s"
2276
2303
 
2277
2304
    def __init__(self, bundle_format, other):
2281
2308
 
2282
2309
 
2283
2310
class BadInventoryFormat(BzrError):
2284
 
    
 
2311
 
2285
2312
    _fmt = "Root class for inventory serialization errors"
2286
2313
 
2287
2314
 
2306
2333
        self.transport = transport
2307
2334
 
2308
2335
 
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
2336
class UnknownSSH(BzrError):
2319
2337
 
2320
2338
    _fmt = "Unrecognised value for BZR_SSH environment variable: %(vendor)s"
2340
2358
        self.revision_id = revision_id
2341
2359
        self.ghost_revision_id = ghost_revision_id
2342
2360
 
2343
 
        
 
2361
 
2344
2362
class GhostRevisionUnusableHere(BzrError):
2345
2363
 
2346
2364
    _fmt = "Ghost revision {%(revision_id)s} cannot be used here."
2438
2456
 
2439
2457
 
2440
2458
class UnsupportedInventoryKind(BzrError):
2441
 
    
 
2459
 
2442
2460
    _fmt = """Unsupported entry kind %(kind)s"""
2443
2461
 
2444
2462
    def __init__(self, kind):
2456
2474
 
2457
2475
 
2458
2476
class SubsumeTargetNeedsUpgrade(BzrError):
2459
 
    
 
2477
 
2460
2478
    _fmt = """Subsume target %(other_tree)s needs to be upgraded."""
2461
2479
 
2462
2480
    def __init__(self, other_tree):
2490
2508
    def __init__(self, branch):
2491
2509
        self.branch = branch
2492
2510
 
2493
 
        
 
2511
 
2494
2512
class TagAlreadyExists(BzrError):
2495
2513
 
2496
2514
    _fmt = "Tag %(tag_name)s already exists."
2501
2519
 
2502
2520
class MalformedBugIdentifier(BzrError):
2503
2521
 
2504
 
    _fmt = "Did not understand bug identifier %(bug_id)s: %(reason)s"
 
2522
    _fmt = ('Did not understand bug identifier %(bug_id)s: %(reason)s. '
 
2523
            'See "bzr help bugs" for more information on this feature.')
2505
2524
 
2506
2525
    def __init__(self, bug_id, reason):
2507
2526
        self.bug_id = bug_id
2528
2547
        self.branch = branch
2529
2548
 
2530
2549
 
 
2550
class InvalidLineInBugsProperty(BzrError):
 
2551
 
 
2552
    _fmt = ("Invalid line in bugs property: '%(line)s'")
 
2553
 
 
2554
    def __init__(self, line):
 
2555
        self.line = line
 
2556
 
 
2557
 
 
2558
class InvalidBugStatus(BzrError):
 
2559
 
 
2560
    _fmt = ("Invalid bug status: '%(status)s'")
 
2561
 
 
2562
    def __init__(self, status):
 
2563
        self.status = status
 
2564
 
 
2565
 
2531
2566
class UnexpectedSmartServerResponse(BzrError):
2532
2567
 
2533
2568
    _fmt = "Could not understand response from smart server: %(response_tuple)r"
2579
2614
        """
2580
2615
        self.error_from_smart_server = error_from_smart_server
2581
2616
        self.error_tuple = error_from_smart_server.error_tuple
2582
 
        
 
2617
 
2583
2618
 
2584
2619
class ContainerError(BzrError):
2585
2620
    """Base class of container errors."""
2588
2623
class UnknownContainerFormatError(ContainerError):
2589
2624
 
2590
2625
    _fmt = "Unrecognised container format: %(container_format)r"
2591
 
    
 
2626
 
2592
2627
    def __init__(self, container_format):
2593
2628
        self.container_format = container_format
2594
2629
 
2744
2779
    _fmt = "'%(display_url)s' is already standalone."
2745
2780
 
2746
2781
 
 
2782
class AlreadyWithTrees(BzrDirError):
 
2783
 
 
2784
    _fmt = ("Shared repository '%(display_url)s' already creates "
 
2785
            "working trees.")
 
2786
 
 
2787
 
 
2788
class AlreadyWithNoTrees(BzrDirError):
 
2789
 
 
2790
    _fmt = ("Shared repository '%(display_url)s' already doesn't create "
 
2791
            "working trees.")
 
2792
 
 
2793
 
2747
2794
class ReconfigurationNotSupported(BzrDirError):
2748
2795
 
2749
2796
    _fmt = "Requested reconfiguration of '%(display_url)s' is not supported."
2756
2803
 
2757
2804
class UncommittedChanges(BzrError):
2758
2805
 
2759
 
    _fmt = 'Working tree "%(display_url)s" has uncommitted changes.'
 
2806
    _fmt = ('Working tree "%(display_url)s" has uncommitted changes'
 
2807
            ' (See bzr status).%(more)s')
2760
2808
 
2761
 
    def __init__(self, tree):
 
2809
    def __init__(self, tree, more=None):
 
2810
        if more is None:
 
2811
            more = ''
 
2812
        else:
 
2813
            more = ' ' + more
2762
2814
        import bzrlib.urlutils as urlutils
2763
2815
        display_url = urlutils.unescape_for_display(
2764
2816
            tree.bzrdir.root_transport.base, 'ascii')
2765
 
        BzrError.__init__(self, tree=tree, display_url=display_url)
 
2817
        BzrError.__init__(self, tree=tree, display_url=display_url, more=more)
2766
2818
 
2767
2819
 
2768
2820
class MissingTemplateVariable(BzrError):
2803
2855
 
2804
2856
 
2805
2857
class CommandAvailableInPlugin(StandardError):
2806
 
    
 
2858
 
2807
2859
    internal_error = False
2808
2860
 
2809
2861
    def __init__(self, cmd_name, plugin_metadata, provider):
2810
 
        
 
2862
 
2811
2863
        self.plugin_metadata = plugin_metadata
2812
2864
        self.cmd_name = cmd_name
2813
2865
        self.provider = provider
2814
2866
 
2815
2867
    def __str__(self):
2816
2868
 
2817
 
        _fmt = ('"%s" is not a standard bzr command. \n' 
 
2869
        _fmt = ('"%s" is not a standard bzr command. \n'
2818
2870
                'However, the following official plugin provides this command: %s\n'
2819
2871
                'You can install it by going to: %s'
2820
 
                % (self.cmd_name, self.plugin_metadata['name'], 
 
2872
                % (self.cmd_name, self.plugin_metadata['name'],
2821
2873
                    self.plugin_metadata['url']))
2822
2874
 
2823
2875
        return _fmt
2824
2876
 
2825
2877
 
2826
2878
class NoPluginAvailable(BzrError):
2827
 
    pass    
2828
 
 
2829
 
 
2830
 
class NotATerminal(BzrError):
2831
 
 
2832
 
    _fmt = 'Unable to ask for a password without real terminal.'
 
2879
    pass
2833
2880
 
2834
2881
 
2835
2882
class UnableEncodePath(BzrError):
2879
2926
    _fmt = 'Cannot bind address "%(host)s:%(port)i": %(orig_error)s.'
2880
2927
 
2881
2928
    def __init__(self, host, port, orig_error):
 
2929
        # nb: in python2.4 socket.error doesn't have a useful repr
2882
2930
        BzrError.__init__(self, host=host, port=port,
2883
 
            orig_error=orig_error[1])
 
2931
            orig_error=repr(orig_error.args))
2884
2932
 
2885
2933
 
2886
2934
class UnknownRules(BzrError):
2894
2942
class HookFailed(BzrError):
2895
2943
    """Raised when a pre_change_branch_tip hook function fails anything other
2896
2944
    than TipChangeRejected.
 
2945
 
 
2946
    Note that this exception is no longer raised, and the import is only left
 
2947
    to be nice to code which might catch it in a plugin.
2897
2948
    """
2898
2949
 
2899
2950
    _fmt = ("Hook '%(hook_name)s' during %(hook_stage)s failed:\n"
2900
2951
            "%(traceback_text)s%(exc_value)s")
2901
2952
 
2902
 
    def __init__(self, hook_stage, hook_name, exc_info):
 
2953
    def __init__(self, hook_stage, hook_name, exc_info, warn=True):
 
2954
        if warn:
 
2955
            symbol_versioning.warn("BzrError HookFailed has been deprecated "
 
2956
                "as of bzrlib 2.1.", DeprecationWarning, stacklevel=2)
2903
2957
        import traceback
2904
2958
        self.hook_stage = hook_stage
2905
2959
        self.hook_name = hook_name
2914
2968
    """A pre_change_branch_tip hook function may raise this to cleanly and
2915
2969
    explicitly abort a change to a branch tip.
2916
2970
    """
2917
 
    
 
2971
 
2918
2972
    _fmt = u"Tip change rejected: %(msg)s"
2919
2973
 
2920
2974
    def __init__(self, msg):
2934
2988
        BzrError.__init__(self, shelf_id=shelf_id)
2935
2989
 
2936
2990
 
 
2991
class InvalidShelfId(BzrError):
 
2992
 
 
2993
    _fmt = '"%(invalid_id)s" is not a valid shelf id, try a number instead.'
 
2994
 
 
2995
    def __init__(self, invalid_id):
 
2996
        BzrError.__init__(self, invalid_id=invalid_id)
 
2997
 
 
2998
 
 
2999
class JailBreak(BzrError):
 
3000
 
 
3001
    _fmt = "An attempt to access a url outside the server jail was made: '%(url)s'."
 
3002
 
 
3003
    def __init__(self, url):
 
3004
        BzrError.__init__(self, url=url)
 
3005
 
 
3006
 
2937
3007
class UserAbort(BzrError):
2938
3008
 
2939
3009
    _fmt = 'The user aborted the operation.'
 
3010
 
 
3011
 
 
3012
class MustHaveWorkingTree(BzrError):
 
3013
 
 
3014
    _fmt = ("Branching '%(url)s'(%(format)s) must create a working tree.")
 
3015
 
 
3016
    def __init__(self, format, url):
 
3017
        BzrError.__init__(self, format=format, url=url)
 
3018
 
 
3019
 
 
3020
class NoSuchView(BzrError):
 
3021
    """A view does not exist.
 
3022
    """
 
3023
 
 
3024
    _fmt = u"No such view: %(view_name)s."
 
3025
 
 
3026
    def __init__(self, view_name):
 
3027
        self.view_name = view_name
 
3028
 
 
3029
 
 
3030
class ViewsNotSupported(BzrError):
 
3031
    """Views are not supported by a tree format.
 
3032
    """
 
3033
 
 
3034
    _fmt = ("Views are not supported by %(tree)s;"
 
3035
            " use 'bzr upgrade' to change your tree to a later format.")
 
3036
 
 
3037
    def __init__(self, tree):
 
3038
        self.tree = tree
 
3039
 
 
3040
 
 
3041
class FileOutsideView(BzrError):
 
3042
 
 
3043
    _fmt = ('Specified file "%(file_name)s" is outside the current view: '
 
3044
            '%(view_str)s')
 
3045
 
 
3046
    def __init__(self, file_name, view_files):
 
3047
        self.file_name = file_name
 
3048
        self.view_str = ", ".join(view_files)
 
3049
 
 
3050
 
 
3051
class UnresumableWriteGroup(BzrError):
 
3052
 
 
3053
    _fmt = ("Repository %(repository)s cannot resume write group "
 
3054
            "%(write_groups)r: %(reason)s")
 
3055
 
 
3056
    internal_error = True
 
3057
 
 
3058
    def __init__(self, repository, write_groups, reason):
 
3059
        self.repository = repository
 
3060
        self.write_groups = write_groups
 
3061
        self.reason = reason
 
3062
 
 
3063
 
 
3064
class UnsuspendableWriteGroup(BzrError):
 
3065
 
 
3066
    _fmt = ("Repository %(repository)s cannot suspend a write group.")
 
3067
 
 
3068
    internal_error = True
 
3069
 
 
3070
    def __init__(self, repository):
 
3071
        self.repository = repository
 
3072
 
 
3073
 
 
3074
class LossyPushToSameVCS(BzrError):
 
3075
 
 
3076
    _fmt = ("Lossy push not possible between %(source_branch)r and "
 
3077
            "%(target_branch)r that are in the same VCS.")
 
3078
 
 
3079
    internal_error = True
 
3080
 
 
3081
    def __init__(self, source_branch, target_branch):
 
3082
        self.source_branch = source_branch
 
3083
        self.target_branch = target_branch
 
3084
 
 
3085
 
 
3086
class NoRoundtrippingSupport(BzrError):
 
3087
 
 
3088
    _fmt = ("Roundtripping is not supported between %(source_branch)r and "
 
3089
            "%(target_branch)r.")
 
3090
 
 
3091
    internal_error = True
 
3092
 
 
3093
    def __init__(self, source_branch, target_branch):
 
3094
        self.source_branch = source_branch
 
3095
        self.target_branch = target_branch