~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/errors.py

  • Committer: John Arbash Meinel
  • Date: 2006-06-18 02:21:57 UTC
  • mfrom: (1787 +trunk)
  • mto: This revision was merged to the branch mainline in revision 1794.
  • Revision ID: john@arbash-meinel.com-20060618022157-6e33aa9b67c25e4f
[merge] bzr.dev 1787

Show diffs side-by-side

added added

removed removed

Lines of Context:
16
16
 
17
17
"""Exceptions for bzr, and reporting of them.
18
18
 
19
 
There are 3 different classes of error:
20
 
 
21
 
 * KeyboardInterrupt, and OSError with EPIPE - the program terminates 
22
 
   with an appropriate short message
23
 
 
24
 
 * User errors, indicating a problem caused by the user such as a bad URL.
25
 
   These are printed in a short form.
26
 
 
27
 
 * Internal unexpected errors, including most Python builtin errors
28
 
   and some raised from inside bzr.  These are printed with a full 
29
 
   traceback and an invitation to report the bug.
30
 
 
31
19
Exceptions are caught at a high level to report errors to the user, and
32
20
might also be caught inside the program.  Therefore it needs to be
33
21
possible to convert them to a meaningful string, and also for them to be
56
44
Therefore:
57
45
 
58
46
 * create a new exception class for any class of error that can be
59
 
   usefully distinguished.  If no callers are likely to want to catch
60
 
   one but not another, don't worry about them.
61
 
 
62
 
 * the __str__ method should generate something useful; BzrError provides
63
 
   a good default implementation
64
 
 
65
 
Exception strings should start with a capital letter and should not have a
66
 
final fullstop.
 
47
   usefully distinguished.
 
48
 
 
49
 * the printable form of an exception is generated by the base class
 
50
   __str__ method
 
51
 
 
52
Exception strings should start with a capital letter and not have a final
 
53
fullstop.
67
54
"""
68
55
 
69
56
from warnings import warn
94
81
 
95
82
 
96
83
class BzrError(StandardError):
97
 
    
98
 
    is_user_error = True
99
 
    
100
84
    def __str__(self):
101
85
        # XXX: Should we show the exception class in 
102
86
        # exceptions that don't provide their own message?  
135
119
class BzrCheckError(BzrNewError):
136
120
    """Internal check failed: %(message)s"""
137
121
 
138
 
    is_user_error = False
139
 
 
140
122
    def __init__(self, message):
141
123
        BzrNewError.__init__(self)
142
124
        self.message = message
144
126
 
145
127
class InvalidEntryName(BzrNewError):
146
128
    """Invalid entry name: %(name)s"""
147
 
 
148
 
    is_user_error = False
149
 
 
150
129
    def __init__(self, name):
151
130
        BzrNewError.__init__(self)
152
131
        self.name = name
184
163
        self.url = url
185
164
 
186
165
 
187
 
class BzrCommandError(BzrNewError):
188
 
    """Error from user command"""
189
 
 
190
 
    is_user_error = True
191
 
 
192
 
    # Error from malformed user command; please avoid raising this as a
193
 
    # generic exception not caused by user input.
 
166
class BzrCommandError(BzrError):
 
167
    # Error from malformed user command
 
168
    # This is being misused as a generic exception
 
169
    # please subclass. RBC 20051030
194
170
    #
195
171
    # I think it's a waste of effort to differentiate between errors that
196
172
    # are not intended to be caught anyway.  UI code need not subclass
197
173
    # BzrCommandError, and non-UI code should not throw a subclass of
198
174
    # BzrCommandError.  ADHB 20051211
199
 
    def __init__(self, msg):
200
 
        self.msg = msg
201
 
 
202
175
    def __str__(self):
203
 
        return self.msg
 
176
        return self.args[0]
204
177
 
205
178
 
206
179
class BzrOptionError(BzrCommandError):
207
 
    """Error in command line options"""
 
180
    """Some missing or otherwise incorrect option was supplied."""
208
181
 
209
182
    
210
 
class StrictCommitFailed(BzrNewError):
211
 
    """Commit refused because there are unknown files in the tree"""
 
183
class StrictCommitFailed(Exception):
 
184
    """Commit refused because there are unknowns in the tree."""
212
185
 
213
186
 
214
187
# XXX: Should be unified with TransportError; they seem to represent the
260
233
 
261
234
class PathNotChild(BzrNewError):
262
235
    """Path %(path)r is not a child of path %(base)r%(extra)s"""
263
 
 
264
 
    is_user_error = False
265
 
 
266
236
    def __init__(self, path, base, extra=None):
267
237
        BzrNewError.__init__(self)
268
238
        self.path = path
310
280
        self.path = path
311
281
 
312
282
 
313
 
class UnsupportedFormatError(BzrNewError):
314
 
    """Unsupported branch format: %(format)s"""
315
 
 
316
 
 
317
 
class UnknownFormatError(BzrNewError):
318
 
    """Unknown branch format: %(format)r"""
 
283
class UnsupportedFormatError(BzrError):
 
284
    """Specified path is a bzr branch that we recognize but cannot read."""
 
285
    def __str__(self):
 
286
        return 'unsupported branch format: %s' % self.args[0]
 
287
 
 
288
 
 
289
class UnknownFormatError(BzrError):
 
290
    """Specified path is a bzr branch whose format we do not recognize."""
 
291
    def __str__(self):
 
292
        return 'unknown branch format: %s' % self.args[0]
319
293
 
320
294
 
321
295
class IncompatibleFormat(BzrNewError):
359
333
        self.paths_as_string = ' '.join([quotefn(p) for p in paths])
360
334
 
361
335
 
362
 
class BadFileKindError(BzrNewError):
363
 
    """Cannot operate on %(filename)s of unsupported kind %(kind)s"""
364
 
 
365
 
 
366
 
class ForbiddenControlFileError(BzrNewError):
367
 
    """Cannot operate on %(filename)s because it is a control file"""
 
336
class BadFileKindError(BzrError):
 
337
    """Specified file is of a kind that cannot be added.
 
338
 
 
339
    (For example a symlink or device file.)"""
 
340
 
 
341
 
 
342
class ForbiddenFileError(BzrError):
 
343
    """Cannot operate on a file because it is a control file."""
368
344
 
369
345
 
370
346
class LockError(BzrNewError):
402
378
 
403
379
class ObjectNotLocked(LockError):
404
380
    """%(obj)r is not locked"""
405
 
 
406
 
    is_user_error = False
407
 
 
408
381
    # this can indicate that any particular object is not locked; see also
409
382
    # LockNotHeld which means that a particular *lock* object is not held by
410
383
    # the caller -- perhaps they should be unified.
472
445
    """Commit refused because there are unknowns in the tree."""
473
446
 
474
447
 
475
 
class NoSuchRevision(BzrNewError):
476
 
    """Branch %(branch)s has no revision %(revision)s"""
477
 
 
478
 
    is_user_error = False
479
 
 
 
448
class NoSuchRevision(BzrError):
480
449
    def __init__(self, branch, revision):
481
450
        self.branch = branch
482
451
        self.revision = revision
 
452
        msg = "Branch %s has no revision %s" % (branch, revision)
 
453
        BzrError.__init__(self, msg)
483
454
 
484
455
 
485
456
class HistoryMissing(BzrError):
490
461
                          % (branch, object_type, object_id))
491
462
 
492
463
 
493
 
class DivergedBranches(BzrNewError):
494
 
    "These branches have diverged.  Use the merge command to reconcile them."""
495
 
 
496
 
    is_user_error = True
 
464
class DivergedBranches(BzrError):
497
465
 
498
466
    def __init__(self, branch1, branch2):
 
467
        BzrError.__init__(self, "These branches have diverged.  Try merge.")
499
468
        self.branch1 = branch1
500
469
        self.branch2 = branch2
501
470
 
502
471
 
503
 
class UnrelatedBranches(BzrNewError):
504
 
    "Branches have no common ancestor, and no merge base revision was specified."
505
 
 
506
 
    is_user_error = True
507
 
 
508
 
 
509
 
class NoCommonAncestor(BzrNewError):
510
 
    "Revisions have no common ancestor: %(revision_a)s %(revision_b)s"
511
 
 
 
472
class UnrelatedBranches(BzrCommandError):
 
473
    def __init__(self):
 
474
        msg = "Branches have no common ancestor, and no base revision"\
 
475
            " specified."
 
476
        BzrCommandError.__init__(self, msg)
 
477
 
 
478
 
 
479
class NoCommonAncestor(BzrError):
512
480
    def __init__(self, revision_a, revision_b):
513
 
        self.revision_a = revision_a
514
 
        self.revision_b = revision_b
 
481
        msg = "Revisions have no common ancestor: %s %s." \
 
482
            % (revision_a, revision_b) 
 
483
        BzrError.__init__(self, msg)
515
484
 
516
485
 
517
486
class NoCommonRoot(BzrError):