~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/errors.py

  • Committer: Robert Collins
  • Date: 2005-12-08 05:57:00 UTC
  • Revision ID: robertc@robertcollins.net-20051208055700-5d85edd70fd15d4d
Test the uses of WorkingTree from branch.py

Show diffs side-by-side

added added

removed removed

Lines of Context:
1
 
# -*- coding: UTF-8 -*-
 
1
# (C) 2005 Canonical
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
 
 
18
 
__copyright__ = "Copyright (C) 2005 Canonical Ltd."
19
 
__author__ = "Martin Pool <mbp@canonical.com>"
20
 
 
21
 
 
22
 
######################################################################
23
 
# 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
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
 
24
68
class BzrError(StandardError):
25
 
    pass
26
 
 
27
 
 
28
 
class BzrCheckError(BzrError):
29
 
    pass
30
 
 
31
 
 
32
 
class InvalidRevisionNumber(BzrError):
 
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"""
33
120
    def __init__(self, revno):
34
 
        self.args = [revno]
35
 
        
36
 
    def __str__(self):
37
 
        return 'invalid revision number: %r' % self.args[0]
38
 
 
39
 
 
40
 
class InvalidRevisionId(BzrError):
41
 
    pass
 
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
42
139
 
43
140
 
44
141
class BzrCommandError(BzrError):
45
142
    # Error from malformed user command
46
 
    pass
47
 
 
48
 
 
49
 
class NotBranchError(BzrError):
50
 
    """Specified path is not in a branch"""
51
 
    pass
52
 
 
53
 
 
54
 
class NotVersionedError(BzrError):
55
 
    """Specified object is not versioned."""
 
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
56
219
 
57
220
 
58
221
class BadFileKindError(BzrError):
59
222
    """Specified file is of a kind that cannot be added.
60
223
 
61
224
    (For example a symlink or device file.)"""
62
 
    pass
63
225
 
64
226
 
65
227
class ForbiddenFileError(BzrError):
66
228
    """Cannot operate on a file because it is a control file."""
67
 
    pass
68
229
 
69
230
 
70
231
class LockError(Exception):
71
 
    """All exceptions from the lock/unlock functions should be from
72
 
    this exception class.  They will be translated as necessary. The
73
 
    original exception is available as e.original_error
74
 
    """
75
 
    def __init__(self, e=None):
76
 
        self.original_error = e
77
 
        if e:
78
 
            Exception.__init__(self, e)
79
 
        else:
80
 
            Exception.__init__(self)
81
 
 
82
 
 
83
 
class PointlessCommit(Exception):
84
 
    """Commit failed because nothing was changed."""
85
 
 
 
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."""
86
255
 
87
256
class NoSuchRevision(BzrError):
88
257
    def __init__(self, branch, revision):
92
261
        BzrError.__init__(self, msg)
93
262
 
94
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
 
95
272
class DivergedBranches(BzrError):
96
273
    def __init__(self, branch1, branch2):
97
274
        BzrError.__init__(self, "These branches have diverged.")
98
275
        self.branch1 = branch1
99
276
        self.branch2 = branch2
100
277
 
 
278
 
101
279
class UnrelatedBranches(BzrCommandError):
102
280
    def __init__(self):
103
281
        msg = "Branches have no common ancestor, and no base revision"\
143
321
    def __init__(self, branch):
144
322
        msg = "Branch %s has no commits." % branch
145
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