← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/errors.py

  • Committer: John Arbash Meinel
  • Date: 2006-10-11 00:23:23 UTC
  • mfrom: (2070 +trunk)
  • mto: This revision was merged to the branch mainline in revision 2071.
  • Revision ID: john@arbash-meinel.com-20061011002323-82ba88c293d7caff
[merge] bzr.dev 2070

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/errors.py
1
 
# Copyright (C) 2005, 2006, 2007 Canonical Ltd
 
1
# Copyright (C) 2005, 2006 Canonical
2
2
#
3
3
# This program is free software; you can redistribute it and/or modify
4
4
# it under the terms of the GNU General Public License as published by
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 '%s.%s' % (sys.exc_type.__module__, sys.exc_type.__name__)
 
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 (or absent) this was probably caused by a
52
 
    bzr bug and should be displayed with a traceback; if False 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
97
    
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
 
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=%s' \
106
 
                % (self.__class__.__name__,
107
 
                   self.__dict__,
108
 
                   getattr(self, '_fmt', None),
109
 
                   str(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
 
135
124
        # XXX: Use the underlying BzrError to always generate the args attribute
136
125
        # if it doesn't exist.  We can't use super here, because exceptions are
137
126
        # old-style classes in python2.4 (but new in 2.5).  --bmc, 20060426
138
 
        symbol_versioning.warn('BzrNewError was deprecated in bzr 0.13; '
139
 
             'please convert %s to use BzrError instead' 
140
 
             % self.__class__.__name__,
141
 
             DeprecationWarning,
142
 
             stacklevel=2)
143
127
        BzrError.__init__(self, *args)
144
128
        for key, value in kwds.items():
145
129
            setattr(self, key, value)
158
142
                   self.__dict__, str(e))
159
143
 
160
144
 
161
 
class AlreadyBuilding(BzrError):
162
 
    
163
 
    _fmt = "The tree builder is already building a tree."
164
 
 
165
 
 
166
 
class BzrCheckError(BzrError):
167
 
    
168
 
    _fmt = "Internal check failed: %(message)s"
169
 
 
170
 
    internal_error = True
 
145
class AlreadyBuilding(BzrNewError):
 
146
    """The tree builder is already building a tree."""
 
147
 
 
148
 
 
149
class BzrCheckError(BzrNewError):
 
150
    """Internal check failed: %(message)s"""
 
151
 
 
152
    is_user_error = False
171
153
 
172
154
    def __init__(self, message):
173
 
        BzrError.__init__(self)
 
155
        BzrNewError.__init__(self)
174
156
        self.message = message
175
157
 
176
158
 
177
 
class InvalidEntryName(BzrError):
178
 
    
179
 
    _fmt = "Invalid entry name: %(name)s"
 
159
class InvalidEntryName(BzrNewError):
 
160
    """Invalid entry name: %(name)s"""
180
161
 
181
 
    internal_error = True
 
162
    is_user_error = False
182
163
 
183
164
    def __init__(self, name):
184
 
        BzrError.__init__(self)
 
165
        BzrNewError.__init__(self)
185
166
        self.name = name
186
167
 
187
168
 
188
 
class InvalidRevisionNumber(BzrError):
189
 
    
190
 
    _fmt = "Invalid revision number %(revno)s"
191
 
 
 
169
class InvalidRevisionNumber(BzrNewError):
 
170
    """Invalid revision number %(revno)d"""
192
171
    def __init__(self, revno):
193
 
        BzrError.__init__(self)
 
172
        BzrNewError.__init__(self)
194
173
        self.revno = revno
195
174
 
196
175
 
197
 
class InvalidRevisionId(BzrError):
198
 
 
199
 
    _fmt = "Invalid revision-id {%(revision_id)s} in %(branch)s"
 
176
class InvalidRevisionId(BzrNewError):
 
177
    """Invalid revision-id {%(revision_id)s} in %(branch)s"""
200
178
 
201
179
    def __init__(self, revision_id, branch):
202
180
        # branch can be any string or object with __str__ defined
203
 
        BzrError.__init__(self)
 
181
        BzrNewError.__init__(self)
204
182
        self.revision_id = revision_id
205
183
        self.branch = branch
206
184
 
207
 
class ReservedId(BzrError):
208
 
 
209
 
    _fmt = "Reserved revision-id {%(revision_id)s}"
210
 
 
211
 
    def __init__(self, revision_id):
212
 
        self.revision_id = revision_id
213
 
 
214
 
class NoSuchId(BzrError):
215
 
 
216
 
    _fmt = "The file id %(file_id)s is not present in the tree %(tree)s."
 
185
 
 
186
class NoSuchId(BzrNewError):
 
187
    """The file id %(file_id)s is not present in the tree %(tree)s."""
217
188
    
218
189
    def __init__(self, tree, file_id):
219
 
        BzrError.__init__(self)
 
190
        BzrNewError.__init__(self)
220
191
        self.file_id = file_id
221
192
        self.tree = tree
222
193
 
223
194
 
224
 
class InventoryModified(BzrError):
225
 
 
226
 
    _fmt = ("The current inventory for the tree %(tree)r has been modified, "
227
 
            "so a clean inventory cannot be read without data loss.")
228
 
 
229
 
    internal_error = True
230
 
 
231
 
    def __init__(self, tree):
232
 
        self.tree = tree
233
 
 
234
 
 
235
 
class NoWorkingTree(BzrError):
236
 
 
237
 
    _fmt = "No WorkingTree exists for %(base)s."
 
195
class NoWorkingTree(BzrNewError):
 
196
    """No WorkingTree exists for %(base)s."""
238
197
    
239
198
    def __init__(self, base):
240
 
        BzrError.__init__(self)
 
199
        BzrNewError.__init__(self)
241
200
        self.base = base
242
201
 
243
202
 
244
 
class NotBuilding(BzrError):
245
 
 
246
 
    _fmt = "Not currently building a tree."
247
 
 
248
 
 
249
 
class NotLocalUrl(BzrError):
250
 
 
251
 
    _fmt = "%(url)s is not a local path."
252
 
 
 
203
class NotBuilding(BzrNewError):
 
204
    """Not currently building a tree."""
 
205
 
 
206
 
 
207
class NotLocalUrl(BzrNewError):
 
208
    """%(url)s is not a local path."""
 
209
    
253
210
    def __init__(self, url):
 
211
        BzrNewError.__init__(self)
254
212
        self.url = url
255
213
 
256
214
 
257
 
class WorkingTreeAlreadyPopulated(BzrError):
258
 
 
259
 
    _fmt = """Working tree already populated in %(base)s"""
260
 
 
261
 
    internal_error = True
262
 
 
263
 
    def __init__(self, base):
264
 
        self.base = base
265
 
 
266
 
class BzrCommandError(BzrError):
 
215
class BzrCommandError(BzrNewError):
267
216
    """Error from user command"""
268
217
 
269
 
    internal_error = False
 
218
    is_user_error = True
270
219
 
271
220
    # Error from malformed user command; please avoid raising this as a
272
221
    # generic exception not caused by user input.
287
236
        return self.msg
288
237
 
289
238
 
290
 
class NotWriteLocked(BzrError):
291
 
 
292
 
    _fmt = """%(not_locked)r is not write locked but needs to be."""
293
 
 
294
 
    def __init__(self, not_locked):
295
 
        self.not_locked = not_locked
296
 
 
297
 
 
298
239
class BzrOptionError(BzrCommandError):
299
 
 
300
 
    _fmt = "Error in command line options"
301
 
 
302
 
 
303
 
class BadOptionValue(BzrError):
304
 
 
305
 
    _fmt = """Bad value "%(value)s" for option "%(name)s"."""
306
 
 
307
 
    def __init__(self, name, value):
308
 
        BzrError.__init__(self, name=name, value=value)
 
240
    """Error in command line options"""
309
241
 
310
242
    
311
 
class StrictCommitFailed(BzrError):
312
 
 
313
 
    _fmt = "Commit refused because there are unknown files in the tree"
 
243
class StrictCommitFailed(BzrNewError):
 
244
    """Commit refused because there are unknown files in the tree"""
314
245
 
315
246
 
316
247
# XXX: Should be unified with TransportError; they seem to represent the
317
248
# same thing
318
 
class PathError(BzrError):
319
 
    
320
 
    _fmt = "Generic path error: %(path)r%(extra)s)"
 
249
class PathError(BzrNewError):
 
250
    """Generic path error: %(path)r%(extra)s)"""
321
251
 
322
252
    def __init__(self, path, extra=None):
323
 
        BzrError.__init__(self)
 
253
        BzrNewError.__init__(self)
324
254
        self.path = path
325
255
        if extra:
326
256
            self.extra = ': ' + str(extra)
329
259
 
330
260
 
331
261
class NoSuchFile(PathError):
332
 
 
333
 
    _fmt = "No such file: %(path)r%(extra)s"
 
262
    """No such file: %(path)r%(extra)s"""
334
263
 
335
264
 
336
265
class FileExists(PathError):
337
 
 
338
 
    _fmt = "File exists: %(path)r%(extra)s"
339
 
 
340
 
 
341
 
class RenameFailedFilesExist(BzrError):
342
 
    """Used when renaming and both source and dest exist."""
343
 
 
344
 
    _fmt = ("Could not rename %(source)s => %(dest)s because both files exist."
345
 
         "%(extra)s")
346
 
 
347
 
    def __init__(self, source, dest, extra=None):
348
 
        BzrError.__init__(self)
349
 
        self.source = str(source)
350
 
        self.dest = str(dest)
351
 
        if extra:
352
 
            self.extra = ' ' + str(extra)
353
 
        else:
354
 
            self.extra = ''
355
 
 
356
 
 
357
 
class NotADirectory(PathError):
358
 
 
359
 
    _fmt = "%(path)r is not a directory %(extra)s"
360
 
 
361
 
 
362
 
class NotInWorkingDirectory(PathError):
363
 
 
364
 
    _fmt = "%(path)r is not in the working directory %(extra)s"
 
266
    """File exists: %(path)r%(extra)s"""
365
267
 
366
268
 
367
269
class DirectoryNotEmpty(PathError):
368
 
 
369
 
    _fmt = "Directory not empty: %(path)r%(extra)s"
370
 
 
371
 
 
372
 
class ReadingCompleted(BzrError):
373
 
    
374
 
    _fmt = ("The MediumRequest '%(request)s' has already had finish_reading "
375
 
            "called upon it - the request has been completed and no more "
376
 
            "data may be read.")
377
 
 
378
 
    internal_error = True
379
 
 
380
 
    def __init__(self, request):
381
 
        self.request = request
 
270
    """Directory not empty: %(path)r%(extra)s"""
382
271
 
383
272
 
384
273
class ResourceBusy(PathError):
385
 
 
386
 
    _fmt = "Device or resource busy: %(path)r%(extra)s"
 
274
    """Device or resource busy: %(path)r%(extra)s"""
387
275
 
388
276
 
389
277
class PermissionDenied(PathError):
390
 
 
391
 
    _fmt = "Permission denied: %(path)r%(extra)s"
 
278
    """Permission denied: %(path)r%(extra)s"""
392
279
 
393
280
 
394
281
class InvalidURL(PathError):
395
 
 
396
 
    _fmt = "Invalid url supplied to transport: %(path)r%(extra)s"
 
282
    """Invalid url supplied to transport: %(path)r%(extra)s"""
397
283
 
398
284
 
399
285
class InvalidURLJoin(PathError):
400
 
 
401
 
    _fmt = "Invalid URL join request: %(args)s%(extra)s"
 
286
    """Invalid URL join request: %(args)s%(extra)s"""
402
287
 
403
288
    def __init__(self, msg, base, args):
404
289
        PathError.__init__(self, base, msg)
405
290
        self.args = [base] + list(args)
406
291
 
407
292
 
408
 
class UnknownHook(BzrError):
409
 
 
410
 
    _fmt = "The %(type)s hook '%(hook)s' is unknown in this version of bzrlib."
411
 
 
412
 
    def __init__(self, hook_type, hook_name):
413
 
        BzrError.__init__(self)
414
 
        self.type = hook_type
415
 
        self.hook = hook_name
416
 
 
417
 
 
418
293
class UnsupportedProtocol(PathError):
419
 
 
420
 
    _fmt = 'Unsupported protocol for url "%(path)s"%(extra)s'
 
294
    """Unsupported protocol for url "%(path)s"%(extra)s"""
421
295
 
422
296
    def __init__(self, url, extra):
423
297
        PathError.__init__(self, url, extra=extra)
424
298
 
425
299
 
426
300
class ShortReadvError(PathError):
427
 
 
428
 
    _fmt = "readv() read %(actual)s bytes rather than %(length)s bytes at %(offset)s for %(path)s%(extra)s"
429
 
 
430
 
    internal_error = True
 
301
    """readv() read %(actual)s bytes rather than %(length)s bytes at %(offset)s for %(path)s%(extra)s"""
 
302
 
 
303
    is_user_error = False
431
304
 
432
305
    def __init__(self, path, offset, length, actual, extra=None):
433
306
        PathError.__init__(self, path, extra=extra)
436
309
        self.actual = actual
437
310
 
438
311
 
439
 
class PathNotChild(BzrError):
440
 
 
441
 
    _fmt = "Path %(path)r is not a child of path %(base)r%(extra)s"
442
 
 
443
 
    internal_error = True
 
312
class PathNotChild(BzrNewError):
 
313
    """Path %(path)r is not a child of path %(base)r%(extra)s"""
 
314
 
 
315
    is_user_error = False
444
316
 
445
317
    def __init__(self, path, base, extra=None):
446
 
        BzrError.__init__(self)
 
318
        BzrNewError.__init__(self)
447
319
        self.path = path
448
320
        self.base = base
449
321
        if extra:
453
325
 
454
326
 
455
327
class InvalidNormalization(PathError):
456
 
 
457
 
    _fmt = "Path %(path)r is not unicode normalized"
 
328
    """Path %(path)r is not unicode normalized"""
458
329
 
459
330
 
460
331
# TODO: This is given a URL; we try to unescape it but doing that from inside
461
332
# the exception object is a bit undesirable.
462
333
# TODO: Probably this behavior of should be a common superclass 
463
334
class NotBranchError(PathError):
464
 
 
465
 
    _fmt = "Not a branch: %(path)s"
 
335
    """Not a branch: %(path)s"""
466
336
 
467
337
    def __init__(self, path):
468
338
       import bzrlib.urlutils as urlutils
470
340
 
471
341
 
472
342
class AlreadyBranchError(PathError):
473
 
 
474
 
    _fmt = "Already a branch: %(path)s."
 
343
    """Already a branch: %(path)s."""
475
344
 
476
345
 
477
346
class BranchExistsWithoutWorkingTree(PathError):
478
 
 
479
 
    _fmt = "Directory contains a branch, but no working tree \
480
 
(use bzr checkout if you wish to build a working tree): %(path)s"
 
347
    """Directory contains a branch, but no working tree \
 
348
(use bzr checkout if you wish to build a working tree): %(path)s"""
481
349
 
482
350
 
483
351
class AtomicFileAlreadyClosed(PathError):
484
 
 
485
 
    _fmt = "'%(function)s' called on an AtomicFile after it was closed: %(path)s"
 
352
    """'%(function)s' called on an AtomicFile after it was closed: %(path)s"""
486
353
 
487
354
    def __init__(self, path, function):
488
355
        PathError.__init__(self, path=path, extra=None)
490
357
 
491
358
 
492
359
class InaccessibleParent(PathError):
493
 
 
494
 
    _fmt = "Parent not accessible given base %(base)s and relative path %(path)s"
 
360
    """Parent not accessible given base %(base)s and relative path %(path)s"""
495
361
 
496
362
    def __init__(self, path, base):
497
363
        PathError.__init__(self, path)
498
364
        self.base = base
499
365
 
500
366
 
501
 
class NoRepositoryPresent(BzrError):
502
 
 
503
 
    _fmt = "No repository present: %(path)r"
 
367
class NoRepositoryPresent(BzrNewError):
 
368
    """No repository present: %(path)r"""
504
369
    def __init__(self, bzrdir):
505
 
        BzrError.__init__(self)
 
370
        BzrNewError.__init__(self)
506
371
        self.path = bzrdir.transport.clone('..').base
507
372
 
508
373
 
509
 
class FileInWrongBranch(BzrError):
510
 
 
511
 
    _fmt = "File %(path)s in not in branch %(branch_base)s."
 
374
class FileInWrongBranch(BzrNewError):
 
375
    """File %(path)s in not in branch %(branch_base)s."""
512
376
 
513
377
    def __init__(self, branch, path):
514
 
        BzrError.__init__(self)
 
378
        BzrNewError.__init__(self)
515
379
        self.branch = branch
516
380
        self.branch_base = branch.base
517
381
        self.path = path
518
382
 
519
383
 
520
 
class UnsupportedFormatError(BzrError):
521
 
    
522
 
    _fmt = "Unsupported branch format: %(format)s"
523
 
 
524
 
 
525
 
class UnknownFormatError(BzrError):
526
 
    
527
 
    _fmt = "Unknown branch format: %(format)r"
528
 
 
529
 
 
530
 
class IncompatibleFormat(BzrError):
531
 
    
532
 
    _fmt = "Format %(format)s is not compatible with .bzr version %(bzrdir)s."
 
384
class UnsupportedFormatError(BzrNewError):
 
385
    """Unsupported branch format: %(format)s"""
 
386
 
 
387
 
 
388
class UnknownFormatError(BzrNewError):
 
389
    """Unknown branch format: %(format)r"""
 
390
 
 
391
 
 
392
class IncompatibleFormat(BzrNewError):
 
393
    """Format %(format)s is not compatible with .bzr version %(bzrdir)s."""
533
394
 
534
395
    def __init__(self, format, bzrdir_format):
535
 
        BzrError.__init__(self)
 
396
        BzrNewError.__init__(self)
536
397
        self.format = format
537
398
        self.bzrdir = bzrdir_format
538
399
 
539
400
 
540
 
class IncompatibleRevision(BzrError):
541
 
    
542
 
    _fmt = "Revision is not compatible with %(repo_format)s"
 
401
class IncompatibleRevision(BzrNewError):
 
402
    """Revision is not compatible with %(repo_format)s"""
543
403
 
544
404
    def __init__(self, repo_format):
545
 
        BzrError.__init__(self)
 
405
        BzrNewError.__init__(self)
546
406
        self.repo_format = repo_format
547
407
 
548
408
 
549
 
class AlreadyVersionedError(BzrError):
550
 
    """Used when a path is expected not to be versioned, but it is."""
551
 
 
552
 
    _fmt = "%(context_info)s%(path)s is already versioned"
553
 
 
554
 
    def __init__(self, path, context_info=None):
555
 
        """Construct a new AlreadyVersionedError.
556
 
 
557
 
        :param path: This is the path which is versioned,
558
 
        which should be in a user friendly form.
559
 
        :param context_info: If given, this is information about the context,
560
 
        which could explain why this is expected to not be versioned.
561
 
        """
562
 
        BzrError.__init__(self)
563
 
        self.path = path
564
 
        if context_info is None:
565
 
            self.context_info = ''
566
 
        else:
567
 
            self.context_info = context_info + ". "
568
 
 
569
 
 
570
 
class NotVersionedError(BzrError):
571
 
    """Used when a path is expected to be versioned, but it is not."""
572
 
 
573
 
    _fmt = "%(context_info)s%(path)s is not versioned"
574
 
 
575
 
    def __init__(self, path, context_info=None):
576
 
        """Construct a new NotVersionedError.
577
 
 
578
 
        :param path: This is the path which is not versioned,
579
 
        which should be in a user friendly form.
580
 
        :param context_info: If given, this is information about the context,
581
 
        which could explain why this is expected to be versioned.
582
 
        """
583
 
        BzrError.__init__(self)
584
 
        self.path = path
585
 
        if context_info is None:
586
 
            self.context_info = ''
587
 
        else:
588
 
            self.context_info = context_info + ". "
589
 
 
590
 
 
591
 
class PathsNotVersionedError(BzrError):
592
 
    """Used when reporting several paths which are not versioned"""
593
 
 
594
 
    _fmt = "Path(s) are not versioned: %(paths_as_string)s"
 
409
class NotVersionedError(BzrNewError):
 
410
    """%(path)s is not versioned"""
 
411
    def __init__(self, path):
 
412
        BzrNewError.__init__(self)
 
413
        self.path = path
 
414
 
 
415
 
 
416
class PathsNotVersionedError(BzrNewError):
 
417
    # used when reporting several paths are not versioned
 
418
    """Path(s) are not versioned: %(paths_as_string)s"""
595
419
 
596
420
    def __init__(self, paths):
597
421
        from bzrlib.osutils import quotefn
598
 
        BzrError.__init__(self)
 
422
        BzrNewError.__init__(self)
599
423
        self.paths = paths
600
424
        self.paths_as_string = ' '.join([quotefn(p) for p in paths])
601
425
 
602
426
 
603
 
class PathsDoNotExist(BzrError):
604
 
 
605
 
    _fmt = "Path(s) do not exist: %(paths_as_string)s%(extra)s"
 
427
class PathsDoNotExist(BzrNewError):
 
428
    """Path(s) do not exist: %(paths_as_string)s"""
606
429
 
607
430
    # used when reporting that paths are neither versioned nor in the working
608
431
    # tree
609
432
 
610
 
    def __init__(self, paths, extra=None):
 
433
    def __init__(self, paths):
611
434
        # circular import
612
435
        from bzrlib.osutils import quotefn
613
 
        BzrError.__init__(self)
 
436
        BzrNewError.__init__(self)
614
437
        self.paths = paths
615
438
        self.paths_as_string = ' '.join([quotefn(p) for p in paths])
616
 
        if extra:
617
 
            self.extra = ': ' + str(extra)
618
 
        else:
619
 
            self.extra = ''
620
 
 
621
 
 
622
 
class BadFileKindError(BzrError):
623
 
 
624
 
    _fmt = 'Cannot operate on "%(filename)s" of unsupported kind "%(kind)s"'
625
 
 
626
 
    def __init__(self, filename, kind):
627
 
        BzrError.__init__(self, filename=filename, kind=kind)
628
 
 
629
 
 
630
 
class ForbiddenControlFileError(BzrError):
631
 
 
632
 
    _fmt = "Cannot operate on %(filename)s because it is a control file"
633
 
 
634
 
 
635
 
class LockError(BzrError):
636
 
 
637
 
    _fmt = "Lock error: %(message)s"
638
 
 
639
 
    internal_error = True
640
 
 
 
439
 
 
440
 
 
441
class BadFileKindError(BzrNewError):
 
442
    """Cannot operate on %(filename)s of unsupported kind %(kind)s"""
 
443
 
 
444
 
 
445
class ForbiddenControlFileError(BzrNewError):
 
446
    """Cannot operate on %(filename)s because it is a control file"""
 
447
 
 
448
 
 
449
class LockError(BzrNewError):
 
450
    """Lock error: %(message)s"""
641
451
    # All exceptions from the lock/unlock functions should be from
642
452
    # this exception class.  They will be translated as necessary. The
643
453
    # original exception is available as e.original_error
647
457
        self.message = message
648
458
 
649
459
 
650
 
class LockActive(LockError):
651
 
 
652
 
    _fmt = "The lock for '%(lock_description)s' is in use and cannot be broken."
653
 
 
654
 
    internal_error = False
655
 
 
656
 
    def __init__(self, lock_description):
657
 
        self.lock_description = lock_description
658
 
 
659
 
 
660
460
class CommitNotPossible(LockError):
661
 
 
662
 
    _fmt = "A commit was attempted but we do not have a write lock open."
663
 
 
 
461
    """A commit was attempted but we do not have a write lock open."""
664
462
    def __init__(self):
665
463
        pass
666
464
 
667
465
 
668
466
class AlreadyCommitted(LockError):
669
 
 
670
 
    _fmt = "A rollback was requested, but is not able to be accomplished."
671
 
 
 
467
    """A rollback was requested, but is not able to be accomplished."""
672
468
    def __init__(self):
673
469
        pass
674
470
 
675
471
 
676
472
class ReadOnlyError(LockError):
677
 
 
678
 
    _fmt = "A write attempt was made in a read only transaction on %(obj)s"
679
 
 
680
 
    # TODO: There should also be an error indicating that you need a write
681
 
    # lock and don't have any lock at all... mbp 20070226
682
 
 
 
473
    """A write attempt was made in a read only transaction on %(obj)s"""
683
474
    def __init__(self, obj):
684
475
        self.obj = obj
685
476
 
686
477
 
687
 
class OutSideTransaction(BzrError):
688
 
 
689
 
    _fmt = "A transaction related operation was attempted after the transaction finished."
 
478
class OutSideTransaction(BzrNewError):
 
479
    """A transaction related operation was attempted after the transaction finished."""
690
480
 
691
481
 
692
482
class ObjectNotLocked(LockError):
 
483
    """%(obj)r is not locked"""
693
484
 
694
 
    _fmt = "%(obj)r is not locked"
 
485
    is_user_error = False
695
486
 
696
487
    # this can indicate that any particular object is not locked; see also
697
488
    # LockNotHeld which means that a particular *lock* object is not held by
701
492
 
702
493
 
703
494
class ReadOnlyObjectDirtiedError(ReadOnlyError):
704
 
 
705
 
    _fmt = "Cannot change object %(obj)r in read only transaction"
706
 
 
 
495
    """Cannot change object %(obj)r in read only transaction"""
707
496
    def __init__(self, obj):
708
497
        self.obj = obj
709
498
 
710
499
 
711
500
class UnlockableTransport(LockError):
712
 
 
713
 
    _fmt = "Cannot lock: transport is read only: %(transport)s"
714
 
 
 
501
    """Cannot lock: transport is read only: %(transport)s"""
715
502
    def __init__(self, transport):
716
503
        self.transport = transport
717
504
 
718
505
 
719
506
class LockContention(LockError):
720
 
 
721
 
    _fmt = "Could not acquire lock %(lock)s"
722
 
    # TODO: show full url for lock, combining the transport and relative
723
 
    # bits?
724
 
 
725
 
    internal_error = False
726
 
    
 
507
    """Could not acquire lock %(lock)s"""
 
508
    # TODO: show full url for lock, combining the transport and relative bits?
727
509
    def __init__(self, lock):
728
510
        self.lock = lock
729
511
 
730
512
 
731
513
class LockBroken(LockError):
732
 
 
733
 
    _fmt = "Lock was broken while still open: %(lock)s - check storage consistency!"
734
 
 
735
 
    internal_error = False
736
 
 
 
514
    """Lock was broken while still open: %(lock)s - check storage consistency!"""
737
515
    def __init__(self, lock):
738
516
        self.lock = lock
739
517
 
740
518
 
741
519
class LockBreakMismatch(LockError):
742
 
 
743
 
    _fmt = "Lock was released and re-acquired before being broken: %(lock)s: held by %(holder)r, wanted to break %(target)r"
744
 
 
745
 
    internal_error = False
746
 
 
 
520
    """Lock was released and re-acquired before being broken: %(lock)s: held by %(holder)r, wanted to break %(target)r"""
747
521
    def __init__(self, lock, holder, target):
748
522
        self.lock = lock
749
523
        self.holder = holder
751
525
 
752
526
 
753
527
class LockNotHeld(LockError):
754
 
 
755
 
    _fmt = "Lock not held: %(lock)s"
756
 
 
757
 
    internal_error = False
758
 
 
 
528
    """Lock not held: %(lock)s"""
759
529
    def __init__(self, lock):
760
530
        self.lock = lock
761
531
 
762
532
 
763
 
class PointlessCommit(BzrError):
764
 
 
765
 
    _fmt = "No changes to commit"
766
 
 
767
 
 
768
 
class UpgradeReadonly(BzrError):
769
 
 
770
 
    _fmt = "Upgrade URL cannot work with readonly URLs."
771
 
 
772
 
 
773
 
class UpToDateFormat(BzrError):
774
 
 
775
 
    _fmt = "The branch format %(format)s is already at the most recent format."
 
533
class PointlessCommit(BzrNewError):
 
534
    """No changes to commit"""
 
535
 
 
536
 
 
537
class UpgradeReadonly(BzrNewError):
 
538
    """Upgrade URL cannot work with readonly URL's."""
 
539
 
 
540
 
 
541
class UpToDateFormat(BzrNewError):
 
542
    """The branch format %(format)s is already at the most recent format."""
776
543
 
777
544
    def __init__(self, format):
778
 
        BzrError.__init__(self)
 
545
        BzrNewError.__init__(self)
779
546
        self.format = format
780
547
 
781
548
 
782
549
class StrictCommitFailed(Exception):
783
 
 
784
 
    _fmt = "Commit refused because there are unknowns in the tree."
785
 
 
786
 
 
787
 
class NoSuchRevision(BzrError):
788
 
 
789
 
    _fmt = "Branch %(branch)s has no revision %(revision)s"
790
 
 
791
 
    internal_error = True
 
550
    """Commit refused because there are unknowns in the tree."""
 
551
 
 
552
 
 
553
class NoSuchRevision(BzrNewError):
 
554
    """Branch %(branch)s has no revision %(revision)s"""
 
555
 
 
556
    is_user_error = False
792
557
 
793
558
    def __init__(self, branch, revision):
794
 
        BzrError.__init__(self, branch=branch, revision=revision)
795
 
 
796
 
 
797
 
class NotLeftParentDescendant(BzrError):
798
 
 
799
 
    _fmt = "Revision %(old_revision)s is not the left parent of"\
800
 
        " %(new_revision)s, but branch %(branch_location)s expects this"
801
 
 
802
 
    internal_error = True
803
 
 
804
 
    def __init__(self, branch, old_revision, new_revision):
805
 
        BzrError.__init__(self, branch_location=branch.base,
806
 
                          old_revision=old_revision,
807
 
                          new_revision=new_revision)
808
 
 
809
 
 
810
 
class NoSuchRevisionSpec(BzrError):
811
 
 
812
 
    _fmt = "No namespace registered for string: %(spec)r"
 
559
        BzrNewError.__init__(self, branch=branch, revision=revision)
 
560
 
 
561
 
 
562
class NoSuchRevisionSpec(BzrNewError):
 
563
    """No namespace registered for string: %(spec)r"""
813
564
 
814
565
    def __init__(self, spec):
815
 
        BzrError.__init__(self, spec=spec)
816
 
 
817
 
 
818
 
class NoSuchRevisionInTree(NoSuchRevision):
819
 
    """When using Tree.revision_tree, and the revision is not accessible."""
820
 
    
821
 
    _fmt = "The revision id %(revision_id)s is not present in the tree %(tree)s."
822
 
 
823
 
    def __init__(self, tree, revision_id):
824
 
        BzrError.__init__(self)
825
 
        self.tree = tree
826
 
        self.revision_id = revision_id
827
 
 
828
 
 
829
 
class InvalidRevisionSpec(BzrError):
830
 
 
831
 
    _fmt = "Requested revision: %(spec)r does not exist in branch: %(branch)s%(extra)s"
 
566
        BzrNewError.__init__(self, spec=spec)
 
567
 
 
568
 
 
569
class InvalidRevisionSpec(BzrNewError):
 
570
    """Requested revision: '%(spec)s' does not exist in branch:
 
571
%(branch)s%(extra)s"""
832
572
 
833
573
    def __init__(self, spec, branch, extra=None):
834
 
        BzrError.__init__(self, branch=branch, spec=spec)
 
574
        BzrNewError.__init__(self, branch=branch, spec=spec)
835
575
        if extra:
836
576
            self.extra = '\n' + str(extra)
837
577
        else:
839
579
 
840
580
 
841
581
class HistoryMissing(BzrError):
842
 
 
843
 
    _fmt = "%(branch)s is missing %(object_type)s {%(object_id)s}"
844
 
 
845
 
 
846
 
class AppendRevisionsOnlyViolation(BzrError):
847
 
 
848
 
    _fmt = 'Operation denied because it would change the main history, '\
849
 
           'which is not permitted by the append_revisions_only setting on'\
850
 
           ' branch "%(location)s".'
851
 
 
852
 
    def __init__(self, location):
853
 
       import bzrlib.urlutils as urlutils
854
 
       location = urlutils.unescape_for_display(location, 'ascii')
855
 
       BzrError.__init__(self, location=location)
856
 
 
857
 
 
858
 
class DivergedBranches(BzrError):
859
 
    
860
 
    _fmt = "These branches have diverged.  Use the merge command to reconcile them."""
861
 
 
862
 
    internal_error = False
 
582
    def __init__(self, branch, object_type, object_id):
 
583
        self.branch = branch
 
584
        BzrError.__init__(self,
 
585
                          '%s is missing %s {%s}'
 
586
                          % (branch, object_type, object_id))
 
587
 
 
588
 
 
589
class DivergedBranches(BzrNewError):
 
590
    "These branches have diverged.  Use the merge command to reconcile them."""
 
591
 
 
592
    is_user_error = True
863
593
 
864
594
    def __init__(self, branch1, branch2):
865
595
        self.branch1 = branch1
866
596
        self.branch2 = branch2
867
597
 
868
598
 
869
 
class NotLefthandHistory(BzrError):
870
 
 
871
 
    _fmt = "Supplied history does not follow left-hand parents"
872
 
 
873
 
    internal_error = True
874
 
 
875
 
    def __init__(self, history):
876
 
        BzrError.__init__(self, history=history)
877
 
 
878
 
 
879
 
class UnrelatedBranches(BzrError):
880
 
 
881
 
    _fmt = "Branches have no common ancestor, and no merge base revision was specified."
882
 
 
883
 
    internal_error = False
884
 
 
885
 
 
886
 
class NoCommonAncestor(BzrError):
887
 
    
888
 
    _fmt = "Revisions have no common ancestor: %(revision_a)s %(revision_b)s"
 
599
class UnrelatedBranches(BzrNewError):
 
600
    "Branches have no common ancestor, and no merge base revision was specified."
 
601
 
 
602
    is_user_error = True
 
603
 
 
604
 
 
605
class NoCommonAncestor(BzrNewError):
 
606
    "Revisions have no common ancestor: %(revision_a)s %(revision_b)s"
889
607
 
890
608
    def __init__(self, revision_a, revision_b):
891
609
        self.revision_a = revision_a
893
611
 
894
612
 
895
613
class NoCommonRoot(BzrError):
896
 
 
897
 
    _fmt = "Revisions are not derived from the same root: " \
898
 
           "%(revision_a)s %(revision_b)s."
899
 
 
900
614
    def __init__(self, revision_a, revision_b):
901
 
        BzrError.__init__(self, revision_a=revision_a, revision_b=revision_b)
 
615
        msg = "Revisions are not derived from the same root: %s %s." \
 
616
            % (revision_a, revision_b) 
 
617
        BzrError.__init__(self, msg)
 
618
 
902
619
 
903
620
 
904
621
class NotAncestor(BzrError):
905
 
 
906
 
    _fmt = "Revision %(rev_id)s is not an ancestor of %(not_ancestor_id)s"
907
 
 
908
622
    def __init__(self, rev_id, not_ancestor_id):
909
 
        BzrError.__init__(self, rev_id=rev_id,
910
 
            not_ancestor_id=not_ancestor_id)
 
623
        msg = "Revision %s is not an ancestor of %s" % (not_ancestor_id, 
 
624
                                                        rev_id)
 
625
        BzrError.__init__(self, msg)
 
626
        self.rev_id = rev_id
 
627
        self.not_ancestor_id = not_ancestor_id
911
628
 
912
629
 
913
630
class InstallFailed(BzrError):
914
 
 
915
631
    def __init__(self, revisions):
916
 
        revision_str = ", ".join(str(r) for r in revisions)
917
 
        msg = "Could not install revisions:\n%s" % revision_str
 
632
        msg = "Could not install revisions:\n%s" % " ,".join(revisions)
918
633
        BzrError.__init__(self, msg)
919
634
        self.revisions = revisions
920
635
 
921
636
 
922
637
class AmbiguousBase(BzrError):
923
 
 
924
638
    def __init__(self, bases):
925
639
        warn("BzrError AmbiguousBase has been deprecated as of bzrlib 0.8.",
926
640
                DeprecationWarning)
930
644
        self.bases = bases
931
645
 
932
646
 
933
 
class NoCommits(BzrError):
934
 
 
935
 
    _fmt = "Branch %(branch)s has no commits."
 
647
class NoCommits(BzrNewError):
 
648
    """Branch %(branch)s has no commits."""
936
649
 
937
650
    def __init__(self, branch):
938
 
        BzrError.__init__(self, branch=branch)
 
651
        BzrNewError.__init__(self, branch=branch)
939
652
 
940
653
 
941
654
class UnlistableStore(BzrError):
942
 
 
943
655
    def __init__(self, store):
944
656
        BzrError.__init__(self, "Store %s is not listable" % store)
945
657
 
946
658
 
947
659
 
948
660
class UnlistableBranch(BzrError):
949
 
 
950
661
    def __init__(self, br):
951
662
        BzrError.__init__(self, "Stores for branch %s are not listable" % br)
952
663
 
953
664
 
954
 
class BoundBranchOutOfDate(BzrError):
955
 
 
956
 
    _fmt = "Bound branch %(branch)s is out of date with master branch %(master)s."
957
 
 
 
665
class BoundBranchOutOfDate(BzrNewError):
 
666
    """Bound branch %(branch)s is out of date with master branch %(master)s."""
958
667
    def __init__(self, branch, master):
959
 
        BzrError.__init__(self)
 
668
        BzrNewError.__init__(self)
960
669
        self.branch = branch
961
670
        self.master = master
962
671
 
963
672
        
964
 
class CommitToDoubleBoundBranch(BzrError):
965
 
 
966
 
    _fmt = "Cannot commit to branch %(branch)s. It is bound to %(master)s, which is bound to %(remote)s."
967
 
 
 
673
class CommitToDoubleBoundBranch(BzrNewError):
 
674
    """Cannot commit to branch %(branch)s. It is bound to %(master)s, which is bound to %(remote)s."""
968
675
    def __init__(self, branch, master, remote):
969
 
        BzrError.__init__(self)
 
676
        BzrNewError.__init__(self)
970
677
        self.branch = branch
971
678
        self.master = master
972
679
        self.remote = remote
973
680
 
974
681
 
975
 
class OverwriteBoundBranch(BzrError):
976
 
 
977
 
    _fmt = "Cannot pull --overwrite to a branch which is bound %(branch)s"
978
 
 
 
682
class OverwriteBoundBranch(BzrNewError):
 
683
    """Cannot pull --overwrite to a branch which is bound %(branch)s"""
979
684
    def __init__(self, branch):
980
 
        BzrError.__init__(self)
 
685
        BzrNewError.__init__(self)
981
686
        self.branch = branch
982
687
 
983
688
 
984
 
class BoundBranchConnectionFailure(BzrError):
985
 
 
986
 
    _fmt = "Unable to connect to target of bound branch %(branch)s => %(target)s: %(error)s"
987
 
 
 
689
class BoundBranchConnectionFailure(BzrNewError):
 
690
    """Unable to connect to target of bound branch %(branch)s => %(target)s: %(error)s"""
988
691
    def __init__(self, branch, target, error):
989
 
        BzrError.__init__(self)
 
692
        BzrNewError.__init__(self)
990
693
        self.branch = branch
991
694
        self.target = target
992
695
        self.error = error
993
696
 
994
697
 
995
 
class WeaveError(BzrError):
996
 
 
997
 
    _fmt = "Error in processing weave: %(message)s"
 
698
class WeaveError(BzrNewError):
 
699
    """Error in processing weave: %(message)s"""
998
700
 
999
701
    def __init__(self, message=None):
1000
 
        BzrError.__init__(self)
 
702
        BzrNewError.__init__(self)
1001
703
        self.message = message
1002
704
 
1003
705
 
1004
706
class WeaveRevisionAlreadyPresent(WeaveError):
1005
 
 
1006
 
    _fmt = "Revision {%(revision_id)s} already present in %(weave)s"
1007
 
 
 
707
    """Revision {%(revision_id)s} already present in %(weave)s"""
1008
708
    def __init__(self, revision_id, weave):
1009
709
 
1010
710
        WeaveError.__init__(self)
1013
713
 
1014
714
 
1015
715
class WeaveRevisionNotPresent(WeaveError):
1016
 
 
1017
 
    _fmt = "Revision {%(revision_id)s} not present in %(weave)s"
 
716
    """Revision {%(revision_id)s} not present in %(weave)s"""
1018
717
 
1019
718
    def __init__(self, revision_id, weave):
1020
719
        WeaveError.__init__(self)
1023
722
 
1024
723
 
1025
724
class WeaveFormatError(WeaveError):
1026
 
 
1027
 
    _fmt = "Weave invariant violated: %(what)s"
 
725
    """Weave invariant violated: %(what)s"""
1028
726
 
1029
727
    def __init__(self, what):
1030
728
        WeaveError.__init__(self)
1032
730
 
1033
731
 
1034
732
class WeaveParentMismatch(WeaveError):
1035
 
 
1036
 
    _fmt = "Parents are mismatched between two revisions."
 
733
    """Parents are mismatched between two revisions."""
1037
734
    
1038
735
 
1039
736
class WeaveInvalidChecksum(WeaveError):
1040
 
 
1041
 
    _fmt = "Text did not match it's checksum: %(message)s"
1042
 
 
1043
 
 
1044
 
class WeaveTextDiffers(WeaveError):
1045
 
 
1046
 
    _fmt = "Weaves differ on text content. Revision: {%(revision_id)s}, %(weave_a)s, %(weave_b)s"
1047
 
 
1048
 
    def __init__(self, revision_id, weave_a, weave_b):
1049
 
        WeaveError.__init__(self)
1050
 
        self.revision_id = revision_id
1051
 
        self.weave_a = weave_a
1052
 
        self.weave_b = weave_b
1053
 
 
1054
 
 
1055
 
class WeaveTextDiffers(WeaveError):
1056
 
 
1057
 
    _fmt = "Weaves differ on text content. Revision: {%(revision_id)s}, %(weave_a)s, %(weave_b)s"
1058
 
 
1059
 
    def __init__(self, revision_id, weave_a, weave_b):
1060
 
        WeaveError.__init__(self)
1061
 
        self.revision_id = revision_id
1062
 
        self.weave_a = weave_a
1063
 
        self.weave_b = weave_b
1064
 
 
1065
 
 
1066
 
class VersionedFileError(BzrError):
1067
 
    
1068
 
    _fmt = "Versioned file error"
 
737
    """Text did not match it's checksum: %(message)s"""
 
738
 
 
739
 
 
740
class WeaveTextDiffers(WeaveError):
 
741
    """Weaves differ on text content. Revision: {%(revision_id)s}, %(weave_a)s, %(weave_b)s"""
 
742
 
 
743
    def __init__(self, revision_id, weave_a, weave_b):
 
744
        WeaveError.__init__(self)
 
745
        self.revision_id = revision_id
 
746
        self.weave_a = weave_a
 
747
        self.weave_b = weave_b
 
748
 
 
749
 
 
750
class WeaveTextDiffers(WeaveError):
 
751
    """Weaves differ on text content. Revision: {%(revision_id)s}, %(weave_a)s, %(weave_b)s"""
 
752
 
 
753
    def __init__(self, revision_id, weave_a, weave_b):
 
754
        WeaveError.__init__(self)
 
755
        self.revision_id = revision_id
 
756
        self.weave_a = weave_a
 
757
        self.weave_b = weave_b
 
758
 
 
759
 
 
760
class VersionedFileError(BzrNewError):
 
761
    """Versioned file error."""
1069
762
 
1070
763
 
1071
764
class RevisionNotPresent(VersionedFileError):
1072
 
    
1073
 
    _fmt = "Revision {%(revision_id)s} not present in %(file_id)s."
 
765
    """Revision {%(revision_id)s} not present in %(file_id)s."""
1074
766
 
1075
767
    def __init__(self, revision_id, file_id):
1076
768
        VersionedFileError.__init__(self)
1079
771
 
1080
772
 
1081
773
class RevisionAlreadyPresent(VersionedFileError):
1082
 
    
1083
 
    _fmt = "Revision {%(revision_id)s} already present in %(file_id)s."
 
774
    """Revision {%(revision_id)s} already present in %(file_id)s."""
1084
775
 
1085
776
    def __init__(self, revision_id, file_id):
1086
777
        VersionedFileError.__init__(self)
1088
779
        self.file_id = file_id
1089
780
 
1090
781
 
1091
 
class KnitError(BzrError):
1092
 
    
1093
 
    _fmt = "Knit error"
1094
 
 
1095
 
    internal_error = True
 
782
class KnitError(BzrNewError):
 
783
    """Knit error"""
1096
784
 
1097
785
 
1098
786
class KnitHeaderError(KnitError):
1099
 
 
1100
 
    _fmt = "Knit header error: %(badline)r unexpected for file %(filename)s"
1101
 
 
1102
 
    def __init__(self, badline, filename):
 
787
    """Knit header error: %(badline)r unexpected"""
 
788
 
 
789
    def __init__(self, badline):
1103
790
        KnitError.__init__(self)
1104
791
        self.badline = badline
1105
 
        self.filename = filename
1106
792
 
1107
793
 
1108
794
class KnitCorrupt(KnitError):
1109
 
 
1110
 
    _fmt = "Knit %(filename)s corrupt: %(how)s"
 
795
    """Knit %(filename)s corrupt: %(how)s"""
1111
796
 
1112
797
    def __init__(self, filename, how):
1113
798
        KnitError.__init__(self)
1115
800
        self.how = how
1116
801
 
1117
802
 
1118
 
class KnitIndexUnknownMethod(KnitError):
1119
 
    """Raised when we don't understand the storage method.
1120
 
 
1121
 
    Currently only 'fulltext' and 'line-delta' are supported.
1122
 
    """
1123
 
    
1124
 
    _fmt = ("Knit index %(filename)s does not have a known method"
1125
 
            " in options: %(options)r")
1126
 
 
1127
 
    def __init__(self, filename, options):
1128
 
        KnitError.__init__(self)
1129
 
        self.filename = filename
1130
 
        self.options = options
1131
 
 
1132
 
 
1133
 
class NoSuchExportFormat(BzrError):
1134
 
    
1135
 
    _fmt = "Export format %(format)r not supported"
1136
 
 
 
803
class NoSuchExportFormat(BzrNewError):
 
804
    """Export format %(format)r not supported"""
1137
805
    def __init__(self, format):
1138
 
        BzrError.__init__(self)
 
806
        BzrNewError.__init__(self)
1139
807
        self.format = format
1140
808
 
1141
809
 
1142
 
class TransportError(BzrError):
1143
 
    
1144
 
    _fmt = "Transport error: %(msg)s %(orig_error)s"
 
810
class TransportError(BzrNewError):
 
811
    """Transport error: %(msg)s %(orig_error)s"""
1145
812
 
1146
813
    def __init__(self, msg=None, orig_error=None):
1147
814
        if msg is None and orig_error is not None:
1152
819
            msg =  ''
1153
820
        self.msg = msg
1154
821
        self.orig_error = orig_error
1155
 
        BzrError.__init__(self)
1156
 
 
1157
 
 
1158
 
class TooManyConcurrentRequests(BzrError):
1159
 
 
1160
 
    _fmt = ("The medium '%(medium)s' has reached its concurrent request limit. "
1161
 
            "Be sure to finish_writing and finish_reading on the "
1162
 
            "current request that is open.")
1163
 
 
1164
 
    internal_error = True
1165
 
 
1166
 
    def __init__(self, medium):
1167
 
        self.medium = medium
 
822
        BzrNewError.__init__(self)
1168
823
 
1169
824
 
1170
825
class SmartProtocolError(TransportError):
1171
 
 
1172
 
    _fmt = "Generic bzr smart protocol error: %(details)s"
 
826
    """Generic bzr smart protocol error: %(details)s"""
1173
827
 
1174
828
    def __init__(self, details):
1175
829
        self.details = details
1177
831
 
1178
832
# A set of semi-meaningful errors which can be thrown
1179
833
class TransportNotPossible(TransportError):
1180
 
 
1181
 
    _fmt = "Transport operation not possible: %(msg)s %(orig_error)s"
 
834
    """Transport operation not possible: %(msg)s %(orig_error)s"""
1182
835
 
1183
836
 
1184
837
class ConnectionError(TransportError):
1185
 
 
1186
 
    _fmt = "Connection error: %(msg)s %(orig_error)s"
1187
 
 
1188
 
 
1189
 
class SocketConnectionError(ConnectionError):
1190
 
 
1191
 
    _fmt = "%(msg)s %(host)s%(port)s%(orig_error)s"
1192
 
 
1193
 
    def __init__(self, host, port=None, msg=None, orig_error=None):
1194
 
        if msg is None:
1195
 
            msg = 'Failed to connect to'
1196
 
        if orig_error is None:
1197
 
            orig_error = ''
1198
 
        else:
1199
 
            orig_error = '; ' + str(orig_error)
1200
 
        ConnectionError.__init__(self, msg=msg, orig_error=orig_error)
1201
 
        self.host = host
1202
 
        if port is None:
1203
 
            self.port = ''
1204
 
        else:
1205
 
            self.port = ':%s' % port
 
838
    """Connection error: %(msg)s %(orig_error)s"""
1206
839
 
1207
840
 
1208
841
class ConnectionReset(TransportError):
1209
 
 
1210
 
    _fmt = "Connection closed: %(msg)s %(orig_error)s"
 
842
    """Connection closed: %(msg)s %(orig_error)s"""
1211
843
 
1212
844
 
1213
845
class InvalidRange(TransportError):
1214
 
 
1215
 
    _fmt = "Invalid range access in %(path)s at %(offset)s."
 
846
    """Invalid range access in %(path)s at %(offset)s."""
1216
847
    
1217
848
    def __init__(self, path, offset):
1218
849
        TransportError.__init__(self, ("Invalid range access in %s at %d"
1222
853
 
1223
854
 
1224
855
class InvalidHttpResponse(TransportError):
1225
 
 
1226
 
    _fmt = "Invalid http response for %(path)s: %(msg)s"
 
856
    """Invalid http response for %(path)s: %(msg)s"""
1227
857
 
1228
858
    def __init__(self, path, msg, orig_error=None):
1229
859
        self.path = path
1231
861
 
1232
862
 
1233
863
class InvalidHttpRange(InvalidHttpResponse):
1234
 
 
1235
 
    _fmt = "Invalid http range %(range)r for %(path)s: %(msg)s"
 
864
    """Invalid http range "%(range)s" for %(path)s: %(msg)s"""
1236
865
    
1237
866
    def __init__(self, path, range, msg):
1238
867
        self.range = range
1240
869
 
1241
870
 
1242
871
class InvalidHttpContentType(InvalidHttpResponse):
1243
 
 
1244
 
    _fmt = 'Invalid http Content-type "%(ctype)s" for %(path)s: %(msg)s'
 
872
    """Invalid http Content-type "%(ctype)s" for %(path)s: %(msg)s"""
1245
873
    
1246
874
    def __init__(self, path, ctype, msg):
1247
875
        self.ctype = ctype
1249
877
 
1250
878
 
1251
879
class ConflictsInTree(BzrError):
1252
 
 
1253
 
    _fmt = "Working tree has conflicts."
 
880
    def __init__(self):
 
881
        BzrError.__init__(self, "Working tree has conflicts.")
1254
882
 
1255
883
 
1256
884
class ParseConfigError(BzrError):
1257
 
 
1258
885
    def __init__(self, errors, filename):
1259
886
        if filename is None:
1260
887
            filename = ""
1263
890
        BzrError.__init__(self, message)
1264
891
 
1265
892
 
1266
 
class NoEmailInUsername(BzrError):
1267
 
 
1268
 
    _fmt = "%(username)r does not seem to contain a reasonable email address"
 
893
class NoEmailInUsername(BzrNewError):
 
894
    """%(username)r does not seem to contain a reasonable email address"""
1269
895
 
1270
896
    def __init__(self, username):
1271
 
        BzrError.__init__(self)
 
897
        BzrNewError.__init__(self)
1272
898
        self.username = username
1273
899
 
1274
900
 
1275
901
class SigningFailed(BzrError):
1276
 
 
1277
 
    _fmt = "Failed to gpg sign data with command %(command_line)r"
1278
 
 
1279
902
    def __init__(self, command_line):
1280
 
        BzrError.__init__(self, command_line=command_line)
 
903
        BzrError.__init__(self, "Failed to gpg sign data with command '%s'"
 
904
                               % command_line)
1281
905
 
1282
906
 
1283
907
class WorkingTreeNotRevision(BzrError):
1284
 
 
1285
 
    _fmt = ("The working tree for %(basedir)s has changed since" 
1286
 
            " the last commit, but weave merge requires that it be"
1287
 
            " unchanged")
1288
 
 
1289
908
    def __init__(self, tree):
1290
 
        BzrError.__init__(self, basedir=tree.basedir)
1291
 
 
1292
 
 
1293
 
class CantReprocessAndShowBase(BzrError):
1294
 
 
1295
 
    _fmt = "Can't reprocess and show base, because reprocessing obscures " \
1296
 
           "the relationship of conflicting lines to the base"
1297
 
 
1298
 
 
1299
 
class GraphCycleError(BzrError):
1300
 
 
1301
 
    _fmt = "Cycle in graph %(graph)r"
1302
 
 
 
909
        BzrError.__init__(self, "The working tree for %s has changed since"
 
910
                          " last commit, but weave merge requires that it be"
 
911
                          " unchanged." % tree.basedir)
 
912
 
 
913
 
 
914
class CantReprocessAndShowBase(BzrNewError):
 
915
    """Can't reprocess and show base.
 
916
Reprocessing obscures relationship of conflicting lines to base."""
 
917
 
 
918
 
 
919
class GraphCycleError(BzrNewError):
 
920
    """Cycle in graph %(graph)r"""
1303
921
    def __init__(self, graph):
1304
 
        BzrError.__init__(self)
 
922
        BzrNewError.__init__(self)
1305
923
        self.graph = graph
1306
924
 
1307
925
 
1308
 
class WritingCompleted(BzrError):
1309
 
 
1310
 
    _fmt = ("The MediumRequest '%(request)s' has already had finish_writing "
1311
 
            "called upon it - accept bytes may not be called anymore.")
1312
 
 
1313
 
    internal_error = True
1314
 
 
1315
 
    def __init__(self, request):
1316
 
        self.request = request
1317
 
 
1318
 
 
1319
 
class WritingNotComplete(BzrError):
1320
 
 
1321
 
    _fmt = ("The MediumRequest '%(request)s' has not has finish_writing "
1322
 
            "called upon it - until the write phase is complete no "
1323
 
            "data may be read.")
1324
 
 
1325
 
    internal_error = True
1326
 
 
1327
 
    def __init__(self, request):
1328
 
        self.request = request
1329
 
 
1330
 
 
1331
 
class NotConflicted(BzrError):
1332
 
 
1333
 
    _fmt = "File %(filename)s is not conflicted."
 
926
class NotConflicted(BzrNewError):
 
927
    """File %(filename)s is not conflicted."""
1334
928
 
1335
929
    def __init__(self, filename):
1336
 
        BzrError.__init__(self)
 
930
        BzrNewError.__init__(self)
1337
931
        self.filename = filename
1338
932
 
1339
933
 
1340
 
class MediumNotConnected(BzrError):
1341
 
 
1342
 
    _fmt = """The medium '%(medium)s' is not connected."""
1343
 
 
1344
 
    internal_error = True
1345
 
 
1346
 
    def __init__(self, medium):
1347
 
        self.medium = medium
1348
 
 
1349
 
 
1350
934
class MustUseDecorated(Exception):
1351
 
    
1352
 
    _fmt = """A decorating function has requested its original command be used."""
1353
 
    
1354
 
 
1355
 
class NoBundleFound(BzrError):
1356
 
 
1357
 
    _fmt = "No bundle was found in %(filename)s"
1358
 
 
 
935
    """A decorating function has requested its original command be used.
 
936
    
 
937
    This should never escape bzr, so does not need to be printable.
 
938
    """
 
939
 
 
940
 
 
941
class NoBundleFound(BzrNewError):
 
942
    """No bundle was found in %(filename)s"""
1359
943
    def __init__(self, filename):
1360
 
        BzrError.__init__(self)
 
944
        BzrNewError.__init__(self)
1361
945
        self.filename = filename
1362
946
 
1363
947
 
1364
 
class BundleNotSupported(BzrError):
1365
 
 
1366
 
    _fmt = "Unable to handle bundle version %(version)s: %(msg)s"
1367
 
 
 
948
class BundleNotSupported(BzrNewError):
 
949
    """Unable to handle bundle version %(version)s: %(msg)s"""
1368
950
    def __init__(self, version, msg):
1369
 
        BzrError.__init__(self)
 
951
        BzrNewError.__init__(self)
1370
952
        self.version = version
1371
953
        self.msg = msg
1372
954
 
1373
955
 
1374
 
class MissingText(BzrError):
1375
 
 
1376
 
    _fmt = "Branch %(base)s is missing revision %(text_revision)s of %(file_id)s"
 
956
class MissingText(BzrNewError):
 
957
    """Branch %(base)s is missing revision %(text_revision)s of %(file_id)s"""
1377
958
 
1378
959
    def __init__(self, branch, text_revision, file_id):
1379
 
        BzrError.__init__(self)
 
960
        BzrNewError.__init__(self)
1380
961
        self.branch = branch
1381
962
        self.base = branch.base
1382
963
        self.text_revision = text_revision
1383
964
        self.file_id = file_id
1384
965
 
1385
966
 
1386
 
class DuplicateFileId(BzrError):
1387
 
 
1388
 
    _fmt = "File id {%(file_id)s} already exists in inventory as %(entry)s"
1389
 
 
1390
 
    def __init__(self, file_id, entry):
1391
 
        BzrError.__init__(self)
1392
 
        self.file_id = file_id
1393
 
        self.entry = entry
1394
 
 
1395
 
 
1396
 
class DuplicateKey(BzrError):
1397
 
 
1398
 
    _fmt = "Key %(key)s is already present in map"
1399
 
 
1400
 
 
1401
 
class MalformedTransform(BzrError):
1402
 
 
1403
 
    _fmt = "Tree transform is malformed %(conflicts)r"
1404
 
 
1405
 
 
1406
 
class NoFinalPath(BzrError):
1407
 
 
1408
 
    _fmt = ("No final name for trans_id %(trans_id)r\n"
1409
 
            "file-id: %(file_id)r\n"
1410
 
            "root trans-id: %(root_trans_id)r\n")
1411
 
 
1412
 
    def __init__(self, trans_id, transform):
1413
 
        self.trans_id = trans_id
1414
 
        self.file_id = transform.final_file_id(trans_id)
1415
 
        self.root_trans_id = transform.root
1416
 
 
1417
 
 
1418
 
class BzrBadParameter(BzrError):
1419
 
 
1420
 
    _fmt = "Bad parameter: %(param)r"
1421
 
 
1422
 
    # This exception should never be thrown, but it is a base class for all
1423
 
    # parameter-to-function errors.
1424
 
 
 
967
class DuplicateKey(BzrNewError):
 
968
    """Key %(key)s is already present in map"""
 
969
 
 
970
 
 
971
class MalformedTransform(BzrNewError):
 
972
    """Tree transform is malformed %(conflicts)r"""
 
973
 
 
974
 
 
975
class BzrBadParameter(BzrNewError):
 
976
    """A bad parameter : %(param)s is not usable.
 
977
    
 
978
    This exception should never be thrown, but it is a base class for all
 
979
    parameter-to-function errors.
 
980
    """
1425
981
    def __init__(self, param):
1426
 
        BzrError.__init__(self)
 
982
        BzrNewError.__init__(self)
1427
983
        self.param = param
1428
984
 
1429
985
 
1430
986
class BzrBadParameterNotUnicode(BzrBadParameter):
1431
 
 
1432
 
    _fmt = "Parameter %(param)s is neither unicode nor utf8."
1433
 
 
1434
 
 
1435
 
class ReusingTransform(BzrError):
1436
 
 
1437
 
    _fmt = "Attempt to reuse a transform that has already been applied."
1438
 
 
1439
 
 
1440
 
class CantMoveRoot(BzrError):
1441
 
 
1442
 
    _fmt = "Moving the root directory is not supported at this time"
1443
 
 
1444
 
 
1445
 
class BzrMoveFailedError(BzrError):
1446
 
 
1447
 
    _fmt = "Could not move %(from_path)s%(operator)s %(to_path)s%(extra)s"
1448
 
 
1449
 
    def __init__(self, from_path='', to_path='', extra=None):
1450
 
        BzrError.__init__(self)
1451
 
        if extra:
1452
 
            self.extra = ': ' + str(extra)
1453
 
        else:
1454
 
            self.extra = ''
1455
 
 
1456
 
        has_from = len(from_path) > 0
1457
 
        has_to = len(to_path) > 0
1458
 
        if has_from:
1459
 
            self.from_path = osutils.splitpath(from_path)[-1]
1460
 
        else:
1461
 
            self.from_path = ''
1462
 
 
1463
 
        if has_to:
1464
 
            self.to_path = osutils.splitpath(to_path)[-1]
1465
 
        else:
1466
 
            self.to_path = ''
1467
 
 
1468
 
        self.operator = ""
1469
 
        if has_from and has_to:
1470
 
            self.operator = " =>"
1471
 
        elif has_from:
1472
 
            self.from_path = "from " + from_path
1473
 
        elif has_to:
1474
 
            self.operator = "to"
1475
 
        else:
1476
 
            self.operator = "file"
1477
 
 
1478
 
 
1479
 
class BzrRenameFailedError(BzrMoveFailedError):
1480
 
 
1481
 
    _fmt = "Could not rename %(from_path)s%(operator)s %(to_path)s%(extra)s"
1482
 
 
1483
 
    def __init__(self, from_path, to_path, extra=None):
1484
 
        BzrMoveFailedError.__init__(self, from_path, to_path, extra)
 
987
    """Parameter %(param)s is neither unicode nor utf8."""
 
988
 
 
989
 
 
990
class ReusingTransform(BzrNewError):
 
991
    """Attempt to reuse a transform that has already been applied."""
 
992
 
 
993
 
 
994
class CantMoveRoot(BzrNewError):
 
995
    """Moving the root directory is not supported at this time"""
1485
996
 
1486
997
 
1487
998
class BzrBadParameterNotString(BzrBadParameter):
1488
 
 
1489
 
    _fmt = "Parameter %(param)s is not a string or unicode string."
 
999
    """Parameter %(param)s is not a string or unicode string."""
1490
1000
 
1491
1001
 
1492
1002
class BzrBadParameterMissing(BzrBadParameter):
1493
 
 
1494
 
    _fmt = "Parameter $(param)s is required but not present."
 
1003
    """Parameter $(param)s is required but not present."""
1495
1004
 
1496
1005
 
1497
1006
class BzrBadParameterUnicode(BzrBadParameter):
1498
 
 
1499
 
    _fmt = "Parameter %(param)s is unicode but only byte-strings are permitted."
 
1007
    """Parameter %(param)s is unicode but only byte-strings are permitted."""
1500
1008
 
1501
1009
 
1502
1010
class BzrBadParameterContainsNewline(BzrBadParameter):
1503
 
 
1504
 
    _fmt = "Parameter %(param)s contains a newline."
1505
 
 
1506
 
 
1507
 
class DependencyNotPresent(BzrError):
1508
 
 
1509
 
    _fmt = 'Unable to import library "%(library)s": %(error)s'
 
1011
    """Parameter %(param)s contains a newline."""
 
1012
 
 
1013
 
 
1014
class DependencyNotPresent(BzrNewError):
 
1015
    """Unable to import library "%(library)s": %(error)s"""
1510
1016
 
1511
1017
    def __init__(self, library, error):
1512
 
        BzrError.__init__(self, library=library, error=error)
 
1018
        BzrNewError.__init__(self, library=library, error=error)
1513
1019
 
1514
1020
 
1515
1021
class ParamikoNotPresent(DependencyNotPresent):
1516
 
 
1517
 
    _fmt = "Unable to import paramiko (required for sftp support): %(error)s"
 
1022
    """Unable to import paramiko (required for sftp support): %(error)s"""
1518
1023
 
1519
1024
    def __init__(self, error):
1520
1025
        DependencyNotPresent.__init__(self, 'paramiko', error)
1521
1026
 
1522
1027
 
1523
 
class PointlessMerge(BzrError):
1524
 
 
1525
 
    _fmt = "Nothing to merge."
1526
 
 
1527
 
 
1528
 
class UninitializableFormat(BzrError):
1529
 
 
1530
 
    _fmt = "Format %(format)s cannot be initialised by this version of bzr."
 
1028
class PointlessMerge(BzrNewError):
 
1029
    """Nothing to merge."""
 
1030
 
 
1031
 
 
1032
class UninitializableFormat(BzrNewError):
 
1033
    """Format %(format)s cannot be initialised by this version of bzr."""
1531
1034
 
1532
1035
    def __init__(self, format):
1533
 
        BzrError.__init__(self)
 
1036
        BzrNewError.__init__(self)
1534
1037
        self.format = format
1535
1038
 
1536
1039
 
1537
 
class BadConversionTarget(BzrError):
1538
 
 
1539
 
    _fmt = "Cannot convert to format %(format)s.  %(problem)s"
 
1040
class BadConversionTarget(BzrNewError):
 
1041
    """Cannot convert to format %(format)s.  %(problem)s"""
1540
1042
 
1541
1043
    def __init__(self, problem, format):
1542
 
        BzrError.__init__(self)
 
1044
        BzrNewError.__init__(self)
1543
1045
        self.problem = problem
1544
1046
        self.format = format
1545
1047
 
1546
1048
 
1547
 
class NoDiff(BzrError):
1548
 
 
1549
 
    _fmt = "Diff is not installed on this machine: %(msg)s"
 
1049
class NoDiff(BzrNewError):
 
1050
    """Diff is not installed on this machine: %(msg)s"""
1550
1051
 
1551
1052
    def __init__(self, msg):
1552
 
        BzrError.__init__(self, msg=msg)
1553
 
 
1554
 
 
1555
 
class NoDiff3(BzrError):
1556
 
 
1557
 
    _fmt = "Diff3 is not installed on this machine."
1558
 
 
1559
 
 
1560
 
class ExistingLimbo(BzrError):
1561
 
 
1562
 
    _fmt = """This tree contains left-over files from a failed operation.
1563
 
    Please examine %(limbo_dir)s to see if it contains any files you wish to
1564
 
    keep, and delete it when you are done."""
1565
 
    
1566
 
    def __init__(self, limbo_dir):
1567
 
       BzrError.__init__(self)
1568
 
       self.limbo_dir = limbo_dir
1569
 
 
1570
 
 
1571
 
class ImmortalLimbo(BzrError):
1572
 
 
1573
 
    _fmt = """Unable to delete transform temporary directory $(limbo_dir)s.
1574
 
    Please examine %(limbo_dir)s to see if it contains any files you wish to
1575
 
    keep, and delete it when you are done."""
1576
 
 
1577
 
    def __init__(self, limbo_dir):
1578
 
       BzrError.__init__(self)
1579
 
       self.limbo_dir = limbo_dir
1580
 
 
1581
 
 
1582
 
class OutOfDateTree(BzrError):
1583
 
 
1584
 
    _fmt = "Working tree is out of date, please run 'bzr update'."
 
1053
        BzrNewError.__init__(self, msg=msg)
 
1054
 
 
1055
 
 
1056
class NoDiff3(BzrNewError):
 
1057
    """Diff3 is not installed on this machine."""
 
1058
 
 
1059
 
 
1060
class ExistingLimbo(BzrNewError):
 
1061
    """This tree contains left-over files from a failed operation.
 
1062
    Please examine %(limbo_dir)s to see if it contains any files you wish to
 
1063
    keep, and delete it when you are done.
 
1064
    """
 
1065
    def __init__(self, limbo_dir):
 
1066
       BzrNewError.__init__(self)
 
1067
       self.limbo_dir = limbo_dir
 
1068
 
 
1069
 
 
1070
class ImmortalLimbo(BzrNewError):
 
1071
    """Unable to delete transform temporary directory $(limbo_dir)s.
 
1072
    Please examine %(limbo_dir)s to see if it contains any files you wish to
 
1073
    keep, and delete it when you are done.
 
1074
    """
 
1075
    def __init__(self, limbo_dir):
 
1076
       BzrNewError.__init__(self)
 
1077
       self.limbo_dir = limbo_dir
 
1078
 
 
1079
 
 
1080
class OutOfDateTree(BzrNewError):
 
1081
    """Working tree is out of date, please run 'bzr update'."""
1585
1082
 
1586
1083
    def __init__(self, tree):
1587
 
        BzrError.__init__(self)
 
1084
        BzrNewError.__init__(self)
1588
1085
        self.tree = tree
1589
1086
 
1590
1087
 
1591
 
class MergeModifiedFormatError(BzrError):
1592
 
 
1593
 
    _fmt = "Error in merge modified format"
1594
 
 
1595
 
 
1596
 
class ConflictFormatError(BzrError):
1597
 
 
1598
 
    _fmt = "Format error in conflict listings"
1599
 
 
1600
 
 
1601
 
class CorruptRepository(BzrError):
1602
 
 
1603
 
    _fmt = """An error has been detected in the repository %(repo_path)s.
 
1088
class MergeModifiedFormatError(BzrNewError):
 
1089
    """Error in merge modified format"""
 
1090
 
 
1091
 
 
1092
class ConflictFormatError(BzrNewError):
 
1093
    """Format error in conflict listings"""
 
1094
 
 
1095
 
 
1096
class CorruptRepository(BzrNewError):
 
1097
    """An error has been detected in the repository %(repo_path)s.
1604
1098
Please run bzr reconcile on this repository."""
1605
1099
 
1606
1100
    def __init__(self, repo):
1607
 
        BzrError.__init__(self)
 
1101
        BzrNewError.__init__(self)
1608
1102
        self.repo_path = repo.bzrdir.root_transport.base
1609
1103
 
1610
1104
 
1611
 
class UpgradeRequired(BzrError):
1612
 
 
1613
 
    _fmt = "To use this feature you must upgrade your branch at %(path)s."
 
1105
class UpgradeRequired(BzrNewError):
 
1106
    """To use this feature you must upgrade your branch at %(path)s."""
1614
1107
 
1615
1108
    def __init__(self, path):
1616
 
        BzrError.__init__(self)
 
1109
        BzrNewError.__init__(self)
1617
1110
        self.path = path
1618
1111
 
1619
1112
 
1620
 
class LocalRequiresBoundBranch(BzrError):
1621
 
 
1622
 
    _fmt = "Cannot perform local-only commits on unbound branches."
1623
 
 
1624
 
 
1625
 
class MissingProgressBarFinish(BzrError):
1626
 
 
1627
 
    _fmt = "A nested progress bar was not 'finished' correctly."
1628
 
 
1629
 
 
1630
 
class InvalidProgressBarType(BzrError):
1631
 
 
1632
 
    _fmt = """Environment variable BZR_PROGRESS_BAR='%(bar_type)s is not a supported type
 
1113
class LocalRequiresBoundBranch(BzrNewError):
 
1114
    """Cannot perform local-only commits on unbound branches."""
 
1115
 
 
1116
 
 
1117
class MissingProgressBarFinish(BzrNewError):
 
1118
    """A nested progress bar was not 'finished' correctly."""
 
1119
 
 
1120
 
 
1121
class InvalidProgressBarType(BzrNewError):
 
1122
    """Environment variable BZR_PROGRESS_BAR='%(bar_type)s is not a supported type
1633
1123
Select one of: %(valid_types)s"""
1634
1124
 
1635
1125
    def __init__(self, bar_type, valid_types):
1636
 
        BzrError.__init__(self, bar_type=bar_type, valid_types=valid_types)
1637
 
 
1638
 
 
1639
 
class UnsupportedOperation(BzrError):
1640
 
 
1641
 
    _fmt = "The method %(mname)s is not supported on objects of type %(tname)s."
1642
 
 
 
1126
        BzrNewError.__init__(self, bar_type=bar_type, valid_types=valid_types)
 
1127
 
 
1128
 
 
1129
class UnsupportedOperation(BzrNewError):
 
1130
    """The method %(mname)s is not supported on objects of type %(tname)s."""
1643
1131
    def __init__(self, method, method_self):
1644
1132
        self.method = method
1645
1133
        self.mname = method.__name__
1646
1134
        self.tname = type(method_self).__name__
1647
1135
 
1648
1136
 
1649
 
class CannotSetRevisionId(UnsupportedOperation):
1650
 
    """Raised when a commit is attempting to set a revision id but cant."""
1651
 
 
1652
 
 
1653
 
class NonAsciiRevisionId(UnsupportedOperation):
1654
 
    """Raised when a commit is attempting to set a non-ascii revision id but cant."""
1655
 
 
1656
 
 
1657
 
class BinaryFile(BzrError):
1658
 
    
1659
 
    _fmt = "File is binary but should be text."
1660
 
 
1661
 
 
1662
 
class IllegalPath(BzrError):
1663
 
 
1664
 
    _fmt = "The path %(path)s is not permitted on this platform"
 
1137
class BinaryFile(BzrNewError):
 
1138
    """File is binary but should be text."""
 
1139
 
 
1140
 
 
1141
class IllegalPath(BzrNewError):
 
1142
    """The path %(path)s is not permitted on this platform"""
1665
1143
 
1666
1144
    def __init__(self, path):
1667
 
        BzrError.__init__(self)
 
1145
        BzrNewError.__init__(self)
1668
1146
        self.path = path
1669
1147
 
1670
1148
 
1671
 
class TestamentMismatch(BzrError):
1672
 
 
1673
 
    _fmt = """Testament did not match expected value.  
 
1149
class TestamentMismatch(BzrNewError):
 
1150
    """Testament did not match expected value.  
1674
1151
       For revision_id {%(revision_id)s}, expected {%(expected)s}, measured 
1675
 
       {%(measured)s}"""
1676
 
 
 
1152
       {%(measured)s}
 
1153
    """
1677
1154
    def __init__(self, revision_id, expected, measured):
1678
1155
        self.revision_id = revision_id
1679
1156
        self.expected = expected
1680
1157
        self.measured = measured
1681
1158
 
1682
1159
 
1683
 
class NotABundle(BzrError):
1684
 
    
1685
 
    _fmt = "Not a bzr revision-bundle: %(text)r"
 
1160
class NotABundle(BzrNewError):
 
1161
    """Not a bzr revision-bundle: %(text)r"""
1686
1162
 
1687
1163
    def __init__(self, text):
1688
 
        BzrError.__init__(self)
 
1164
        BzrNewError.__init__(self)
1689
1165
        self.text = text
1690
1166
 
1691
1167
 
1692
 
class BadBundle(BzrError): 
1693
 
    
1694
 
    _fmt = "Bad bzr revision-bundle: %(text)r"
 
1168
class BadBundle(BzrNewError): 
 
1169
    """Bad bzr revision-bundle: %(text)r"""
1695
1170
 
1696
1171
    def __init__(self, text):
1697
 
        BzrError.__init__(self)
 
1172
        BzrNewError.__init__(self)
1698
1173
        self.text = text
1699
1174
 
1700
1175
 
1701
1176
class MalformedHeader(BadBundle): 
1702
 
    
1703
 
    _fmt = "Malformed bzr revision-bundle header: %(text)r"
 
1177
    """Malformed bzr revision-bundle header: %(text)r"""
 
1178
 
 
1179
    def __init__(self, text):
 
1180
        BzrNewError.__init__(self)
 
1181
        self.text = text
1704
1182
 
1705
1183
 
1706
1184
class MalformedPatches(BadBundle): 
1707
 
    
1708
 
    _fmt = "Malformed patches in bzr revision-bundle: %(text)r"
 
1185
    """Malformed patches in bzr revision-bundle: %(text)r"""
 
1186
 
 
1187
    def __init__(self, text):
 
1188
        BzrNewError.__init__(self)
 
1189
        self.text = text
1709
1190
 
1710
1191
 
1711
1192
class MalformedFooter(BadBundle): 
1712
 
    
1713
 
    _fmt = "Malformed footer in bzr revision-bundle: %(text)r"
 
1193
    """Malformed footer in bzr revision-bundle: %(text)r"""
 
1194
 
 
1195
    def __init__(self, text):
 
1196
        BzrNewError.__init__(self)
 
1197
        self.text = text
1714
1198
 
1715
1199
 
1716
1200
class UnsupportedEOLMarker(BadBundle):
1717
 
    
1718
 
    _fmt = "End of line marker was not \\n in bzr revision-bundle"    
 
1201
    """End of line marker was not \\n in bzr revision-bundle"""    
1719
1202
 
1720
1203
    def __init__(self):
1721
 
        # XXX: BadBundle's constructor assumes there's explanatory text, 
1722
 
        # but for this there is not
1723
 
        BzrError.__init__(self)
1724
 
 
1725
 
 
1726
 
class IncompatibleBundleFormat(BzrError):
1727
 
    
1728
 
    _fmt = "Bundle format %(bundle_format)s is incompatible with %(other)s"
 
1204
        BzrNewError.__init__(self)
 
1205
 
 
1206
 
 
1207
class IncompatibleFormat(BzrNewError):
 
1208
    """Bundle format %(bundle_format)s is incompatible with %(other)s"""
1729
1209
 
1730
1210
    def __init__(self, bundle_format, other):
1731
 
        BzrError.__init__(self)
 
1211
        BzrNewError.__init__(self)
1732
1212
        self.bundle_format = bundle_format
1733
1213
        self.other = other
1734
1214
 
1735
1215
 
1736
 
class BadInventoryFormat(BzrError):
1737
 
    
1738
 
    _fmt = "Root class for inventory serialization errors"
 
1216
class BadInventoryFormat(BzrNewError):
 
1217
    """Root class for inventory serialization errors"""
1739
1218
 
1740
1219
 
1741
1220
class UnexpectedInventoryFormat(BadInventoryFormat):
1742
 
 
1743
 
    _fmt = "The inventory was not in the expected format:\n %(msg)s"
 
1221
    """The inventory was not in the expected format:\n %(msg)s"""
1744
1222
 
1745
1223
    def __init__(self, msg):
1746
1224
        BadInventoryFormat.__init__(self, msg=msg)
1747
1225
 
1748
1226
 
1749
 
class RootNotRich(BzrError):
1750
 
 
1751
 
    _fmt = """This operation requires rich root data storage"""
1752
 
 
1753
 
 
1754
 
class NoSmartMedium(BzrError):
1755
 
 
1756
 
    _fmt = "The transport '%(transport)s' cannot tunnel the smart protocol."
1757
 
 
1758
 
    internal_error = True
1759
 
 
1760
 
    def __init__(self, transport):
1761
 
        self.transport = transport
1762
 
 
1763
 
 
1764
1227
class NoSmartServer(NotBranchError):
1765
 
 
1766
 
    _fmt = "No smart server available at %(url)s"
 
1228
    """No smart server available at %(url)s"""
1767
1229
 
1768
1230
    def __init__(self, url):
1769
1231
        self.url = url
1770
1232
 
1771
1233
 
1772
 
class UnknownSSH(BzrError):
1773
 
 
1774
 
    _fmt = "Unrecognised value for BZR_SSH environment variable: %(vendor)s"
 
1234
class UnknownSSH(BzrNewError):
 
1235
    """Unrecognised value for BZR_SSH environment variable: %(vendor)s"""
1775
1236
 
1776
1237
    def __init__(self, vendor):
1777
 
        BzrError.__init__(self)
 
1238
        BzrNewError.__init__(self)
1778
1239
        self.vendor = vendor
1779
1240
 
1780
1241
 
1781
 
class GhostRevisionUnusableHere(BzrError):
1782
 
 
1783
 
    _fmt = "Ghost revision {%(revision_id)s} cannot be used here."
 
1242
class GhostRevisionUnusableHere(BzrNewError):
 
1243
    """Ghost revision {%(revision_id)s} cannot be used here."""
1784
1244
 
1785
1245
    def __init__(self, revision_id):
1786
 
        BzrError.__init__(self)
 
1246
        BzrNewError.__init__(self)
1787
1247
        self.revision_id = revision_id
1788
1248
 
1789
1249
 
1790
 
class IllegalUseOfScopeReplacer(BzrError):
1791
 
 
1792
 
    _fmt = "ScopeReplacer object %(name)r was used incorrectly: %(msg)s%(extra)s"
1793
 
 
1794
 
    internal_error = True
 
1250
class IllegalUseOfScopeReplacer(BzrNewError):
 
1251
    """ScopeReplacer object %(name)r was used incorrectly: %(msg)s%(extra)s"""
 
1252
 
 
1253
    is_user_error = False
1795
1254
 
1796
1255
    def __init__(self, name, msg, extra=None):
1797
 
        BzrError.__init__(self)
 
1256
        BzrNewError.__init__(self)
1798
1257
        self.name = name
1799
1258
        self.msg = msg
1800
1259
        if extra:
1803
1262
            self.extra = ''
1804
1263
 
1805
1264
 
1806
 
class InvalidImportLine(BzrError):
1807
 
 
1808
 
    _fmt = "Not a valid import statement: %(msg)\n%(text)s"
1809
 
 
1810
 
    internal_error = True
 
1265
class InvalidImportLine(BzrNewError):
 
1266
    """Not a valid import statement: %(msg)\n%(text)s"""
 
1267
 
 
1268
    is_user_error = False
1811
1269
 
1812
1270
    def __init__(self, text, msg):
1813
 
        BzrError.__init__(self)
 
1271
        BzrNewError.__init__(self)
1814
1272
        self.text = text
1815
1273
        self.msg = msg
1816
1274
 
1817
1275
 
1818
 
class ImportNameCollision(BzrError):
1819
 
 
1820
 
    _fmt = "Tried to import an object to the same name as an existing object. %(name)s"
1821
 
 
1822
 
    internal_error = True
 
1276
class ImportNameCollision(BzrNewError):
 
1277
    """Tried to import an object to the same name as an existing object. %(name)s"""
 
1278
 
 
1279
    is_user_error = False
1823
1280
 
1824
1281
    def __init__(self, name):
1825
 
        BzrError.__init__(self)
 
1282
        BzrNewError.__init__(self)
1826
1283
        self.name = name
1827
 
 
1828
 
 
1829
 
class UnsupportedInventoryKind(BzrError):
1830
 
    
1831
 
    _fmt = """Unsupported entry kind %(kind)s"""
1832
 
 
1833
 
    def __init__(self, kind):
1834
 
        self.kind = kind
1835
 
 
1836
 
 
1837
 
class BadSubsumeSource(BzrError):
1838
 
 
1839
 
    _fmt = """Can't subsume %(other_tree)s into %(tree)s.  %(reason)s"""
1840
 
 
1841
 
    def __init__(self, tree, other_tree, reason):
1842
 
        self.tree = tree
1843
 
        self.other_tree = other_tree
1844
 
        self.reason = reason
1845
 
 
1846
 
 
1847
 
class SubsumeTargetNeedsUpgrade(BzrError):
1848
 
    
1849
 
    _fmt = """Subsume target %(other_tree)s needs to be upgraded."""
1850
 
 
1851
 
    def __init__(self, other_tree):
1852
 
        self.other_tree = other_tree
1853
 
 
1854
 
 
1855
 
class BadReferenceTarget(BzrError):
1856
 
 
1857
 
    _fmt = "Can't add reference to %(other_tree)s into %(tree)s.  %(reason)s"
1858
 
 
1859
 
    internal_error = True
1860
 
 
1861
 
    def __init__(self, tree, other_tree, reason):
1862
 
        self.tree = tree
1863
 
        self.other_tree = other_tree
1864
 
        self.reason = reason
1865
 
 
1866
 
 
1867
 
class NoSuchTag(BzrError):
1868
 
 
1869
 
    _fmt = "No such tag: %(tag_name)s"
1870
 
 
1871
 
    def __init__(self, tag_name):
1872
 
        self.tag_name = tag_name
1873
 
 
1874
 
 
1875
 
class TagsNotSupported(BzrError):
1876
 
 
1877
 
    _fmt = "Tags not supported by %(branch)s; you may be able to use bzr upgrade."
1878
 
 
1879
 
    def __init__(self, branch):
1880
 
        self.branch = branch
1881
 
 
1882
 
        
1883
 
class TagAlreadyExists(BzrError):
1884
 
 
1885
 
    _fmt = "Tag %(tag_name)s already exists."
1886
 
 
1887
 
    def __init__(self, tag_name):
1888
 
        self.tag_name = tag_name