~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/errors.py

  • Committer: John Arbash Meinel
  • Date: 2005-07-04 05:44:40 UTC
  • mto: (0.5.85) (1185.82.1 bzr-w-changeset)
  • mto: This revision was merged to the branch mainline in revision 1738.
  • Revision ID: john@arbash-meinel.com-20050704054440-ed584dd40745fdde
Refactoring, moving test code into test (switching back to assert is None)

Show diffs side-by-side

added added

removed removed

Lines of Context:
1
 
# (C) 2005 Canonical
2
 
 
3
 
# This program is free software; you can redistribute it and/or modify
4
 
# it under the terms of the GNU General Public License as published by
5
 
# the Free Software Foundation; either version 2 of the License, or
6
 
# (at your option) any later version.
7
 
 
8
 
# This program is distributed in the hope that it will be useful,
9
 
# but WITHOUT ANY WARRANTY; without even the implied warranty of
10
 
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
11
 
# GNU General Public License for more details.
12
 
 
13
 
# You should have received a copy of the GNU General Public License
14
 
# along with this program; if not, write to the Free Software
15
 
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
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
 
 
68
 
class BzrError(StandardError):
69
 
    def __str__(self):
70
 
        # XXX: Should we show the exception class in 
71
 
        # exceptions that don't provide their own message?  
72
 
        # maybe it should be done at a higher level
73
 
        ## n = self.__class__.__name__ + ': '
74
 
        n = ''
75
 
        if len(self.args) == 1:
76
 
            return str(self.args[0])
77
 
        elif len(self.args) == 2:
78
 
            # further explanation or suggestions
79
 
            try:
80
 
                return n + '\n  '.join([self.args[0]] + self.args[1])
81
 
            except TypeError:
82
 
                return n + "%r" % self
83
 
        else:
84
 
            return n + `self.args`
85
 
 
86
 
 
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
 
 
96
 
    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
139
 
 
140
 
 
141
 
class BzrCommandError(BzrError):
142
 
    # Error from malformed user command
143
 
    # This is being misused as a generic exception
144
 
    # pleae subclass. RBC 20051030
145
 
    def __str__(self):
146
 
        return self.args[0]
147
 
 
148
 
 
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
 
 
157
 
class PathError(BzrNewError):
158
 
    """Generic path error: %(path)r%(extra)s)"""
159
 
    def __init__(self, path, extra=None):
160
 
        BzrNewError.__init__(self)
161
 
        self.path = path
162
 
        if extra:
163
 
            self.extra = ': ' + str(extra)
164
 
        else:
165
 
            self.extra = ''
166
 
 
167
 
 
168
 
class NoSuchFile(PathError):
169
 
    """No such file: %(path)r%(extra)s"""
170
 
 
171
 
 
172
 
class FileExists(PathError):
173
 
    """File exists: %(path)r%(extra)s"""
174
 
 
175
 
 
176
 
class PermissionDenied(PathError):
177
 
    """Permission denied: %(path)r%(extra)s"""
178
 
 
179
 
 
180
 
class PathNotChild(BzrNewError):
181
 
    """Path %(path)r is not a child of path %(base)r%(extra)s"""
182
 
    def __init__(self, path, base, extra=None):
183
 
        BzrNewError.__init__(self)
184
 
        self.path = path
185
 
        self.base = base
186
 
        if extra:
187
 
            self.extra = ': ' + str(extra)
188
 
        else:
189
 
            self.extra = ''
190
 
 
191
 
 
192
 
class NotBranchError(BzrNewError):
193
 
    """Not a branch: %(path)s"""
194
 
    def __init__(self, path):
195
 
        BzrNewError.__init__(self)
196
 
        self.path = path
197
 
 
198
 
 
199
 
class FileInWrongBranch(BzrNewError):
200
 
    """File %(path)s in not in branch %(branch_base)s."""
201
 
    def __init__(self, branch, path):
202
 
        BzrNewError.__init__(self)
203
 
        self.branch = branch
204
 
        self.branch_base = branch.base
205
 
        self.path = path
206
 
 
207
 
 
208
 
class UnsupportedFormatError(BzrError):
209
 
    """Specified path is a bzr branch that we cannot read."""
210
 
    def __str__(self):
211
 
        return 'unsupported branch format: %s' % self.args[0]
212
 
 
213
 
 
214
 
class NotVersionedError(BzrNewError):
215
 
    """%(path)s is not versioned"""
216
 
    def __init__(self, path):
217
 
        BzrNewError.__init__(self)
218
 
        self.path = path
219
 
 
220
 
 
221
 
class BadFileKindError(BzrError):
222
 
    """Specified file is of a kind that cannot be added.
223
 
 
224
 
    (For example a symlink or device file.)"""
225
 
 
226
 
 
227
 
class ForbiddenFileError(BzrError):
228
 
    """Cannot operate on a file because it is a control file."""
229
 
 
230
 
 
231
 
class LockError(Exception):
232
 
    """Lock error"""
233
 
    # All exceptions from the lock/unlock functions should be from
234
 
    # this exception class.  They will be translated as necessary. The
235
 
    # original exception is available as e.original_error
236
 
 
237
 
 
238
 
class CommitNotPossible(LockError):
239
 
    """A commit was attempted but we do not have a write lock open."""
240
 
 
241
 
 
242
 
class AlreadyCommitted(LockError):
243
 
    """A rollback was requested, but is not able to be accomplished."""
244
 
 
245
 
 
246
 
class ReadOnlyError(LockError):
247
 
    """A write attempt was made in a read only transaction."""
248
 
 
249
 
 
250
 
class PointlessCommit(BzrNewError):
251
 
    """No changes to commit"""
252
 
 
253
 
class StrictCommitFailed(Exception):
254
 
    """Commit refused because there are unknowns in the tree."""
255
 
 
256
 
class NoSuchRevision(BzrError):
257
 
    def __init__(self, branch, revision):
258
 
        self.branch = branch
259
 
        self.revision = revision
260
 
        msg = "Branch %s has no revision %s" % (branch, revision)
261
 
        BzrError.__init__(self, msg)
262
 
 
263
 
 
264
 
class HistoryMissing(BzrError):
265
 
    def __init__(self, branch, object_type, object_id):
266
 
        self.branch = branch
267
 
        BzrError.__init__(self,
268
 
                          '%s is missing %s {%s}'
269
 
                          % (branch, object_type, object_id))
270
 
 
271
 
 
272
 
class DivergedBranches(BzrError):
273
 
    def __init__(self, branch1, branch2):
274
 
        BzrError.__init__(self, "These branches have diverged.  Try merge.")
275
 
        self.branch1 = branch1
276
 
        self.branch2 = branch2
277
 
 
278
 
 
279
 
class UnrelatedBranches(BzrCommandError):
280
 
    def __init__(self):
281
 
        msg = "Branches have no common ancestor, and no base revision"\
282
 
            " specified."
283
 
        BzrCommandError.__init__(self, msg)
284
 
 
285
 
class NoCommonAncestor(BzrError):
286
 
    def __init__(self, revision_a, revision_b):
287
 
        msg = "Revisions have no common ancestor: %s %s." \
288
 
            % (revision_a, revision_b) 
289
 
        BzrError.__init__(self, msg)
290
 
 
291
 
class NoCommonRoot(BzrError):
292
 
    def __init__(self, revision_a, revision_b):
293
 
        msg = "Revisions are not derived from the same root: %s %s." \
294
 
            % (revision_a, revision_b) 
295
 
        BzrError.__init__(self, msg)
296
 
 
297
 
class NotAncestor(BzrError):
298
 
    def __init__(self, rev_id, not_ancestor_id):
299
 
        msg = "Revision %s is not an ancestor of %s" % (not_ancestor_id, 
300
 
                                                        rev_id)
301
 
        BzrError.__init__(self, msg)
302
 
        self.rev_id = rev_id
303
 
        self.not_ancestor_id = not_ancestor_id
304
 
 
305
 
 
306
 
class InstallFailed(BzrError):
307
 
    def __init__(self, revisions):
308
 
        msg = "Could not install revisions:\n%s" % " ,".join(revisions)
309
 
        BzrError.__init__(self, msg)
310
 
        self.revisions = revisions
311
 
 
312
 
 
313
 
class AmbiguousBase(BzrError):
314
 
    def __init__(self, bases):
315
 
        msg = "The correct base is unclear, becase %s are all equally close" %\
316
 
            ", ".join(bases)
317
 
        BzrError.__init__(self, msg)
318
 
        self.bases = bases
319
 
 
320
 
class NoCommits(BzrError):
321
 
    def __init__(self, branch):
322
 
        msg = "Branch %s has no commits." % branch
323
 
        BzrError.__init__(self, msg)
324
 
 
325
 
class UnlistableStore(BzrError):
326
 
    def __init__(self, store):
327
 
        BzrError.__init__(self, "Store %s is not listable" % store)
328
 
 
329
 
class UnlistableBranch(BzrError):
330
 
    def __init__(self, br):
331
 
        BzrError.__init__(self, "Stores for branch %s are not listable" % br)
332
 
 
333
 
 
334
 
class WeaveError(BzrNewError):
335
 
    """Error in processing weave: %(message)s"""
336
 
    def __init__(self, message=None):
337
 
        BzrNewError.__init__(self)
338
 
        self.message = message
339
 
 
340
 
 
341
 
class WeaveRevisionAlreadyPresent(WeaveError):
342
 
    """Revision {%(revision_id)s} already present in %(weave)s"""
343
 
    def __init__(self, revision_id, weave):
344
 
        WeaveError.__init__(self)
345
 
        self.revision_id = revision_id
346
 
        self.weave = weave
347
 
 
348
 
 
349
 
class WeaveRevisionNotPresent(WeaveError):
350
 
    """Revision {%(revision_id)s} not present in %(weave)s"""
351
 
    def __init__(self, revision_id, weave):
352
 
        WeaveError.__init__(self)
353
 
        self.revision_id = revision_id
354
 
        self.weave = weave
355
 
 
356
 
 
357
 
class WeaveFormatError(WeaveError):
358
 
    """Weave invariant violated: %(what)s"""
359
 
    def __init__(self, what):
360
 
        WeaveError.__init__(self)
361
 
        self.what = what
362
 
 
363
 
 
364
 
class WeaveParentMismatch(WeaveError):
365
 
    """Parents are mismatched between two revisions."""
366
 
    
367
 
 
368
 
class NoSuchExportFormat(BzrNewError):
369
 
    """Export format %(format)r not supported"""
370
 
    def __init__(self, format):
371
 
        BzrNewError.__init__(self)
372
 
        self.format = format
373
 
 
374
 
 
375
 
class TransportError(BzrError):
376
 
    """All errors thrown by Transport implementations should derive
377
 
    from this class.
378
 
    """
379
 
    def __init__(self, msg=None, orig_error=None):
380
 
        if msg is None and orig_error is not None:
381
 
            msg = str(orig_error)
382
 
        BzrError.__init__(self, msg)
383
 
        self.msg = msg
384
 
        self.orig_error = orig_error
385
 
 
386
 
# A set of semi-meaningful errors which can be thrown
387
 
class TransportNotPossible(TransportError):
388
 
    """This is for transports where a specific function is explicitly not
389
 
    possible. Such as pushing files to an HTTP server.
390
 
    """
391
 
    pass
392
 
 
393
 
 
394
 
class ConnectionError(TransportError):
395
 
    """A connection problem prevents file retrieval.
396
 
    This does not indicate whether the file exists or not; it indicates that a
397
 
    precondition for requesting the file was not met.
398
 
    """
399
 
    def __init__(self, msg=None, orig_error=None):
400
 
        TransportError.__init__(self, msg=msg, orig_error=orig_error)
401
 
 
402
 
 
403
 
class ConnectionReset(TransportError):
404
 
    """The connection has been closed."""
405
 
    pass
406
 
 
407
 
class ConflictsInTree(BzrError):
408
 
    def __init__(self):
409
 
        BzrError.__init__(self, "Working tree has conflicts.")
410
 
 
411
 
class ParseConfigError(BzrError):
412
 
    def __init__(self, errors, filename):
413
 
        if filename is None:
414
 
            filename = ""
415
 
        message = "Error(s) parsing config file %s:\n%s" % \
416
 
            (filename, ('\n'.join(e.message for e in errors)))
417
 
        BzrError.__init__(self, message)
418
 
 
419
 
class SigningFailed(BzrError):
420
 
    def __init__(self, command_line):
421
 
        BzrError.__init__(self, "Failed to gpg sign data with command '%s'"
422
 
                               % command_line)
423
 
 
424
 
class WorkingTreeNotRevision(BzrError):
425
 
    def __init__(self, tree):
426
 
        BzrError.__init__(self, "The working tree for %s has changed since"
427
 
                          " last commit, but weave merge requires that it be"
428
 
                          " unchanged." % tree.basedir)
429
 
 
430
 
class CantReprocessAndShowBase(BzrNewError):
431
 
    """Can't reprocess and show base.
432
 
Reprocessing obscures relationship of conflicting lines to base."""
433
 
 
434
 
class GraphCycleError(BzrNewError):
435
 
    """Cycle in graph %(graph)r"""
436
 
    def __init__(self, graph):
437
 
        BzrNewError.__init__(self)
438
 
        self.graph = graph
439
 
 
440
 
class NotConflicted(BzrNewError):
441
 
    """File %(filename)s is not conflicted."""
442
 
    def __init__(self, filename):
443
 
        BzrNewError.__init__(self)
444
 
        self.filename = filename
445
 
 
446
 
class MustUseDecorated(Exception):
447
 
    """A decorating function has requested its original command be used.
448
 
    
449
 
    This should never escape bzr, so does not need to be printable.
450
 
    """
451
 
 
452
 
class MissingText(BzrNewError):
453
 
    """Branch %(base)s is missing revision %(text_revision)s of %(file_id)s"""
454
 
    def __init__(self, branch, text_revision, file_id):
455
 
        self.branch = branch
456
 
        self.base = branch.base
457
 
        self.text_revision = text_revision
458
 
        self.file_id = file_id