← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/errors.py

  • Committer: Martin Pool
  • Date: 2009-03-03 03:01:49 UTC
  • mfrom: (4070 +trunk)
  • mto: This revision was merged to the branch mainline in revision 4073.
  • Revision ID: mbp@sourcefrog.net-20090303030149-8p8o8hszdtqa7w8f
merge trunk

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/errors.py
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,
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.")
648
648
 
649
649
 
650
650
class ReadError(PathError):
651
 
    
 
651
 
652
652
    _fmt = """Error reading from %(path)r."""
653
653
 
654
654
 
689
689
 
690
690
# TODO: This is given a URL; we try to unescape it but doing that from inside
691
691
# the exception object is a bit undesirable.
692
 
# TODO: Probably this behavior of should be a common superclass 
 
692
# TODO: Probably this behavior of should be a common superclass
693
693
class NotBranchError(PathError):
694
694
 
695
695
    _fmt = 'Not a branch: "%(path)s".'
764
764
 
765
765
 
766
766
class UnknownFormatError(BzrError):
767
 
    
 
767
 
768
768
    _fmt = "Unknown %(kind)s format: %(format)r"
769
769
 
770
770
    def __init__(self, format, kind='branch'):
773
773
 
774
774
 
775
775
class IncompatibleFormat(BzrError):
776
 
    
 
776
 
777
777
    _fmt = "Format %(format)s is not compatible with .bzr version %(bzrdir)s."
778
778
 
779
779
    def __init__(self, format, bzrdir_format):
796
796
 
797
797
 
798
798
class IncompatibleRevision(BzrError):
799
 
    
 
799
 
800
800
    _fmt = "Revision is not compatible with %(repo_format)s"
801
801
 
802
802
    def __init__(self, repo_format):
1130
1130
 
1131
1131
class NoSuchRevisionInTree(NoSuchRevision):
1132
1132
    """When using Tree.revision_tree, and the revision is not accessible."""
1133
 
    
 
1133
 
1134
1134
    _fmt = "The revision id {%(revision_id)s} is not present in the tree %(tree)s."
1135
1135
 
1136
1136
    def __init__(self, tree, revision_id):
1200
1200
 
1201
1201
 
1202
1202
class NoCommonAncestor(BzrError):
1203
 
    
 
1203
 
1204
1204
    _fmt = "Revisions have no common ancestor: %(revision_a)s %(revision_b)s"
1205
1205
 
1206
1206
    def __init__(self, revision_a, revision_b):
1274
1274
        self.branch = branch
1275
1275
        self.master = master
1276
1276
 
1277
 
        
 
1277
 
1278
1278
class CommitToDoubleBoundBranch(BzrError):
1279
1279
 
1280
1280
    _fmt = ("Cannot commit to branch %(branch)s."
1350
1350
class WeaveParentMismatch(WeaveError):
1351
1351
 
1352
1352
    _fmt = "Parents are mismatched between two revisions. %(message)s"
1353
 
    
 
1353
 
1354
1354
 
1355
1355
class WeaveInvalidChecksum(WeaveError):
1356
1356
 
1382
1382
 
1383
1383
 
1384
1384
class VersionedFileError(BzrError):
1385
 
    
 
1385
 
1386
1386
    _fmt = "Versioned file error"
1387
1387
 
1388
1388
 
1389
1389
class RevisionNotPresent(VersionedFileError):
1390
 
    
 
1390
 
1391
1391
    _fmt = 'Revision {%(revision_id)s} not present in "%(file_id)s".'
1392
1392
 
1393
1393
    def __init__(self, revision_id, file_id):
1397
1397
 
1398
1398
 
1399
1399
class RevisionAlreadyPresent(VersionedFileError):
1400
 
    
 
1400
 
1401
1401
    _fmt = 'Revision {%(revision_id)s} already present in "%(file_id)s".'
1402
1402
 
1403
1403
    def __init__(self, revision_id, file_id):
1412
1412
 
1413
1413
 
1414
1414
class KnitError(InternalBzrError):
1415
 
    
 
1415
 
1416
1416
    _fmt = "Knit error"
1417
1417
 
1418
1418
 
1450
1450
    def __init__(self, stream_format, target_format):
1451
1451
        self.stream_format = stream_format
1452
1452
        self.target_format = target_format
1453
 
        
 
1453
 
1454
1454
 
1455
1455
class KnitDataStreamUnknown(KnitError):
1456
1456
    # Indicates a data stream we don't know how to handle.
1459
1459
 
1460
1460
    def __init__(self, stream_format):
1461
1461
        self.stream_format = stream_format
1462
 
        
 
1462
 
1463
1463
 
1464
1464
class KnitHeaderError(KnitError):
1465
1465
 
1475
1475
 
1476
1476
    Currently only 'fulltext' and 'line-delta' are supported.
1477
1477
    """
1478
 
    
 
1478
 
1479
1479
    _fmt = ("Knit index %(filename)s does not have a known method"
1480
1480
            " in options: %(options)r")
1481
1481
 
1532
1532
 
1533
1533
 
1534
1534
class NoSuchExportFormat(BzrError):
1535
 
    
 
1535
 
1536
1536
    _fmt = "Export format %(format)r not supported"
1537
1537
 
1538
1538
    def __init__(self, format):
1541
1541
 
1542
1542
 
1543
1543
class TransportError(BzrError):
1544
 
    
 
1544
 
1545
1545
    _fmt = "Transport error: %(msg)s %(orig_error)s"
1546
1546
 
1547
1547
    def __init__(self, msg=None, orig_error=None):
1729
1729
 
1730
1730
class WorkingTreeNotRevision(BzrError):
1731
1731
 
1732
 
    _fmt = ("The working tree for %(basedir)s has changed since" 
 
1732
    _fmt = ("The working tree for %(basedir)s has changed since"
1733
1733
            " the last commit, but weave merge requires that it be"
1734
1734
            " unchanged")
1735
1735
 
2049
2049
    _fmt = """This tree contains left-over files from a failed operation.
2050
2050
    Please examine %(limbo_dir)s to see if it contains any files you wish to
2051
2051
    keep, and delete it when you are done."""
2052
 
    
 
2052
 
2053
2053
    def __init__(self, limbo_dir):
2054
2054
       BzrError.__init__(self)
2055
2055
       self.limbo_dir = limbo_dir
2202
2202
 
2203
2203
 
2204
2204
class BinaryFile(BzrError):
2205
 
    
 
2205
 
2206
2206
    _fmt = "File is binary but should be text."
2207
2207
 
2208
2208
 
2228
2228
 
2229
2229
 
2230
2230
class NotABundle(BzrError):
2231
 
    
 
2231
 
2232
2232
    _fmt = "Not a bzr revision-bundle: %(text)r"
2233
2233
 
2234
2234
    def __init__(self, text):
2236
2236
        self.text = text
2237
2237
 
2238
2238
 
2239
 
class BadBundle(BzrError): 
2240
 
    
 
2239
class BadBundle(BzrError):
 
2240
 
2241
2241
    _fmt = "Bad bzr revision-bundle: %(text)r"
2242
2242
 
2243
2243
    def __init__(self, text):
2245
2245
        self.text = text
2246
2246
 
2247
2247
 
2248
 
class MalformedHeader(BadBundle): 
2249
 
    
 
2248
class MalformedHeader(BadBundle):
 
2249
 
2250
2250
    _fmt = "Malformed bzr revision-bundle header: %(text)r"
2251
2251
 
2252
2252
 
2253
 
class MalformedPatches(BadBundle): 
2254
 
    
 
2253
class MalformedPatches(BadBundle):
 
2254
 
2255
2255
    _fmt = "Malformed patches in bzr revision-bundle: %(text)r"
2256
2256
 
2257
2257
 
2258
 
class MalformedFooter(BadBundle): 
2259
 
    
 
2258
class MalformedFooter(BadBundle):
 
2259
 
2260
2260
    _fmt = "Malformed footer in bzr revision-bundle: %(text)r"
2261
2261
 
2262
2262
 
2263
2263
class UnsupportedEOLMarker(BadBundle):
2264
 
    
2265
 
    _fmt = "End of line marker was not \\n in bzr revision-bundle"    
 
2264
 
 
2265
    _fmt = "End of line marker was not \\n in bzr revision-bundle"
2266
2266
 
2267
2267
    def __init__(self):
2268
 
        # XXX: BadBundle's constructor assumes there's explanatory text, 
 
2268
        # XXX: BadBundle's constructor assumes there's explanatory text,
2269
2269
        # but for this there is not
2270
2270
        BzrError.__init__(self)
2271
2271
 
2272
2272
 
2273
2273
class IncompatibleBundleFormat(BzrError):
2274
 
    
 
2274
 
2275
2275
    _fmt = "Bundle format %(bundle_format)s is incompatible with %(other)s"
2276
2276
 
2277
2277
    def __init__(self, bundle_format, other):
2281
2281
 
2282
2282
 
2283
2283
class BadInventoryFormat(BzrError):
2284
 
    
 
2284
 
2285
2285
    _fmt = "Root class for inventory serialization errors"
2286
2286
 
2287
2287
 
2340
2340
        self.revision_id = revision_id
2341
2341
        self.ghost_revision_id = ghost_revision_id
2342
2342
 
2343
 
        
 
2343
 
2344
2344
class GhostRevisionUnusableHere(BzrError):
2345
2345
 
2346
2346
    _fmt = "Ghost revision {%(revision_id)s} cannot be used here."
2438
2438
 
2439
2439
 
2440
2440
class UnsupportedInventoryKind(BzrError):
2441
 
    
 
2441
 
2442
2442
    _fmt = """Unsupported entry kind %(kind)s"""
2443
2443
 
2444
2444
    def __init__(self, kind):
2456
2456
 
2457
2457
 
2458
2458
class SubsumeTargetNeedsUpgrade(BzrError):
2459
 
    
 
2459
 
2460
2460
    _fmt = """Subsume target %(other_tree)s needs to be upgraded."""
2461
2461
 
2462
2462
    def __init__(self, other_tree):
2490
2490
    def __init__(self, branch):
2491
2491
        self.branch = branch
2492
2492
 
2493
 
        
 
2493
 
2494
2494
class TagAlreadyExists(BzrError):
2495
2495
 
2496
2496
    _fmt = "Tag %(tag_name)s already exists."
2579
2579
        """
2580
2580
        self.error_from_smart_server = error_from_smart_server
2581
2581
        self.error_tuple = error_from_smart_server.error_tuple
2582
 
        
 
2582
 
2583
2583
 
2584
2584
class ContainerError(BzrError):
2585
2585
    """Base class of container errors."""
2588
2588
class UnknownContainerFormatError(ContainerError):
2589
2589
 
2590
2590
    _fmt = "Unrecognised container format: %(container_format)r"
2591
 
    
 
2591
 
2592
2592
    def __init__(self, container_format):
2593
2593
        self.container_format = container_format
2594
2594
 
2815
2815
 
2816
2816
 
2817
2817
class CommandAvailableInPlugin(StandardError):
2818
 
    
 
2818
 
2819
2819
    internal_error = False
2820
2820
 
2821
2821
    def __init__(self, cmd_name, plugin_metadata, provider):
2822
 
        
 
2822
 
2823
2823
        self.plugin_metadata = plugin_metadata
2824
2824
        self.cmd_name = cmd_name
2825
2825
        self.provider = provider
2826
2826
 
2827
2827
    def __str__(self):
2828
2828
 
2829
 
        _fmt = ('"%s" is not a standard bzr command. \n' 
 
2829
        _fmt = ('"%s" is not a standard bzr command. \n'
2830
2830
                'However, the following official plugin provides this command: %s\n'
2831
2831
                'You can install it by going to: %s'
2832
 
                % (self.cmd_name, self.plugin_metadata['name'], 
 
2832
                % (self.cmd_name, self.plugin_metadata['name'],
2833
2833
                    self.plugin_metadata['url']))
2834
2834
 
2835
2835
        return _fmt
2836
2836
 
2837
2837
 
2838
2838
class NoPluginAvailable(BzrError):
2839
 
    pass    
 
2839
    pass
2840
2840
 
2841
2841
 
2842
2842
class NotATerminal(BzrError):
2926
2926
    """A pre_change_branch_tip hook function may raise this to cleanly and
2927
2927
    explicitly abort a change to a branch tip.
2928
2928
    """
2929
 
    
 
2929
 
2930
2930
    _fmt = u"Tip change rejected: %(msg)s"
2931
2931
 
2932
2932
    def __init__(self, msg):
2965
2965
 
2966
2966
    def __init__(self, format, url):
2967
2967
        BzrError.__init__(self, format=format, url=url)
 
2968
 
 
2969
 
 
2970
class NoSuchView(BzrError):
 
2971
    """A view does not exist.
 
2972
    """
 
2973
 
 
2974
    _fmt = u"No such view: %(view_name)s."
 
2975
 
 
2976
    def __init__(self, view_name):
 
2977
        self.view_name = view_name
 
2978
 
 
2979
 
 
2980
class ViewsNotSupported(BzrError):
 
2981
    """Views are not supported by a tree format.
 
2982
    """
 
2983
 
 
2984
    _fmt = ("Views are not supported by %(tree)s;"
 
2985
            " use 'bzr upgrade' to change your tree to a later format.")
 
2986
 
 
2987
    def __init__(self, tree):
 
2988
        self.tree = tree
 
2989
 
 
2990
 
 
2991
class FileOutsideView(BzrError):
 
2992
 
 
2993
    _fmt = ('Specified file "%(file_name)s" is outside the current view: '
 
2994
            '%(view_str)s')
 
2995
 
 
2996
    def __init__(self, file_name, view_files):
 
2997
        self.file_name = file_name
 
2998
        self.view_str = ", ".join(view_files)
 
2999
 
 
3000
 
 
3001
class UnresumableWriteGroup(BzrError):
 
3002
 
 
3003
    _fmt = ("Repository %(repository)s cannot resume write group "
 
3004
            "%(write_groups)r: %(reason)s")
 
3005
 
 
3006
    internal_error = True
 
3007
 
 
3008
    def __init__(self, repository, write_groups, reason):
 
3009
        self.repository = repository
 
3010
        self.write_groups = write_groups
 
3011
        self.reason = reason
 
3012
 
 
3013
 
 
3014
class UnsuspendableWriteGroup(BzrError):
 
3015
 
 
3016
    _fmt = ("Repository %(repository)s cannot suspend a write group.")
 
3017
 
 
3018
    internal_error = True
 
3019
 
 
3020
    def __init__(self, repository):
 
3021
        self.repository = repository