/brz/remove-bazaar

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

« back to all changes in this revision

Viewing changes to bzrlib/errors.py

  • Committer: Vincent Ladeuil
  • Date: 2007-07-18 09:43:41 UTC
  • mto: (2778.5.1 vila)
  • mto: This revision was merged to the branch mainline in revision 2789.
  • Revision ID: v.ladeuil+lp@free.fr-20070718094341-edmgsog3el06yqow
Add performance analysis of missing.

Show diffs side-by-side

added added

removed removed

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