~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/errors.py

  • Committer: Jelmer Vernooij
  • Date: 2005-10-02 13:14:12 UTC
  • mto: This revision was merged to the branch mainline in revision 1414.
  • Revision ID: jelmer@samba.org-20051002131412-c44d6cd10336ac94
Add test for empty commit messages.

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
 
        # XXX: Should we show the exception class in 
73
 
        # exceptions that don't provide their own message?  
74
 
        # maybe it should be done at a higher level
75
 
        ## n = self.__class__.__name__ + ': '
76
 
        n = ''
77
26
        if len(self.args) == 1:
78
 
            return str(self.args[0])
 
27
            return self.args[0]
79
28
        elif len(self.args) == 2:
80
29
            # further explanation or suggestions
81
 
            try:
82
 
                return n + '\n  '.join([self.args[0]] + self.args[1])
83
 
            except TypeError:
84
 
                return n + "%r" % self
 
30
            return '\n  '.join([self.args[0]] + self.args[1])
85
31
        else:
86
 
            return n + `self.args`
87
 
 
88
 
 
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
 
 
 
32
            return `self.args`
 
33
 
 
34
 
 
35
class BzrCheckError(BzrError):
 
36
    pass
 
37
 
 
38
 
 
39
class InvalidRevisionNumber(BzrError):
98
40
    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
 
41
        return 'invalid revision number: %r' % self.args[0]
 
42
 
 
43
 
 
44
class InvalidRevisionId(BzrError):
 
45
    pass
141
46
 
142
47
 
143
48
class BzrCommandError(BzrError):
144
49
    # 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
 
    def __str__(self):
153
 
        return self.args[0]
154
 
 
155
 
 
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
213
 
 
214
 
 
215
 
class UnsupportedFormatError(BzrError):
216
 
    """Specified path is a bzr branch that we cannot read."""
217
 
    def __str__(self):
218
 
        return 'unsupported branch format: %s' % self.args[0]
219
 
 
220
 
 
221
 
class NotVersionedError(BzrNewError):
222
 
    """%(path)s is not versioned"""
223
 
    def __init__(self, path):
224
 
        BzrNewError.__init__(self)
225
 
        self.path = path
 
50
    pass
 
51
 
 
52
 
 
53
class NotBranchError(BzrError):
 
54
    """Specified path is not in a branch"""
 
55
    pass
 
56
 
 
57
 
 
58
class NotVersionedError(BzrError):
 
59
    """Specified object is not versioned."""
226
60
 
227
61
 
228
62
class BadFileKindError(BzrError):
229
63
    """Specified file is of a kind that cannot be added.
230
64
 
231
65
    (For example a symlink or device file.)"""
 
66
    pass
232
67
 
233
68
 
234
69
class ForbiddenFileError(BzrError):
235
70
    """Cannot operate on a file because it is a control file."""
 
71
    pass
236
72
 
237
73
 
238
74
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
243
 
 
244
 
 
245
 
class CommitNotPossible(LockError):
246
 
    """A commit was attempted but we do not have a write lock open."""
247
 
 
248
 
 
249
 
class AlreadyCommitted(LockError):
250
 
    """A rollback was requested, but is not able to be accomplished."""
251
 
 
252
 
 
253
 
class ReadOnlyError(LockError):
254
 
    """A write attempt was made in a read only transaction."""
255
 
 
256
 
 
257
 
class PointlessCommit(BzrNewError):
258
 
    """No changes to commit"""
259
 
 
260
 
class StrictCommitFailed(Exception):
261
 
    """Commit refused because there are unknowns in the tree."""
 
75
    """All exceptions from the lock/unlock functions should be from
 
76
    this exception class.  They will be translated as necessary. The
 
77
    original exception is available as e.original_error
 
78
    """
 
79
    def __init__(self, e=None):
 
80
        self.original_error = e
 
81
        if e:
 
82
            Exception.__init__(self, e)
 
83
        else:
 
84
            Exception.__init__(self)
 
85
 
 
86
 
 
87
class PointlessCommit(Exception):
 
88
    """Commit failed because nothing was changed."""
 
89
 
262
90
 
263
91
class NoSuchRevision(BzrError):
264
92
    def __init__(self, branch, revision):
278
106
 
279
107
class DivergedBranches(BzrError):
280
108
    def __init__(self, branch1, branch2):
281
 
        BzrError.__init__(self, "These branches have diverged.  Try merge.")
 
109
        BzrError.__init__(self, "These branches have diverged.")
282
110
        self.branch1 = branch1
283
111
        self.branch2 = branch2
284
112
 
338
166
        BzrError.__init__(self, "Stores for branch %s are not listable" % br)
339
167
 
340
168
 
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
 
 
 
169
from bzrlib.weave import WeaveError
385
170
 
386
171
class TransportError(BzrError):
387
172
    """All errors thrown by Transport implementations should derive
401
186
    """
402
187
    pass
403
188
 
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
 
 
 
189
class NonRelativePath(TransportError):
 
190
    """An absolute path was supplied, that could not be decoded into
 
191
    a relative path.
 
192
    """
 
193
    pass
 
194
 
 
195
class NoSuchFile(TransportError, IOError):
 
196
    """A get() was issued for a file that doesn't exist."""
 
197
    def __init__(self, msg=None, orig_error=None):
 
198
        import errno
 
199
        TransportError.__init__(self, msg=msg, orig_error=orig_error)
 
200
        IOError.__init__(self, errno.ENOENT, self.msg)
 
201
 
 
202
class FileExists(TransportError, OSError):
 
203
    """An operation was attempted, which would overwrite an entry,
 
204
    but overwritting is not supported.
 
205
 
 
206
    mkdir() can throw this, but put() just overwites existing files.
 
207
    """
 
208
    def __init__(self, msg=None, orig_error=None):
 
209
        import errno
 
210
        TransportError.__init__(self, msg=msg, orig_error=orig_error)
 
211
        OSError.__init__(self, errno.EEXIST, self.msg)
 
212
 
 
213
class PermissionDenied(TransportError):
 
214
    """An operation cannot succeed because of a lack of permissions."""
 
215
    pass
413
216
 
414
217
class ConnectionReset(TransportError):
415
218
    """The connection has been closed."""
416
219
    pass
417
220
 
418
 
class ConflictsInTree(BzrError):
419
 
    def __init__(self):
420
 
        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