~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/errors.py

  • Committer: Robert Collins
  • Date: 2005-10-30 00:00:09 UTC
  • mfrom: (1185.16.134)
  • Revision ID: robertc@robertcollins.net-20051030000009-9db99a338a0dfdac
MergeĀ fromĀ Martin.

Show diffs side-by-side

added added

removed removed

Lines of Context:
1
 
#! /usr/bin/env python
2
 
# -*- coding: UTF-8 -*-
 
1
# (C) 2005 Canonical
3
2
 
4
3
# This program is free software; you can redistribute it and/or modify
5
4
# it under the terms of the GNU General Public License as published by
15
14
# along with this program; if not, write to the Free Software
16
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
17
16
 
18
 
 
19
 
__copyright__ = "Copyright (C) 2005 Canonical Ltd."
20
 
__author__ = "Martin Pool <mbp@canonical.com>"
21
 
 
22
 
 
23
 
######################################################################
24
 
# exceptions 
 
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
 
25
65
class BzrError(StandardError):
26
 
    pass
27
 
 
28
 
class BzrCheckError(BzrError):
29
 
    pass
 
66
    def __str__(self):
 
67
        # XXX: Should we show the exception class in 
 
68
        # exceptions that don't provide their own message?  
 
69
        # maybe it should be done at a higher level
 
70
        ## n = self.__class__.__name__ + ': '
 
71
        n = ''
 
72
        if len(self.args) == 1:
 
73
            return str(self.args[0])
 
74
        elif len(self.args) == 2:
 
75
            # further explanation or suggestions
 
76
            try:
 
77
                return n + '\n  '.join([self.args[0]] + self.args[1])
 
78
            except TypeError:
 
79
                return n + "%r" % self
 
80
        else:
 
81
            return n + `self.args`
 
82
 
 
83
 
 
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
 
 
93
    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
30
128
 
31
129
 
32
130
class BzrCommandError(BzrError):
33
131
    # Error from malformed user command
34
 
    pass
35
 
 
36
 
 
37
 
class NotBranchError(BzrError):
38
 
    """Specified path is not in a branch"""
39
 
    pass
40
 
 
41
 
 
42
 
class NotVersionedError(BzrError):
43
 
    """Specified object is not versioned."""
 
132
    def __str__(self):
 
133
        return self.args[0]
 
134
 
 
135
class StrictCommitFailed(Exception):
 
136
    """Commit refused because there are unknowns in the tree."""
 
137
 
 
138
class NotBranchError(BzrNewError):
 
139
    """Not a branch: %(path)s"""
 
140
    def __init__(self, path):
 
141
        BzrNewError.__init__(self)
 
142
        self.path = path
 
143
 
 
144
 
 
145
class UnsupportedFormatError(BzrError):
 
146
    """Specified path is a bzr branch that we cannot read."""
 
147
    def __str__(self):
 
148
        return 'unsupported branch format: %s' % self.args[0]
 
149
 
 
150
 
 
151
class NotVersionedError(BzrNewError):
 
152
    """%(path)s is not versioned"""
 
153
    def __init__(self, path):
 
154
        BzrNewError.__init__(self)
 
155
        self.path = path
44
156
 
45
157
 
46
158
class BadFileKindError(BzrError):
47
159
    """Specified file is of a kind that cannot be added.
48
160
 
49
161
    (For example a symlink or device file.)"""
50
 
    pass
51
162
 
52
163
 
53
164
class ForbiddenFileError(BzrError):
54
165
    """Cannot operate on a file because it is a control file."""
55
 
    pass
56
166
 
57
167
 
58
168
class LockError(Exception):
59
 
    """All exceptions from the lock/unlock functions should be from
60
 
    this exception class.  They will be translated as necessary. The
61
 
    original exception is available as e.original_error
62
 
    """
63
 
    def __init__(self, e=None):
64
 
        self.original_error = e
65
 
        if e:
66
 
            Exception.__init__(self, e)
67
 
        else:
68
 
            Exception.__init__(self)
 
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
 
173
 
 
174
 
 
175
class CommitNotPossible(LockError):
 
176
    """A commit was attempted but we do not have a write lock open."""
 
177
 
 
178
 
 
179
class AlreadyCommitted(LockError):
 
180
    """A rollback was requested, but is not able to be accomplished."""
 
181
 
 
182
 
 
183
class ReadOnlyError(LockError):
 
184
    """A write attempt was made in a read only transaction."""
 
185
 
 
186
 
 
187
class PointlessCommit(BzrNewError):
 
188
    """No changes to commit"""
 
189
 
 
190
class StrictCommitFailed(Exception):
 
191
    """Commit refused because there are unknowns in the tree."""
 
192
 
 
193
class NoSuchRevision(BzrError):
 
194
    def __init__(self, branch, revision):
 
195
        self.branch = branch
 
196
        self.revision = revision
 
197
        msg = "Branch %s has no revision %s" % (branch, revision)
 
198
        BzrError.__init__(self, msg)
 
199
 
 
200
 
 
201
class HistoryMissing(BzrError):
 
202
    def __init__(self, branch, object_type, object_id):
 
203
        self.branch = branch
 
204
        BzrError.__init__(self,
 
205
                          '%s is missing %s {%s}'
 
206
                          % (branch, object_type, object_id))
 
207
 
 
208
 
 
209
class DivergedBranches(BzrError):
 
210
    def __init__(self, branch1, branch2):
 
211
        BzrError.__init__(self, "These branches have diverged.")
 
212
        self.branch1 = branch1
 
213
        self.branch2 = branch2
 
214
 
 
215
 
 
216
class UnrelatedBranches(BzrCommandError):
 
217
    def __init__(self):
 
218
        msg = "Branches have no common ancestor, and no base revision"\
 
219
            " specified."
 
220
        BzrCommandError.__init__(self, msg)
 
221
 
 
222
class NoCommonAncestor(BzrError):
 
223
    def __init__(self, revision_a, revision_b):
 
224
        msg = "Revisions have no common ancestor: %s %s." \
 
225
            % (revision_a, revision_b) 
 
226
        BzrError.__init__(self, msg)
 
227
 
 
228
class NoCommonRoot(BzrError):
 
229
    def __init__(self, revision_a, revision_b):
 
230
        msg = "Revisions are not derived from the same root: %s %s." \
 
231
            % (revision_a, revision_b) 
 
232
        BzrError.__init__(self, msg)
 
233
 
 
234
class NotAncestor(BzrError):
 
235
    def __init__(self, rev_id, not_ancestor_id):
 
236
        msg = "Revision %s is not an ancestor of %s" % (not_ancestor_id, 
 
237
                                                        rev_id)
 
238
        BzrError.__init__(self, msg)
 
239
        self.rev_id = rev_id
 
240
        self.not_ancestor_id = not_ancestor_id
 
241
 
 
242
 
 
243
class NotAncestor(BzrError):
 
244
    def __init__(self, rev_id, not_ancestor_id):
 
245
        self.rev_id = rev_id
 
246
        self.not_ancestor_id = not_ancestor_id
 
247
        msg = "Revision %s is not an ancestor of %s" % (not_ancestor_id, 
 
248
                                                        rev_id)
 
249
        BzrError.__init__(self, msg)
 
250
 
 
251
 
 
252
class InstallFailed(BzrError):
 
253
    def __init__(self, revisions):
 
254
        msg = "Could not install revisions:\n%s" % " ,".join(revisions)
 
255
        BzrError.__init__(self, msg)
 
256
        self.revisions = revisions
 
257
 
 
258
 
 
259
class AmbiguousBase(BzrError):
 
260
    def __init__(self, bases):
 
261
        msg = "The correct base is unclear, becase %s are all equally close" %\
 
262
            ", ".join(bases)
 
263
        BzrError.__init__(self, msg)
 
264
        self.bases = bases
 
265
 
 
266
class NoCommits(BzrError):
 
267
    def __init__(self, branch):
 
268
        msg = "Branch %s has no commits." % branch
 
269
        BzrError.__init__(self, msg)
 
270
 
 
271
class UnlistableStore(BzrError):
 
272
    def __init__(self, store):
 
273
        BzrError.__init__(self, "Store %s is not listable" % store)
 
274
 
 
275
class UnlistableBranch(BzrError):
 
276
    def __init__(self, br):
 
277
        BzrError.__init__(self, "Stores for branch %s are not listable" % br)
 
278
 
 
279
 
 
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
    
 
313
 
 
314
class TransportError(BzrError):
 
315
    """All errors thrown by Transport implementations should derive
 
316
    from this class.
 
317
    """
 
318
    def __init__(self, msg=None, orig_error=None):
 
319
        if msg is None and orig_error is not None:
 
320
            msg = str(orig_error)
 
321
        BzrError.__init__(self, msg)
 
322
        self.msg = msg
 
323
        self.orig_error = orig_error
 
324
 
 
325
# A set of semi-meaningful errors which can be thrown
 
326
class TransportNotPossible(TransportError):
 
327
    """This is for transports where a specific function is explicitly not
 
328
    possible. Such as pushing files to an HTTP server.
 
329
    """
 
330
    pass
 
331
 
 
332
class NonRelativePath(TransportError):
 
333
    """An absolute path was supplied, that could not be decoded into
 
334
    a relative path.
 
335
    """
 
336
    pass
 
337
 
 
338
class NoSuchFile(TransportError, IOError):
 
339
    """A get() was issued for a file that doesn't exist."""
 
340
 
 
341
    # XXX: Is multiple inheritance for exceptions really needed?
 
342
 
 
343
    def __str__(self):
 
344
        return 'no such file: ' + self.msg
 
345
 
 
346
    def __init__(self, msg=None, orig_error=None):
 
347
        import errno
 
348
        TransportError.__init__(self, msg=msg, orig_error=orig_error)
 
349
        IOError.__init__(self, errno.ENOENT, self.msg)
 
350
 
 
351
class FileExists(TransportError, OSError):
 
352
    """An operation was attempted, which would overwrite an entry,
 
353
    but overwritting is not supported.
 
354
 
 
355
    mkdir() can throw this, but put() just overwites existing files.
 
356
    """
 
357
    # XXX: Is multiple inheritance for exceptions really needed?
 
358
    def __init__(self, msg=None, orig_error=None):
 
359
        import errno
 
360
        TransportError.__init__(self, msg=msg, orig_error=orig_error)
 
361
        OSError.__init__(self, errno.EEXIST, self.msg)
 
362
 
 
363
class PermissionDenied(TransportError):
 
364
    """An operation cannot succeed because of a lack of permissions."""
 
365
    pass
 
366
 
 
367
class ConnectionReset(TransportError):
 
368
    """The connection has been closed."""
 
369
    pass
 
370
 
 
371
class ConflictsInTree(BzrError):
 
372
    def __init__(self):
 
373
        BzrError.__init__(self, "Working tree has conflicts.")
 
374
 
 
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
class SigningFailed(BzrError):
 
384
    def __init__(self, command_line):
 
385
        BzrError.__init__(self, "Failed to gpg sign data with command '%s'"
 
386
                               % 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