~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/errors.py

  • Committer: Robert Collins
  • Date: 2005-10-09 22:43:56 UTC
  • mfrom: (1185.12.18)
  • Revision ID: robertc@robertcollins.net-20051009224356-9e0f3edb29f2498f
merge from Aaron - unbreaks open_containing and the fetch progress bar

Show diffs side-by-side

added added

removed removed

Lines of Context:
1
 
# (C) 2005 Canonical
 
1
# -*- coding: UTF-8 -*-
2
2
 
3
3
# This program is free software; you can redistribute it and/or modify
4
4
# it under the terms of the GNU General Public License as published by
14
14
# along with this program; if not, write to the Free Software
15
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
16
16
 
17
 
"""Exceptions for bzr, and reporting of them.
18
 
 
19
 
Exceptions are caught at a high level to report errors to the user, and
20
 
might also be caught inside the program.  Therefore it needs to be
21
 
possible to convert them to a meaningful string, and also for them to be
22
 
interrogated by the program.
23
 
 
24
 
Exceptions are defined such that the arguments given to the constructor
25
 
are stored in the object as properties of the same name.  When the
26
 
object is printed as a string, the doc string of the class is used as
27
 
a format string with the property dictionary available to it.
28
 
 
29
 
This means that exceptions can used like this:
30
 
 
31
 
>>> import sys
32
 
>>> try:
33
 
...   raise NotBranchError(path='/foo/bar')
34
 
... except:
35
 
...   print sys.exc_type
36
 
...   print sys.exc_value
37
 
...   path = getattr(sys.exc_value, 'path')
38
 
...   if path is not None:
39
 
...     print path
40
 
bzrlib.errors.NotBranchError
41
 
Not a branch: /foo/bar
42
 
/foo/bar
43
 
 
44
 
Therefore:
45
 
 
46
 
 * 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.
54
 
"""
55
 
 
56
 
# based on Scott James Remnant's hct error classes
57
 
 
58
 
# TODO: is there any value in providing the .args field used by standard
59
 
# python exceptions?   A list of values with no names seems less useful 
60
 
# to me.
61
 
 
62
 
# TODO: Perhaps convert the exception to a string at the moment it's 
63
 
# constructed to make sure it will succeed.  But that says nothing about
64
 
# exceptions that are never raised.
65
 
 
66
 
# TODO: Convert all the other error classes here to BzrNewError, and eliminate
67
 
# the old one.
68
 
 
69
 
 
 
17
 
 
18
__copyright__ = "Copyright (C) 2005 Canonical Ltd."
 
19
__author__ = "Martin Pool <mbp@canonical.com>"
 
20
 
 
21
 
 
22
######################################################################
 
23
# exceptions 
70
24
class BzrError(StandardError):
71
25
    def __str__(self):
72
26
        # XXX: Should we show the exception class in 
75
29
        ## n = self.__class__.__name__ + ': '
76
30
        n = ''
77
31
        if len(self.args) == 1:
78
 
            return str(self.args[0])
 
32
            return n + self.args[0]
79
33
        elif len(self.args) == 2:
80
34
            # further explanation or suggestions
81
35
            try:
86
40
            return n + `self.args`
87
41
 
88
42
 
89
 
class BzrNewError(BzrError):
90
 
    """bzr error"""
91
 
    # base classes should override the docstring with their human-
92
 
    # readable explanation
93
 
 
94
 
    def __init__(self, **kwds):
95
 
        for key, value in kwds.items():
96
 
            setattr(self, key, value)
97
 
 
 
43
class BzrCheckError(BzrError):
 
44
    pass
 
45
 
 
46
 
 
47
class InvalidRevisionNumber(BzrError):
98
48
    def __str__(self):
99
 
        try:
100
 
            return self.__doc__ % self.__dict__
101
 
        except (NameError, ValueError, KeyError), e:
102
 
            return 'Unprintable exception %s: %s' \
103
 
                % (self.__class__.__name__, str(e))
104
 
 
105
 
 
106
 
class BzrCheckError(BzrNewError):
107
 
    """Internal check failed: %(message)s"""
108
 
    def __init__(self, message):
109
 
        BzrNewError.__init__(self)
110
 
        self.message = message
111
 
 
112
 
 
113
 
class InvalidEntryName(BzrNewError):
114
 
    """Invalid entry name: %(name)s"""
115
 
    def __init__(self, name):
116
 
        BzrNewError.__init__(self)
117
 
        self.name = name
118
 
 
119
 
 
120
 
class InvalidRevisionNumber(BzrNewError):
121
 
    """Invalid revision number %(revno)d"""
122
 
    def __init__(self, revno):
123
 
        BzrNewError.__init__(self)
124
 
        self.revno = revno
125
 
 
126
 
 
127
 
class InvalidRevisionId(BzrNewError):
128
 
    """Invalid revision-id {%(revision_id)s} in %(branch)s"""
129
 
    def __init__(self, revision_id, branch):
130
 
        BzrNewError.__init__(self)
131
 
        self.revision_id = revision_id
132
 
        self.branch = branch
133
 
 
134
 
 
135
 
class NoWorkingTree(BzrNewError):
136
 
    """No WorkingTree exists for %s(base)."""
137
 
    
138
 
    def __init__(self, base):
139
 
        BzrNewError.__init__(self)
140
 
        self.base = base
 
49
        return 'invalid revision number: %r' % self.args[0]
 
50
 
 
51
 
 
52
class InvalidRevisionId(BzrError):
 
53
    pass
141
54
 
142
55
 
143
56
class BzrCommandError(BzrError):
144
57
    # Error from malformed user command
145
 
    # This is being misused as a generic exception
146
 
    # pleae subclass. RBC 20051030
147
 
    #
148
 
    # I think it's a waste of effort to differentiate between errors that
149
 
    # are not intended to be caught anyway.  UI code need not subclass
150
 
    # BzrCommandError, and non-UI code should not throw a subclass of
151
 
    # BzrCommandError.  ADHB 20051211
152
58
    def __str__(self):
153
59
        return self.args[0]
154
60
 
155
61
 
156
 
class BzrOptionError(BzrCommandError):
157
 
    """Some missing or otherwise incorrect option was supplied."""
158
 
 
159
 
    
160
 
class StrictCommitFailed(Exception):
161
 
    """Commit refused because there are unknowns in the tree."""
162
 
 
163
 
 
164
 
class PathError(BzrNewError):
165
 
    """Generic path error: %(path)r%(extra)s)"""
166
 
    def __init__(self, path, extra=None):
167
 
        BzrNewError.__init__(self)
168
 
        self.path = path
169
 
        if extra:
170
 
            self.extra = ': ' + str(extra)
171
 
        else:
172
 
            self.extra = ''
173
 
 
174
 
 
175
 
class NoSuchFile(PathError):
176
 
    """No such file: %(path)r%(extra)s"""
177
 
 
178
 
 
179
 
class FileExists(PathError):
180
 
    """File exists: %(path)r%(extra)s"""
181
 
 
182
 
 
183
 
class PermissionDenied(PathError):
184
 
    """Permission denied: %(path)r%(extra)s"""
185
 
 
186
 
 
187
 
class PathNotChild(BzrNewError):
188
 
    """Path %(path)r is not a child of path %(base)r%(extra)s"""
189
 
    def __init__(self, path, base, extra=None):
190
 
        BzrNewError.__init__(self)
191
 
        self.path = path
192
 
        self.base = base
193
 
        if extra:
194
 
            self.extra = ': ' + str(extra)
195
 
        else:
196
 
            self.extra = ''
197
 
 
198
 
 
199
 
class NotBranchError(BzrNewError):
200
 
    """Not a branch: %(path)s"""
201
 
    def __init__(self, path):
202
 
        BzrNewError.__init__(self)
203
 
        self.path = path
204
 
 
205
 
 
206
 
class FileInWrongBranch(BzrNewError):
207
 
    """File %(path)s in not in branch %(branch_base)s."""
208
 
    def __init__(self, branch, path):
209
 
        BzrNewError.__init__(self)
210
 
        self.branch = branch
211
 
        self.branch_base = branch.base
212
 
        self.path = path
 
62
class NotBranchError(BzrError):
 
63
    """Specified path is not in a branch"""
 
64
    def __str__(self):
 
65
        return 'not a branch: %s' % self.args[0]
213
66
 
214
67
 
215
68
class UnsupportedFormatError(BzrError):
218
71
        return 'unsupported branch format: %s' % self.args[0]
219
72
 
220
73
 
221
 
class NotVersionedError(BzrNewError):
222
 
    """%(path)s is not versioned"""
223
 
    def __init__(self, path):
224
 
        BzrNewError.__init__(self)
225
 
        self.path = path
 
74
class NotVersionedError(BzrError):
 
75
    """Specified object is not versioned."""
226
76
 
227
77
 
228
78
class BadFileKindError(BzrError):
229
79
    """Specified file is of a kind that cannot be added.
230
80
 
231
81
    (For example a symlink or device file.)"""
 
82
    pass
232
83
 
233
84
 
234
85
class ForbiddenFileError(BzrError):
235
86
    """Cannot operate on a file because it is a control file."""
 
87
    pass
236
88
 
237
89
 
238
90
class LockError(Exception):
239
 
    """Lock error"""
240
 
    # All exceptions from the lock/unlock functions should be from
241
 
    # this exception class.  They will be translated as necessary. The
242
 
    # original exception is available as e.original_error
 
91
    """All exceptions from the lock/unlock functions should be from
 
92
    this exception class.  They will be translated as necessary. The
 
93
    original exception is available as e.original_error
 
94
    """
 
95
    def __init__(self, e=None):
 
96
        self.original_error = e
 
97
        if e:
 
98
            Exception.__init__(self, e)
 
99
        else:
 
100
            Exception.__init__(self)
243
101
 
244
102
 
245
103
class CommitNotPossible(LockError):
254
112
    """A write attempt was made in a read only transaction."""
255
113
 
256
114
 
257
 
class PointlessCommit(BzrNewError):
258
 
    """No changes to commit"""
 
115
class PointlessCommit(Exception):
 
116
    """Commit failed because nothing was changed."""
259
117
 
260
 
class StrictCommitFailed(Exception):
261
 
    """Commit refused because there are unknowns in the tree."""
262
118
 
263
119
class NoSuchRevision(BzrError):
264
120
    def __init__(self, branch, revision):
278
134
 
279
135
class DivergedBranches(BzrError):
280
136
    def __init__(self, branch1, branch2):
281
 
        BzrError.__init__(self, "These branches have diverged.  Try merge.")
 
137
        BzrError.__init__(self, "These branches have diverged.")
282
138
        self.branch1 = branch1
283
139
        self.branch2 = branch2
284
140
 
310
166
        self.not_ancestor_id = not_ancestor_id
311
167
 
312
168
 
 
169
class NotAncestor(BzrError):
 
170
    def __init__(self, rev_id, not_ancestor_id):
 
171
        self.rev_id = rev_id
 
172
        self.not_ancestor_id = not_ancestor_id
 
173
        msg = "Revision %s is not an ancestor of %s" % (not_ancestor_id, 
 
174
                                                        rev_id)
 
175
        BzrError.__init__(self, msg)
 
176
 
 
177
 
313
178
class InstallFailed(BzrError):
314
179
    def __init__(self, revisions):
315
180
        msg = "Could not install revisions:\n%s" % " ,".join(revisions)
338
203
        BzrError.__init__(self, "Stores for branch %s are not listable" % br)
339
204
 
340
205
 
341
 
class WeaveError(BzrNewError):
342
 
    """Error in processing weave: %(message)s"""
343
 
    def __init__(self, message=None):
344
 
        BzrNewError.__init__(self)
345
 
        self.message = message
346
 
 
347
 
 
348
 
class WeaveRevisionAlreadyPresent(WeaveError):
349
 
    """Revision {%(revision_id)s} already present in %(weave)s"""
350
 
    def __init__(self, revision_id, weave):
351
 
        WeaveError.__init__(self)
352
 
        self.revision_id = revision_id
353
 
        self.weave = weave
354
 
 
355
 
 
356
 
class WeaveRevisionNotPresent(WeaveError):
357
 
    """Revision {%(revision_id)s} not present in %(weave)s"""
358
 
    def __init__(self, revision_id, weave):
359
 
        WeaveError.__init__(self)
360
 
        self.revision_id = revision_id
361
 
        self.weave = weave
362
 
 
363
 
 
364
 
class WeaveFormatError(WeaveError):
365
 
    """Weave invariant violated: %(what)s"""
366
 
    def __init__(self, what):
367
 
        WeaveError.__init__(self)
368
 
        self.what = what
369
 
 
370
 
 
371
 
class WeaveParentMismatch(WeaveError):
372
 
    """Parents are mismatched between two revisions."""
373
 
    
374
 
 
375
 
class WeaveInvalidChecksum(WeaveError):
376
 
    """Text did not match it's checksum: %(message)s"""
377
 
 
378
 
 
379
 
class NoSuchExportFormat(BzrNewError):
380
 
    """Export format %(format)r not supported"""
381
 
    def __init__(self, format):
382
 
        BzrNewError.__init__(self)
383
 
        self.format = format
384
 
 
 
206
from bzrlib.weave import WeaveError, WeaveParentMismatch
385
207
 
386
208
class TransportError(BzrError):
387
209
    """All errors thrown by Transport implementations should derive
401
223
    """
402
224
    pass
403
225
 
404
 
 
405
 
class ConnectionError(TransportError):
406
 
    """A connection problem prevents file retrieval.
407
 
    This does not indicate whether the file exists or not; it indicates that a
408
 
    precondition for requesting the file was not met.
409
 
    """
410
 
    def __init__(self, msg=None, orig_error=None):
411
 
        TransportError.__init__(self, msg=msg, orig_error=orig_error)
412
 
 
 
226
class NonRelativePath(TransportError):
 
227
    """An absolute path was supplied, that could not be decoded into
 
228
    a relative path.
 
229
    """
 
230
    pass
 
231
 
 
232
class NoSuchFile(TransportError, IOError):
 
233
    """A get() was issued for a file that doesn't exist."""
 
234
 
 
235
    # XXX: Is multiple inheritance for exceptions really needed?
 
236
 
 
237
    def __str__(self):
 
238
        return 'no such file: ' + self.msg
 
239
 
 
240
    def __init__(self, msg=None, orig_error=None):
 
241
        import errno
 
242
        TransportError.__init__(self, msg=msg, orig_error=orig_error)
 
243
        IOError.__init__(self, errno.ENOENT, self.msg)
 
244
 
 
245
class FileExists(TransportError, OSError):
 
246
    """An operation was attempted, which would overwrite an entry,
 
247
    but overwritting is not supported.
 
248
 
 
249
    mkdir() can throw this, but put() just overwites existing files.
 
250
    """
 
251
    # XXX: Is multiple inheritance for exceptions really needed?
 
252
    def __init__(self, msg=None, orig_error=None):
 
253
        import errno
 
254
        TransportError.__init__(self, msg=msg, orig_error=orig_error)
 
255
        OSError.__init__(self, errno.EEXIST, self.msg)
 
256
 
 
257
class PermissionDenied(TransportError):
 
258
    """An operation cannot succeed because of a lack of permissions."""
 
259
    pass
413
260
 
414
261
class ConnectionReset(TransportError):
415
262
    """The connection has been closed."""
418
265
class ConflictsInTree(BzrError):
419
266
    def __init__(self):
420
267
        BzrError.__init__(self, "Working tree has conflicts.")
421
 
 
422
 
class ParseConfigError(BzrError):
423
 
    def __init__(self, errors, filename):
424
 
        if filename is None:
425
 
            filename = ""
426
 
        message = "Error(s) parsing config file %s:\n%s" % \
427
 
            (filename, ('\n'.join(e.message for e in errors)))
428
 
        BzrError.__init__(self, message)
429
 
 
430
 
class SigningFailed(BzrError):
431
 
    def __init__(self, command_line):
432
 
        BzrError.__init__(self, "Failed to gpg sign data with command '%s'"
433
 
                               % command_line)
434
 
 
435
 
class WorkingTreeNotRevision(BzrError):
436
 
    def __init__(self, tree):
437
 
        BzrError.__init__(self, "The working tree for %s has changed since"
438
 
                          " last commit, but weave merge requires that it be"
439
 
                          " unchanged." % tree.basedir)
440
 
 
441
 
class CantReprocessAndShowBase(BzrNewError):
442
 
    """Can't reprocess and show base.
443
 
Reprocessing obscures relationship of conflicting lines to base."""
444
 
 
445
 
class GraphCycleError(BzrNewError):
446
 
    """Cycle in graph %(graph)r"""
447
 
    def __init__(self, graph):
448
 
        BzrNewError.__init__(self)
449
 
        self.graph = graph
450
 
 
451
 
 
452
 
class NotConflicted(BzrNewError):
453
 
    """File %(filename)s is not conflicted."""
454
 
 
455
 
    def __init__(self, filename):
456
 
        BzrNewError.__init__(self)
457
 
        self.filename = filename
458
 
 
459
 
 
460
 
class MustUseDecorated(Exception):
461
 
    """A decorating function has requested its original command be used.
462
 
    
463
 
    This should never escape bzr, so does not need to be printable.
464
 
    """
465
 
 
466
 
class MissingText(BzrNewError):
467
 
    """Branch %(base)s is missing revision %(text_revision)s of %(file_id)s"""
468
 
 
469
 
    def __init__(self, branch, text_revision, file_id):
470
 
        BzrNewError.__init__(self)
471
 
        self.branch = branch
472
 
        self.base = branch.base
473
 
        self.text_revision = text_revision
474
 
        self.file_id = file_id
475
 
 
476
 
 
477
 
class BzrBadParameter(BzrNewError):
478
 
    """Parameter %(param)s is neither unicode nor utf8."""
479
 
    
480
 
    def __init__(self, param):
481
 
        BzrNewError.__init__(self)
482
 
        self.param = param