~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/errors.py

  • Committer: Robert Collins
  • Date: 2005-10-17 21:57:32 UTC
  • mto: This revision was merged to the branch mainline in revision 1462.
  • Revision ID: robertc@robertcollins.net-20051017215732-08f487800e726748
Allow creation of testaments from uncommitted data, and use that to get signatures before committing revisions.

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
 
...   print sys.exc_value.path
38
 
bzrlib.errors.NotBranchError
39
 
Not a branch: /foo/bar
40
 
/foo/bar
41
 
 
42
 
Therefore:
43
 
 
44
 
 * create a new exception class for any class of error that can be
45
 
   usefully distinguished.
46
 
 
47
 
 * the printable form of an exception is generated by the base class
48
 
   __str__ method
49
 
 
50
 
Exception strings should start with a capital letter and not have a final
51
 
fullstop.
52
 
"""
53
 
 
54
 
# based on Scott James Remnant's hct error classes
55
 
 
56
 
# TODO: is there any value in providing the .args field used by standard
57
 
# python exceptions?   A list of values with no names seems less useful 
58
 
# to me.
59
 
 
60
 
# TODO: Perhaps convert the exception to a string at the moment it's 
61
 
# constructed to make sure it will succeed.  But that says nothing about
62
 
# exceptions that are never raised.
63
 
 
64
 
# TODO: Convert all the other error classes here to BzrNewError, and eliminate
65
 
# the old one.
66
 
 
67
 
 
 
17
 
 
18
__copyright__ = "Copyright (C) 2005 Canonical Ltd."
 
19
__author__ = "Martin Pool <mbp@canonical.com>"
 
20
 
 
21
# TODO: Change to a standard exception pattern: 
 
22
#
 
23
# - docstring of exceptions is a template for formatting the exception
 
24
#   so the __str__ method can be defined only in the superclass
 
25
# - the arguments to the exception are interpolated into this string
 
26
#
 
27
# when printing the exception we'd then require special handling only
 
28
# for built-in exceptions with no decent __str__ method, such as 
 
29
# ValueError and AssertionError.  See 
 
30
# scott@canonical.com--2005/hct--devel--0.10 util/errors.py
 
31
 
 
32
 
 
33
######################################################################
 
34
# exceptions 
68
35
class BzrError(StandardError):
69
36
    def __str__(self):
70
37
        # XXX: Should we show the exception class in 
84
51
            return n + `self.args`
85
52
 
86
53
 
87
 
class BzrNewError(BzrError):
88
 
    """bzr error"""
89
 
    # base classes should override the docstring with their human-
90
 
    # readable explanation
91
 
 
92
 
    def __init__(self, **kwds):
93
 
        for key, value in kwds.items():
94
 
            setattr(self, key, value)
95
 
 
 
54
class BzrCheckError(BzrError):
 
55
    pass
 
56
 
 
57
 
 
58
class InvalidRevisionNumber(BzrError):
96
59
    def __str__(self):
97
 
        try:
98
 
            return self.__doc__ % self.__dict__
99
 
        except (NameError, ValueError, KeyError), e:
100
 
            return 'Unprintable exception %s: %s' \
101
 
                % (self.__class__.__name__, str(e))
102
 
 
103
 
 
104
 
class BzrCheckError(BzrNewError):
105
 
    """Internal check failed: %(message)s"""
106
 
    def __init__(self, message):
107
 
        BzrNewError.__init__(self)
108
 
        self.message = message
109
 
 
110
 
 
111
 
class InvalidEntryName(BzrNewError):
112
 
    """Invalid entry name: %(name)s"""
113
 
    def __init__(self, name):
114
 
        BzrNewError.__init__(self)
115
 
        self.name = name
116
 
 
117
 
 
118
 
class InvalidRevisionNumber(BzrNewError):
119
 
    """Invalid revision number %(revno)d"""
120
 
    def __init__(self, revno):
121
 
        BzrNewError.__init__(self)
122
 
        self.revno = revno
123
 
 
124
 
 
125
 
class InvalidRevisionId(BzrNewError):
126
 
    """Invalid revision-id {%(revision_id)s} in %(branch)s"""
127
 
    def __init__(self, revision_id, branch):
128
 
        BzrNewError.__init__(self)
129
 
        self.revision_id = revision_id
130
 
        self.branch = branch
131
 
 
132
 
 
133
 
class NoWorkingTree(BzrNewError):
134
 
    """No WorkingTree exists for %s(base)."""
135
 
    
136
 
    def __init__(self, base):
137
 
        BzrNewError.__init__(self)
138
 
        self.base = base
 
60
        return 'invalid revision number: %r' % self.args[0]
 
61
 
 
62
 
 
63
class InvalidRevisionId(BzrError):
 
64
    pass
139
65
 
140
66
 
141
67
class BzrCommandError(BzrError):
142
68
    # Error from malformed user command
143
 
    # This is being misused as a generic exception
144
 
    # pleae subclass. RBC 20051030
145
69
    def __str__(self):
146
70
        return self.args[0]
147
71
 
148
72
 
149
 
class BzrOptionError(BzrCommandError):
150
 
    """Some missing or otherwise incorrect option was supplied."""
151
 
 
152
 
    
153
 
class StrictCommitFailed(Exception):
154
 
    """Commit refused because there are unknowns in the tree."""
155
 
 
156
 
class NotBranchError(BzrNewError):
157
 
    """Not a branch: %(path)s"""
158
 
    def __init__(self, path):
159
 
        BzrNewError.__init__(self)
160
 
        self.path = path
161
 
 
162
 
 
163
 
class FileInWrongBranch(BzrNewError):
164
 
    """File %(path)s in not in branch %(branch_base)s."""
165
 
    def __init__(self, branch, path):
166
 
        BzrNewError.__init__(self)
167
 
        self.branch = branch
168
 
        self.branch_base = branch.base
169
 
        self.path = path
 
73
class NotBranchError(BzrError):
 
74
    """Specified path is not in a branch"""
 
75
    def __str__(self):
 
76
        return 'not a branch: %s' % self.args[0]
170
77
 
171
78
 
172
79
class UnsupportedFormatError(BzrError):
175
82
        return 'unsupported branch format: %s' % self.args[0]
176
83
 
177
84
 
178
 
class NotVersionedError(BzrNewError):
179
 
    """%(path)s is not versioned"""
180
 
    def __init__(self, path):
181
 
        BzrNewError.__init__(self)
182
 
        self.path = path
 
85
class NotVersionedError(BzrError):
 
86
    """Specified object is not versioned."""
183
87
 
184
88
 
185
89
class BadFileKindError(BzrError):
186
90
    """Specified file is of a kind that cannot be added.
187
91
 
188
92
    (For example a symlink or device file.)"""
 
93
    pass
189
94
 
190
95
 
191
96
class ForbiddenFileError(BzrError):
192
97
    """Cannot operate on a file because it is a control file."""
 
98
    pass
193
99
 
194
100
 
195
101
class LockError(Exception):
196
 
    """Lock error"""
197
 
    # All exceptions from the lock/unlock functions should be from
198
 
    # this exception class.  They will be translated as necessary. The
199
 
    # original exception is available as e.original_error
 
102
    """All exceptions from the lock/unlock functions should be from
 
103
    this exception class.  They will be translated as necessary. The
 
104
    original exception is available as e.original_error
 
105
    """
 
106
    def __init__(self, e=None):
 
107
        self.original_error = e
 
108
        if e:
 
109
            Exception.__init__(self, e)
 
110
        else:
 
111
            Exception.__init__(self)
200
112
 
201
113
 
202
114
class CommitNotPossible(LockError):
211
123
    """A write attempt was made in a read only transaction."""
212
124
 
213
125
 
214
 
class PointlessCommit(BzrNewError):
215
 
    """No changes to commit"""
 
126
class PointlessCommit(Exception):
 
127
    """Commit failed because nothing was changed."""
216
128
 
217
 
class StrictCommitFailed(Exception):
218
 
    """Commit refused because there are unknowns in the tree."""
219
129
 
220
130
class NoSuchRevision(BzrError):
221
131
    def __init__(self, branch, revision):
267
177
        self.not_ancestor_id = not_ancestor_id
268
178
 
269
179
 
 
180
class NotAncestor(BzrError):
 
181
    def __init__(self, rev_id, not_ancestor_id):
 
182
        self.rev_id = rev_id
 
183
        self.not_ancestor_id = not_ancestor_id
 
184
        msg = "Revision %s is not an ancestor of %s" % (not_ancestor_id, 
 
185
                                                        rev_id)
 
186
        BzrError.__init__(self, msg)
 
187
 
 
188
 
270
189
class InstallFailed(BzrError):
271
190
    def __init__(self, revisions):
272
191
        msg = "Could not install revisions:\n%s" % " ,".join(revisions)
295
214
        BzrError.__init__(self, "Stores for branch %s are not listable" % br)
296
215
 
297
216
 
298
 
class WeaveError(BzrNewError):
299
 
    """Error in processing weave: %(message)s"""
300
 
    def __init__(self, message=None):
301
 
        BzrNewError.__init__(self)
302
 
        self.message = message
303
 
 
304
 
 
305
 
class WeaveRevisionAlreadyPresent(WeaveError):
306
 
    """Revision {%(revision_id)s} already present in %(weave)s"""
307
 
    def __init__(self, revision_id, weave):
308
 
        WeaveError.__init__(self)
309
 
        self.revision_id = revision_id
310
 
        self.weave = weave
311
 
 
312
 
 
313
 
class WeaveRevisionNotPresent(WeaveError):
314
 
    """Revision {%(revision_id)s} not present in %(weave)s"""
315
 
    def __init__(self, revision_id, weave):
316
 
        WeaveError.__init__(self)
317
 
        self.revision_id = revision_id
318
 
        self.weave = weave
319
 
 
320
 
 
321
 
class WeaveFormatError(WeaveError):
322
 
    """Weave invariant violated: %(what)s"""
323
 
    def __init__(self, what):
324
 
        WeaveError.__init__(self)
325
 
        self.what = what
326
 
 
327
 
 
328
 
class WeaveParentMismatch(WeaveError):
329
 
    """Parents are mismatched between two revisions."""
330
 
    
331
 
 
332
 
class NoSuchExportFormat(BzrNewError):
333
 
    """Export format %(format)r not supported"""
334
 
    def __init__(self, format):
335
 
        BzrNewError.__init__(self)
336
 
        self.format = format
337
 
 
 
217
from bzrlib.weave import WeaveError, WeaveParentMismatch
338
218
 
339
219
class TransportError(BzrError):
340
220
    """All errors thrown by Transport implementations should derive
373
253
        TransportError.__init__(self, msg=msg, orig_error=orig_error)
374
254
        IOError.__init__(self, errno.ENOENT, self.msg)
375
255
 
376
 
class ConnectionError(TransportError, IOError):
377
 
    """
378
 
    A connection problem prevents file retrieval.
379
 
    This does not indicate whether the file exists or not; it indicates that a
380
 
    precondition for requesting the file was not met.
381
 
    """
382
 
 
383
 
    # XXX: Is multiple inheritance for exceptions really needed?
384
 
 
385
 
    def __str__(self):
386
 
        return 'connection error: ' + self.msg
387
 
 
388
 
    def __init__(self, msg=None, orig_error=None):
389
 
        import errno
390
 
        TransportError.__init__(self, msg=msg, orig_error=orig_error)
391
 
        IOError.__init__(self, errno.ENOENT, self.msg)
392
 
 
393
 
 
394
256
class FileExists(TransportError, OSError):
395
257
    """An operation was attempted, which would overwrite an entry,
396
258
    but overwritting is not supported.
415
277
    def __init__(self):
416
278
        BzrError.__init__(self, "Working tree has conflicts.")
417
279
 
418
 
class ParseConfigError(BzrError):
419
 
    def __init__(self, errors, filename):
420
 
        if filename is None:
421
 
            filename = ""
422
 
        message = "Error(s) parsing config file %s:\n%s" % \
423
 
            (filename, ('\n'.join(e.message for e in errors)))
424
 
        BzrError.__init__(self, message)
425
 
 
426
280
class SigningFailed(BzrError):
427
281
    def __init__(self, command_line):
428
282
        BzrError.__init__(self, "Failed to gpg sign data with command '%s'"
429
283
                               % command_line)
430
 
 
431
 
class WorkingTreeNotRevision(BzrError):
432
 
    def __init__(self, tree):
433
 
        BzrError.__init__(self, "The working tree for %s has changed since"
434
 
                          " last commit, but weave merge requires that it be"
435
 
                          " unchanged." % tree.basedir)
436
 
 
437
 
class CantReprocessAndShowBase(BzrNewError):
438
 
    """Can't reprocess and show base.
439
 
Reprocessing obscures relationship of conflicting lines to base."""
440
 
 
441
 
class GraphCycleError(BzrNewError):
442
 
    """Cycle in graph %(graph)r"""
443
 
    def __init__(self, graph):
444
 
        BzrNewError.__init__(self)
445
 
        self.graph = graph
446
 
 
447
 
class NotConflicted(BzrNewError):
448
 
    """File %(filename)s is not conflicted."""
449
 
    def __init__(self, filename):
450
 
        BzrNewError.__init__(self)
451
 
        self.filename = filename
452
 
 
453
 
class MustUseDecorated(Exception):
454
 
    """A decorating function has requested its original command be used.
455
 
    
456
 
    This should never escape bzr, so does not need to be printable.
457
 
    """
458
 
 
459
 
class MissingText(BzrNewError):
460
 
    """Branch %(base)s is missing revision %(text_revision)s of %(file_id)s"""
461
 
    def __init__(self, branch, text_revision, file_id):
462
 
        self.branch = branch
463
 
        self.base = branch.base
464
 
        self.text_revision = text_revision
465
 
        self.file_id = file_id