~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 23:13:00 UTC
  • mto: This revision was merged to the branch mainline in revision 1462.
  • Revision ID: robertc@robertcollins.net-20051017231300-e1c9e931bcfacd6a
Branch.open_containing now returns a tuple (Branch, relative-path).

This allows direct access to the common case of 'get me this file
from its branch'. (Robert Collins)

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
 
 
51
 
# based on Scott James Remnant's hct error classes
52
 
 
53
 
# TODO: is there any value in providing the .args field used by standard
54
 
# python exceptions?   A list of values with no names seems less useful 
55
 
# to me.
56
 
 
57
 
# TODO: Perhaps convert the exception to a string at the moment it's 
58
 
# constructed to make sure it will succeed.  But that says nothing about
59
 
# exceptions that are never raised.
60
 
 
61
 
# TODO: Convert all the other error classes here to BzrNewError, and eliminate
62
 
# the old one.
63
 
 
64
 
 
 
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 
65
35
class BzrError(StandardError):
66
36
    def __str__(self):
67
37
        # XXX: Should we show the exception class in 
81
51
            return n + `self.args`
82
52
 
83
53
 
84
 
class BzrNewError(BzrError):
85
 
    """bzr error"""
86
 
    # base classes should override the docstring with their human-
87
 
    # readable explanation
88
 
 
89
 
    def __init__(self, **kwds):
90
 
        for key, value in kwds.items():
91
 
            setattr(self, key, value)
92
 
 
 
54
class BzrCheckError(BzrError):
 
55
    pass
 
56
 
 
57
 
 
58
class InvalidRevisionNumber(BzrError):
93
59
    def __str__(self):
94
 
        try:
95
 
            return self.__doc__ % self.__dict__
96
 
        except (NameError, ValueError, KeyError), e:
97
 
            return 'Unprintable exception %s: %s' \
98
 
                % (self.__class__.__name__, str(e))
99
 
 
100
 
 
101
 
class BzrCheckError(BzrNewError):
102
 
    """Internal check failed: %(message)s"""
103
 
    def __init__(self, message):
104
 
        BzrNewError.__init__(self)
105
 
        self.message = message
106
 
 
107
 
 
108
 
class InvalidEntryName(BzrNewError):
109
 
    """Invalid entry name: %(name)s"""
110
 
    def __init__(self, name):
111
 
        BzrNewError.__init__(self)
112
 
        self.name = name
113
 
 
114
 
 
115
 
class InvalidRevisionNumber(BzrNewError):
116
 
    """Invalid revision number %(revno)d"""
117
 
    def __init__(self, revno):
118
 
        BzrNewError.__init__(self)
119
 
        self.revno = revno
120
 
 
121
 
 
122
 
class InvalidRevisionId(BzrNewError):
123
 
    """Invalid revision-id {%(revision_id)s} in %(branch)s"""
124
 
    def __init__(self, revision_id, branch):
125
 
        BzrNewError.__init__(self)
126
 
        self.revision_id = revision_id
127
 
        self.branch = branch
 
60
        return 'invalid revision number: %r' % self.args[0]
 
61
 
 
62
 
 
63
class InvalidRevisionId(BzrError):
 
64
    pass
128
65
 
129
66
 
130
67
class BzrCommandError(BzrError):
132
69
    def __str__(self):
133
70
        return self.args[0]
134
71
 
135
 
class StrictCommitFailed(Exception):
136
 
    """Commit refused because there are unknowns in the tree."""
137
72
 
138
 
class NotBranchError(BzrNewError):
139
 
    """Not a branch: %(path)s"""
140
 
    def __init__(self, path):
141
 
        BzrNewError.__init__(self)
142
 
        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]
143
77
 
144
78
 
145
79
class UnsupportedFormatError(BzrError):
148
82
        return 'unsupported branch format: %s' % self.args[0]
149
83
 
150
84
 
151
 
class NotVersionedError(BzrNewError):
152
 
    """%(path)s is not versioned"""
153
 
    def __init__(self, path):
154
 
        BzrNewError.__init__(self)
155
 
        self.path = path
 
85
class NotVersionedError(BzrError):
 
86
    """Specified object is not versioned."""
156
87
 
157
88
 
158
89
class BadFileKindError(BzrError):
159
90
    """Specified file is of a kind that cannot be added.
160
91
 
161
92
    (For example a symlink or device file.)"""
 
93
    pass
162
94
 
163
95
 
164
96
class ForbiddenFileError(BzrError):
165
97
    """Cannot operate on a file because it is a control file."""
 
98
    pass
166
99
 
167
100
 
168
101
class LockError(Exception):
169
 
    """Lock error"""
170
 
    # All exceptions from the lock/unlock functions should be from
171
 
    # this exception class.  They will be translated as necessary. The
172
 
    # 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)
173
112
 
174
113
 
175
114
class CommitNotPossible(LockError):
184
123
    """A write attempt was made in a read only transaction."""
185
124
 
186
125
 
187
 
class PointlessCommit(BzrNewError):
188
 
    """No changes to commit"""
 
126
class PointlessCommit(Exception):
 
127
    """Commit failed because nothing was changed."""
189
128
 
190
 
class StrictCommitFailed(Exception):
191
 
    """Commit refused because there are unknowns in the tree."""
192
129
 
193
130
class NoSuchRevision(BzrError):
194
131
    def __init__(self, branch, revision):
277
214
        BzrError.__init__(self, "Stores for branch %s are not listable" % br)
278
215
 
279
216
 
280
 
class WeaveError(BzrNewError):
281
 
    """Error in processing weave: %(message)s"""
282
 
    def __init__(self, message=None):
283
 
        BzrNewError.__init__(self)
284
 
        self.message = message
285
 
 
286
 
 
287
 
class WeaveRevisionAlreadyPresent(WeaveError):
288
 
    """Revision {%(revision_id)s} already present in %(weave)s"""
289
 
    def __init__(self, revision_id, weave):
290
 
        WeaveError.__init__(self)
291
 
        self.revision_id = revision_id
292
 
        self.weave = weave
293
 
 
294
 
 
295
 
class WeaveRevisionNotPresent(WeaveError):
296
 
    """Revision {%(revision_id)s} not present in %(weave)s"""
297
 
    def __init__(self, revision_id, weave):
298
 
        WeaveError.__init__(self)
299
 
        self.revision_id = revision_id
300
 
        self.weave = weave
301
 
 
302
 
 
303
 
class WeaveFormatError(WeaveError):
304
 
    """Weave invariant violated: %(what)s"""
305
 
    def __init__(self, what):
306
 
        WeaveError.__init__(self)
307
 
        self.what = what
308
 
 
309
 
 
310
 
class WeaveParentMismatch(WeaveError):
311
 
    """Parents are mismatched between two revisions."""
312
 
    
 
217
from bzrlib.weave import WeaveError, WeaveParentMismatch
313
218
 
314
219
class TransportError(BzrError):
315
220
    """All errors thrown by Transport implementations should derive
372
277
    def __init__(self):
373
278
        BzrError.__init__(self, "Working tree has conflicts.")
374
279
 
375
 
class ParseConfigError(BzrError):
376
 
    def __init__(self, errors, filename):
377
 
        if filename is None:
378
 
            filename = ""
379
 
        message = "Error(s) parsing config file %s:\n%s" % \
380
 
            (filename, ('\n'.join(e.message for e in errors)))
381
 
        BzrError.__init__(self, message)
382
 
 
383
280
class SigningFailed(BzrError):
384
281
    def __init__(self, command_line):
385
282
        BzrError.__init__(self, "Failed to gpg sign data with command '%s'"
386
283
                               % command_line)
387
 
 
388
 
class WorkingTreeNotRevision(BzrError):
389
 
    def __init__(self, tree):
390
 
        BzrError.__init__(self, "The working tree for %s has changed since"
391
 
                          " last commit, but weave merge requires that it be"
392
 
                          " unchanged." % tree.basedir)
393
 
 
394
 
class CantReprocessAndShowBase(BzrNewError):
395
 
    """Can't reprocess and show base.
396
 
Reprocessing obscures relationship of conflicting lines to base."""
397
 
 
398
 
class GraphCycleError(BzrNewError):
399
 
    """Cycle in graph %(graph)r"""
400
 
    def __init__(self, graph):
401
 
        BzrNewError.__init__(self)
402
 
        self.graph = graph