← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/errors.py

  • Committer: Alexander Belchenko
  • Date: 2007-10-04 05:50:44 UTC
  • mfrom: (2881 +trunk)
  • mto: This revision was merged to the branch mainline in revision 2884.
  • Revision ID: bialix@ukr.net-20071004055044-pb88kgkfayawro8n
merge bzr.dev

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/errors.py
44
44
# 'unprintable'.
45
45
 
46
46
 
 
47
# return codes from the bzr program
 
48
EXIT_OK = 0
 
49
EXIT_ERROR = 3
 
50
EXIT_INTERNAL_ERROR = 4
 
51
 
 
52
 
47
53
class BzrError(StandardError):
48
54
    """
49
55
    Base class for errors raised by bzrlib.
95
101
        try:
96
102
            fmt = self._get_format_string()
97
103
            if fmt:
98
 
                s = fmt % self.__dict__
 
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
                s = fmt % d
99
109
                # __str__() should always return a 'str' object
100
110
                # never a 'unicode' object.
101
111
                if isinstance(s, unicode):
126
136
               )
127
137
 
128
138
 
 
139
class InternalBzrError(BzrError):
 
140
    """Base class for errors that are internal in nature.
 
141
 
 
142
    This is a convenience class for errors that are internal. The
 
143
    internal_error attribute can still be altered in subclasses, if needed.
 
144
    Using this class is simply an easy way to get internal errors.
 
145
    """
 
146
 
 
147
    internal_error = True
 
148
 
 
149
 
129
150
class BzrNewError(BzrError):
130
151
    """Deprecated error base class."""
131
152
    # base classes should override the docstring with their human-
164
185
    _fmt = "The tree builder is already building a tree."
165
186
 
166
187
 
167
 
class BzrCheckError(BzrError):
 
188
class BzrCheckError(InternalBzrError):
168
189
    
169
190
    _fmt = "Internal check failed: %(message)s"
170
191
 
171
 
    internal_error = True
172
 
 
173
192
    def __init__(self, message):
174
193
        BzrError.__init__(self)
175
194
        self.message = message
176
195
 
177
196
 
178
 
class DisabledMethod(BzrError):
 
197
class DisabledMethod(InternalBzrError):
179
198
 
180
199
    _fmt = "The smart server method '%(class_name)s' is disabled."
181
200
 
182
 
    internal_error = True
183
 
 
184
201
    def __init__(self, class_name):
185
202
        BzrError.__init__(self)
186
203
        self.class_name = class_name
207
224
        self.transport = transport
208
225
 
209
226
 
210
 
class InvalidEntryName(BzrError):
 
227
class InvalidEntryName(InternalBzrError):
211
228
    
212
229
    _fmt = "Invalid entry name: %(name)s"
213
230
 
214
 
    internal_error = True
215
 
 
216
231
    def __init__(self, name):
217
232
        BzrError.__init__(self)
218
233
        self.name = name
245
260
        self.revision_id = revision_id
246
261
 
247
262
 
 
263
class RootMissing(InternalBzrError):
 
264
 
 
265
    _fmt = ("The root entry of a tree must be the first entry supplied to "
 
266
        "record_entry_contents.")
 
267
 
 
268
 
248
269
class NoHelpTopic(BzrError):
249
270
 
250
271
    _fmt = ("No help could be found for '%(topic)s'. "
273
294
        BzrError.__init__(self, repository=repository, file_id=file_id)
274
295
 
275
296
 
276
 
class InventoryModified(BzrError):
 
297
class InventoryModified(InternalBzrError):
277
298
 
278
299
    _fmt = ("The current inventory for the tree %(tree)r has been modified,"
279
300
            " so a clean inventory cannot be read without data loss.")
280
301
 
281
 
    internal_error = True
282
 
 
283
302
    def __init__(self, tree):
284
303
        self.tree = tree
285
304
 
306
325
        self.url = url
307
326
 
308
327
 
309
 
class WorkingTreeAlreadyPopulated(BzrError):
 
328
class WorkingTreeAlreadyPopulated(InternalBzrError):
310
329
 
311
330
    _fmt = 'Working tree already populated in "%(base)s"'
312
331
 
313
 
    internal_error = True
314
 
 
315
332
    def __init__(self, base):
316
333
        self.base = base
317
334
 
 
335
 
318
336
class BzrCommandError(BzrError):
319
337
    """Error from user command"""
320
338
 
321
 
    internal_error = False
322
 
 
323
339
    # Error from malformed user command; please avoid raising this as a
324
340
    # generic exception not caused by user input.
325
341
    #
481
497
    _fmt = 'Directory not empty: "%(path)s"%(extra)s'
482
498
 
483
499
 
484
 
class ReadingCompleted(BzrError):
 
500
class ReadingCompleted(InternalBzrError):
485
501
    
486
502
    _fmt = ("The MediumRequest '%(request)s' has already had finish_reading "
487
503
            "called upon it - the request has been completed and no more "
488
504
            "data may be read.")
489
505
 
490
 
    internal_error = True
491
 
 
492
506
    def __init__(self, request):
493
507
        self.request = request
494
508
 
770
784
    _fmt = 'Cannot operate on "%(filename)s" because it is a control file'
771
785
 
772
786
 
773
 
class LockError(BzrError):
 
787
class LockError(InternalBzrError):
774
788
 
775
789
    _fmt = "Lock error: %(msg)s"
776
790
 
777
 
    internal_error = True
778
 
 
779
791
    # All exceptions from the lock/unlock functions should be from
780
792
    # this exception class.  They will be translated as necessary. The
781
793
    # original exception is available as e.original_error
783
795
    # New code should prefer to raise specific subclasses
784
796
    def __init__(self, message):
785
797
        # Python 2.5 uses a slot for StandardError.message,
786
 
        # so use a different variable name
787
 
        # so it is exposed in self.__dict__
 
798
        # so use a different variable name.  We now work around this in
 
799
        # BzrError.__str__, but this member name is kept for compatability.
788
800
        self.msg = message
789
801
 
790
802
 
918
930
 
919
931
    _fmt = "The object %(obj)s does not support token specifying a token when locking."
920
932
 
921
 
    internal_error = True
922
 
 
923
933
    def __init__(self, obj):
924
934
        self.obj = obj
925
935
 
975
985
    _fmt = "Commit refused because there are unknowns in the tree."
976
986
 
977
987
 
978
 
class NoSuchRevision(BzrError):
 
988
class NoSuchRevision(InternalBzrError):
979
989
 
980
990
    _fmt = "%(branch)s has no revision %(revision)s"
981
991
 
982
 
    internal_error = True
983
 
 
984
992
    def __init__(self, branch, revision):
985
993
        # 'branch' may sometimes be an internal object like a KnitRevisionStore
986
994
        BzrError.__init__(self, branch=branch, revision=revision)
987
995
 
988
996
 
989
997
# zero_ninetyone: this exception is no longer raised and should be removed
990
 
class NotLeftParentDescendant(BzrError):
 
998
class NotLeftParentDescendant(InternalBzrError):
991
999
 
992
1000
    _fmt = ("Revision %(old_revision)s is not the left parent of"
993
1001
            " %(new_revision)s, but branch %(branch_location)s expects this")
994
1002
 
995
 
    internal_error = True
996
 
 
997
1003
    def __init__(self, branch, old_revision, new_revision):
998
1004
        BzrError.__init__(self, branch_location=branch.base,
999
1005
                          old_revision=old_revision,
1059
1065
    _fmt = ("These branches have diverged."
1060
1066
            " Use the merge command to reconcile them.")
1061
1067
 
1062
 
    internal_error = False
1063
 
 
1064
1068
    def __init__(self, branch1, branch2):
1065
1069
        self.branch1 = branch1
1066
1070
        self.branch2 = branch2
1067
1071
 
1068
1072
 
1069
 
class NotLefthandHistory(BzrError):
 
1073
class NotLefthandHistory(InternalBzrError):
1070
1074
 
1071
1075
    _fmt = "Supplied history does not follow left-hand parents"
1072
1076
 
1073
 
    internal_error = True
1074
 
 
1075
1077
    def __init__(self, history):
1076
1078
        BzrError.__init__(self, history=history)
1077
1079
 
1081
1083
    _fmt = ("Branches have no common ancestor, and"
1082
1084
            " no merge base revision was specified.")
1083
1085
 
1084
 
    internal_error = False
1085
 
 
1086
1086
 
1087
1087
class NoCommonAncestor(BzrError):
1088
1088
    
1299
1299
    _fmt = "Text did not match its checksum: %(message)s"
1300
1300
 
1301
1301
 
1302
 
class KnitError(BzrError):
 
1302
class KnitError(InternalBzrError):
1303
1303
    
1304
1304
    _fmt = "Knit error"
1305
1305
 
1306
 
    internal_error = True
1307
 
 
1308
1306
 
1309
1307
class KnitCorrupt(KnitError):
1310
1308
 
1374
1372
        BzrError.__init__(self)
1375
1373
 
1376
1374
 
1377
 
class TooManyConcurrentRequests(BzrError):
 
1375
class TooManyConcurrentRequests(InternalBzrError):
1378
1376
 
1379
1377
    _fmt = ("The medium '%(medium)s' has reached its concurrent request limit."
1380
1378
            " Be sure to finish_writing and finish_reading on the"
1381
1379
            " currently open request.")
1382
1380
 
1383
 
    internal_error = True
1384
 
 
1385
1381
    def __init__(self, medium):
1386
1382
        self.medium = medium
1387
1383
 
1577
1573
        self.graph = graph
1578
1574
 
1579
1575
 
1580
 
class WritingCompleted(BzrError):
 
1576
class WritingCompleted(InternalBzrError):
1581
1577
 
1582
1578
    _fmt = ("The MediumRequest '%(request)s' has already had finish_writing "
1583
1579
            "called upon it - accept bytes may not be called anymore.")
1584
1580
 
1585
 
    internal_error = True
1586
 
 
1587
1581
    def __init__(self, request):
1588
1582
        self.request = request
1589
1583
 
1590
1584
 
1591
 
class WritingNotComplete(BzrError):
 
1585
class WritingNotComplete(InternalBzrError):
1592
1586
 
1593
1587
    _fmt = ("The MediumRequest '%(request)s' has not has finish_writing "
1594
1588
            "called upon it - until the write phase is complete no "
1595
1589
            "data may be read.")
1596
1590
 
1597
 
    internal_error = True
1598
 
 
1599
1591
    def __init__(self, request):
1600
1592
        self.request = request
1601
1593
 
1609
1601
        self.filename = filename
1610
1602
 
1611
1603
 
1612
 
class MediumNotConnected(BzrError):
 
1604
class MediumNotConnected(InternalBzrError):
1613
1605
 
1614
1606
    _fmt = """The medium '%(medium)s' is not connected."""
1615
1607
 
1616
 
    internal_error = True
1617
 
 
1618
1608
    def __init__(self, medium):
1619
1609
        self.medium = medium
1620
1610
 
1696
1686
        self.root_trans_id = transform.root
1697
1687
 
1698
1688
 
1699
 
class BzrBadParameter(BzrError):
 
1689
class BzrBadParameter(InternalBzrError):
1700
1690
 
1701
1691
    _fmt = "Bad parameter: %(param)r"
1702
1692
 
1703
 
    internal_error = True
1704
 
 
1705
1693
    # This exception should never be thrown, but it is a base class for all
1706
1694
    # parameter-to-function errors.
1707
1695
 
2090
2078
    _fmt = """This operation requires rich root data storage"""
2091
2079
 
2092
2080
 
2093
 
class NoSmartMedium(BzrError):
 
2081
class NoSmartMedium(InternalBzrError):
2094
2082
 
2095
2083
    _fmt = "The transport '%(transport)s' cannot tunnel the smart protocol."
2096
2084
 
2097
 
    internal_error = True
2098
 
 
2099
2085
    def __init__(self, transport):
2100
2086
        self.transport = transport
2101
2087
 
2132
2118
        self.revision_id = revision_id
2133
2119
 
2134
2120
 
2135
 
class IllegalUseOfScopeReplacer(BzrError):
 
2121
class IllegalUseOfScopeReplacer(InternalBzrError):
2136
2122
 
2137
2123
    _fmt = ("ScopeReplacer object %(name)r was used incorrectly:"
2138
2124
            " %(msg)s%(extra)s")
2139
2125
 
2140
 
    internal_error = True
2141
 
 
2142
2126
    def __init__(self, name, msg, extra=None):
2143
2127
        BzrError.__init__(self)
2144
2128
        self.name = name
2149
2133
            self.extra = ''
2150
2134
 
2151
2135
 
2152
 
class InvalidImportLine(BzrError):
 
2136
class InvalidImportLine(InternalBzrError):
2153
2137
 
2154
2138
    _fmt = "Not a valid import statement: %(msg)\n%(text)s"
2155
2139
 
2156
 
    internal_error = True
2157
 
 
2158
2140
    def __init__(self, text, msg):
2159
2141
        BzrError.__init__(self)
2160
2142
        self.text = text
2161
2143
        self.msg = msg
2162
2144
 
2163
2145
 
2164
 
class ImportNameCollision(BzrError):
 
2146
class ImportNameCollision(InternalBzrError):
2165
2147
 
2166
2148
    _fmt = ("Tried to import an object to the same name as"
2167
2149
            " an existing object. %(name)s")
2168
2150
 
2169
 
    internal_error = True
2170
 
 
2171
2151
    def __init__(self, name):
2172
2152
        BzrError.__init__(self)
2173
2153
        self.name = name
2238
2218
        self.other_tree = other_tree
2239
2219
 
2240
2220
 
2241
 
class BadReferenceTarget(BzrError):
 
2221
class BadReferenceTarget(InternalBzrError):
2242
2222
 
2243
2223
    _fmt = "Can't add reference to %(other_tree)s into %(tree)s." \
2244
2224
           "%(reason)s"
2245
2225
 
2246
 
    internal_error = True
2247
 
 
2248
2226
    def __init__(self, tree, other_tree, reason):
2249
2227
        self.tree = tree
2250
2228
        self.other_tree = other_tree
2319
2297
 
2320
2298
    _fmt = "Unexpected end of container stream"
2321
2299
 
2322
 
    internal_error = False
2323
 
 
2324
2300
 
2325
2301
class UnknownRecordTypeError(ContainerError):
2326
2302
 
2354
2330
        self.name = name
2355
2331
 
2356
2332
 
2357
 
class NoDestinationAddress(BzrError):
 
2333
class NoDestinationAddress(InternalBzrError):
2358
2334
 
2359
2335
    _fmt = "Message does not have a destination address."
2360
2336
 
2361
 
    internal_error = True
2362
 
 
2363
2337
 
2364
2338
class SMTPError(BzrError):
2365
2339