~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-22 18:24:25 UTC
  • mfrom: (1803 +trunk)
  • mto: (1793.3.6 bundle-fixes)
  • mto: This revision was merged to the branch mainline in revision 1806.
  • Revision ID: john@arbash-meinel.com-20060622182425-6f45cb7acd587216
[merge] bzr.dev 1804 and fix conflicts.

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
 
19
31
Exceptions are caught at a high level to report errors to the user, and
20
32
might also be caught inside the program.  Therefore it needs to be
21
33
possible to convert them to a meaningful string, and also for them to be
44
56
Therefore:
45
57
 
46
58
 * create a new exception class for any class of error that can be
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.
 
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.
54
67
"""
55
68
 
56
69
from warnings import warn
81
94
 
82
95
 
83
96
class BzrError(StandardError):
 
97
    
 
98
    is_user_error = True
 
99
    
84
100
    def __str__(self):
85
101
        # XXX: Should we show the exception class in 
86
102
        # exceptions that don't provide their own message?  
119
135
class BzrCheckError(BzrNewError):
120
136
    """Internal check failed: %(message)s"""
121
137
 
 
138
    is_user_error = False
 
139
 
122
140
    def __init__(self, message):
123
141
        BzrNewError.__init__(self)
124
142
        self.message = message
126
144
 
127
145
class InvalidEntryName(BzrNewError):
128
146
    """Invalid entry name: %(name)s"""
 
147
 
 
148
    is_user_error = False
 
149
 
129
150
    def __init__(self, name):
130
151
        BzrNewError.__init__(self)
131
152
        self.name = name
163
184
        self.url = url
164
185
 
165
186
 
166
 
class BzrCommandError(BzrError):
167
 
    # Error from malformed user command
168
 
    # This is being misused as a generic exception
169
 
    # please subclass. RBC 20051030
 
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.
170
194
    #
171
195
    # I think it's a waste of effort to differentiate between errors that
172
196
    # are not intended to be caught anyway.  UI code need not subclass
173
197
    # BzrCommandError, and non-UI code should not throw a subclass of
174
198
    # BzrCommandError.  ADHB 20051211
 
199
    def __init__(self, msg):
 
200
        self.msg = msg
 
201
 
175
202
    def __str__(self):
176
 
        return self.args[0]
 
203
        return self.msg
177
204
 
178
205
 
179
206
class BzrOptionError(BzrCommandError):
180
 
    """Some missing or otherwise incorrect option was supplied."""
 
207
    """Error in command line options"""
181
208
 
182
209
    
183
 
class StrictCommitFailed(Exception):
184
 
    """Commit refused because there are unknowns in the tree."""
 
210
class StrictCommitFailed(BzrNewError):
 
211
    """Commit refused because there are unknown files in the tree"""
185
212
 
186
213
 
187
214
# XXX: Should be unified with TransportError; they seem to represent the
233
260
 
234
261
class PathNotChild(BzrNewError):
235
262
    """Path %(path)r is not a child of path %(base)r%(extra)s"""
 
263
 
 
264
    is_user_error = False
 
265
 
236
266
    def __init__(self, path, base, extra=None):
237
267
        BzrNewError.__init__(self)
238
268
        self.path = path
280
310
        self.path = path
281
311
 
282
312
 
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]
 
313
class UnsupportedFormatError(BzrNewError):
 
314
    """Unsupported branch format: %(format)s"""
 
315
 
 
316
 
 
317
class UnknownFormatError(BzrNewError):
 
318
    """Unknown branch format: %(format)r"""
293
319
 
294
320
 
295
321
class IncompatibleFormat(BzrNewError):
333
359
        self.paths_as_string = ' '.join([quotefn(p) for p in paths])
334
360
 
335
361
 
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."""
 
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"""
344
368
 
345
369
 
346
370
class LockError(BzrNewError):
378
402
 
379
403
class ObjectNotLocked(LockError):
380
404
    """%(obj)r is not locked"""
 
405
 
 
406
    is_user_error = False
 
407
 
381
408
    # this can indicate that any particular object is not locked; see also
382
409
    # LockNotHeld which means that a particular *lock* object is not held by
383
410
    # the caller -- perhaps they should be unified.
445
472
    """Commit refused because there are unknowns in the tree."""
446
473
 
447
474
 
448
 
class NoSuchRevision(BzrError):
 
475
class NoSuchRevision(BzrNewError):
 
476
    """Branch %(branch)s has no revision %(revision)s"""
 
477
 
 
478
    is_user_error = False
 
479
 
449
480
    def __init__(self, branch, revision):
450
481
        self.branch = branch
451
482
        self.revision = revision
452
 
        msg = "Branch %s has no revision %s" % (branch, revision)
453
 
        BzrError.__init__(self, msg)
454
483
 
455
484
 
456
485
class HistoryMissing(BzrError):
461
490
                          % (branch, object_type, object_id))
462
491
 
463
492
 
464
 
class DivergedBranches(BzrError):
 
493
class DivergedBranches(BzrNewError):
 
494
    "These branches have diverged.  Use the merge command to reconcile them."""
 
495
 
 
496
    is_user_error = True
465
497
 
466
498
    def __init__(self, branch1, branch2):
467
 
        BzrError.__init__(self, "These branches have diverged.  Try merge.")
468
499
        self.branch1 = branch1
469
500
        self.branch2 = branch2
470
501
 
471
502
 
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):
 
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
 
480
512
    def __init__(self, revision_a, revision_b):
481
 
        msg = "Revisions have no common ancestor: %s %s." \
482
 
            % (revision_a, revision_b) 
483
 
        BzrError.__init__(self, msg)
 
513
        self.revision_a = revision_a
 
514
        self.revision_b = revision_b
484
515
 
485
516
 
486
517
class NoCommonRoot(BzrError):