/brz/remove-bazaar

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar

« back to all changes in this revision

Viewing changes to bzrlib/errors.py

  • Committer: John Arbash Meinel
  • Date: 2005-12-01 19:57:43 UTC
  • mto: (1185.50.19 bzr-jam-integration)
  • mto: This revision was merged to the branch mainline in revision 1532.
  • Revision ID: john@arbash-meinel.com-20051201195743-57aefc694d237938
Reintroduced ensure_config_dir_exists() for sftp

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 PathNotChild(BzrNewError):
 
158
    """Path %(path)r is not a child of path %(base)r"""
 
159
    def __init__(self, path, base):
 
160
        BzrNewError.__init__(self)
 
161
        self.path = path
 
162
        self.base = base
 
163
 
 
164
 
 
165
class NotBranchError(BzrNewError):
 
166
    """Not a branch: %(path)s"""
 
167
    def __init__(self, path):
 
168
        BzrNewError.__init__(self)
 
169
        self.path = path
 
170
 
 
171
 
 
172
class FileInWrongBranch(BzrNewError):
 
173
    """File %(path)s in not in branch %(branch_base)s."""
 
174
    def __init__(self, branch, path):
 
175
        BzrNewError.__init__(self)
 
176
        self.branch = branch
 
177
        self.branch_base = branch.base
 
178
        self.path = path
 
179
 
 
180
 
 
181
class UnsupportedFormatError(BzrError):
 
182
    """Specified path is a bzr branch that we cannot read."""
 
183
    def __str__(self):
 
184
        return 'unsupported branch format: %s' % self.args[0]
 
185
 
 
186
 
 
187
class NotVersionedError(BzrNewError):
 
188
    """%(path)s is not versioned"""
 
189
    def __init__(self, path):
 
190
        BzrNewError.__init__(self)
 
191
        self.path = path
 
192
 
 
193
 
 
194
class BadFileKindError(BzrError):
 
195
    """Specified file is of a kind that cannot be added.
 
196
 
 
197
    (For example a symlink or device file.)"""
 
198
 
 
199
 
 
200
class ForbiddenFileError(BzrError):
 
201
    """Cannot operate on a file because it is a control file."""
 
202
 
 
203
 
 
204
class LockError(Exception):
 
205
    """Lock error"""
 
206
    # All exceptions from the lock/unlock functions should be from
 
207
    # this exception class.  They will be translated as necessary. The
 
208
    # original exception is available as e.original_error
 
209
 
 
210
 
 
211
class CommitNotPossible(LockError):
 
212
    """A commit was attempted but we do not have a write lock open."""
 
213
 
 
214
 
 
215
class AlreadyCommitted(LockError):
 
216
    """A rollback was requested, but is not able to be accomplished."""
 
217
 
 
218
 
 
219
class ReadOnlyError(LockError):
 
220
    """A write attempt was made in a read only transaction."""
 
221
 
 
222
 
 
223
class PointlessCommit(BzrNewError):
 
224
    """No changes to commit"""
 
225
 
 
226
class StrictCommitFailed(Exception):
 
227
    """Commit refused because there are unknowns in the tree."""
 
228
 
 
229
class NoSuchRevision(BzrError):
 
230
    def __init__(self, branch, revision):
 
231
        self.branch = branch
 
232
        self.revision = revision
 
233
        msg = "Branch %s has no revision %s" % (branch, revision)
 
234
        BzrError.__init__(self, msg)
 
235
 
 
236
 
 
237
class HistoryMissing(BzrError):
 
238
    def __init__(self, branch, object_type, object_id):
 
239
        self.branch = branch
 
240
        BzrError.__init__(self,
 
241
                          '%s is missing %s {%s}'
 
242
                          % (branch, object_type, object_id))
 
243
 
 
244
 
 
245
class DivergedBranches(BzrError):
 
246
    def __init__(self, branch1, branch2):
 
247
        BzrError.__init__(self, "These branches have diverged.")
 
248
        self.branch1 = branch1
 
249
        self.branch2 = branch2
 
250
 
 
251
 
 
252
class UnrelatedBranches(BzrCommandError):
 
253
    def __init__(self):
 
254
        msg = "Branches have no common ancestor, and no base revision"\
 
255
            " specified."
 
256
        BzrCommandError.__init__(self, msg)
 
257
 
 
258
class NoCommonAncestor(BzrError):
 
259
    def __init__(self, revision_a, revision_b):
 
260
        msg = "Revisions have no common ancestor: %s %s." \
 
261
            % (revision_a, revision_b) 
 
262
        BzrError.__init__(self, msg)
 
263
 
 
264
class NoCommonRoot(BzrError):
 
265
    def __init__(self, revision_a, revision_b):
 
266
        msg = "Revisions are not derived from the same root: %s %s." \
 
267
            % (revision_a, revision_b) 
 
268
        BzrError.__init__(self, msg)
 
269
 
 
270
class NotAncestor(BzrError):
 
271
    def __init__(self, rev_id, not_ancestor_id):
 
272
        msg = "Revision %s is not an ancestor of %s" % (not_ancestor_id, 
 
273
                                                        rev_id)
 
274
        BzrError.__init__(self, msg)
 
275
        self.rev_id = rev_id
 
276
        self.not_ancestor_id = not_ancestor_id
 
277
 
 
278
 
 
279
class InstallFailed(BzrError):
 
280
    def __init__(self, revisions):
 
281
        msg = "Could not install revisions:\n%s" % " ,".join(revisions)
 
282
        BzrError.__init__(self, msg)
 
283
        self.revisions = revisions
 
284
 
 
285
 
 
286
class AmbiguousBase(BzrError):
 
287
    def __init__(self, bases):
 
288
        msg = "The correct base is unclear, becase %s are all equally close" %\
 
289
            ", ".join(bases)
 
290
        BzrError.__init__(self, msg)
 
291
        self.bases = bases
 
292
 
 
293
class NoCommits(BzrError):
 
294
    def __init__(self, branch):
 
295
        msg = "Branch %s has no commits." % branch
 
296
        BzrError.__init__(self, msg)
 
297
 
 
298
class UnlistableStore(BzrError):
 
299
    def __init__(self, store):
 
300
        BzrError.__init__(self, "Store %s is not listable" % store)
 
301
 
 
302
class UnlistableBranch(BzrError):
 
303
    def __init__(self, br):
 
304
        BzrError.__init__(self, "Stores for branch %s are not listable" % br)
 
305
 
 
306
 
 
307
class WeaveError(BzrNewError):
 
308
    """Error in processing weave: %(message)s"""
 
309
    def __init__(self, message=None):
 
310
        BzrNewError.__init__(self)
 
311
        self.message = message
 
312
 
 
313
 
 
314
class WeaveRevisionAlreadyPresent(WeaveError):
 
315
    """Revision {%(revision_id)s} already present in %(weave)s"""
 
316
    def __init__(self, revision_id, weave):
 
317
        WeaveError.__init__(self)
 
318
        self.revision_id = revision_id
 
319
        self.weave = weave
 
320
 
 
321
 
 
322
class WeaveRevisionNotPresent(WeaveError):
 
323
    """Revision {%(revision_id)s} not present in %(weave)s"""
 
324
    def __init__(self, revision_id, weave):
 
325
        WeaveError.__init__(self)
 
326
        self.revision_id = revision_id
 
327
        self.weave = weave
 
328
 
 
329
 
 
330
class WeaveFormatError(WeaveError):
 
331
    """Weave invariant violated: %(what)s"""
 
332
    def __init__(self, what):
 
333
        WeaveError.__init__(self)
 
334
        self.what = what
 
335
 
 
336
 
 
337
class WeaveParentMismatch(WeaveError):
 
338
    """Parents are mismatched between two revisions."""
 
339
    
 
340
 
 
341
class NoSuchExportFormat(BzrNewError):
 
342
    """Export format %(format)r not supported"""
 
343
    def __init__(self, format):
 
344
        BzrNewError.__init__(self)
 
345
        self.format = format
 
346
 
 
347
 
 
348
class TransportError(BzrError):
 
349
    """All errors thrown by Transport implementations should derive
 
350
    from this class.
 
351
    """
 
352
    def __init__(self, msg=None, orig_error=None):
 
353
        if msg is None and orig_error is not None:
 
354
            msg = str(orig_error)
 
355
        BzrError.__init__(self, msg)
 
356
        self.msg = msg
 
357
        self.orig_error = orig_error
 
358
 
 
359
# A set of semi-meaningful errors which can be thrown
 
360
class TransportNotPossible(TransportError):
 
361
    """This is for transports where a specific function is explicitly not
 
362
    possible. Such as pushing files to an HTTP server.
 
363
    """
 
364
    pass
 
365
 
 
366
class NonRelativePath(TransportError):
 
367
    """An absolute path was supplied, that could not be decoded into
 
368
    a relative path.
 
369
    """
 
370
    pass
 
371
 
 
372
class NoSuchFile(TransportError, IOError):
 
373
    """A get() was issued for a file that doesn't exist."""
 
374
 
 
375
    # XXX: Is multiple inheritance for exceptions really needed?
 
376
 
 
377
    def __str__(self):
 
378
        return 'no such file: ' + self.msg
 
379
 
 
380
    def __init__(self, msg=None, orig_error=None):
 
381
        import errno
 
382
        TransportError.__init__(self, msg=msg, orig_error=orig_error)
 
383
        IOError.__init__(self, errno.ENOENT, self.msg)
 
384
 
 
385
class ConnectionError(TransportError, IOError):
 
386
    """
 
387
    A connection problem prevents file retrieval.
 
388
    This does not indicate whether the file exists or not; it indicates that a
 
389
    precondition for requesting the file was not met.
 
390
    """
 
391
 
 
392
    # XXX: Is multiple inheritance for exceptions really needed?
 
393
 
 
394
    def __str__(self):
 
395
        return 'connection error: ' + self.msg
 
396
 
 
397
    def __init__(self, msg=None, orig_error=None):
 
398
        import errno
 
399
        TransportError.__init__(self, msg=msg, orig_error=orig_error)
 
400
        IOError.__init__(self, errno.ENOENT, self.msg)
 
401
 
 
402
 
 
403
class FileExists(TransportError, OSError):
 
404
    """An operation was attempted, which would overwrite an entry,
 
405
    but overwritting is not supported.
 
406
 
 
407
    mkdir() can throw this, but put() just overwites existing files.
 
408
    """
 
409
    # XXX: Is multiple inheritance for exceptions really needed?
 
410
    def __init__(self, msg=None, orig_error=None):
 
411
        import errno
 
412
        TransportError.__init__(self, msg=msg, orig_error=orig_error)
 
413
        OSError.__init__(self, errno.EEXIST, self.msg)
 
414
 
 
415
class PermissionDenied(TransportError):
 
416
    """An operation cannot succeed because of a lack of permissions."""
 
417
    pass
 
418
 
 
419
class ConnectionReset(TransportError):
 
420
    """The connection has been closed."""
 
421
    pass
 
422
 
 
423
class ConflictsInTree(BzrError):
 
424
    def __init__(self):
 
425
        BzrError.__init__(self, "Working tree has conflicts.")
 
426
 
 
427
class ParseConfigError(BzrError):
 
428
    def __init__(self, errors, filename):
 
429
        if filename is None:
 
430
            filename = ""
 
431
        message = "Error(s) parsing config file %s:\n%s" % \
 
432
            (filename, ('\n'.join(e.message for e in errors)))
 
433
        BzrError.__init__(self, message)
 
434
 
 
435
class SigningFailed(BzrError):
 
436
    def __init__(self, command_line):
 
437
        BzrError.__init__(self, "Failed to gpg sign data with command '%s'"
 
438
                               % command_line)
 
439
 
 
440
class WorkingTreeNotRevision(BzrError):
 
441
    def __init__(self, tree):
 
442
        BzrError.__init__(self, "The working tree for %s has changed since"
 
443
                          " last commit, but weave merge requires that it be"
 
444
                          " unchanged." % tree.basedir)
 
445
 
 
446
class CantReprocessAndShowBase(BzrNewError):
 
447
    """Can't reprocess and show base.
 
448
Reprocessing obscures relationship of conflicting lines to base."""
 
449
 
 
450
class GraphCycleError(BzrNewError):
 
451
    """Cycle in graph %(graph)r"""
 
452
    def __init__(self, graph):
 
453
        BzrNewError.__init__(self)
 
454
        self.graph = graph
 
455
 
 
456
class NotConflicted(BzrNewError):
 
457
    """File %(filename)s is not conflicted."""
 
458
    def __init__(self, filename):
 
459
        BzrNewError.__init__(self)
 
460
        self.filename = filename
 
461
 
 
462
class MustUseDecorated(Exception):
 
463
    """A decorating function has requested its original command be used.
 
464
    
 
465
    This should never escape bzr, so does not need to be printable.
 
466
    """
 
467
 
 
468
class MissingText(BzrNewError):
 
469
    """Branch %(base)s is missing revision %(text_revision)s of %(file_id)s"""
 
470
    def __init__(self, branch, text_revision, file_id):
 
471
        self.branch = branch
 
472
        self.base = branch.base
 
473
        self.text_revision = text_revision
 
474
        self.file_id = file_id