~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/errors.py

  • Committer: mbp at sourcefrog
  • Date: 2005-03-23 06:25:55 UTC
  • Revision ID: mbp@sourcefrog.net-20050323062555-5489339018d0c043
- import a subset of elementtree for easier installation

Show diffs side-by-side

added added

removed removed

Lines of Context:
 
1
#! /usr/bin/env python
1
2
# -*- coding: UTF-8 -*-
2
3
 
3
4
# This program is free software; you can redistribute it and/or modify
22
23
######################################################################
23
24
# exceptions 
24
25
class BzrError(StandardError):
25
 
    def __str__(self):
26
 
        # XXX: Should we show the exception class in 
27
 
        # exceptions that don't provide their own message?  
28
 
        # maybe it should be done at a higher level
29
 
        ## n = self.__class__.__name__ + ': '
30
 
        n = ''
31
 
        if len(self.args) == 1:
32
 
            return n + self.args[0]
33
 
        elif len(self.args) == 2:
34
 
            # further explanation or suggestions
35
 
            try:
36
 
                return n + '\n  '.join([self.args[0]] + self.args[1])
37
 
            except TypeError:
38
 
                return n + "%r" % self
39
 
        else:
40
 
            return n + `self.args`
41
 
 
 
26
    pass
42
27
 
43
28
class BzrCheckError(BzrError):
44
29
    pass
45
30
 
46
31
 
47
 
class InvalidRevisionNumber(BzrError):
48
 
    def __str__(self):
49
 
        return 'invalid revision number: %r' % self.args[0]
50
 
 
51
 
 
52
 
class InvalidRevisionId(BzrError):
53
 
    pass
54
 
 
55
 
 
56
 
class BzrCommandError(BzrError):
57
 
    # Error from malformed user command
58
 
    def __str__(self):
59
 
        return self.args[0]
60
 
 
61
 
 
62
 
class NotBranchError(BzrError):
63
 
    """Specified path is not in a branch"""
64
 
    def __str__(self):
65
 
        return 'not a branch: %s' % self.args[0]
66
 
 
67
 
 
68
 
class NotVersionedError(BzrError):
69
 
    """Specified object is not versioned."""
70
 
 
71
 
 
72
 
class BadFileKindError(BzrError):
73
 
    """Specified file is of a kind that cannot be added.
74
 
 
75
 
    (For example a symlink or device file.)"""
76
 
    pass
77
 
 
78
 
 
79
 
class ForbiddenFileError(BzrError):
80
 
    """Cannot operate on a file because it is a control file."""
81
 
    pass
82
 
 
83
 
 
84
 
class LockError(Exception):
85
 
    """All exceptions from the lock/unlock functions should be from
86
 
    this exception class.  They will be translated as necessary. The
87
 
    original exception is available as e.original_error
88
 
    """
89
 
    def __init__(self, e=None):
90
 
        self.original_error = e
91
 
        if e:
92
 
            Exception.__init__(self, e)
93
 
        else:
94
 
            Exception.__init__(self)
95
 
 
96
 
 
97
 
class PointlessCommit(Exception):
98
 
    """Commit failed because nothing was changed."""
99
 
 
100
 
 
101
 
class NoSuchRevision(BzrError):
102
 
    def __init__(self, branch, revision):
103
 
        self.branch = branch
104
 
        self.revision = revision
105
 
        msg = "Branch %s has no revision %s" % (branch, revision)
106
 
        BzrError.__init__(self, msg)
107
 
 
108
 
 
109
 
class HistoryMissing(BzrError):
110
 
    def __init__(self, branch, object_type, object_id):
111
 
        self.branch = branch
112
 
        BzrError.__init__(self,
113
 
                          '%s is missing %s {%s}'
114
 
                          % (branch, object_type, object_id))
115
 
 
116
 
 
117
 
class DivergedBranches(BzrError):
118
 
    def __init__(self, branch1, branch2):
119
 
        BzrError.__init__(self, "These branches have diverged.")
120
 
        self.branch1 = branch1
121
 
        self.branch2 = branch2
122
 
 
123
 
 
124
 
class UnrelatedBranches(BzrCommandError):
125
 
    def __init__(self):
126
 
        msg = "Branches have no common ancestor, and no base revision"\
127
 
            " specified."
128
 
        BzrCommandError.__init__(self, msg)
129
 
 
130
 
class NoCommonAncestor(BzrError):
131
 
    def __init__(self, revision_a, revision_b):
132
 
        msg = "Revisions have no common ancestor: %s %s." \
133
 
            % (revision_a, revision_b) 
134
 
        BzrError.__init__(self, msg)
135
 
 
136
 
class NoCommonRoot(BzrError):
137
 
    def __init__(self, revision_a, revision_b):
138
 
        msg = "Revisions are not derived from the same root: %s %s." \
139
 
            % (revision_a, revision_b) 
140
 
        BzrError.__init__(self, msg)
141
 
 
142
 
class NotAncestor(BzrError):
143
 
    def __init__(self, rev_id, not_ancestor_id):
144
 
        msg = "Revision %s is not an ancestor of %s" % (not_ancestor_id, 
145
 
                                                        rev_id)
146
 
        BzrError.__init__(self, msg)
147
 
        self.rev_id = rev_id
148
 
        self.not_ancestor_id = not_ancestor_id
149
 
 
150
 
 
151
 
class NotAncestor(BzrError):
152
 
    def __init__(self, rev_id, not_ancestor_id):
153
 
        self.rev_id = rev_id
154
 
        self.not_ancestor_id = not_ancestor_id
155
 
        msg = "Revision %s is not an ancestor of %s" % (not_ancestor_id, 
156
 
                                                        rev_id)
157
 
        BzrError.__init__(self, msg)
158
 
 
159
 
 
160
 
class InstallFailed(BzrError):
161
 
    def __init__(self, revisions):
162
 
        msg = "Could not install revisions:\n%s" % " ,".join(revisions)
163
 
        BzrError.__init__(self, msg)
164
 
        self.revisions = revisions
165
 
 
166
 
 
167
 
class AmbiguousBase(BzrError):
168
 
    def __init__(self, bases):
169
 
        msg = "The correct base is unclear, becase %s are all equally close" %\
170
 
            ", ".join(bases)
171
 
        BzrError.__init__(self, msg)
172
 
        self.bases = bases
173
 
 
174
 
class NoCommits(BzrError):
175
 
    def __init__(self, branch):
176
 
        msg = "Branch %s has no commits." % branch
177
 
        BzrError.__init__(self, msg)
178
 
 
179
 
class UnlistableStore(BzrError):
180
 
    def __init__(self, store):
181
 
        BzrError.__init__(self, "Store %s is not listable" % store)
182
 
 
183
 
class UnlistableBranch(BzrError):
184
 
    def __init__(self, br):
185
 
        BzrError.__init__(self, "Stores for branch %s are not listable" % br)
186
 
 
187
 
 
188
 
from bzrlib.weave import WeaveError
189
 
 
190
 
class TransportError(BzrError):
191
 
    """All errors thrown by Transport implementations should derive
192
 
    from this class.
193
 
    """
194
 
    def __init__(self, msg=None, orig_error=None):
195
 
        if msg is None and orig_error is not None:
196
 
            msg = str(orig_error)
197
 
        BzrError.__init__(self, msg)
198
 
        self.msg = msg
199
 
        self.orig_error = orig_error
200
 
 
201
 
# A set of semi-meaningful errors which can be thrown
202
 
class TransportNotPossible(TransportError):
203
 
    """This is for transports where a specific function is explicitly not
204
 
    possible. Such as pushing files to an HTTP server.
205
 
    """
206
 
    pass
207
 
 
208
 
class NonRelativePath(TransportError):
209
 
    """An absolute path was supplied, that could not be decoded into
210
 
    a relative path.
211
 
    """
212
 
    pass
213
 
 
214
 
class NoSuchFile(TransportError, IOError):
215
 
    """A get() was issued for a file that doesn't exist."""
216
 
 
217
 
    # XXX: Is multiple inheritance for exceptions really needed?
218
 
 
219
 
    def __str__(self):
220
 
        return 'no such file: ' + self.msg
221
 
 
222
 
    def __init__(self, msg=None, orig_error=None):
223
 
        import errno
224
 
        TransportError.__init__(self, msg=msg, orig_error=orig_error)
225
 
        IOError.__init__(self, errno.ENOENT, self.msg)
226
 
 
227
 
class FileExists(TransportError, OSError):
228
 
    """An operation was attempted, which would overwrite an entry,
229
 
    but overwritting is not supported.
230
 
 
231
 
    mkdir() can throw this, but put() just overwites existing files.
232
 
    """
233
 
    # XXX: Is multiple inheritance for exceptions really needed?
234
 
    def __init__(self, msg=None, orig_error=None):
235
 
        import errno
236
 
        TransportError.__init__(self, msg=msg, orig_error=orig_error)
237
 
        OSError.__init__(self, errno.EEXIST, self.msg)
238
 
 
239
 
class PermissionDenied(TransportError):
240
 
    """An operation cannot succeed because of a lack of permissions."""
241
 
    pass
242
 
 
243
 
class ConnectionReset(TransportError):
244
 
    """The connection has been closed."""
245
 
    pass
 
32
 
 
33
 
 
34
def bailout(msg, explanation=[]):
 
35
    ex = BzrError(msg, explanation)
 
36
    import trace
 
37
    trace._tracefile.write('* raising %s\n' % ex)
 
38
    raise ex
246
39