~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/errors.py

  • Committer: Canonical.com Patch Queue Manager
  • Date: 2006-07-06 03:15:29 UTC
  • mfrom: (1711.2.78 jam-integration)
  • Revision ID: pqm@pqm.ubuntu.com-20060706031529-e189d8c3f42076be
(jam) allow plugins to include benchmarks

Show diffs side-by-side

added added

removed removed

Lines of Context:
1
 
# Copyright (C) 2005, 2006, 2007 Canonical Ltd
2
 
#
 
1
# Copyright (C) 2005, 2006 Canonical
 
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
5
5
# the Free Software Foundation; either version 2 of the License, or
6
6
# (at your option) any later version.
7
 
#
 
7
 
8
8
# This program is distributed in the hope that it will be useful,
9
9
# but WITHOUT ANY WARRANTY; without even the implied warranty of
10
10
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
11
11
# GNU General Public License for more details.
12
 
#
 
12
 
13
13
# You should have received a copy of the GNU General Public License
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
17
"""Exceptions for bzr, and reporting of them.
 
18
 
 
19
There are 3 different classes of error:
 
20
 
 
21
 * KeyboardInterrupt, and OSError with EPIPE - the program terminates 
 
22
   with an appropriate short message
 
23
 
 
24
 * User errors, indicating a problem caused by the user such as a bad URL.
 
25
   These are printed in a short form.
 
26
 
 
27
 * Internal unexpected errors, including most Python builtin errors
 
28
   and some raised from inside bzr.  These are printed with a full 
 
29
   traceback and an invitation to report the bug.
 
30
 
 
31
Exceptions are caught at a high level to report errors to the user, and
 
32
might also be caught inside the program.  Therefore it needs to be
 
33
possible to convert them to a meaningful string, and also for them to be
 
34
interrogated by the program.
 
35
 
 
36
Exceptions are defined such that the arguments given to the constructor
 
37
are stored in the object as properties of the same name.  When the
 
38
object is printed as a string, the doc string of the class is used as
 
39
a format string with the property dictionary available to it.
 
40
 
 
41
This means that exceptions can used like this:
 
42
 
 
43
>>> import sys
 
44
>>> try:
 
45
...   raise NotBranchError(path='/foo/bar')
 
46
... except:
 
47
...   print sys.exc_type
 
48
...   print sys.exc_value
 
49
...   path = getattr(sys.exc_value, 'path', None)
 
50
...   if path is not None:
 
51
...     print path
 
52
bzrlib.errors.NotBranchError
 
53
Not a branch: /foo/bar
 
54
/foo/bar
 
55
 
 
56
Therefore:
 
57
 
 
58
 * create a new exception class for any class of error that can be
 
59
   usefully distinguished.  If no callers are likely to want to catch
 
60
   one but not another, don't worry about them.
 
61
 
 
62
 * the __str__ method should generate something useful; BzrError provides
 
63
   a good default implementation
 
64
 
 
65
Exception strings should start with a capital letter and should not have a
 
66
final fullstop.
18
67
"""
19
68
 
20
 
 
21
 
from bzrlib import (
22
 
    osutils,
23
 
    symbol_versioning,
24
 
    )
25
 
from bzrlib.patches import (
26
 
    MalformedHunkHeader,
27
 
    MalformedLine,
28
 
    MalformedPatchHeader,
29
 
    PatchConflict,
30
 
    PatchSyntax,
31
 
    )
32
 
 
 
69
from warnings import warn
 
70
 
 
71
from bzrlib.patches import (PatchSyntax, 
 
72
                            PatchConflict, 
 
73
                            MalformedPatchHeader,
 
74
                            MalformedHunkHeader,
 
75
                            MalformedLine,)
 
76
 
 
77
 
 
78
# based on Scott James Remnant's hct error classes
33
79
 
34
80
# TODO: is there any value in providing the .args field used by standard
35
81
# python exceptions?   A list of values with no names seems less useful 
39
85
# constructed to make sure it will succeed.  But that says nothing about
40
86
# exceptions that are never raised.
41
87
 
42
 
# TODO: selftest assertRaises should probably also check that every error
43
 
# raised can be formatted as a string successfully, and without giving
44
 
# 'unprintable'.
 
88
# TODO: Convert all the other error classes here to BzrNewError, and eliminate
 
89
# the old one.
 
90
 
 
91
# TODO: The pattern (from hct) of using classes docstrings as message
 
92
# templates is cute but maybe not such a great idea - perhaps should have a
 
93
# separate static message_template.
45
94
 
46
95
 
47
96
class BzrError(StandardError):
48
 
    """
49
 
    Base class for errors raised by bzrlib.
50
 
 
51
 
    :cvar internal_error: if True this was probably caused by a bzr bug and
52
 
    should be displayed with a traceback; if False (or absent) this was
53
 
    probably a user or environment error and they don't need the gory details.
54
 
    (That can be overridden by -Derror on the command line.)
55
 
 
56
 
    :cvar _fmt: Format string to display the error; this is expanded
57
 
    by the instance's dict.
58
 
    """
59
 
    
60
 
    internal_error = False
61
 
 
62
 
    def __init__(self, msg=None, **kwds):
63
 
        """Construct a new BzrError.
64
 
 
65
 
        There are two alternative forms for constructing these objects.
66
 
        Either a preformatted string may be passed, or a set of named
67
 
        arguments can be given.  The first is for generic "user" errors which
68
 
        are not intended to be caught and so do not need a specific subclass.
69
 
        The second case is for use with subclasses that provide a _fmt format
70
 
        string to print the arguments.  
71
 
 
72
 
        Keyword arguments are taken as parameters to the error, which can 
73
 
        be inserted into the format string template.  It's recommended 
74
 
        that subclasses override the __init__ method to require specific 
75
 
        parameters.
76
 
 
77
 
        :param msg: If given, this is the literal complete text for the error,
78
 
        not subject to expansion.
79
 
        """
80
 
        StandardError.__init__(self)
81
 
        if msg is not None:
82
 
            # I was going to deprecate this, but it actually turns out to be
83
 
            # quite handy - mbp 20061103.
84
 
            self._preformatted_string = msg
 
97
    
 
98
    is_user_error = True
 
99
    
 
100
    def __str__(self):
 
101
        # XXX: Should we show the exception class in 
 
102
        # exceptions that don't provide their own message?  
 
103
        # maybe it should be done at a higher level
 
104
        ## n = self.__class__.__name__ + ': '
 
105
        n = ''
 
106
        if len(self.args) == 1:
 
107
            return str(self.args[0])
 
108
        elif len(self.args) == 2:
 
109
            # further explanation or suggestions
 
110
            try:
 
111
                return n + '\n  '.join([self.args[0]] + self.args[1])
 
112
            except TypeError:
 
113
                return n + "%r" % self
85
114
        else:
86
 
            self._preformatted_string = None
87
 
            for key, value in kwds.items():
88
 
                setattr(self, key, value)
89
 
 
90
 
    def __str__(self):
91
 
        s = getattr(self, '_preformatted_string', None)
92
 
        if s is not None:
93
 
            # contains a preformatted message; must be cast to plain str
94
 
            return str(s)
95
 
        try:
96
 
            fmt = self._get_format_string()
97
 
            if fmt:
98
 
                s = fmt % self.__dict__
99
 
                # __str__() should always return a 'str' object
100
 
                # never a 'unicode' object.
101
 
                if isinstance(s, unicode):
102
 
                    return s.encode('utf8')
103
 
                return s
104
 
        except (AttributeError, TypeError, NameError, ValueError, KeyError), e:
105
 
            return 'Unprintable exception %s: dict=%r, fmt=%r, error=%r' \
106
 
                % (self.__class__.__name__,
107
 
                   self.__dict__,
108
 
                   getattr(self, '_fmt', None),
109
 
                   e)
110
 
 
111
 
    def _get_format_string(self):
112
 
        """Return format string for this exception or None"""
113
 
        fmt = getattr(self, '_fmt', None)
114
 
        if fmt is not None:
115
 
            return fmt
116
 
        fmt = getattr(self, '__doc__', None)
117
 
        if fmt is not None:
118
 
            symbol_versioning.warn("%s uses its docstring as a format, "
119
 
                    "it should use _fmt instead" % self.__class__.__name__,
120
 
                    DeprecationWarning)
121
 
            return fmt
122
 
        return 'Unprintable exception %s: dict=%r, fmt=%r' \
123
 
            % (self.__class__.__name__,
124
 
               self.__dict__,
125
 
               getattr(self, '_fmt', None),
126
 
               )
 
115
            return n + `self.args`
127
116
 
128
117
 
129
118
class BzrNewError(BzrError):
130
 
    """Deprecated error base class."""
 
119
    """bzr error"""
131
120
    # base classes should override the docstring with their human-
132
121
    # readable explanation
133
122
 
134
 
    def __init__(self, *args, **kwds):
135
 
        # XXX: Use the underlying BzrError to always generate the args
136
 
        # attribute if it doesn't exist.  We can't use super here, because
137
 
        # exceptions are old-style classes in python2.4 (but new in 2.5).
138
 
        # --bmc, 20060426
139
 
        symbol_versioning.warn('BzrNewError was deprecated in bzr 0.13; '
140
 
             'please convert %s to use BzrError instead'
141
 
             % self.__class__.__name__,
142
 
             DeprecationWarning,
143
 
             stacklevel=2)
144
 
        BzrError.__init__(self, *args)
 
123
    def __init__(self, **kwds):
145
124
        for key, value in kwds.items():
146
125
            setattr(self, key, value)
147
126
 
148
127
    def __str__(self):
149
128
        try:
150
 
            # __str__() should always return a 'str' object
151
 
            # never a 'unicode' object.
152
 
            s = self.__doc__ % self.__dict__
153
 
            if isinstance(s, unicode):
154
 
                return s.encode('utf8')
155
 
            return s
156
 
        except (TypeError, NameError, ValueError, KeyError), e:
157
 
            return 'Unprintable exception %s(%r): %r' \
158
 
                % (self.__class__.__name__,
159
 
                   self.__dict__, e)
160
 
 
161
 
 
162
 
class AlreadyBuilding(BzrError):
163
 
    
164
 
    _fmt = "The tree builder is already building a tree."
165
 
 
166
 
 
167
 
class BzrCheckError(BzrError):
168
 
    
169
 
    _fmt = "Internal check failed: %(message)s"
170
 
 
171
 
    internal_error = True
 
129
            return self.__doc__ % self.__dict__
 
130
        except (NameError, ValueError, KeyError), e:
 
131
            return 'Unprintable exception %s: %s' \
 
132
                % (self.__class__.__name__, str(e))
 
133
 
 
134
 
 
135
class BzrCheckError(BzrNewError):
 
136
    """Internal check failed: %(message)s"""
 
137
 
 
138
    is_user_error = False
172
139
 
173
140
    def __init__(self, message):
174
 
        BzrError.__init__(self)
 
141
        BzrNewError.__init__(self)
175
142
        self.message = message
176
143
 
177
144
 
178
 
class DisabledMethod(BzrError):
179
 
 
180
 
    _fmt = "The smart server method '%(class_name)s' is disabled."
181
 
 
182
 
    internal_error = True
183
 
 
184
 
    def __init__(self, class_name):
185
 
        BzrError.__init__(self)
186
 
        self.class_name = class_name
187
 
 
188
 
 
189
 
class IncompatibleAPI(BzrError):
190
 
 
191
 
    _fmt = 'The API for "%(api)s" is not compatible with "%(wanted)s". '\
192
 
        'It supports versions "%(minimum)s" to "%(current)s".'
193
 
 
194
 
    def __init__(self, api, wanted, minimum, current):
195
 
        self.api = api
196
 
        self.wanted = wanted
197
 
        self.minimum = minimum
198
 
        self.current = current
199
 
 
200
 
 
201
 
class InvalidEntryName(BzrError):
202
 
    
203
 
    _fmt = "Invalid entry name: %(name)s"
204
 
 
205
 
    internal_error = True
 
145
class InvalidEntryName(BzrNewError):
 
146
    """Invalid entry name: %(name)s"""
 
147
 
 
148
    is_user_error = False
206
149
 
207
150
    def __init__(self, name):
208
 
        BzrError.__init__(self)
 
151
        BzrNewError.__init__(self)
209
152
        self.name = name
210
153
 
211
154
 
212
 
class InvalidRevisionNumber(BzrError):
213
 
    
214
 
    _fmt = "Invalid revision number %(revno)s"
215
 
 
 
155
class InvalidRevisionNumber(BzrNewError):
 
156
    """Invalid revision number %(revno)d"""
216
157
    def __init__(self, revno):
217
 
        BzrError.__init__(self)
 
158
        BzrNewError.__init__(self)
218
159
        self.revno = revno
219
160
 
220
161
 
221
 
class InvalidRevisionId(BzrError):
222
 
 
223
 
    _fmt = "Invalid revision-id {%(revision_id)s} in %(branch)s"
224
 
 
 
162
class InvalidRevisionId(BzrNewError):
 
163
    """Invalid revision-id {%(revision_id)s} in %(branch)s"""
225
164
    def __init__(self, revision_id, branch):
226
165
        # branch can be any string or object with __str__ defined
227
 
        BzrError.__init__(self)
 
166
        BzrNewError.__init__(self)
228
167
        self.revision_id = revision_id
229
168
        self.branch = branch
230
169
 
231
 
class ReservedId(BzrError):
232
 
 
233
 
    _fmt = "Reserved revision-id {%(revision_id)s}"
234
 
 
235
 
    def __init__(self, revision_id):
236
 
        self.revision_id = revision_id
237
 
 
238
 
 
239
 
class NoHelpTopic(BzrError):
240
 
 
241
 
    _fmt = ("No help could be found for '%(topic)s'. "
242
 
        "Please use 'bzr help topics' to obtain a list of topics.")
243
 
 
244
 
    def __init__(self, topic):
245
 
        self.topic = topic
246
 
 
247
 
 
248
 
class NoSuchId(BzrError):
249
 
 
250
 
    _fmt = "The file id %(file_id)s is not present in the tree %(tree)s."
251
 
    
252
 
    def __init__(self, tree, file_id):
253
 
        BzrError.__init__(self)
254
 
        self.file_id = file_id
255
 
        self.tree = tree
256
 
 
257
 
 
258
 
class InventoryModified(BzrError):
259
 
 
260
 
    _fmt = ("The current inventory for the tree %(tree)r has been modified,"
261
 
            " so a clean inventory cannot be read without data loss.")
262
 
 
263
 
    internal_error = True
264
 
 
265
 
    def __init__(self, tree):
266
 
        self.tree = tree
267
 
 
268
 
 
269
 
class NoWorkingTree(BzrError):
270
 
 
271
 
    _fmt = "No WorkingTree exists for %(base)s."
 
170
 
 
171
class NoWorkingTree(BzrNewError):
 
172
    """No WorkingTree exists for %(base)s."""
272
173
    
273
174
    def __init__(self, base):
274
 
        BzrError.__init__(self)
 
175
        BzrNewError.__init__(self)
275
176
        self.base = base
276
177
 
277
178
 
278
 
class NotBuilding(BzrError):
279
 
 
280
 
    _fmt = "Not currently building a tree."
281
 
 
282
 
 
283
 
class NotLocalUrl(BzrError):
284
 
 
285
 
    _fmt = "%(url)s is not a local path."
286
 
 
 
179
class NotLocalUrl(BzrNewError):
 
180
    """%(url)s is not a local path."""
 
181
    
287
182
    def __init__(self, url):
 
183
        BzrNewError.__init__(self)
288
184
        self.url = url
289
185
 
290
186
 
291
 
class WorkingTreeAlreadyPopulated(BzrError):
292
 
 
293
 
    _fmt = """Working tree already populated in %(base)s"""
294
 
 
295
 
    internal_error = True
296
 
 
297
 
    def __init__(self, base):
298
 
        self.base = base
299
 
 
300
 
class BzrCommandError(BzrError):
 
187
class BzrCommandError(BzrNewError):
301
188
    """Error from user command"""
302
189
 
303
 
    internal_error = False
 
190
    is_user_error = True
304
191
 
305
192
    # Error from malformed user command; please avoid raising this as a
306
193
    # generic exception not caused by user input.
310
197
    # BzrCommandError, and non-UI code should not throw a subclass of
311
198
    # BzrCommandError.  ADHB 20051211
312
199
    def __init__(self, msg):
313
 
        # Object.__str__() must return a real string
314
 
        # returning a Unicode string is a python error.
315
 
        if isinstance(msg, unicode):
316
 
            self.msg = msg.encode('utf8')
317
 
        else:
318
 
            self.msg = msg
 
200
        self.msg = msg
319
201
 
320
202
    def __str__(self):
321
203
        return self.msg
322
204
 
323
205
 
324
 
class NotWriteLocked(BzrError):
325
 
 
326
 
    _fmt = """%(not_locked)r is not write locked but needs to be."""
327
 
 
328
 
    def __init__(self, not_locked):
329
 
        self.not_locked = not_locked
330
 
 
331
 
 
332
206
class BzrOptionError(BzrCommandError):
333
 
 
334
 
    _fmt = "Error in command line options"
335
 
 
336
 
 
337
 
class BadOptionValue(BzrError):
338
 
 
339
 
    _fmt = """Bad value "%(value)s" for option "%(name)s"."""
340
 
 
341
 
    def __init__(self, name, value):
342
 
        BzrError.__init__(self, name=name, value=value)
 
207
    """Error in command line options"""
343
208
 
344
209
    
345
 
class StrictCommitFailed(BzrError):
346
 
 
347
 
    _fmt = "Commit refused because there are unknown files in the tree"
 
210
class StrictCommitFailed(BzrNewError):
 
211
    """Commit refused because there are unknown files in the tree"""
348
212
 
349
213
 
350
214
# XXX: Should be unified with TransportError; they seem to represent the
351
215
# same thing
352
 
# RBC 20060929: I think that unifiying with TransportError would be a mistake
353
 
# - this is finer than a TransportError - and more useful as such. It 
354
 
# differentiates between 'transport has failed' and 'operation on a transport
355
 
# has failed.'
356
 
class PathError(BzrError):
357
 
    
358
 
    _fmt = "Generic path error: %(path)r%(extra)s)"
 
216
class PathError(BzrNewError):
 
217
    """Generic path error: %(path)r%(extra)s)"""
359
218
 
360
219
    def __init__(self, path, extra=None):
361
 
        BzrError.__init__(self)
 
220
        BzrNewError.__init__(self)
362
221
        self.path = path
363
222
        if extra:
364
223
            self.extra = ': ' + str(extra)
367
226
 
368
227
 
369
228
class NoSuchFile(PathError):
370
 
 
371
 
    _fmt = "No such file: %(path)r%(extra)s"
 
229
    """No such file: %(path)r%(extra)s"""
372
230
 
373
231
 
374
232
class FileExists(PathError):
375
 
 
376
 
    _fmt = "File exists: %(path)r%(extra)s"
377
 
 
378
 
 
379
 
class RenameFailedFilesExist(BzrError):
380
 
    """Used when renaming and both source and dest exist."""
381
 
 
382
 
    _fmt = ("Could not rename %(source)s => %(dest)s because both files exist."
383
 
            "%(extra)s")
384
 
 
385
 
    def __init__(self, source, dest, extra=None):
386
 
        BzrError.__init__(self)
387
 
        self.source = str(source)
388
 
        self.dest = str(dest)
389
 
        if extra:
390
 
            self.extra = ' ' + str(extra)
391
 
        else:
392
 
            self.extra = ''
393
 
 
394
 
 
395
 
class NotADirectory(PathError):
396
 
 
397
 
    _fmt = "%(path)r is not a directory %(extra)s"
398
 
 
399
 
 
400
 
class NotInWorkingDirectory(PathError):
401
 
 
402
 
    _fmt = "%(path)r is not in the working directory %(extra)s"
 
233
    """File exists: %(path)r%(extra)s"""
403
234
 
404
235
 
405
236
class DirectoryNotEmpty(PathError):
406
 
 
407
 
    _fmt = "Directory not empty: %(path)r%(extra)s"
408
 
 
409
 
 
410
 
class ReadingCompleted(BzrError):
411
 
    
412
 
    _fmt = ("The MediumRequest '%(request)s' has already had finish_reading "
413
 
            "called upon it - the request has been completed and no more "
414
 
            "data may be read.")
415
 
 
416
 
    internal_error = True
417
 
 
418
 
    def __init__(self, request):
419
 
        self.request = request
 
237
    """Directory not empty: %(path)r%(extra)s"""
420
238
 
421
239
 
422
240
class ResourceBusy(PathError):
423
 
 
424
 
    _fmt = "Device or resource busy: %(path)r%(extra)s"
 
241
    """Device or resource busy: %(path)r%(extra)s"""
425
242
 
426
243
 
427
244
class PermissionDenied(PathError):
428
 
 
429
 
    _fmt = "Permission denied: %(path)r%(extra)s"
 
245
    """Permission denied: %(path)r%(extra)s"""
430
246
 
431
247
 
432
248
class InvalidURL(PathError):
433
 
 
434
 
    _fmt = "Invalid url supplied to transport: %(path)r%(extra)s"
 
249
    """Invalid url supplied to transport: %(path)r%(extra)s"""
435
250
 
436
251
 
437
252
class InvalidURLJoin(PathError):
438
 
 
439
 
    _fmt = "Invalid URL join request: %(args)s%(extra)s"
 
253
    """Invalid URL join request: %(args)s%(extra)s"""
440
254
 
441
255
    def __init__(self, msg, base, args):
442
256
        PathError.__init__(self, base, msg)
443
 
        self.args = [base] + list(args)
444
 
 
445
 
 
446
 
class UnknownHook(BzrError):
447
 
 
448
 
    _fmt = "The %(type)s hook '%(hook)s' is unknown in this version of bzrlib."
449
 
 
450
 
    def __init__(self, hook_type, hook_name):
451
 
        BzrError.__init__(self)
452
 
        self.type = hook_type
453
 
        self.hook = hook_name
454
 
 
455
 
 
456
 
class UnsupportedProtocol(PathError):
457
 
 
458
 
    _fmt = 'Unsupported protocol for url "%(path)s"%(extra)s'
459
 
 
460
 
    def __init__(self, url, extra):
461
 
        PathError.__init__(self, url, extra=extra)
462
 
 
463
 
 
464
 
class ReadError(PathError):
465
 
    
466
 
    _fmt = """Error reading from %(path)r."""
467
 
 
468
 
 
469
 
class ShortReadvError(PathError):
470
 
 
471
 
    _fmt = ("readv() read %(actual)s bytes rather than %(length)s bytes"
472
 
            " at %(offset)s for %(path)s%(extra)s")
473
 
 
474
 
    internal_error = True
475
 
 
476
 
    def __init__(self, path, offset, length, actual, extra=None):
477
 
        PathError.__init__(self, path, extra=extra)
478
 
        self.offset = offset
479
 
        self.length = length
480
 
        self.actual = actual
481
 
 
482
 
 
483
 
class PathNotChild(PathError):
484
 
 
485
 
    _fmt = "Path %(path)r is not a child of path %(base)r%(extra)s"
486
 
 
487
 
    internal_error = True
 
257
        self.args = [base]
 
258
        self.args.extend(args)
 
259
 
 
260
 
 
261
class PathNotChild(BzrNewError):
 
262
    """Path %(path)r is not a child of path %(base)r%(extra)s"""
 
263
 
 
264
    is_user_error = False
488
265
 
489
266
    def __init__(self, path, base, extra=None):
490
 
        BzrError.__init__(self)
 
267
        BzrNewError.__init__(self)
491
268
        self.path = path
492
269
        self.base = base
493
270
        if extra:
496
273
            self.extra = ''
497
274
 
498
275
 
499
 
class InvalidNormalization(PathError):
500
 
 
501
 
    _fmt = "Path %(path)r is not unicode normalized"
502
 
 
503
 
 
504
276
# TODO: This is given a URL; we try to unescape it but doing that from inside
505
277
# the exception object is a bit undesirable.
506
278
# TODO: Probably this behavior of should be a common superclass 
507
279
class NotBranchError(PathError):
508
 
 
509
 
    _fmt = "Not a branch: %(path)s"
 
280
    """Not a branch: %(path)s"""
510
281
 
511
282
    def __init__(self, path):
512
283
       import bzrlib.urlutils as urlutils
513
284
       self.path = urlutils.unescape_for_display(path, 'ascii')
514
285
 
515
286
 
516
 
class NoSubmitBranch(PathError):
517
 
 
518
 
    _fmt = 'No submit branch available for branch "%(path)s"'
519
 
 
520
 
    def __init__(self, branch):
521
 
       import bzrlib.urlutils as urlutils
522
 
       self.path = urlutils.unescape_for_display(branch.base, 'ascii')
523
 
 
524
 
 
525
287
class AlreadyBranchError(PathError):
526
 
 
527
 
    _fmt = "Already a branch: %(path)s."
 
288
    """Already a branch: %(path)s."""
528
289
 
529
290
 
530
291
class BranchExistsWithoutWorkingTree(PathError):
531
 
 
532
 
    _fmt = "Directory contains a branch, but no working tree \
533
 
(use bzr checkout if you wish to build a working tree): %(path)s"
534
 
 
535
 
 
536
 
class AtomicFileAlreadyClosed(PathError):
537
 
 
538
 
    _fmt = ("'%(function)s' called on an AtomicFile after it was closed:"
539
 
            " %(path)s")
540
 
 
541
 
    def __init__(self, path, function):
542
 
        PathError.__init__(self, path=path, extra=None)
543
 
        self.function = function
544
 
 
545
 
 
546
 
class InaccessibleParent(PathError):
547
 
 
548
 
    _fmt = ("Parent not accessible given base %(base)s and"
549
 
            " relative path %(path)s")
550
 
 
551
 
    def __init__(self, path, base):
552
 
        PathError.__init__(self, path)
553
 
        self.base = base
554
 
 
555
 
 
556
 
class NoRepositoryPresent(BzrError):
557
 
 
558
 
    _fmt = "No repository present: %(path)r"
 
292
    """Directory contains a branch, but no working tree \
 
293
(use bzr checkout if you wish to build a working tree): %(path)s"""
 
294
 
 
295
 
 
296
class NoRepositoryPresent(BzrNewError):
 
297
    """No repository present: %(path)r"""
559
298
    def __init__(self, bzrdir):
560
 
        BzrError.__init__(self)
 
299
        BzrNewError.__init__(self)
561
300
        self.path = bzrdir.transport.clone('..').base
562
301
 
563
302
 
564
 
class FileInWrongBranch(BzrError):
565
 
 
566
 
    _fmt = "File %(path)s in not in branch %(branch_base)s."
 
303
class FileInWrongBranch(BzrNewError):
 
304
    """File %(path)s in not in branch %(branch_base)s."""
567
305
 
568
306
    def __init__(self, branch, path):
569
 
        BzrError.__init__(self)
 
307
        BzrNewError.__init__(self)
570
308
        self.branch = branch
571
309
        self.branch_base = branch.base
572
310
        self.path = path
573
311
 
574
312
 
575
 
class UnsupportedFormatError(BzrError):
576
 
 
577
 
    _fmt = "Unsupported branch format: %(format)s\nPlease run 'bzr upgrade'"
578
 
 
579
 
 
580
 
class UnknownFormatError(BzrError):
581
 
    
582
 
    _fmt = "Unknown branch format: %(format)r"
583
 
 
584
 
 
585
 
class IncompatibleFormat(BzrError):
586
 
    
587
 
    _fmt = "Format %(format)s is not compatible with .bzr version %(bzrdir)s."
 
313
class UnsupportedFormatError(BzrNewError):
 
314
    """Unsupported branch format: %(format)s"""
 
315
 
 
316
 
 
317
class UnknownFormatError(BzrNewError):
 
318
    """Unknown branch format: %(format)r"""
 
319
 
 
320
 
 
321
class IncompatibleFormat(BzrNewError):
 
322
    """Format %(format)s is not compatible with .bzr version %(bzrdir)s."""
588
323
 
589
324
    def __init__(self, format, bzrdir_format):
590
 
        BzrError.__init__(self)
 
325
        BzrNewError.__init__(self)
591
326
        self.format = format
592
327
        self.bzrdir = bzrdir_format
593
328
 
594
329
 
595
 
class IncompatibleRepositories(BzrError):
596
 
 
597
 
    _fmt = "Repository %(target)s is not compatible with repository"\
598
 
        " %(source)s"
599
 
 
600
 
    def __init__(self, source, target):
601
 
        BzrError.__init__(self, target=target, source=source)
602
 
 
603
 
 
604
 
class IncompatibleRevision(BzrError):
605
 
    
606
 
    _fmt = "Revision is not compatible with %(repo_format)s"
607
 
 
608
 
    def __init__(self, repo_format):
609
 
        BzrError.__init__(self)
610
 
        self.repo_format = repo_format
611
 
 
612
 
 
613
 
class AlreadyVersionedError(BzrError):
614
 
    """Used when a path is expected not to be versioned, but it is."""
615
 
 
616
 
    _fmt = "%(context_info)s%(path)s is already versioned"
617
 
 
618
 
    def __init__(self, path, context_info=None):
619
 
        """Construct a new AlreadyVersionedError.
620
 
 
621
 
        :param path: This is the path which is versioned,
622
 
        which should be in a user friendly form.
623
 
        :param context_info: If given, this is information about the context,
624
 
        which could explain why this is expected to not be versioned.
625
 
        """
626
 
        BzrError.__init__(self)
627
 
        self.path = path
628
 
        if context_info is None:
629
 
            self.context_info = ''
630
 
        else:
631
 
            self.context_info = context_info + ". "
632
 
 
633
 
 
634
 
class NotVersionedError(BzrError):
635
 
    """Used when a path is expected to be versioned, but it is not."""
636
 
 
637
 
    _fmt = "%(context_info)s%(path)s is not versioned"
638
 
 
639
 
    def __init__(self, path, context_info=None):
640
 
        """Construct a new NotVersionedError.
641
 
 
642
 
        :param path: This is the path which is not versioned,
643
 
        which should be in a user friendly form.
644
 
        :param context_info: If given, this is information about the context,
645
 
        which could explain why this is expected to be versioned.
646
 
        """
647
 
        BzrError.__init__(self)
648
 
        self.path = path
649
 
        if context_info is None:
650
 
            self.context_info = ''
651
 
        else:
652
 
            self.context_info = context_info + ". "
653
 
 
654
 
 
655
 
class PathsNotVersionedError(BzrError):
656
 
    """Used when reporting several paths which are not versioned"""
657
 
 
658
 
    _fmt = "Path(s) are not versioned: %(paths_as_string)s"
 
330
class NotVersionedError(BzrNewError):
 
331
    """%(path)s is not versioned"""
 
332
    def __init__(self, path):
 
333
        BzrNewError.__init__(self)
 
334
        self.path = path
 
335
 
 
336
 
 
337
class PathsNotVersionedError(BzrNewError):
 
338
    # used when reporting several paths are not versioned
 
339
    """Path(s) are not versioned: %(paths_as_string)s"""
659
340
 
660
341
    def __init__(self, paths):
661
342
        from bzrlib.osutils import quotefn
662
 
        BzrError.__init__(self)
 
343
        BzrNewError.__init__(self)
663
344
        self.paths = paths
664
345
        self.paths_as_string = ' '.join([quotefn(p) for p in paths])
665
346
 
666
347
 
667
 
class PathsDoNotExist(BzrError):
668
 
 
669
 
    _fmt = "Path(s) do not exist: %(paths_as_string)s%(extra)s"
 
348
class PathsDoNotExist(BzrNewError):
 
349
    """Path(s) do not exist: %(paths_as_string)s"""
670
350
 
671
351
    # used when reporting that paths are neither versioned nor in the working
672
352
    # tree
673
353
 
674
 
    def __init__(self, paths, extra=None):
 
354
    def __init__(self, paths):
675
355
        # circular import
676
356
        from bzrlib.osutils import quotefn
677
 
        BzrError.__init__(self)
 
357
        BzrNewError.__init__(self)
678
358
        self.paths = paths
679
359
        self.paths_as_string = ' '.join([quotefn(p) for p in paths])
680
 
        if extra:
681
 
            self.extra = ': ' + str(extra)
682
 
        else:
683
 
            self.extra = ''
684
 
 
685
 
 
686
 
class BadFileKindError(BzrError):
687
 
 
688
 
    _fmt = 'Cannot operate on "%(filename)s" of unsupported kind "%(kind)s"'
689
 
 
690
 
    def __init__(self, filename, kind):
691
 
        BzrError.__init__(self, filename=filename, kind=kind)
692
 
 
693
 
 
694
 
class ForbiddenControlFileError(BzrError):
695
 
 
696
 
    _fmt = "Cannot operate on %(filename)s because it is a control file"
697
 
 
698
 
 
699
 
class LockError(BzrError):
700
 
 
701
 
    _fmt = "Lock error: %(msg)s"
702
 
 
703
 
    internal_error = True
704
 
 
 
360
 
 
361
 
 
362
class BadFileKindError(BzrNewError):
 
363
    """Cannot operate on %(filename)s of unsupported kind %(kind)s"""
 
364
 
 
365
 
 
366
class ForbiddenControlFileError(BzrNewError):
 
367
    """Cannot operate on %(filename)s because it is a control file"""
 
368
 
 
369
 
 
370
class LockError(BzrNewError):
 
371
    """Lock error: %(message)s"""
705
372
    # All exceptions from the lock/unlock functions should be from
706
373
    # this exception class.  They will be translated as necessary. The
707
374
    # original exception is available as e.original_error
708
375
    #
709
376
    # New code should prefer to raise specific subclasses
710
377
    def __init__(self, message):
711
 
        # Python 2.5 uses a slot for StandardError.message,
712
 
        # so use a different variable name
713
 
        # so it is exposed in self.__dict__
714
 
        self.msg = message
715
 
 
716
 
 
717
 
class LockActive(LockError):
718
 
 
719
 
    _fmt = "The lock for '%(lock_description)s' is in use and cannot be broken."
720
 
 
721
 
    internal_error = False
722
 
 
723
 
    def __init__(self, lock_description):
724
 
        self.lock_description = lock_description
 
378
        self.message = message
725
379
 
726
380
 
727
381
class CommitNotPossible(LockError):
728
 
 
729
 
    _fmt = "A commit was attempted but we do not have a write lock open."
730
 
 
 
382
    """A commit was attempted but we do not have a write lock open."""
731
383
    def __init__(self):
732
384
        pass
733
385
 
734
386
 
735
387
class AlreadyCommitted(LockError):
736
 
 
737
 
    _fmt = "A rollback was requested, but is not able to be accomplished."
738
 
 
 
388
    """A rollback was requested, but is not able to be accomplished."""
739
389
    def __init__(self):
740
390
        pass
741
391
 
742
392
 
743
393
class ReadOnlyError(LockError):
744
 
 
745
 
    _fmt = "A write attempt was made in a read only transaction on %(obj)s"
746
 
 
747
 
    # TODO: There should also be an error indicating that you need a write
748
 
    # lock and don't have any lock at all... mbp 20070226
749
 
 
 
394
    """A write attempt was made in a read only transaction on %(obj)s"""
750
395
    def __init__(self, obj):
751
396
        self.obj = obj
752
397
 
753
398
 
754
 
class ReadOnlyLockError(LockError):
755
 
 
756
 
    _fmt = "Cannot acquire write lock on %(fname)s. %(msg)s"
757
 
 
758
 
    def __init__(self, fname, msg):
759
 
        LockError.__init__(self, '')
760
 
        self.fname = fname
761
 
        self.msg = msg
762
 
 
763
 
 
764
 
class OutSideTransaction(BzrError):
765
 
 
766
 
    _fmt = ("A transaction related operation was attempted after"
767
 
            " the transaction finished.")
 
399
class OutSideTransaction(BzrNewError):
 
400
    """A transaction related operation was attempted after the transaction finished."""
768
401
 
769
402
 
770
403
class ObjectNotLocked(LockError):
 
404
    """%(obj)r is not locked"""
771
405
 
772
 
    _fmt = "%(obj)r is not locked"
 
406
    is_user_error = False
773
407
 
774
408
    # this can indicate that any particular object is not locked; see also
775
409
    # LockNotHeld which means that a particular *lock* object is not held by
779
413
 
780
414
 
781
415
class ReadOnlyObjectDirtiedError(ReadOnlyError):
782
 
 
783
 
    _fmt = "Cannot change object %(obj)r in read only transaction"
784
 
 
 
416
    """Cannot change object %(obj)r in read only transaction"""
785
417
    def __init__(self, obj):
786
418
        self.obj = obj
787
419
 
788
420
 
789
421
class UnlockableTransport(LockError):
790
 
 
791
 
    _fmt = "Cannot lock: transport is read only: %(transport)s"
792
 
 
 
422
    """Cannot lock: transport is read only: %(transport)s"""
793
423
    def __init__(self, transport):
794
424
        self.transport = transport
795
425
 
796
426
 
797
427
class LockContention(LockError):
798
 
 
799
 
    _fmt = "Could not acquire lock %(lock)s"
800
 
    # TODO: show full url for lock, combining the transport and relative
801
 
    # bits?
802
 
 
803
 
    internal_error = False
804
 
 
 
428
    """Could not acquire lock %(lock)s"""
 
429
    # TODO: show full url for lock, combining the transport and relative bits?
805
430
    def __init__(self, lock):
806
431
        self.lock = lock
807
432
 
808
433
 
809
434
class LockBroken(LockError):
810
 
 
811
 
    _fmt = ("Lock was broken while still open: %(lock)s"
812
 
            " - check storage consistency!")
813
 
 
814
 
    internal_error = False
815
 
 
 
435
    """Lock was broken while still open: %(lock)s - check storage consistency!"""
816
436
    def __init__(self, lock):
817
437
        self.lock = lock
818
438
 
819
439
 
820
440
class LockBreakMismatch(LockError):
821
 
 
822
 
    _fmt = ("Lock was released and re-acquired before being broken:"
823
 
            " %(lock)s: held by %(holder)r, wanted to break %(target)r")
824
 
 
825
 
    internal_error = False
826
 
 
 
441
    """Lock was released and re-acquired before being broken: %(lock)s: held by %(holder)r, wanted to break %(target)r"""
827
442
    def __init__(self, lock, holder, target):
828
443
        self.lock = lock
829
444
        self.holder = holder
831
446
 
832
447
 
833
448
class LockNotHeld(LockError):
834
 
 
835
 
    _fmt = "Lock not held: %(lock)s"
836
 
 
837
 
    internal_error = False
838
 
 
 
449
    """Lock not held: %(lock)s"""
839
450
    def __init__(self, lock):
840
451
        self.lock = lock
841
452
 
842
453
 
843
 
class TokenLockingNotSupported(LockError):
844
 
 
845
 
    _fmt = "The object %(obj)s does not support token specifying a token when locking."
846
 
 
847
 
    internal_error = True
848
 
 
849
 
    def __init__(self, obj):
850
 
        self.obj = obj
851
 
 
852
 
 
853
 
class TokenMismatch(LockBroken):
854
 
 
855
 
    _fmt = "The lock token %(given_token)r does not match lock token %(lock_token)r."
856
 
 
857
 
    internal_error = True
858
 
 
859
 
    def __init__(self, given_token, lock_token):
860
 
        self.given_token = given_token
861
 
        self.lock_token = lock_token
862
 
 
863
 
 
864
 
class PointlessCommit(BzrError):
865
 
 
866
 
    _fmt = "No changes to commit"
867
 
 
868
 
 
869
 
class CannotCommitSelectedFileMerge(BzrError):
870
 
 
871
 
    _fmt = 'Selected-file commit of merges is not supported yet:'\
872
 
        ' files %(files_str)s'
873
 
 
874
 
    def __init__(self, files):
875
 
        files_str = ', '.join(files)
876
 
        BzrError.__init__(self, files=files, files_str=files_str)
877
 
 
878
 
 
879
 
class UpgradeReadonly(BzrError):
880
 
 
881
 
    _fmt = "Upgrade URL cannot work with readonly URLs."
882
 
 
883
 
 
884
 
class UpToDateFormat(BzrError):
885
 
 
886
 
    _fmt = "The branch format %(format)s is already at the most recent format."
 
454
class PointlessCommit(BzrNewError):
 
455
    """No changes to commit"""
 
456
 
 
457
 
 
458
class UpgradeReadonly(BzrNewError):
 
459
    """Upgrade URL cannot work with readonly URL's."""
 
460
 
 
461
 
 
462
class UpToDateFormat(BzrNewError):
 
463
    """The branch format %(format)s is already at the most recent format."""
887
464
 
888
465
    def __init__(self, format):
889
 
        BzrError.__init__(self)
 
466
        BzrNewError.__init__(self)
890
467
        self.format = format
891
468
 
892
469
 
 
470
 
893
471
class StrictCommitFailed(Exception):
894
 
 
895
 
    _fmt = "Commit refused because there are unknowns in the tree."
896
 
 
897
 
 
898
 
class NoSuchRevision(BzrError):
899
 
 
900
 
    _fmt = "Branch %(branch)s has no revision %(revision)s"
901
 
 
902
 
    internal_error = True
 
472
    """Commit refused because there are unknowns in the tree."""
 
473
 
 
474
 
 
475
class NoSuchRevision(BzrNewError):
 
476
    """Branch %(branch)s has no revision %(revision)s"""
 
477
 
 
478
    is_user_error = False
903
479
 
904
480
    def __init__(self, branch, revision):
905
 
        BzrError.__init__(self, branch=branch, revision=revision)
906
 
 
907
 
 
908
 
class NotLeftParentDescendant(BzrError):
909
 
 
910
 
    _fmt = ("Revision %(old_revision)s is not the left parent of"
911
 
            " %(new_revision)s, but branch %(branch_location)s expects this")
912
 
 
913
 
    internal_error = True
914
 
 
915
 
    def __init__(self, branch, old_revision, new_revision):
916
 
        BzrError.__init__(self, branch_location=branch.base,
917
 
                          old_revision=old_revision,
918
 
                          new_revision=new_revision)
919
 
 
920
 
 
921
 
class NoSuchRevisionSpec(BzrError):
922
 
 
923
 
    _fmt = "No namespace registered for string: %(spec)r"
924
 
 
925
 
    def __init__(self, spec):
926
 
        BzrError.__init__(self, spec=spec)
927
 
 
928
 
 
929
 
class NoSuchRevisionInTree(NoSuchRevision):
930
 
    """When using Tree.revision_tree, and the revision is not accessible."""
931
 
    
932
 
    _fmt = "The revision id %(revision_id)s is not present in the tree %(tree)s."
933
 
 
934
 
    def __init__(self, tree, revision_id):
935
 
        BzrError.__init__(self)
936
 
        self.tree = tree
937
 
        self.revision_id = revision_id
938
 
 
939
 
 
940
 
class InvalidRevisionSpec(BzrError):
941
 
 
942
 
    _fmt = ("Requested revision: %(spec)r does not exist in branch:"
943
 
            " %(branch)s%(extra)s")
944
 
 
945
 
    def __init__(self, spec, branch, extra=None):
946
 
        BzrError.__init__(self, branch=branch, spec=spec)
947
 
        if extra:
948
 
            self.extra = '\n' + str(extra)
949
 
        else:
950
 
            self.extra = ''
 
481
        self.branch = branch
 
482
        self.revision = revision
951
483
 
952
484
 
953
485
class HistoryMissing(BzrError):
954
 
 
955
 
    _fmt = "%(branch)s is missing %(object_type)s {%(object_id)s}"
956
 
 
957
 
 
958
 
class AppendRevisionsOnlyViolation(BzrError):
959
 
 
960
 
    _fmt = ('Operation denied because it would change the main history,'
961
 
           ' which is not permitted by the append_revisions_only setting on'
962
 
           ' branch "%(location)s".')
963
 
 
964
 
    def __init__(self, location):
965
 
       import bzrlib.urlutils as urlutils
966
 
       location = urlutils.unescape_for_display(location, 'ascii')
967
 
       BzrError.__init__(self, location=location)
968
 
 
969
 
 
970
 
class DivergedBranches(BzrError):
971
 
 
972
 
    _fmt = ("These branches have diverged."
973
 
            " Use the merge command to reconcile them.")
974
 
 
975
 
    internal_error = False
 
486
    def __init__(self, branch, object_type, object_id):
 
487
        self.branch = branch
 
488
        BzrError.__init__(self,
 
489
                          '%s is missing %s {%s}'
 
490
                          % (branch, object_type, object_id))
 
491
 
 
492
 
 
493
class DivergedBranches(BzrNewError):
 
494
    "These branches have diverged.  Use the merge command to reconcile them."""
 
495
 
 
496
    is_user_error = True
976
497
 
977
498
    def __init__(self, branch1, branch2):
978
499
        self.branch1 = branch1
979
500
        self.branch2 = branch2
980
501
 
981
502
 
982
 
class NotLefthandHistory(BzrError):
983
 
 
984
 
    _fmt = "Supplied history does not follow left-hand parents"
985
 
 
986
 
    internal_error = True
987
 
 
988
 
    def __init__(self, history):
989
 
        BzrError.__init__(self, history=history)
990
 
 
991
 
 
992
 
class UnrelatedBranches(BzrError):
993
 
 
994
 
    _fmt = ("Branches have no common ancestor, and"
995
 
            " no merge base revision was specified.")
996
 
 
997
 
    internal_error = False
998
 
 
999
 
 
1000
 
class NoCommonAncestor(BzrError):
1001
 
    
1002
 
    _fmt = "Revisions have no common ancestor: %(revision_a)s %(revision_b)s"
 
503
class UnrelatedBranches(BzrNewError):
 
504
    "Branches have no common ancestor, and no merge base revision was specified."
 
505
 
 
506
    is_user_error = True
 
507
 
 
508
 
 
509
class NoCommonAncestor(BzrNewError):
 
510
    "Revisions have no common ancestor: %(revision_a)s %(revision_b)s"
1003
511
 
1004
512
    def __init__(self, revision_a, revision_b):
1005
513
        self.revision_a = revision_a
1007
515
 
1008
516
 
1009
517
class NoCommonRoot(BzrError):
1010
 
 
1011
 
    _fmt = ("Revisions are not derived from the same root: "
1012
 
           "%(revision_a)s %(revision_b)s.")
1013
 
 
1014
518
    def __init__(self, revision_a, revision_b):
1015
 
        BzrError.__init__(self, revision_a=revision_a, revision_b=revision_b)
 
519
        msg = "Revisions are not derived from the same root: %s %s." \
 
520
            % (revision_a, revision_b) 
 
521
        BzrError.__init__(self, msg)
 
522
 
1016
523
 
1017
524
 
1018
525
class NotAncestor(BzrError):
1019
 
 
1020
 
    _fmt = "Revision %(rev_id)s is not an ancestor of %(not_ancestor_id)s"
1021
 
 
1022
526
    def __init__(self, rev_id, not_ancestor_id):
1023
 
        BzrError.__init__(self, rev_id=rev_id,
1024
 
            not_ancestor_id=not_ancestor_id)
 
527
        msg = "Revision %s is not an ancestor of %s" % (not_ancestor_id, 
 
528
                                                        rev_id)
 
529
        BzrError.__init__(self, msg)
 
530
        self.rev_id = rev_id
 
531
        self.not_ancestor_id = not_ancestor_id
1025
532
 
1026
533
 
1027
534
class InstallFailed(BzrError):
1028
 
 
1029
535
    def __init__(self, revisions):
1030
 
        revision_str = ", ".join(str(r) for r in revisions)
1031
 
        msg = "Could not install revisions:\n%s" % revision_str
 
536
        msg = "Could not install revisions:\n%s" % " ,".join(revisions)
1032
537
        BzrError.__init__(self, msg)
1033
538
        self.revisions = revisions
1034
539
 
1035
540
 
1036
541
class AmbiguousBase(BzrError):
1037
 
 
1038
542
    def __init__(self, bases):
1039
543
        warn("BzrError AmbiguousBase has been deprecated as of bzrlib 0.8.",
1040
544
                DeprecationWarning)
1041
 
        msg = ("The correct base is unclear, because %s are all equally close"
1042
 
                % ", ".join(bases))
 
545
        msg = "The correct base is unclear, because %s are all equally close" %\
 
546
            ", ".join(bases)
1043
547
        BzrError.__init__(self, msg)
1044
548
        self.bases = bases
1045
549
 
1046
550
 
1047
551
class NoCommits(BzrError):
1048
 
 
1049
 
    _fmt = "Branch %(branch)s has no commits."
1050
 
 
1051
552
    def __init__(self, branch):
1052
 
        BzrError.__init__(self, branch=branch)
 
553
        msg = "Branch %s has no commits." % branch
 
554
        BzrError.__init__(self, msg)
1053
555
 
1054
556
 
1055
557
class UnlistableStore(BzrError):
1056
 
 
1057
558
    def __init__(self, store):
1058
559
        BzrError.__init__(self, "Store %s is not listable" % store)
1059
560
 
1060
561
 
1061
562
 
1062
563
class UnlistableBranch(BzrError):
1063
 
 
1064
564
    def __init__(self, br):
1065
565
        BzrError.__init__(self, "Stores for branch %s are not listable" % br)
1066
566
 
1067
567
 
1068
 
class BoundBranchOutOfDate(BzrError):
1069
 
 
1070
 
    _fmt = ("Bound branch %(branch)s is out of date"
1071
 
            " with master branch %(master)s.")
1072
 
 
 
568
class BoundBranchOutOfDate(BzrNewError):
 
569
    """Bound branch %(branch)s is out of date with master branch %(master)s."""
1073
570
    def __init__(self, branch, master):
1074
 
        BzrError.__init__(self)
 
571
        BzrNewError.__init__(self)
1075
572
        self.branch = branch
1076
573
        self.master = master
1077
574
 
1078
575
        
1079
 
class CommitToDoubleBoundBranch(BzrError):
1080
 
 
1081
 
    _fmt = ("Cannot commit to branch %(branch)s."
1082
 
            " It is bound to %(master)s, which is bound to %(remote)s.")
1083
 
 
 
576
class CommitToDoubleBoundBranch(BzrNewError):
 
577
    """Cannot commit to branch %(branch)s. It is bound to %(master)s, which is bound to %(remote)s."""
1084
578
    def __init__(self, branch, master, remote):
1085
 
        BzrError.__init__(self)
 
579
        BzrNewError.__init__(self)
1086
580
        self.branch = branch
1087
581
        self.master = master
1088
582
        self.remote = remote
1089
583
 
1090
584
 
1091
 
class OverwriteBoundBranch(BzrError):
1092
 
 
1093
 
    _fmt = "Cannot pull --overwrite to a branch which is bound %(branch)s"
1094
 
 
 
585
class OverwriteBoundBranch(BzrNewError):
 
586
    """Cannot pull --overwrite to a branch which is bound %(branch)s"""
1095
587
    def __init__(self, branch):
1096
 
        BzrError.__init__(self)
 
588
        BzrNewError.__init__(self)
1097
589
        self.branch = branch
1098
590
 
1099
591
 
1100
 
class BoundBranchConnectionFailure(BzrError):
1101
 
 
1102
 
    _fmt = ("Unable to connect to target of bound branch %(branch)s"
1103
 
            " => %(target)s: %(error)s")
1104
 
 
 
592
class BoundBranchConnectionFailure(BzrNewError):
 
593
    """Unable to connect to target of bound branch %(branch)s => %(target)s: %(error)s"""
1105
594
    def __init__(self, branch, target, error):
1106
 
        BzrError.__init__(self)
 
595
        BzrNewError.__init__(self)
1107
596
        self.branch = branch
1108
597
        self.target = target
1109
598
        self.error = error
1110
599
 
1111
600
 
1112
 
class WeaveError(BzrError):
1113
 
 
1114
 
    _fmt = "Error in processing weave: %(message)s"
 
601
class WeaveError(BzrNewError):
 
602
    """Error in processing weave: %(message)s"""
1115
603
 
1116
604
    def __init__(self, message=None):
1117
 
        BzrError.__init__(self)
 
605
        BzrNewError.__init__(self)
1118
606
        self.message = message
1119
607
 
1120
608
 
1121
609
class WeaveRevisionAlreadyPresent(WeaveError):
1122
 
 
1123
 
    _fmt = "Revision {%(revision_id)s} already present in %(weave)s"
1124
 
 
 
610
    """Revision {%(revision_id)s} already present in %(weave)s"""
1125
611
    def __init__(self, revision_id, weave):
1126
612
 
1127
613
        WeaveError.__init__(self)
1130
616
 
1131
617
 
1132
618
class WeaveRevisionNotPresent(WeaveError):
1133
 
 
1134
 
    _fmt = "Revision {%(revision_id)s} not present in %(weave)s"
 
619
    """Revision {%(revision_id)s} not present in %(weave)s"""
1135
620
 
1136
621
    def __init__(self, revision_id, weave):
1137
622
        WeaveError.__init__(self)
1140
625
 
1141
626
 
1142
627
class WeaveFormatError(WeaveError):
1143
 
 
1144
 
    _fmt = "Weave invariant violated: %(what)s"
 
628
    """Weave invariant violated: %(what)s"""
1145
629
 
1146
630
    def __init__(self, what):
1147
631
        WeaveError.__init__(self)
1149
633
 
1150
634
 
1151
635
class WeaveParentMismatch(WeaveError):
1152
 
 
1153
 
    _fmt = "Parents are mismatched between two revisions."
 
636
    """Parents are mismatched between two revisions."""
1154
637
    
1155
638
 
1156
639
class WeaveInvalidChecksum(WeaveError):
1157
 
 
1158
 
    _fmt = "Text did not match it's checksum: %(message)s"
1159
 
 
1160
 
 
1161
 
class WeaveTextDiffers(WeaveError):
1162
 
 
1163
 
    _fmt = ("Weaves differ on text content. Revision:"
1164
 
            " {%(revision_id)s}, %(weave_a)s, %(weave_b)s")
1165
 
 
1166
 
    def __init__(self, revision_id, weave_a, weave_b):
1167
 
        WeaveError.__init__(self)
1168
 
        self.revision_id = revision_id
1169
 
        self.weave_a = weave_a
1170
 
        self.weave_b = weave_b
1171
 
 
1172
 
 
1173
 
class WeaveTextDiffers(WeaveError):
1174
 
 
1175
 
    _fmt = ("Weaves differ on text content. Revision:"
1176
 
            " {%(revision_id)s}, %(weave_a)s, %(weave_b)s")
1177
 
 
1178
 
    def __init__(self, revision_id, weave_a, weave_b):
1179
 
        WeaveError.__init__(self)
1180
 
        self.revision_id = revision_id
1181
 
        self.weave_a = weave_a
1182
 
        self.weave_b = weave_b
1183
 
 
1184
 
 
1185
 
class VersionedFileError(BzrError):
1186
 
    
1187
 
    _fmt = "Versioned file error"
 
640
    """Text did not match it's checksum: %(message)s"""
 
641
 
 
642
 
 
643
class WeaveTextDiffers(WeaveError):
 
644
    """Weaves differ on text content. Revision: {%(revision_id)s}, %(weave_a)s, %(weave_b)s"""
 
645
 
 
646
    def __init__(self, revision_id, weave_a, weave_b):
 
647
        WeaveError.__init__(self)
 
648
        self.revision_id = revision_id
 
649
        self.weave_a = weave_a
 
650
        self.weave_b = weave_b
 
651
 
 
652
 
 
653
class WeaveTextDiffers(WeaveError):
 
654
    """Weaves differ on text content. Revision: {%(revision_id)s}, %(weave_a)s, %(weave_b)s"""
 
655
 
 
656
    def __init__(self, revision_id, weave_a, weave_b):
 
657
        WeaveError.__init__(self)
 
658
        self.revision_id = revision_id
 
659
        self.weave_a = weave_a
 
660
        self.weave_b = weave_b
 
661
 
 
662
 
 
663
class VersionedFileError(BzrNewError):
 
664
    """Versioned file error."""
1188
665
 
1189
666
 
1190
667
class RevisionNotPresent(VersionedFileError):
1191
 
    
1192
 
    _fmt = "Revision {%(revision_id)s} not present in %(file_id)s."
 
668
    """Revision {%(revision_id)s} not present in %(file_id)s."""
1193
669
 
1194
670
    def __init__(self, revision_id, file_id):
1195
671
        VersionedFileError.__init__(self)
1198
674
 
1199
675
 
1200
676
class RevisionAlreadyPresent(VersionedFileError):
1201
 
    
1202
 
    _fmt = "Revision {%(revision_id)s} already present in %(file_id)s."
 
677
    """Revision {%(revision_id)s} already present in %(file_id)s."""
1203
678
 
1204
679
    def __init__(self, revision_id, file_id):
1205
680
        VersionedFileError.__init__(self)
1207
682
        self.file_id = file_id
1208
683
 
1209
684
 
1210
 
class KnitError(BzrError):
1211
 
    
1212
 
    _fmt = "Knit error"
1213
 
 
1214
 
    internal_error = True
 
685
class KnitError(BzrNewError):
 
686
    """Knit error"""
1215
687
 
1216
688
 
1217
689
class KnitHeaderError(KnitError):
1218
 
 
1219
 
    _fmt = "Knit header error: %(badline)r unexpected for file %(filename)s"
1220
 
 
1221
 
    def __init__(self, badline, filename):
 
690
    """Knit header error: %(badline)r unexpected"""
 
691
 
 
692
    def __init__(self, badline):
1222
693
        KnitError.__init__(self)
1223
694
        self.badline = badline
1224
 
        self.filename = filename
1225
695
 
1226
696
 
1227
697
class KnitCorrupt(KnitError):
1228
 
 
1229
 
    _fmt = "Knit %(filename)s corrupt: %(how)s"
 
698
    """Knit %(filename)s corrupt: %(how)s"""
1230
699
 
1231
700
    def __init__(self, filename, how):
1232
701
        KnitError.__init__(self)
1234
703
        self.how = how
1235
704
 
1236
705
 
1237
 
class KnitIndexUnknownMethod(KnitError):
1238
 
    """Raised when we don't understand the storage method.
1239
 
 
1240
 
    Currently only 'fulltext' and 'line-delta' are supported.
1241
 
    """
1242
 
    
1243
 
    _fmt = ("Knit index %(filename)s does not have a known method"
1244
 
            " in options: %(options)r")
1245
 
 
1246
 
    def __init__(self, filename, options):
1247
 
        KnitError.__init__(self)
1248
 
        self.filename = filename
1249
 
        self.options = options
1250
 
 
1251
 
 
1252
 
class NoSuchExportFormat(BzrError):
1253
 
    
1254
 
    _fmt = "Export format %(format)r not supported"
1255
 
 
 
706
class NoSuchExportFormat(BzrNewError):
 
707
    """Export format %(format)r not supported"""
1256
708
    def __init__(self, format):
1257
 
        BzrError.__init__(self)
 
709
        BzrNewError.__init__(self)
1258
710
        self.format = format
1259
711
 
1260
712
 
1261
713
class TransportError(BzrError):
1262
 
    
1263
 
    _fmt = "Transport error: %(msg)s %(orig_error)s"
1264
 
 
 
714
    """All errors thrown by Transport implementations should derive
 
715
    from this class.
 
716
    """
1265
717
    def __init__(self, msg=None, orig_error=None):
1266
718
        if msg is None and orig_error is not None:
1267
719
            msg = str(orig_error)
1268
 
        if orig_error is None:
1269
 
            orig_error = ''
1270
 
        if msg is None:
1271
 
            msg =  ''
 
720
        BzrError.__init__(self, msg)
1272
721
        self.msg = msg
1273
722
        self.orig_error = orig_error
1274
 
        BzrError.__init__(self)
1275
 
 
1276
 
 
1277
 
class TooManyConcurrentRequests(BzrError):
1278
 
 
1279
 
    _fmt = ("The medium '%(medium)s' has reached its concurrent request limit."
1280
 
            " Be sure to finish_writing and finish_reading on the"
1281
 
            " currently open request.")
1282
 
 
1283
 
    internal_error = True
1284
 
 
1285
 
    def __init__(self, medium):
1286
 
        self.medium = medium
1287
 
 
1288
 
 
1289
 
class SmartProtocolError(TransportError):
1290
 
 
1291
 
    _fmt = "Generic bzr smart protocol error: %(details)s"
1292
 
 
1293
 
    def __init__(self, details):
1294
 
        self.details = details
1295
723
 
1296
724
 
1297
725
# A set of semi-meaningful errors which can be thrown
1298
726
class TransportNotPossible(TransportError):
1299
 
 
1300
 
    _fmt = "Transport operation not possible: %(msg)s %(orig_error)s"
 
727
    """This is for transports where a specific function is explicitly not
 
728
    possible. Such as pushing files to an HTTP server.
 
729
    """
 
730
    pass
1301
731
 
1302
732
 
1303
733
class ConnectionError(TransportError):
1304
 
 
1305
 
    _fmt = "Connection error: %(msg)s %(orig_error)s"
1306
 
 
1307
 
 
1308
 
class SocketConnectionError(ConnectionError):
1309
 
 
1310
 
    _fmt = "%(msg)s %(host)s%(port)s%(orig_error)s"
1311
 
 
1312
 
    def __init__(self, host, port=None, msg=None, orig_error=None):
1313
 
        if msg is None:
1314
 
            msg = 'Failed to connect to'
1315
 
        if orig_error is None:
1316
 
            orig_error = ''
1317
 
        else:
1318
 
            orig_error = '; ' + str(orig_error)
1319
 
        ConnectionError.__init__(self, msg=msg, orig_error=orig_error)
1320
 
        self.host = host
1321
 
        if port is None:
1322
 
            self.port = ''
1323
 
        else:
1324
 
            self.port = ':%s' % port
 
734
    """A connection problem prevents file retrieval.
 
735
    This does not indicate whether the file exists or not; it indicates that a
 
736
    precondition for requesting the file was not met.
 
737
    """
 
738
    def __init__(self, msg=None, orig_error=None):
 
739
        TransportError.__init__(self, msg=msg, orig_error=orig_error)
1325
740
 
1326
741
 
1327
742
class ConnectionReset(TransportError):
1328
 
 
1329
 
    _fmt = "Connection closed: %(msg)s %(orig_error)s"
1330
 
 
1331
 
 
1332
 
class InvalidRange(TransportError):
1333
 
 
1334
 
    _fmt = "Invalid range access in %(path)s at %(offset)s."
1335
 
    
1336
 
    def __init__(self, path, offset):
1337
 
        TransportError.__init__(self, ("Invalid range access in %s at %d"
1338
 
                                       % (path, offset)))
1339
 
        self.path = path
1340
 
        self.offset = offset
1341
 
 
1342
 
 
1343
 
class InvalidHttpResponse(TransportError):
1344
 
 
1345
 
    _fmt = "Invalid http response for %(path)s: %(msg)s"
1346
 
 
1347
 
    def __init__(self, path, msg, orig_error=None):
1348
 
        self.path = path
1349
 
        TransportError.__init__(self, msg, orig_error=orig_error)
1350
 
 
1351
 
 
1352
 
class InvalidHttpRange(InvalidHttpResponse):
1353
 
 
1354
 
    _fmt = "Invalid http range %(range)r for %(path)s: %(msg)s"
1355
 
    
1356
 
    def __init__(self, path, range, msg):
1357
 
        self.range = range
1358
 
        InvalidHttpResponse.__init__(self, path, msg)
1359
 
 
1360
 
 
1361
 
class InvalidHttpContentType(InvalidHttpResponse):
1362
 
 
1363
 
    _fmt = 'Invalid http Content-type "%(ctype)s" for %(path)s: %(msg)s'
1364
 
    
1365
 
    def __init__(self, path, ctype, msg):
1366
 
        self.ctype = ctype
1367
 
        InvalidHttpResponse.__init__(self, path, msg)
1368
 
 
1369
 
 
1370
 
class RedirectRequested(TransportError):
1371
 
 
1372
 
    _fmt = '%(source)s is%(permanently)s redirected to %(target)s'
1373
 
 
1374
 
    def __init__(self, source, target, is_permament=False, qual_proto=None):
1375
 
        self.source = source
1376
 
        self.target = target
1377
 
        if is_permament:
1378
 
            self.permanently = ' permanently'
1379
 
        else:
1380
 
            self.permanently = ''
1381
 
        self.is_permament = is_permament
1382
 
        self._qualified_proto = qual_proto
1383
 
        TransportError.__init__(self)
1384
 
 
1385
 
    def _requalify_url(self, url):
1386
 
        """Restore the qualified proto in front of the url"""
1387
 
        # When this exception is raised, source and target are in
1388
 
        # user readable format. But some transports may use a
1389
 
        # different proto (http+urllib:// will present http:// to
1390
 
        # the user. If a qualified proto is specified, the code
1391
 
        # trapping the exception can get the qualified urls to
1392
 
        # properly handle the redirection themself (creating a
1393
 
        # new transport object from the target url for example).
1394
 
        # But checking that the scheme of the original and
1395
 
        # redirected urls are the same can be tricky. (see the
1396
 
        # FIXME in BzrDir.open_from_transport for the unique use
1397
 
        # case so far).
1398
 
        if self._qualified_proto is None:
1399
 
            return url
1400
 
 
1401
 
        # The TODO related to NotBranchError mention that doing
1402
 
        # that kind of manipulation on the urls may not be the
1403
 
        # exception object job. On the other hand, this object is
1404
 
        # the interface between the code and the user so
1405
 
        # presenting the urls in different ways is indeed its
1406
 
        # job...
1407
 
        import urlparse
1408
 
        proto, netloc, path, query, fragment = urlparse.urlsplit(url)
1409
 
        return urlparse.urlunsplit((self._qualified_proto, netloc, path,
1410
 
                                   query, fragment))
1411
 
 
1412
 
    def get_source_url(self):
1413
 
        return self._requalify_url(self.source)
1414
 
 
1415
 
    def get_target_url(self):
1416
 
        return self._requalify_url(self.target)
1417
 
 
1418
 
 
1419
 
class TooManyRedirections(TransportError):
1420
 
 
1421
 
    _fmt = "Too many redirections"
 
743
    """The connection has been closed."""
 
744
    pass
 
745
 
1422
746
 
1423
747
class ConflictsInTree(BzrError):
1424
 
 
1425
 
    _fmt = "Working tree has conflicts."
 
748
    def __init__(self):
 
749
        BzrError.__init__(self, "Working tree has conflicts.")
1426
750
 
1427
751
 
1428
752
class ParseConfigError(BzrError):
1429
 
 
1430
753
    def __init__(self, errors, filename):
1431
754
        if filename is None:
1432
755
            filename = ""
1435
758
        BzrError.__init__(self, message)
1436
759
 
1437
760
 
1438
 
class NoEmailInUsername(BzrError):
1439
 
 
1440
 
    _fmt = "%(username)r does not seem to contain a reasonable email address"
1441
 
 
1442
 
    def __init__(self, username):
1443
 
        BzrError.__init__(self)
1444
 
        self.username = username
1445
 
 
1446
 
 
1447
761
class SigningFailed(BzrError):
1448
 
 
1449
 
    _fmt = "Failed to gpg sign data with command %(command_line)r"
1450
 
 
1451
762
    def __init__(self, command_line):
1452
 
        BzrError.__init__(self, command_line=command_line)
 
763
        BzrError.__init__(self, "Failed to gpg sign data with command '%s'"
 
764
                               % command_line)
1453
765
 
1454
766
 
1455
767
class WorkingTreeNotRevision(BzrError):
1456
 
 
1457
 
    _fmt = ("The working tree for %(basedir)s has changed since" 
1458
 
            " the last commit, but weave merge requires that it be"
1459
 
            " unchanged")
1460
 
 
1461
768
    def __init__(self, tree):
1462
 
        BzrError.__init__(self, basedir=tree.basedir)
1463
 
 
1464
 
 
1465
 
class CantReprocessAndShowBase(BzrError):
1466
 
 
1467
 
    _fmt = ("Can't reprocess and show base, because reprocessing obscures "
1468
 
           "the relationship of conflicting lines to the base")
1469
 
 
1470
 
 
1471
 
class GraphCycleError(BzrError):
1472
 
 
1473
 
    _fmt = "Cycle in graph %(graph)r"
1474
 
 
 
769
        BzrError.__init__(self, "The working tree for %s has changed since"
 
770
                          " last commit, but weave merge requires that it be"
 
771
                          " unchanged." % tree.basedir)
 
772
 
 
773
 
 
774
class CantReprocessAndShowBase(BzrNewError):
 
775
    """Can't reprocess and show base.
 
776
Reprocessing obscures relationship of conflicting lines to base."""
 
777
 
 
778
 
 
779
class GraphCycleError(BzrNewError):
 
780
    """Cycle in graph %(graph)r"""
1475
781
    def __init__(self, graph):
1476
 
        BzrError.__init__(self)
 
782
        BzrNewError.__init__(self)
1477
783
        self.graph = graph
1478
784
 
1479
785
 
1480
 
class WritingCompleted(BzrError):
1481
 
 
1482
 
    _fmt = ("The MediumRequest '%(request)s' has already had finish_writing "
1483
 
            "called upon it - accept bytes may not be called anymore.")
1484
 
 
1485
 
    internal_error = True
1486
 
 
1487
 
    def __init__(self, request):
1488
 
        self.request = request
1489
 
 
1490
 
 
1491
 
class WritingNotComplete(BzrError):
1492
 
 
1493
 
    _fmt = ("The MediumRequest '%(request)s' has not has finish_writing "
1494
 
            "called upon it - until the write phase is complete no "
1495
 
            "data may be read.")
1496
 
 
1497
 
    internal_error = True
1498
 
 
1499
 
    def __init__(self, request):
1500
 
        self.request = request
1501
 
 
1502
 
 
1503
 
class NotConflicted(BzrError):
1504
 
 
1505
 
    _fmt = "File %(filename)s is not conflicted."
 
786
class NotConflicted(BzrNewError):
 
787
    """File %(filename)s is not conflicted."""
1506
788
 
1507
789
    def __init__(self, filename):
1508
 
        BzrError.__init__(self)
 
790
        BzrNewError.__init__(self)
1509
791
        self.filename = filename
1510
792
 
1511
793
 
1512
 
class MediumNotConnected(BzrError):
1513
 
 
1514
 
    _fmt = """The medium '%(medium)s' is not connected."""
1515
 
 
1516
 
    internal_error = True
1517
 
 
1518
 
    def __init__(self, medium):
1519
 
        self.medium = medium
1520
 
 
1521
 
 
1522
794
class MustUseDecorated(Exception):
1523
 
 
1524
 
    _fmt = "A decorating function has requested its original command be used."
1525
 
 
1526
 
 
1527
 
class NoBundleFound(BzrError):
1528
 
 
1529
 
    _fmt = "No bundle was found in %(filename)s"
1530
 
 
 
795
    """A decorating function has requested its original command be used.
 
796
    
 
797
    This should never escape bzr, so does not need to be printable.
 
798
    """
 
799
 
 
800
 
 
801
class NoBundleFound(BzrNewError):
 
802
    """No bundle was found in %(filename)s"""
1531
803
    def __init__(self, filename):
1532
 
        BzrError.__init__(self)
 
804
        BzrNewError.__init__(self)
1533
805
        self.filename = filename
1534
806
 
1535
807
 
1536
 
class BundleNotSupported(BzrError):
1537
 
 
1538
 
    _fmt = "Unable to handle bundle version %(version)s: %(msg)s"
1539
 
 
 
808
class BundleNotSupported(BzrNewError):
 
809
    """Unable to handle bundle version %(version)s: %(msg)s"""
1540
810
    def __init__(self, version, msg):
1541
 
        BzrError.__init__(self)
 
811
        BzrNewError.__init__(self)
1542
812
        self.version = version
1543
813
        self.msg = msg
1544
814
 
1545
815
 
1546
 
class MissingText(BzrError):
1547
 
 
1548
 
    _fmt = ("Branch %(base)s is missing revision"
1549
 
            " %(text_revision)s of %(file_id)s")
 
816
class MissingText(BzrNewError):
 
817
    """Branch %(base)s is missing revision %(text_revision)s of %(file_id)s"""
1550
818
 
1551
819
    def __init__(self, branch, text_revision, file_id):
1552
 
        BzrError.__init__(self)
 
820
        BzrNewError.__init__(self)
1553
821
        self.branch = branch
1554
822
        self.base = branch.base
1555
823
        self.text_revision = text_revision
1556
824
        self.file_id = file_id
1557
825
 
1558
826
 
1559
 
class DuplicateFileId(BzrError):
1560
 
 
1561
 
    _fmt = "File id {%(file_id)s} already exists in inventory as %(entry)s"
1562
 
 
1563
 
    def __init__(self, file_id, entry):
1564
 
        BzrError.__init__(self)
1565
 
        self.file_id = file_id
1566
 
        self.entry = entry
1567
 
 
1568
 
 
1569
 
class DuplicateKey(BzrError):
1570
 
 
1571
 
    _fmt = "Key %(key)s is already present in map"
1572
 
 
1573
 
 
1574
 
class DuplicateHelpPrefix(BzrError):
1575
 
 
1576
 
    _fmt = "The prefix %(prefix)s is in the help search path twice."
1577
 
 
1578
 
    def __init__(self, prefix):
1579
 
        self.prefix = prefix
1580
 
 
1581
 
 
1582
 
class MalformedTransform(BzrError):
1583
 
 
1584
 
    _fmt = "Tree transform is malformed %(conflicts)r"
1585
 
 
1586
 
 
1587
 
class NoFinalPath(BzrError):
1588
 
 
1589
 
    _fmt = ("No final name for trans_id %(trans_id)r\n"
1590
 
            "file-id: %(file_id)r\n"
1591
 
            "root trans-id: %(root_trans_id)r\n")
1592
 
 
1593
 
    def __init__(self, trans_id, transform):
1594
 
        self.trans_id = trans_id
1595
 
        self.file_id = transform.final_file_id(trans_id)
1596
 
        self.root_trans_id = transform.root
1597
 
 
1598
 
 
1599
 
class BzrBadParameter(BzrError):
1600
 
 
1601
 
    _fmt = "Bad parameter: %(param)r"
1602
 
 
1603
 
    internal_error = True
1604
 
 
1605
 
    # This exception should never be thrown, but it is a base class for all
1606
 
    # parameter-to-function errors.
1607
 
 
 
827
class DuplicateKey(BzrNewError):
 
828
    """Key %(key)s is already present in map"""
 
829
 
 
830
 
 
831
class MalformedTransform(BzrNewError):
 
832
    """Tree transform is malformed %(conflicts)r"""
 
833
 
 
834
 
 
835
class BzrBadParameter(BzrNewError):
 
836
    """A bad parameter : %(param)s is not usable.
 
837
    
 
838
    This exception should never be thrown, but it is a base class for all
 
839
    parameter-to-function errors.
 
840
    """
1608
841
    def __init__(self, param):
1609
 
        BzrError.__init__(self)
 
842
        BzrNewError.__init__(self)
1610
843
        self.param = param
1611
844
 
1612
845
 
1613
846
class BzrBadParameterNotUnicode(BzrBadParameter):
1614
 
 
1615
 
    _fmt = "Parameter %(param)s is neither unicode nor utf8."
1616
 
 
1617
 
 
1618
 
class ReusingTransform(BzrError):
1619
 
 
1620
 
    _fmt = "Attempt to reuse a transform that has already been applied."
1621
 
 
1622
 
 
1623
 
class CantMoveRoot(BzrError):
1624
 
 
1625
 
    _fmt = "Moving the root directory is not supported at this time"
1626
 
 
1627
 
 
1628
 
class BzrMoveFailedError(BzrError):
1629
 
 
1630
 
    _fmt = "Could not move %(from_path)s%(operator)s %(to_path)s%(extra)s"
1631
 
 
1632
 
    def __init__(self, from_path='', to_path='', extra=None):
1633
 
        BzrError.__init__(self)
1634
 
        if extra:
1635
 
            self.extra = ': ' + str(extra)
1636
 
        else:
1637
 
            self.extra = ''
1638
 
 
1639
 
        has_from = len(from_path) > 0
1640
 
        has_to = len(to_path) > 0
1641
 
        if has_from:
1642
 
            self.from_path = osutils.splitpath(from_path)[-1]
1643
 
        else:
1644
 
            self.from_path = ''
1645
 
 
1646
 
        if has_to:
1647
 
            self.to_path = osutils.splitpath(to_path)[-1]
1648
 
        else:
1649
 
            self.to_path = ''
1650
 
 
1651
 
        self.operator = ""
1652
 
        if has_from and has_to:
1653
 
            self.operator = " =>"
1654
 
        elif has_from:
1655
 
            self.from_path = "from " + from_path
1656
 
        elif has_to:
1657
 
            self.operator = "to"
1658
 
        else:
1659
 
            self.operator = "file"
1660
 
 
1661
 
 
1662
 
class BzrRenameFailedError(BzrMoveFailedError):
1663
 
 
1664
 
    _fmt = "Could not rename %(from_path)s%(operator)s %(to_path)s%(extra)s"
1665
 
 
1666
 
    def __init__(self, from_path, to_path, extra=None):
1667
 
        BzrMoveFailedError.__init__(self, from_path, to_path, extra)
1668
 
 
1669
 
class BzrRemoveChangedFilesError(BzrError):
1670
 
    """Used when user is trying to remove changed files."""
1671
 
 
1672
 
    _fmt = ("Can't remove changed or unknown files:\n%(changes_as_text)s"
1673
 
        "Use --keep to not delete them, or --force to delete them regardless.")
1674
 
 
1675
 
    def __init__(self, tree_delta):
1676
 
        BzrError.__init__(self)
1677
 
        self.changes_as_text = tree_delta.get_changes_as_text()
1678
 
        #self.paths_as_string = '\n'.join(changed_files)
1679
 
        #self.paths_as_string = '\n'.join([quotefn(p) for p in changed_files])
 
847
    """Parameter %(param)s is neither unicode nor utf8."""
 
848
 
 
849
 
 
850
class ReusingTransform(BzrNewError):
 
851
    """Attempt to reuse a transform that has already been applied."""
 
852
 
 
853
 
 
854
class CantMoveRoot(BzrNewError):
 
855
    """Moving the root directory is not supported at this time"""
1680
856
 
1681
857
 
1682
858
class BzrBadParameterNotString(BzrBadParameter):
1683
 
 
1684
 
    _fmt = "Parameter %(param)s is not a string or unicode string."
 
859
    """Parameter %(param)s is not a string or unicode string."""
1685
860
 
1686
861
 
1687
862
class BzrBadParameterMissing(BzrBadParameter):
1688
 
 
1689
 
    _fmt = "Parameter $(param)s is required but not present."
 
863
    """Parameter $(param)s is required but not present."""
1690
864
 
1691
865
 
1692
866
class BzrBadParameterUnicode(BzrBadParameter):
1693
 
 
1694
 
    _fmt = ("Parameter %(param)s is unicode but"
1695
 
            " only byte-strings are permitted.")
 
867
    """Parameter %(param)s is unicode but only byte-strings are permitted."""
1696
868
 
1697
869
 
1698
870
class BzrBadParameterContainsNewline(BzrBadParameter):
1699
 
 
1700
 
    _fmt = "Parameter %(param)s contains a newline."
1701
 
 
1702
 
 
1703
 
class DependencyNotPresent(BzrError):
1704
 
 
1705
 
    _fmt = 'Unable to import library "%(library)s": %(error)s'
 
871
    """Parameter %(param)s contains a newline."""
 
872
 
 
873
 
 
874
class DependencyNotPresent(BzrNewError):
 
875
    """Unable to import library "%(library)s": %(error)s"""
1706
876
 
1707
877
    def __init__(self, library, error):
1708
 
        BzrError.__init__(self, library=library, error=error)
 
878
        BzrNewError.__init__(self, library=library, error=error)
1709
879
 
1710
880
 
1711
881
class ParamikoNotPresent(DependencyNotPresent):
1712
 
 
1713
 
    _fmt = "Unable to import paramiko (required for sftp support): %(error)s"
 
882
    """Unable to import paramiko (required for sftp support): %(error)s"""
1714
883
 
1715
884
    def __init__(self, error):
1716
885
        DependencyNotPresent.__init__(self, 'paramiko', error)
1717
886
 
1718
887
 
1719
 
class PointlessMerge(BzrError):
1720
 
 
1721
 
    _fmt = "Nothing to merge."
1722
 
 
1723
 
 
1724
 
class UninitializableFormat(BzrError):
1725
 
 
1726
 
    _fmt = "Format %(format)s cannot be initialised by this version of bzr."
 
888
class UninitializableFormat(BzrNewError):
 
889
    """Format %(format)s cannot be initialised by this version of bzr."""
1727
890
 
1728
891
    def __init__(self, format):
1729
 
        BzrError.__init__(self)
1730
 
        self.format = format
1731
 
 
1732
 
 
1733
 
class BadConversionTarget(BzrError):
1734
 
 
1735
 
    _fmt = "Cannot convert to format %(format)s.  %(problem)s"
1736
 
 
1737
 
    def __init__(self, problem, format):
1738
 
        BzrError.__init__(self)
1739
 
        self.problem = problem
1740
 
        self.format = format
1741
 
 
1742
 
 
1743
 
class NoDiff(BzrError):
1744
 
 
1745
 
    _fmt = "Diff is not installed on this machine: %(msg)s"
 
892
        BzrNewError.__init__(self)
 
893
        self.format = format
 
894
 
 
895
 
 
896
class NoDiff(BzrNewError):
 
897
    """Diff is not installed on this machine: %(msg)s"""
1746
898
 
1747
899
    def __init__(self, msg):
1748
 
        BzrError.__init__(self, msg=msg)
1749
 
 
1750
 
 
1751
 
class NoDiff3(BzrError):
1752
 
 
1753
 
    _fmt = "Diff3 is not installed on this machine."
1754
 
 
1755
 
 
1756
 
class ExistingLimbo(BzrError):
1757
 
 
1758
 
    _fmt = """This tree contains left-over files from a failed operation.
1759
 
    Please examine %(limbo_dir)s to see if it contains any files you wish to
1760
 
    keep, and delete it when you are done."""
1761
 
    
1762
 
    def __init__(self, limbo_dir):
1763
 
       BzrError.__init__(self)
1764
 
       self.limbo_dir = limbo_dir
1765
 
 
1766
 
 
1767
 
class ImmortalLimbo(BzrError):
1768
 
 
1769
 
    _fmt = """Unable to delete transform temporary directory $(limbo_dir)s.
1770
 
    Please examine %(limbo_dir)s to see if it contains any files you wish to
1771
 
    keep, and delete it when you are done."""
1772
 
 
1773
 
    def __init__(self, limbo_dir):
1774
 
       BzrError.__init__(self)
1775
 
       self.limbo_dir = limbo_dir
1776
 
 
1777
 
 
1778
 
class OutOfDateTree(BzrError):
1779
 
 
1780
 
    _fmt = "Working tree is out of date, please run 'bzr update'."
 
900
        super(NoDiff, self).__init__(msg=msg)
 
901
 
 
902
 
 
903
class NoDiff3(BzrNewError):
 
904
    """Diff3 is not installed on this machine."""
 
905
 
 
906
 
 
907
class ExistingLimbo(BzrNewError):
 
908
    """This tree contains left-over files from a failed operation.
 
909
    Please examine %(limbo_dir)s to see if it contains any files you wish to
 
910
    keep, and delete it when you are done.
 
911
    """
 
912
    def __init__(self, limbo_dir):
 
913
       BzrNewError.__init__(self)
 
914
       self.limbo_dir = limbo_dir
 
915
 
 
916
 
 
917
class ImmortalLimbo(BzrNewError):
 
918
    """Unable to delete transform temporary directory $(limbo_dir)s.
 
919
    Please examine %(limbo_dir)s to see if it contains any files you wish to
 
920
    keep, and delete it when you are done.
 
921
    """
 
922
    def __init__(self, limbo_dir):
 
923
       BzrNewError.__init__(self)
 
924
       self.limbo_dir = limbo_dir
 
925
 
 
926
 
 
927
class OutOfDateTree(BzrNewError):
 
928
    """Working tree is out of date, please run 'bzr update'."""
1781
929
 
1782
930
    def __init__(self, tree):
1783
 
        BzrError.__init__(self)
 
931
        BzrNewError.__init__(self)
1784
932
        self.tree = tree
1785
933
 
1786
934
 
1787
 
class PublicBranchOutOfDate(BzrError):
1788
 
 
1789
 
    _fmt = 'Public branch "%(public_location)s" lacks revision '\
1790
 
        '"%(revstring)s".'
1791
 
 
1792
 
    def __init__(self, public_location, revstring):
1793
 
        import bzrlib.urlutils as urlutils
1794
 
        public_location = urlutils.unescape_for_display(public_location,
1795
 
                                                        'ascii')
1796
 
        BzrError.__init__(self, public_location=public_location,
1797
 
                          revstring=revstring)
1798
 
 
1799
 
 
1800
 
class MergeModifiedFormatError(BzrError):
1801
 
 
1802
 
    _fmt = "Error in merge modified format"
1803
 
 
1804
 
 
1805
 
class ConflictFormatError(BzrError):
1806
 
 
1807
 
    _fmt = "Format error in conflict listings"
1808
 
 
1809
 
 
1810
 
class CorruptRepository(BzrError):
1811
 
 
1812
 
    _fmt = ("An error has been detected in the repository %(repo_path)s.\n"
1813
 
            "Please run bzr reconcile on this repository.")
 
935
class MergeModifiedFormatError(BzrNewError):
 
936
    """Error in merge modified format"""
 
937
 
 
938
 
 
939
class ConflictFormatError(BzrNewError):
 
940
    """Format error in conflict listings"""
 
941
 
 
942
 
 
943
class CorruptRepository(BzrNewError):
 
944
    """An error has been detected in the repository %(repo_path)s.
 
945
Please run bzr reconcile on this repository."""
1814
946
 
1815
947
    def __init__(self, repo):
1816
 
        BzrError.__init__(self)
 
948
        BzrNewError.__init__(self)
1817
949
        self.repo_path = repo.bzrdir.root_transport.base
1818
950
 
1819
951
 
1820
 
class UpgradeRequired(BzrError):
1821
 
 
1822
 
    _fmt = "To use this feature you must upgrade your branch at %(path)s."
 
952
class UpgradeRequired(BzrNewError):
 
953
    """To use this feature you must upgrade your branch at %(path)s."""
1823
954
 
1824
955
    def __init__(self, path):
1825
 
        BzrError.__init__(self)
 
956
        BzrNewError.__init__(self)
1826
957
        self.path = path
1827
958
 
1828
959
 
1829
 
class LocalRequiresBoundBranch(BzrError):
1830
 
 
1831
 
    _fmt = "Cannot perform local-only commits on unbound branches."
1832
 
 
1833
 
 
1834
 
class MissingProgressBarFinish(BzrError):
1835
 
 
1836
 
    _fmt = "A nested progress bar was not 'finished' correctly."
1837
 
 
1838
 
 
1839
 
class InvalidProgressBarType(BzrError):
1840
 
 
1841
 
    _fmt = ("Environment variable BZR_PROGRESS_BAR='%(bar_type)s"
1842
 
            " is not a supported type Select one of: %(valid_types)s")
1843
 
 
1844
 
    def __init__(self, bar_type, valid_types):
1845
 
        BzrError.__init__(self, bar_type=bar_type, valid_types=valid_types)
1846
 
 
1847
 
 
1848
 
class UnsupportedOperation(BzrError):
1849
 
 
1850
 
    _fmt = ("The method %(mname)s is not supported on"
1851
 
            " objects of type %(tname)s.")
1852
 
 
 
960
class LocalRequiresBoundBranch(BzrNewError):
 
961
    """Cannot perform local-only commits on unbound branches."""
 
962
 
 
963
 
 
964
class MissingProgressBarFinish(BzrNewError):
 
965
    """A nested progress bar was not 'finished' correctly."""
 
966
 
 
967
 
 
968
class UnsupportedOperation(BzrNewError):
 
969
    """The method %(mname)s is not supported on objects of type %(tname)s."""
1853
970
    def __init__(self, method, method_self):
1854
971
        self.method = method
1855
972
        self.mname = method.__name__
1856
973
        self.tname = type(method_self).__name__
1857
974
 
1858
975
 
1859
 
class CannotSetRevisionId(UnsupportedOperation):
1860
 
    """Raised when a commit is attempting to set a revision id but cant."""
1861
 
 
1862
 
 
1863
 
class NonAsciiRevisionId(UnsupportedOperation):
1864
 
    """Raised when a commit is attempting to set a non-ascii revision id
1865
 
       but cant.
1866
 
    """
1867
 
 
1868
 
 
1869
 
class BinaryFile(BzrError):
1870
 
    
1871
 
    _fmt = "File is binary but should be text."
1872
 
 
1873
 
 
1874
 
class IllegalPath(BzrError):
1875
 
 
1876
 
    _fmt = "The path %(path)s is not permitted on this platform"
 
976
class BinaryFile(BzrNewError):
 
977
    """File is binary but should be text."""
 
978
 
 
979
 
 
980
class IllegalPath(BzrNewError):
 
981
    """The path %(path)s is not permitted on this platform"""
1877
982
 
1878
983
    def __init__(self, path):
1879
 
        BzrError.__init__(self)
 
984
        BzrNewError.__init__(self)
1880
985
        self.path = path
1881
986
 
1882
987
 
1883
 
class TestamentMismatch(BzrError):
1884
 
 
1885
 
    _fmt = """Testament did not match expected value.
1886
 
       For revision_id {%(revision_id)s}, expected {%(expected)s}, measured
1887
 
       {%(measured)s}"""
1888
 
 
 
988
class TestamentMismatch(BzrNewError):
 
989
    """Testament did not match expected value.  
 
990
       For revision_id {%(revision_id)s}, expected {%(expected)s}, measured 
 
991
       {%(measured)s}
 
992
    """
1889
993
    def __init__(self, revision_id, expected, measured):
1890
994
        self.revision_id = revision_id
1891
995
        self.expected = expected
1892
996
        self.measured = measured
1893
997
 
1894
998
 
1895
 
class NotABundle(BzrError):
1896
 
    
1897
 
    _fmt = "Not a bzr revision-bundle: %(text)r"
1898
 
 
1899
 
    def __init__(self, text):
1900
 
        BzrError.__init__(self)
1901
 
        self.text = text
1902
 
 
1903
 
 
1904
 
class BadBundle(BzrError): 
1905
 
    
1906
 
    _fmt = "Bad bzr revision-bundle: %(text)r"
1907
 
 
1908
 
    def __init__(self, text):
1909
 
        BzrError.__init__(self)
1910
 
        self.text = text
1911
 
 
1912
 
 
1913
 
class MalformedHeader(BadBundle): 
1914
 
    
1915
 
    _fmt = "Malformed bzr revision-bundle header: %(text)r"
1916
 
 
1917
 
 
1918
 
class MalformedPatches(BadBundle): 
1919
 
    
1920
 
    _fmt = "Malformed patches in bzr revision-bundle: %(text)r"
1921
 
 
1922
 
 
1923
 
class MalformedFooter(BadBundle): 
1924
 
    
1925
 
    _fmt = "Malformed footer in bzr revision-bundle: %(text)r"
1926
 
 
1927
 
 
1928
 
class UnsupportedEOLMarker(BadBundle):
1929
 
    
1930
 
    _fmt = "End of line marker was not \\n in bzr revision-bundle"    
1931
 
 
1932
 
    def __init__(self):
1933
 
        # XXX: BadBundle's constructor assumes there's explanatory text, 
1934
 
        # but for this there is not
1935
 
        BzrError.__init__(self)
1936
 
 
1937
 
 
1938
 
class IncompatibleBundleFormat(BzrError):
1939
 
    
1940
 
    _fmt = "Bundle format %(bundle_format)s is incompatible with %(other)s"
1941
 
 
1942
 
    def __init__(self, bundle_format, other):
1943
 
        BzrError.__init__(self)
1944
 
        self.bundle_format = bundle_format
1945
 
        self.other = other
1946
 
 
1947
 
 
1948
 
class BadInventoryFormat(BzrError):
1949
 
    
1950
 
    _fmt = "Root class for inventory serialization errors"
1951
 
 
1952
 
 
1953
 
class UnexpectedInventoryFormat(BadInventoryFormat):
1954
 
 
1955
 
    _fmt = "The inventory was not in the expected format:\n %(msg)s"
1956
 
 
1957
 
    def __init__(self, msg):
1958
 
        BadInventoryFormat.__init__(self, msg=msg)
1959
 
 
1960
 
 
1961
 
class RootNotRich(BzrError):
1962
 
 
1963
 
    _fmt = """This operation requires rich root data storage"""
1964
 
 
1965
 
 
1966
 
class NoSmartMedium(BzrError):
1967
 
 
1968
 
    _fmt = "The transport '%(transport)s' cannot tunnel the smart protocol."
1969
 
 
1970
 
    internal_error = True
1971
 
 
1972
 
    def __init__(self, transport):
1973
 
        self.transport = transport
1974
 
 
1975
 
 
1976
 
class NoSmartServer(NotBranchError):
1977
 
 
1978
 
    _fmt = "No smart server available at %(url)s"
1979
 
 
1980
 
    def __init__(self, url):
1981
 
        self.url = url
1982
 
 
1983
 
 
1984
 
class UnknownSSH(BzrError):
1985
 
 
1986
 
    _fmt = "Unrecognised value for BZR_SSH environment variable: %(vendor)s"
1987
 
 
1988
 
    def __init__(self, vendor):
1989
 
        BzrError.__init__(self)
1990
 
        self.vendor = vendor
1991
 
 
1992
 
 
1993
 
class SSHVendorNotFound(BzrError):
1994
 
 
1995
 
    _fmt = ("Don't know how to handle SSH connections."
1996
 
            " Please set BZR_SSH environment variable.")
1997
 
 
1998
 
 
1999
 
class GhostRevisionUnusableHere(BzrError):
2000
 
 
2001
 
    _fmt = "Ghost revision {%(revision_id)s} cannot be used here."
2002
 
 
2003
 
    def __init__(self, revision_id):
2004
 
        BzrError.__init__(self)
2005
 
        self.revision_id = revision_id
2006
 
 
2007
 
 
2008
 
class IllegalUseOfScopeReplacer(BzrError):
2009
 
 
2010
 
    _fmt = ("ScopeReplacer object %(name)r was used incorrectly:"
2011
 
            " %(msg)s%(extra)s")
2012
 
 
2013
 
    internal_error = True
2014
 
 
2015
 
    def __init__(self, name, msg, extra=None):
2016
 
        BzrError.__init__(self)
2017
 
        self.name = name
2018
 
        self.msg = msg
2019
 
        if extra:
2020
 
            self.extra = ': ' + str(extra)
2021
 
        else:
2022
 
            self.extra = ''
2023
 
 
2024
 
 
2025
 
class InvalidImportLine(BzrError):
2026
 
 
2027
 
    _fmt = "Not a valid import statement: %(msg)\n%(text)s"
2028
 
 
2029
 
    internal_error = True
2030
 
 
2031
 
    def __init__(self, text, msg):
2032
 
        BzrError.__init__(self)
2033
 
        self.text = text
2034
 
        self.msg = msg
2035
 
 
2036
 
 
2037
 
class ImportNameCollision(BzrError):
2038
 
 
2039
 
    _fmt = ("Tried to import an object to the same name as"
2040
 
            " an existing object. %(name)s")
2041
 
 
2042
 
    internal_error = True
2043
 
 
2044
 
    def __init__(self, name):
2045
 
        BzrError.__init__(self)
2046
 
        self.name = name
2047
 
 
2048
 
 
2049
 
class NotAMergeDirective(BzrError):
2050
 
    """File starting with %(firstline)r is not a merge directive"""
2051
 
    def __init__(self, firstline):
2052
 
        BzrError.__init__(self, firstline=firstline)
2053
 
 
2054
 
 
2055
 
class NoMergeSource(BzrError):
2056
 
    """Raise if no merge source was specified for a merge directive"""
2057
 
 
2058
 
    _fmt = "A merge directive must provide either a bundle or a public"\
2059
 
        " branch location."
2060
 
 
2061
 
 
2062
 
class PatchMissing(BzrError):
2063
 
    """Raise a patch type was specified but no patch supplied"""
2064
 
 
2065
 
    _fmt = "patch_type was %(patch_type)s, but no patch was supplied."
2066
 
 
2067
 
    def __init__(self, patch_type):
2068
 
        BzrError.__init__(self)
2069
 
        self.patch_type = patch_type
2070
 
 
2071
 
 
2072
 
class UnsupportedInventoryKind(BzrError):
2073
 
    
2074
 
    _fmt = """Unsupported entry kind %(kind)s"""
2075
 
 
2076
 
    def __init__(self, kind):
2077
 
        self.kind = kind
2078
 
 
2079
 
 
2080
 
class BadSubsumeSource(BzrError):
2081
 
 
2082
 
    _fmt = """Can't subsume %(other_tree)s into %(tree)s.  %(reason)s"""
2083
 
 
2084
 
    def __init__(self, tree, other_tree, reason):
2085
 
        self.tree = tree
2086
 
        self.other_tree = other_tree
2087
 
        self.reason = reason
2088
 
 
2089
 
 
2090
 
class SubsumeTargetNeedsUpgrade(BzrError):
2091
 
    
2092
 
    _fmt = """Subsume target %(other_tree)s needs to be upgraded."""
2093
 
 
2094
 
    def __init__(self, other_tree):
2095
 
        self.other_tree = other_tree
2096
 
 
2097
 
 
2098
 
class BadReferenceTarget(BzrError):
2099
 
 
2100
 
    _fmt = "Can't add reference to %(other_tree)s into %(tree)s.  %(reason)s"
2101
 
 
2102
 
    internal_error = True
2103
 
 
2104
 
    def __init__(self, tree, other_tree, reason):
2105
 
        self.tree = tree
2106
 
        self.other_tree = other_tree
2107
 
        self.reason = reason
2108
 
 
2109
 
 
2110
 
class NoSuchTag(BzrError):
2111
 
 
2112
 
    _fmt = "No such tag: %(tag_name)s"
2113
 
 
2114
 
    def __init__(self, tag_name):
2115
 
        self.tag_name = tag_name
2116
 
 
2117
 
 
2118
 
class TagsNotSupported(BzrError):
2119
 
 
2120
 
    _fmt = ("Tags not supported by %(branch)s;"
2121
 
            " you may be able to use bzr upgrade --dirstate-tags.")
2122
 
 
2123
 
    def __init__(self, branch):
2124
 
        self.branch = branch
2125
 
 
2126
 
        
2127
 
class TagAlreadyExists(BzrError):
2128
 
 
2129
 
    _fmt = "Tag %(tag_name)s already exists."
2130
 
 
2131
 
    def __init__(self, tag_name):
2132
 
        self.tag_name = tag_name
2133
 
 
2134
 
 
2135
 
class MalformedBugIdentifier(BzrError):
2136
 
 
2137
 
    _fmt = "Did not understand bug identifier %(bug_id)s: %(reason)s"
2138
 
 
2139
 
    def __init__(self, bug_id, reason):
2140
 
        self.bug_id = bug_id
2141
 
        self.reason = reason
2142
 
 
2143
 
 
2144
 
class UnknownBugTrackerAbbreviation(BzrError):
2145
 
 
2146
 
    _fmt = ("Cannot find registered bug tracker called %(abbreviation)s "
2147
 
            "on %(branch)s")
2148
 
 
2149
 
    def __init__(self, abbreviation, branch):
2150
 
        self.abbreviation = abbreviation
2151
 
        self.branch = branch
2152
 
 
2153
 
 
2154
 
class UnexpectedSmartServerResponse(BzrError):
2155
 
 
2156
 
    _fmt = "Could not understand response from smart server: %(response_tuple)r"
2157
 
 
2158
 
    def __init__(self, response_tuple):
2159
 
        self.response_tuple = response_tuple
2160
 
 
2161
 
 
2162
 
class ContainerError(BzrError):
2163
 
    """Base class of container errors."""
2164
 
 
2165
 
 
2166
 
class UnknownContainerFormatError(ContainerError):
2167
 
 
2168
 
    _fmt = "Unrecognised container format: %(container_format)r"
2169
 
    
2170
 
    def __init__(self, container_format):
2171
 
        self.container_format = container_format
2172
 
 
2173
 
 
2174
 
class UnexpectedEndOfContainerError(ContainerError):
2175
 
 
2176
 
    _fmt = "Unexpected end of container stream"
2177
 
 
2178
 
    internal_error = False
2179
 
 
2180
 
 
2181
 
class UnknownRecordTypeError(ContainerError):
2182
 
 
2183
 
    _fmt = "Unknown record type: %(record_type)r"
2184
 
 
2185
 
    def __init__(self, record_type):
2186
 
        self.record_type = record_type
2187
 
 
2188
 
 
2189
 
class InvalidRecordError(ContainerError):
2190
 
 
2191
 
    _fmt = "Invalid record: %(reason)s"
2192
 
 
2193
 
    def __init__(self, reason):
2194
 
        self.reason = reason
2195
 
 
2196
 
 
2197
 
class ContainerHasExcessDataError(ContainerError):
2198
 
 
2199
 
    _fmt = "Container has data after end marker: %(excess)r"
2200
 
 
2201
 
    def __init__(self, excess):
2202
 
        self.excess = excess
2203
 
 
2204
 
 
2205
 
class DuplicateRecordNameError(ContainerError):
2206
 
 
2207
 
    _fmt = "Container has multiple records with the same name: \"%(name)s\""
2208
 
 
2209
 
    def __init__(self, name):
2210
 
        self.name = name
2211
 
 
2212
 
 
2213
 
class NoDestinationAddress(BzrError):
2214
 
 
2215
 
    _fmt = "Message does not have a destination address."
2216
 
 
2217
 
    internal_error = True
2218
 
 
2219
 
 
2220
 
class SMTPError(BzrError):
2221
 
 
2222
 
    _fmt = "SMTP error: %(error)s"
2223
 
 
2224
 
    def __init__(self, error):
2225
 
        self.error = error
 
999
class NotABundle(BzrNewError):
 
1000
    """Not a bzr revision-bundle: %(text)r"""
 
1001
 
 
1002
    def __init__(self, text):
 
1003
        self.text = text
 
1004
 
 
1005
 
 
1006
class BadBundle(Exception): pass
 
1007
 
 
1008
 
 
1009
class MalformedHeader(BadBundle): pass
 
1010
 
 
1011
 
 
1012
class MalformedPatches(BadBundle): pass
 
1013
 
 
1014
 
 
1015
class MalformedFooter(BadBundle): pass