← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/errors.py

  • Committer: Launchpad Translations on behalf of bzr-core
  • Date: 2012-06-06 04:30:55 UTC
  • mto: (6581.1.1 trunk)
  • mto: This revision was merged to the branch mainline in revision 6582.
  • Revision ID: launchpad_translations_on_behalf_of_bzr-core-20120606043055-7qhfrx5pkx33cnwi
Launchpad automatic translations update.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/errors.py
1
 
# Copyright (C) 2005, 2006, 2007 Canonical Ltd
 
1
# Copyright (C) 2005-2011 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
12
12
#
13
13
# You should have received a copy of the GNU General Public License
14
14
# along with this program; if not, write to the Free Software
15
 
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
16
16
 
17
17
"""Exceptions for bzr, and reporting of them.
18
18
"""
19
19
 
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
 
 
 
20
from __future__ import absolute_import
33
21
 
34
22
# TODO: is there any value in providing the .args field used by standard
35
 
# python exceptions?   A list of values with no names seems less useful 
 
23
# python exceptions?   A list of values with no names seems less useful
36
24
# to me.
37
25
 
38
 
# TODO: Perhaps convert the exception to a string at the moment it's 
 
26
# TODO: Perhaps convert the exception to a string at the moment it's
39
27
# constructed to make sure it will succeed.  But that says nothing about
40
28
# exceptions that are never raised.
41
29
 
44
32
# 'unprintable'.
45
33
 
46
34
 
 
35
# return codes from the bzr program
 
36
EXIT_OK = 0
 
37
EXIT_ERROR = 3
 
38
EXIT_INTERNAL_ERROR = 4
 
39
 
 
40
 
47
41
class BzrError(StandardError):
48
42
    """
49
43
    Base class for errors raised by bzrlib.
50
44
 
51
45
    :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.)
 
46
        should be displayed with a traceback; if False (or absent) this was
 
47
        probably a user or environment error and they don't need the gory
 
48
        details.  (That can be overridden by -Derror on the command line.)
55
49
 
56
50
    :cvar _fmt: Format string to display the error; this is expanded
57
 
    by the instance's dict.
 
51
        by the instance's dict.
58
52
    """
59
 
    
 
53
 
60
54
    internal_error = False
61
55
 
62
56
    def __init__(self, msg=None, **kwds):
67
61
        arguments can be given.  The first is for generic "user" errors which
68
62
        are not intended to be caught and so do not need a specific subclass.
69
63
        The second case is for use with subclasses that provide a _fmt format
70
 
        string to print the arguments.  
 
64
        string to print the arguments.
71
65
 
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 
 
66
        Keyword arguments are taken as parameters to the error, which can
 
67
        be inserted into the format string template.  It's recommended
 
68
        that subclasses override the __init__ method to require specific
75
69
        parameters.
76
70
 
77
71
        :param msg: If given, this is the literal complete text for the error,
78
 
        not subject to expansion.
 
72
           not subject to expansion. 'msg' is used instead of 'message' because
 
73
           python evolved and, in 2.6, forbids the use of 'message'.
79
74
        """
80
75
        StandardError.__init__(self)
81
76
        if msg is not None:
87
82
            for key, value in kwds.items():
88
83
                setattr(self, key, value)
89
84
 
90
 
    def __str__(self):
 
85
    def _format(self):
91
86
        s = getattr(self, '_preformatted_string', None)
92
87
        if s is not None:
93
 
            # contains a preformatted message; must be cast to plain str
94
 
            return str(s)
 
88
            # contains a preformatted message
 
89
            return s
95
90
        try:
96
91
            fmt = self._get_format_string()
97
92
            if fmt:
98
 
                s = fmt % self.__dict__
 
93
                d = dict(self.__dict__)
 
94
                s = fmt % d
99
95
                # __str__() should always return a 'str' object
100
96
                # never a 'unicode' object.
101
 
                if isinstance(s, unicode):
102
 
                    return s.encode('utf8')
103
97
                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)
 
98
        except Exception, e:
 
99
            pass # just bind to 'e' for formatting below
 
100
        else:
 
101
            e = None
 
102
        return 'Unprintable exception %s: dict=%r, fmt=%r, error=%r' \
 
103
            % (self.__class__.__name__,
 
104
               self.__dict__,
 
105
               getattr(self, '_fmt', None),
 
106
               e)
 
107
 
 
108
    def __unicode__(self):
 
109
        u = self._format()
 
110
        if isinstance(u, str):
 
111
            # Try decoding the str using the default encoding.
 
112
            u = unicode(u)
 
113
        elif not isinstance(u, unicode):
 
114
            # Try to make a unicode object from it, because __unicode__ must
 
115
            # return a unicode object.
 
116
            u = unicode(u)
 
117
        return u
 
118
 
 
119
    def __str__(self):
 
120
        s = self._format()
 
121
        if isinstance(s, unicode):
 
122
            s = s.encode('utf8')
 
123
        else:
 
124
            # __str__ must return a str.
 
125
            s = str(s)
 
126
        return s
 
127
 
 
128
    def __repr__(self):
 
129
        return '%s(%s)' % (self.__class__.__name__, str(self))
110
130
 
111
131
    def _get_format_string(self):
112
132
        """Return format string for this exception or None"""
113
133
        fmt = getattr(self, '_fmt', None)
114
134
        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
 
               )
127
 
 
128
 
 
129
 
class BzrNewError(BzrError):
130
 
    """Deprecated error base class."""
131
 
    # base classes should override the docstring with their human-
132
 
    # readable explanation
133
 
 
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)
145
 
        for key, value in kwds.items():
146
 
            setattr(self, key, value)
147
 
 
148
 
    def __str__(self):
149
 
        try:
150
 
            # __str__() should always return a 'str' object
151
 
            # never a 'unicode' object.
152
 
            s = self.__doc__ % self.__dict__
153
 
            if isinstance(s, unicode):
154
 
                return s.encode('utf8')
155
 
            return s
156
 
        except (TypeError, NameError, ValueError, KeyError), e:
157
 
            return 'Unprintable exception %s(%r): %r' \
158
 
                % (self.__class__.__name__,
159
 
                   self.__dict__, e)
 
135
            from bzrlib.i18n import gettext
 
136
            return gettext(unicode(fmt)) # _fmt strings should be ascii
 
137
 
 
138
    def __eq__(self, other):
 
139
        if self.__class__ is not other.__class__:
 
140
            return NotImplemented
 
141
        return self.__dict__ == other.__dict__
 
142
 
 
143
 
 
144
class InternalBzrError(BzrError):
 
145
    """Base class for errors that are internal in nature.
 
146
 
 
147
    This is a convenience class for errors that are internal. The
 
148
    internal_error attribute can still be altered in subclasses, if needed.
 
149
    Using this class is simply an easy way to get internal errors.
 
150
    """
 
151
 
 
152
    internal_error = True
160
153
 
161
154
 
162
155
class AlreadyBuilding(BzrError):
163
 
    
 
156
 
164
157
    _fmt = "The tree builder is already building a tree."
165
158
 
166
159
 
167
 
class BzrCheckError(BzrError):
168
 
    
169
 
    _fmt = "Internal check failed: %(message)s"
170
 
 
171
 
    internal_error = True
172
 
 
173
 
    def __init__(self, message):
174
 
        BzrError.__init__(self)
175
 
        self.message = message
176
 
 
177
 
 
178
 
class DisabledMethod(BzrError):
 
160
class BranchError(BzrError):
 
161
    """Base class for concrete 'errors about a branch'."""
 
162
 
 
163
    def __init__(self, branch):
 
164
        BzrError.__init__(self, branch=branch)
 
165
 
 
166
 
 
167
class BzrCheckError(InternalBzrError):
 
168
 
 
169
    _fmt = "Internal check failed: %(msg)s"
 
170
 
 
171
    def __init__(self, msg):
 
172
        BzrError.__init__(self)
 
173
        self.msg = msg
 
174
 
 
175
 
 
176
class DirstateCorrupt(BzrError):
 
177
 
 
178
    _fmt = "The dirstate file (%(state)s) appears to be corrupt: %(msg)s"
 
179
 
 
180
    def __init__(self, state, msg):
 
181
        BzrError.__init__(self)
 
182
        self.state = state
 
183
        self.msg = msg
 
184
 
 
185
 
 
186
class DisabledMethod(InternalBzrError):
179
187
 
180
188
    _fmt = "The smart server method '%(class_name)s' is disabled."
181
189
 
182
 
    internal_error = True
183
 
 
184
190
    def __init__(self, class_name):
185
191
        BzrError.__init__(self)
186
192
        self.class_name = class_name
207
213
        self.transport = transport
208
214
 
209
215
 
210
 
class InvalidEntryName(BzrError):
211
 
    
 
216
class InvalidEntryName(InternalBzrError):
 
217
 
212
218
    _fmt = "Invalid entry name: %(name)s"
213
219
 
214
 
    internal_error = True
215
 
 
216
220
    def __init__(self, name):
217
221
        BzrError.__init__(self)
218
222
        self.name = name
219
223
 
220
224
 
221
225
class InvalidRevisionNumber(BzrError):
222
 
    
 
226
 
223
227
    _fmt = "Invalid revision number %(revno)s"
224
228
 
225
229
    def __init__(self, revno):
237
241
        self.revision_id = revision_id
238
242
        self.branch = branch
239
243
 
 
244
 
240
245
class ReservedId(BzrError):
241
246
 
242
247
    _fmt = "Reserved revision-id {%(revision_id)s}"
245
250
        self.revision_id = revision_id
246
251
 
247
252
 
 
253
class RootMissing(InternalBzrError):
 
254
 
 
255
    _fmt = ("The root entry of a tree must be the first entry supplied to "
 
256
        "the commit builder.")
 
257
 
 
258
 
 
259
class NoPublicBranch(BzrError):
 
260
 
 
261
    _fmt = 'There is no public branch set for "%(branch_url)s".'
 
262
 
 
263
    def __init__(self, branch):
 
264
        import bzrlib.urlutils as urlutils
 
265
        public_location = urlutils.unescape_for_display(branch.base, 'ascii')
 
266
        BzrError.__init__(self, branch_url=public_location)
 
267
 
 
268
 
248
269
class NoHelpTopic(BzrError):
249
270
 
250
271
    _fmt = ("No help could be found for '%(topic)s'. "
256
277
 
257
278
class NoSuchId(BzrError):
258
279
 
259
 
    _fmt = "The file id %(file_id)s is not present in the tree %(tree)s."
260
 
    
 
280
    _fmt = 'The file id "%(file_id)s" is not present in the tree %(tree)s.'
 
281
 
261
282
    def __init__(self, tree, file_id):
262
283
        BzrError.__init__(self)
263
284
        self.file_id = file_id
264
285
        self.tree = tree
265
286
 
266
287
 
267
 
class InventoryModified(BzrError):
 
288
class NoSuchIdInRepository(NoSuchId):
 
289
 
 
290
    _fmt = ('The file id "%(file_id)s" is not present in the repository'
 
291
            ' %(repository)r')
 
292
 
 
293
    def __init__(self, repository, file_id):
 
294
        BzrError.__init__(self, repository=repository, file_id=file_id)
 
295
 
 
296
 
 
297
class NotStacked(BranchError):
 
298
 
 
299
    _fmt = "The branch '%(branch)s' is not stacked."
 
300
 
 
301
 
 
302
class InventoryModified(InternalBzrError):
268
303
 
269
304
    _fmt = ("The current inventory for the tree %(tree)r has been modified,"
270
305
            " so a clean inventory cannot be read without data loss.")
271
306
 
272
 
    internal_error = True
273
 
 
274
307
    def __init__(self, tree):
275
308
        self.tree = tree
276
309
 
277
310
 
278
311
class NoWorkingTree(BzrError):
279
312
 
280
 
    _fmt = "No WorkingTree exists for %(base)s."
281
 
    
 
313
    _fmt = 'No WorkingTree exists for "%(base)s".'
 
314
 
282
315
    def __init__(self, base):
283
316
        BzrError.__init__(self)
284
317
        self.base = base
297
330
        self.url = url
298
331
 
299
332
 
300
 
class WorkingTreeAlreadyPopulated(BzrError):
301
 
 
302
 
    _fmt = """Working tree already populated in %(base)s"""
303
 
 
304
 
    internal_error = True
 
333
class WorkingTreeAlreadyPopulated(InternalBzrError):
 
334
 
 
335
    _fmt = 'Working tree already populated in "%(base)s"'
305
336
 
306
337
    def __init__(self, base):
307
338
        self.base = base
308
339
 
 
340
 
309
341
class BzrCommandError(BzrError):
310
342
    """Error from user command"""
311
343
 
312
 
    internal_error = False
313
 
 
314
344
    # Error from malformed user command; please avoid raising this as a
315
345
    # generic exception not caused by user input.
316
346
    #
318
348
    # are not intended to be caught anyway.  UI code need not subclass
319
349
    # BzrCommandError, and non-UI code should not throw a subclass of
320
350
    # BzrCommandError.  ADHB 20051211
321
 
    def __init__(self, msg):
322
 
        # Object.__str__() must return a real string
323
 
        # returning a Unicode string is a python error.
324
 
        if isinstance(msg, unicode):
325
 
            self.msg = msg.encode('utf8')
326
 
        else:
327
 
            self.msg = msg
328
 
 
329
 
    def __str__(self):
330
 
        return self.msg
331
351
 
332
352
 
333
353
class NotWriteLocked(BzrError):
343
363
    _fmt = "Error in command line options"
344
364
 
345
365
 
 
366
class BadIndexFormatSignature(BzrError):
 
367
 
 
368
    _fmt = "%(value)s is not an index of type %(_type)s."
 
369
 
 
370
    def __init__(self, value, _type):
 
371
        BzrError.__init__(self)
 
372
        self.value = value
 
373
        self._type = _type
 
374
 
 
375
 
 
376
class BadIndexData(BzrError):
 
377
 
 
378
    _fmt = "Error in data for index %(value)s."
 
379
 
 
380
    def __init__(self, value):
 
381
        BzrError.__init__(self)
 
382
        self.value = value
 
383
 
 
384
 
 
385
class BadIndexDuplicateKey(BzrError):
 
386
 
 
387
    _fmt = "The key '%(key)s' is already in index '%(index)s'."
 
388
 
 
389
    def __init__(self, key, index):
 
390
        BzrError.__init__(self)
 
391
        self.key = key
 
392
        self.index = index
 
393
 
 
394
 
 
395
class BadIndexKey(BzrError):
 
396
 
 
397
    _fmt = "The key '%(key)s' is not a valid key."
 
398
 
 
399
    def __init__(self, key):
 
400
        BzrError.__init__(self)
 
401
        self.key = key
 
402
 
 
403
 
 
404
class BadIndexOptions(BzrError):
 
405
 
 
406
    _fmt = "Could not parse options for index %(value)s."
 
407
 
 
408
    def __init__(self, value):
 
409
        BzrError.__init__(self)
 
410
        self.value = value
 
411
 
 
412
 
 
413
class BadIndexValue(BzrError):
 
414
 
 
415
    _fmt = "The value '%(value)s' is not a valid value."
 
416
 
 
417
    def __init__(self, value):
 
418
        BzrError.__init__(self)
 
419
        self.value = value
 
420
 
 
421
 
346
422
class BadOptionValue(BzrError):
347
423
 
348
424
    _fmt = """Bad value "%(value)s" for option "%(name)s"."""
350
426
    def __init__(self, name, value):
351
427
        BzrError.__init__(self, name=name, value=value)
352
428
 
353
 
    
 
429
 
354
430
class StrictCommitFailed(BzrError):
355
431
 
356
432
    _fmt = "Commit refused because there are unknown files in the tree"
359
435
# XXX: Should be unified with TransportError; they seem to represent the
360
436
# same thing
361
437
# RBC 20060929: I think that unifiying with TransportError would be a mistake
362
 
# - this is finer than a TransportError - and more useful as such. It 
 
438
# - this is finer than a TransportError - and more useful as such. It
363
439
# differentiates between 'transport has failed' and 'operation on a transport
364
440
# has failed.'
365
441
class PathError(BzrError):
366
 
    
 
442
 
367
443
    _fmt = "Generic path error: %(path)r%(extra)s)"
368
444
 
369
445
    def __init__(self, path, extra=None):
389
465
    """Used when renaming and both source and dest exist."""
390
466
 
391
467
    _fmt = ("Could not rename %(source)s => %(dest)s because both files exist."
392
 
            "%(extra)s")
 
468
            " (Use --after to tell bzr about a rename that has already"
 
469
            " happened)%(extra)s")
393
470
 
394
471
    def __init__(self, source, dest, extra=None):
395
472
        BzrError.__init__(self)
403
480
 
404
481
class NotADirectory(PathError):
405
482
 
406
 
    _fmt = "%(path)r is not a directory %(extra)s"
 
483
    _fmt = '"%(path)s" is not a directory %(extra)s'
407
484
 
408
485
 
409
486
class NotInWorkingDirectory(PathError):
410
487
 
411
 
    _fmt = "%(path)r is not in the working directory %(extra)s"
 
488
    _fmt = '"%(path)s" is not in the working directory %(extra)s'
412
489
 
413
490
 
414
491
class DirectoryNotEmpty(PathError):
415
492
 
416
 
    _fmt = "Directory not empty: %(path)r%(extra)s"
417
 
 
418
 
 
419
 
class ReadingCompleted(BzrError):
420
 
    
 
493
    _fmt = 'Directory not empty: "%(path)s"%(extra)s'
 
494
 
 
495
 
 
496
class HardLinkNotSupported(PathError):
 
497
 
 
498
    _fmt = 'Hard-linking "%(path)s" is not supported'
 
499
 
 
500
 
 
501
class ReadingCompleted(InternalBzrError):
 
502
 
421
503
    _fmt = ("The MediumRequest '%(request)s' has already had finish_reading "
422
504
            "called upon it - the request has been completed and no more "
423
505
            "data may be read.")
424
506
 
425
 
    internal_error = True
426
 
 
427
507
    def __init__(self, request):
428
508
        self.request = request
429
509
 
430
510
 
431
511
class ResourceBusy(PathError):
432
512
 
433
 
    _fmt = "Device or resource busy: %(path)r%(extra)s"
 
513
    _fmt = 'Device or resource busy: "%(path)s"%(extra)s'
434
514
 
435
515
 
436
516
class PermissionDenied(PathError):
437
517
 
438
 
    _fmt = "Permission denied: %(path)r%(extra)s"
 
518
    _fmt = 'Permission denied: "%(path)s"%(extra)s'
439
519
 
440
520
 
441
521
class InvalidURL(PathError):
442
522
 
443
 
    _fmt = "Invalid url supplied to transport: %(path)r%(extra)s"
 
523
    _fmt = 'Invalid url supplied to transport: "%(path)s"%(extra)s'
444
524
 
445
525
 
446
526
class InvalidURLJoin(PathError):
447
527
 
448
 
    _fmt = "Invalid URL join request: %(args)s%(extra)s"
449
 
 
450
 
    def __init__(self, msg, base, args):
451
 
        PathError.__init__(self, base, msg)
452
 
        self.args = [base] + list(args)
 
528
    _fmt = "Invalid URL join request: %(reason)s: %(base)r + %(join_args)r"
 
529
 
 
530
    def __init__(self, reason, base, join_args):
 
531
        self.reason = reason
 
532
        self.base = base
 
533
        self.join_args = join_args
 
534
        PathError.__init__(self, base, reason)
 
535
 
 
536
 
 
537
class InvalidRebaseURLs(PathError):
 
538
 
 
539
    _fmt = "URLs differ by more than path: %(from_)r and %(to)r"
 
540
 
 
541
    def __init__(self, from_, to):
 
542
        self.from_ = from_
 
543
        self.to = to
 
544
        PathError.__init__(self, from_, 'URLs differ by more than path.')
 
545
 
 
546
 
 
547
class UnavailableRepresentation(InternalBzrError):
 
548
 
 
549
    _fmt = ("The encoding '%(wanted)s' is not available for key %(key)s which "
 
550
        "is encoded as '%(native)s'.")
 
551
 
 
552
    def __init__(self, key, wanted, native):
 
553
        InternalBzrError.__init__(self)
 
554
        self.wanted = wanted
 
555
        self.native = native
 
556
        self.key = key
453
557
 
454
558
 
455
559
class UnknownHook(BzrError):
466
570
 
467
571
    _fmt = 'Unsupported protocol for url "%(path)s"%(extra)s'
468
572
 
469
 
    def __init__(self, url, extra):
 
573
    def __init__(self, url, extra=""):
470
574
        PathError.__init__(self, url, extra=extra)
471
575
 
472
576
 
 
577
class UnstackableBranchFormat(BzrError):
 
578
 
 
579
    _fmt = ("The branch '%(url)s'(%(format)s) is not a stackable format. "
 
580
        "You will need to upgrade the branch to permit branch stacking.")
 
581
 
 
582
    def __init__(self, format, url):
 
583
        BzrError.__init__(self)
 
584
        self.format = format
 
585
        self.url = url
 
586
 
 
587
 
 
588
class UnstackableLocationError(BzrError):
 
589
 
 
590
    _fmt = "The branch '%(branch_url)s' cannot be stacked on '%(target_url)s'."
 
591
 
 
592
    def __init__(self, branch_url, target_url):
 
593
        BzrError.__init__(self)
 
594
        self.branch_url = branch_url
 
595
        self.target_url = target_url
 
596
 
 
597
 
 
598
class UnstackableRepositoryFormat(BzrError):
 
599
 
 
600
    _fmt = ("The repository '%(url)s'(%(format)s) is not a stackable format. "
 
601
        "You will need to upgrade the repository to permit branch stacking.")
 
602
 
 
603
    def __init__(self, format, url):
 
604
        BzrError.__init__(self)
 
605
        self.format = format
 
606
        self.url = url
 
607
 
 
608
 
473
609
class ReadError(PathError):
474
 
    
 
610
 
475
611
    _fmt = """Error reading from %(path)r."""
476
612
 
477
613
 
478
614
class ShortReadvError(PathError):
479
615
 
480
 
    _fmt = ("readv() read %(actual)s bytes rather than %(length)s bytes"
481
 
            " at %(offset)s for %(path)s%(extra)s")
 
616
    _fmt = ('readv() read %(actual)s bytes rather than %(length)s bytes'
 
617
            ' at %(offset)s for "%(path)s"%(extra)s')
482
618
 
483
619
    internal_error = True
484
620
 
489
625
        self.actual = actual
490
626
 
491
627
 
492
 
class PathNotChild(BzrError):
493
 
 
494
 
    _fmt = "Path %(path)r is not a child of path %(base)r%(extra)s"
495
 
 
496
 
    internal_error = True
 
628
class PathNotChild(PathError):
 
629
 
 
630
    _fmt = 'Path "%(path)s" is not a child of path "%(base)s"%(extra)s'
 
631
 
 
632
    internal_error = False
497
633
 
498
634
    def __init__(self, path, base, extra=None):
499
635
        BzrError.__init__(self)
507
643
 
508
644
class InvalidNormalization(PathError):
509
645
 
510
 
    _fmt = "Path %(path)r is not unicode normalized"
 
646
    _fmt = 'Path "%(path)s" is not unicode normalized'
511
647
 
512
648
 
513
649
# TODO: This is given a URL; we try to unescape it but doing that from inside
514
650
# the exception object is a bit undesirable.
515
 
# TODO: Probably this behavior of should be a common superclass 
 
651
# TODO: Probably this behavior of should be a common superclass
516
652
class NotBranchError(PathError):
517
653
 
518
 
    _fmt = "Not a branch: %(path)s"
 
654
    _fmt = 'Not a branch: "%(path)s"%(detail)s.'
519
655
 
520
 
    def __init__(self, path):
 
656
    def __init__(self, path, detail=None, bzrdir=None):
521
657
       import bzrlib.urlutils as urlutils
522
 
       self.path = urlutils.unescape_for_display(path, 'ascii')
 
658
       path = urlutils.unescape_for_display(path, 'ascii')
 
659
       if detail is not None:
 
660
           detail = ': ' + detail
 
661
       self.detail = detail
 
662
       self.bzrdir = bzrdir
 
663
       PathError.__init__(self, path=path)
 
664
 
 
665
    def __repr__(self):
 
666
        return '<%s %r>' % (self.__class__.__name__, self.__dict__)
 
667
 
 
668
    def _format(self):
 
669
        # XXX: Ideally self.detail would be a property, but Exceptions in
 
670
        # Python 2.4 have to be old-style classes so properties don't work.
 
671
        # Instead we override _format.
 
672
        if self.detail is None:
 
673
            if self.bzrdir is not None:
 
674
                try:
 
675
                    self.bzrdir.open_repository()
 
676
                except NoRepositoryPresent:
 
677
                    self.detail = ''
 
678
                except Exception:
 
679
                    # Just ignore unexpected errors.  Raising arbitrary errors
 
680
                    # during str(err) can provoke strange bugs.  Concretely
 
681
                    # Launchpad's codehosting managed to raise NotBranchError
 
682
                    # here, and then get stuck in an infinite loop/recursion
 
683
                    # trying to str() that error.  All this error really cares
 
684
                    # about that there's no working repository there, and if
 
685
                    # open_repository() fails, there probably isn't.
 
686
                    self.detail = ''
 
687
                else:
 
688
                    self.detail = ': location is a repository'
 
689
            else:
 
690
                self.detail = ''
 
691
        return PathError._format(self)
523
692
 
524
693
 
525
694
class NoSubmitBranch(PathError):
531
700
       self.path = urlutils.unescape_for_display(branch.base, 'ascii')
532
701
 
533
702
 
 
703
class AlreadyControlDirError(PathError):
 
704
 
 
705
    _fmt = 'A control directory already exists: "%(path)s".'
 
706
 
 
707
 
534
708
class AlreadyBranchError(PathError):
535
709
 
536
 
    _fmt = "Already a branch: %(path)s."
 
710
    _fmt = 'Already a branch: "%(path)s".'
 
711
 
 
712
 
 
713
class ParentBranchExists(AlreadyBranchError):
 
714
 
 
715
    _fmt = 'Parent branch already exists: "%(path)s".'
537
716
 
538
717
 
539
718
class BranchExistsWithoutWorkingTree(PathError):
540
719
 
541
 
    _fmt = "Directory contains a branch, but no working tree \
542
 
(use bzr checkout if you wish to build a working tree): %(path)s"
 
720
    _fmt = 'Directory contains a branch, but no working tree \
 
721
(use bzr checkout if you wish to build a working tree): "%(path)s"'
543
722
 
544
723
 
545
724
class AtomicFileAlreadyClosed(PathError):
546
725
 
547
 
    _fmt = ("'%(function)s' called on an AtomicFile after it was closed:"
548
 
            " %(path)s")
 
726
    _fmt = ('"%(function)s" called on an AtomicFile after it was closed:'
 
727
            ' "%(path)s"')
549
728
 
550
729
    def __init__(self, path, function):
551
730
        PathError.__init__(self, path=path, extra=None)
554
733
 
555
734
class InaccessibleParent(PathError):
556
735
 
557
 
    _fmt = ("Parent not accessible given base %(base)s and"
558
 
            " relative path %(path)s")
 
736
    _fmt = ('Parent not accessible given base "%(base)s" and'
 
737
            ' relative path "%(path)s"')
559
738
 
560
739
    def __init__(self, path, base):
561
740
        PathError.__init__(self, path)
564
743
 
565
744
class NoRepositoryPresent(BzrError):
566
745
 
567
 
    _fmt = "No repository present: %(path)r"
 
746
    _fmt = 'No repository present: "%(path)s"'
568
747
    def __init__(self, bzrdir):
569
748
        BzrError.__init__(self)
570
749
        self.path = bzrdir.transport.clone('..').base
571
750
 
572
751
 
573
 
class FileInWrongBranch(BzrError):
574
 
 
575
 
    _fmt = "File %(path)s in not in branch %(branch_base)s."
576
 
 
577
 
    def __init__(self, branch, path):
578
 
        BzrError.__init__(self)
579
 
        self.branch = branch
580
 
        self.branch_base = branch.base
581
 
        self.path = path
582
 
 
583
 
 
584
752
class UnsupportedFormatError(BzrError):
585
753
 
586
754
    _fmt = "Unsupported branch format: %(format)s\nPlease run 'bzr upgrade'"
587
755
 
588
756
 
589
757
class UnknownFormatError(BzrError):
590
 
    
591
 
    _fmt = "Unknown branch format: %(format)r"
 
758
 
 
759
    _fmt = "Unknown %(kind)s format: %(format)r"
 
760
 
 
761
    def __init__(self, format, kind='branch'):
 
762
        self.kind = kind
 
763
        self.format = format
592
764
 
593
765
 
594
766
class IncompatibleFormat(BzrError):
595
 
    
 
767
 
596
768
    _fmt = "Format %(format)s is not compatible with .bzr version %(bzrdir)s."
597
769
 
598
770
    def __init__(self, format, bzrdir_format):
601
773
        self.bzrdir = bzrdir_format
602
774
 
603
775
 
 
776
class ParseFormatError(BzrError):
 
777
 
 
778
    _fmt = "Parse error on line %(lineno)d of %(format)s format: %(line)s"
 
779
 
 
780
    def __init__(self, format, lineno, line, text):
 
781
        BzrError.__init__(self)
 
782
        self.format = format
 
783
        self.lineno = lineno
 
784
        self.line = line
 
785
        self.text = text
 
786
 
 
787
 
604
788
class IncompatibleRepositories(BzrError):
605
 
 
606
 
    _fmt = "Repository %(target)s is not compatible with repository"\
607
 
        " %(source)s"
608
 
 
609
 
    def __init__(self, source, target):
610
 
        BzrError.__init__(self, target=target, source=source)
 
789
    """Report an error that two repositories are not compatible.
 
790
 
 
791
    Note that the source and target repositories are permitted to be strings:
 
792
    this exception is thrown from the smart server and may refer to a
 
793
    repository the client hasn't opened.
 
794
    """
 
795
 
 
796
    _fmt = "%(target)s\n" \
 
797
            "is not compatible with\n" \
 
798
            "%(source)s\n" \
 
799
            "%(details)s"
 
800
 
 
801
    def __init__(self, source, target, details=None):
 
802
        if details is None:
 
803
            details = "(no details)"
 
804
        BzrError.__init__(self, target=target, source=source, details=details)
611
805
 
612
806
 
613
807
class IncompatibleRevision(BzrError):
614
 
    
 
808
 
615
809
    _fmt = "Revision is not compatible with %(repo_format)s"
616
810
 
617
811
    def __init__(self, repo_format):
622
816
class AlreadyVersionedError(BzrError):
623
817
    """Used when a path is expected not to be versioned, but it is."""
624
818
 
625
 
    _fmt = "%(context_info)s%(path)s is already versioned"
 
819
    _fmt = "%(context_info)s%(path)s is already versioned."
626
820
 
627
821
    def __init__(self, path, context_info=None):
628
822
        """Construct a new AlreadyVersionedError.
629
823
 
630
824
        :param path: This is the path which is versioned,
631
 
        which should be in a user friendly form.
 
825
            which should be in a user friendly form.
632
826
        :param context_info: If given, this is information about the context,
633
 
        which could explain why this is expected to not be versioned.
 
827
            which could explain why this is expected to not be versioned.
634
828
        """
635
829
        BzrError.__init__(self)
636
830
        self.path = path
643
837
class NotVersionedError(BzrError):
644
838
    """Used when a path is expected to be versioned, but it is not."""
645
839
 
646
 
    _fmt = "%(context_info)s%(path)s is not versioned"
 
840
    _fmt = "%(context_info)s%(path)s is not versioned."
647
841
 
648
842
    def __init__(self, path, context_info=None):
649
843
        """Construct a new NotVersionedError.
650
844
 
651
845
        :param path: This is the path which is not versioned,
652
 
        which should be in a user friendly form.
 
846
            which should be in a user friendly form.
653
847
        :param context_info: If given, this is information about the context,
654
 
        which could explain why this is expected to be versioned.
 
848
            which could explain why this is expected to be versioned.
655
849
        """
656
850
        BzrError.__init__(self)
657
851
        self.path = path
700
894
        BzrError.__init__(self, filename=filename, kind=kind)
701
895
 
702
896
 
 
897
class BadFilenameEncoding(BzrError):
 
898
 
 
899
    _fmt = ('Filename %(filename)r is not valid in your current filesystem'
 
900
            ' encoding %(fs_encoding)s')
 
901
 
 
902
    def __init__(self, filename, fs_encoding):
 
903
        BzrError.__init__(self)
 
904
        self.filename = filename
 
905
        self.fs_encoding = fs_encoding
 
906
 
 
907
 
703
908
class ForbiddenControlFileError(BzrError):
704
909
 
705
 
    _fmt = "Cannot operate on %(filename)s because it is a control file"
706
 
 
707
 
 
708
 
class LockError(BzrError):
 
910
    _fmt = 'Cannot operate on "%(filename)s" because it is a control file'
 
911
 
 
912
 
 
913
class LockError(InternalBzrError):
709
914
 
710
915
    _fmt = "Lock error: %(msg)s"
711
916
 
712
 
    internal_error = True
713
 
 
714
917
    # All exceptions from the lock/unlock functions should be from
715
918
    # this exception class.  They will be translated as necessary. The
716
919
    # original exception is available as e.original_error
717
920
    #
718
921
    # New code should prefer to raise specific subclasses
719
 
    def __init__(self, message):
720
 
        # Python 2.5 uses a slot for StandardError.message,
721
 
        # so use a different variable name
722
 
        # so it is exposed in self.__dict__
723
 
        self.msg = message
 
922
    def __init__(self, msg):
 
923
        self.msg = msg
724
924
 
725
925
 
726
926
class LockActive(LockError):
760
960
        self.obj = obj
761
961
 
762
962
 
763
 
class ReadOnlyLockError(LockError):
764
 
 
765
 
    _fmt = "Cannot acquire write lock on %(fname)s. %(msg)s"
766
 
 
767
 
    def __init__(self, fname, msg):
 
963
class LockFailed(LockError):
 
964
 
 
965
    internal_error = False
 
966
 
 
967
    _fmt = "Cannot lock %(lock)s: %(why)s"
 
968
 
 
969
    def __init__(self, lock, why):
768
970
        LockError.__init__(self, '')
769
 
        self.fname = fname
770
 
        self.msg = msg
 
971
        self.lock = lock
 
972
        self.why = why
771
973
 
772
974
 
773
975
class OutSideTransaction(BzrError):
797
999
 
798
1000
class UnlockableTransport(LockError):
799
1001
 
 
1002
    internal_error = False
 
1003
 
800
1004
    _fmt = "Cannot lock: transport is read only: %(transport)s"
801
1005
 
802
1006
    def __init__(self, transport):
805
1009
 
806
1010
class LockContention(LockError):
807
1011
 
808
 
    _fmt = "Could not acquire lock %(lock)s"
809
 
    # TODO: show full url for lock, combining the transport and relative
810
 
    # bits?
 
1012
    _fmt = 'Could not acquire lock "%(lock)s": %(msg)s'
811
1013
 
812
1014
    internal_error = False
813
1015
 
814
 
    def __init__(self, lock):
 
1016
    def __init__(self, lock, msg=''):
815
1017
        self.lock = lock
 
1018
        self.msg = msg
816
1019
 
817
1020
 
818
1021
class LockBroken(LockError):
839
1042
        self.target = target
840
1043
 
841
1044
 
 
1045
class LockCorrupt(LockError):
 
1046
 
 
1047
    _fmt = ("Lock is apparently held, but corrupted: %(corruption_info)s\n"
 
1048
            "Use 'bzr break-lock' to clear it")
 
1049
 
 
1050
    internal_error = False
 
1051
 
 
1052
    def __init__(self, corruption_info, file_data=None):
 
1053
        self.corruption_info = corruption_info
 
1054
        self.file_data = file_data
 
1055
 
 
1056
 
842
1057
class LockNotHeld(LockError):
843
1058
 
844
1059
    _fmt = "Lock not held: %(lock)s"
853
1068
 
854
1069
    _fmt = "The object %(obj)s does not support token specifying a token when locking."
855
1070
 
856
 
    internal_error = True
857
 
 
858
1071
    def __init__(self, obj):
859
1072
        self.obj = obj
860
1073
 
885
1098
        BzrError.__init__(self, files=files, files_str=files_str)
886
1099
 
887
1100
 
 
1101
class ExcludesUnsupported(BzrError):
 
1102
 
 
1103
    _fmt = ('Excluding paths during commit is not supported by '
 
1104
            'repository at %(repository)r.')
 
1105
 
 
1106
    def __init__(self, repository):
 
1107
        BzrError.__init__(self, repository=repository)
 
1108
 
 
1109
 
 
1110
class BadCommitMessageEncoding(BzrError):
 
1111
 
 
1112
    _fmt = 'The specified commit message contains characters unsupported by '\
 
1113
        'the current encoding.'
 
1114
 
 
1115
 
888
1116
class UpgradeReadonly(BzrError):
889
1117
 
890
1118
    _fmt = "Upgrade URL cannot work with readonly URLs."
904
1132
    _fmt = "Commit refused because there are unknowns in the tree."
905
1133
 
906
1134
 
907
 
class NoSuchRevision(BzrError):
908
 
 
909
 
    _fmt = "Branch %(branch)s has no revision %(revision)s"
910
 
 
911
 
    internal_error = True
 
1135
class NoSuchRevision(InternalBzrError):
 
1136
 
 
1137
    _fmt = "%(branch)s has no revision %(revision)s"
912
1138
 
913
1139
    def __init__(self, branch, revision):
 
1140
        # 'branch' may sometimes be an internal object like a KnitRevisionStore
914
1141
        BzrError.__init__(self, branch=branch, revision=revision)
915
1142
 
916
1143
 
917
 
class NotLeftParentDescendant(BzrError):
918
 
 
919
 
    _fmt = ("Revision %(old_revision)s is not the left parent of"
920
 
            " %(new_revision)s, but branch %(branch_location)s expects this")
921
 
 
922
 
    internal_error = True
923
 
 
924
 
    def __init__(self, branch, old_revision, new_revision):
925
 
        BzrError.__init__(self, branch_location=branch.base,
926
 
                          old_revision=old_revision,
927
 
                          new_revision=new_revision)
 
1144
class RangeInChangeOption(BzrError):
 
1145
 
 
1146
    _fmt = "Option --change does not accept revision ranges"
928
1147
 
929
1148
 
930
1149
class NoSuchRevisionSpec(BzrError):
937
1156
 
938
1157
class NoSuchRevisionInTree(NoSuchRevision):
939
1158
    """When using Tree.revision_tree, and the revision is not accessible."""
940
 
    
941
 
    _fmt = "The revision id %(revision_id)s is not present in the tree %(tree)s."
 
1159
 
 
1160
    _fmt = "The revision id {%(revision_id)s} is not present in the tree %(tree)s."
942
1161
 
943
1162
    def __init__(self, tree, revision_id):
944
1163
        BzrError.__init__(self)
948
1167
 
949
1168
class InvalidRevisionSpec(BzrError):
950
1169
 
951
 
    _fmt = ("Requested revision: %(spec)r does not exist in branch:"
952
 
            " %(branch)s%(extra)s")
 
1170
    _fmt = ("Requested revision: '%(spec)s' does not exist in branch:"
 
1171
            " %(branch_url)s%(extra)s")
953
1172
 
954
1173
    def __init__(self, spec, branch, extra=None):
955
1174
        BzrError.__init__(self, branch=branch, spec=spec)
 
1175
        self.branch_url = getattr(branch, 'user_url', str(branch))
956
1176
        if extra:
957
1177
            self.extra = '\n' + str(extra)
958
1178
        else:
959
1179
            self.extra = ''
960
1180
 
961
1181
 
962
 
class HistoryMissing(BzrError):
963
 
 
964
 
    _fmt = "%(branch)s is missing %(object_type)s {%(object_id)s}"
965
 
 
966
 
 
967
1182
class AppendRevisionsOnlyViolation(BzrError):
968
1183
 
969
1184
    _fmt = ('Operation denied because it would change the main history,'
979
1194
class DivergedBranches(BzrError):
980
1195
 
981
1196
    _fmt = ("These branches have diverged."
982
 
            " Use the merge command to reconcile them.")
983
 
 
984
 
    internal_error = False
 
1197
            " Use the missing command to see how.\n"
 
1198
            "Use the merge command to reconcile them.")
985
1199
 
986
1200
    def __init__(self, branch1, branch2):
987
1201
        self.branch1 = branch1
988
1202
        self.branch2 = branch2
989
1203
 
990
1204
 
991
 
class NotLefthandHistory(BzrError):
 
1205
class NotLefthandHistory(InternalBzrError):
992
1206
 
993
1207
    _fmt = "Supplied history does not follow left-hand parents"
994
1208
 
995
 
    internal_error = True
996
 
 
997
1209
    def __init__(self, history):
998
1210
        BzrError.__init__(self, history=history)
999
1211
 
1003
1215
    _fmt = ("Branches have no common ancestor, and"
1004
1216
            " no merge base revision was specified.")
1005
1217
 
1006
 
    internal_error = False
 
1218
 
 
1219
class CannotReverseCherrypick(BzrError):
 
1220
 
 
1221
    _fmt = ('Selected merge cannot perform reverse cherrypicks.  Try merge3'
 
1222
            ' or diff3.')
1007
1223
 
1008
1224
 
1009
1225
class NoCommonAncestor(BzrError):
1010
 
    
 
1226
 
1011
1227
    _fmt = "Revisions have no common ancestor: %(revision_a)s %(revision_b)s"
1012
1228
 
1013
1229
    def __init__(self, revision_a, revision_b):
1033
1249
            not_ancestor_id=not_ancestor_id)
1034
1250
 
1035
1251
 
1036
 
class InstallFailed(BzrError):
1037
 
 
1038
 
    def __init__(self, revisions):
1039
 
        revision_str = ", ".join(str(r) for r in revisions)
1040
 
        msg = "Could not install revisions:\n%s" % revision_str
1041
 
        BzrError.__init__(self, msg)
1042
 
        self.revisions = revisions
1043
 
 
1044
 
 
1045
 
class AmbiguousBase(BzrError):
1046
 
 
1047
 
    def __init__(self, bases):
1048
 
        warn("BzrError AmbiguousBase has been deprecated as of bzrlib 0.8.",
1049
 
                DeprecationWarning)
1050
 
        msg = ("The correct base is unclear, because %s are all equally close"
1051
 
                % ", ".join(bases))
1052
 
        BzrError.__init__(self, msg)
1053
 
        self.bases = bases
1054
 
 
1055
 
 
1056
 
class NoCommits(BzrError):
 
1252
class NoCommits(BranchError):
1057
1253
 
1058
1254
    _fmt = "Branch %(branch)s has no commits."
1059
1255
 
1060
 
    def __init__(self, branch):
1061
 
        BzrError.__init__(self, branch=branch)
1062
 
 
1063
1256
 
1064
1257
class UnlistableStore(BzrError):
1065
1258
 
1076
1269
 
1077
1270
class BoundBranchOutOfDate(BzrError):
1078
1271
 
1079
 
    _fmt = ("Bound branch %(branch)s is out of date"
1080
 
            " with master branch %(master)s.")
 
1272
    _fmt = ("Bound branch %(branch)s is out of date with master branch"
 
1273
            " %(master)s.%(extra_help)s")
1081
1274
 
1082
1275
    def __init__(self, branch, master):
1083
1276
        BzrError.__init__(self)
1084
1277
        self.branch = branch
1085
1278
        self.master = master
1086
 
 
1087
 
        
 
1279
        self.extra_help = ''
 
1280
 
 
1281
 
1088
1282
class CommitToDoubleBoundBranch(BzrError):
1089
1283
 
1090
1284
    _fmt = ("Cannot commit to branch %(branch)s."
1120
1314
 
1121
1315
class WeaveError(BzrError):
1122
1316
 
1123
 
    _fmt = "Error in processing weave: %(message)s"
 
1317
    _fmt = "Error in processing weave: %(msg)s"
1124
1318
 
1125
 
    def __init__(self, message=None):
 
1319
    def __init__(self, msg=None):
1126
1320
        BzrError.__init__(self)
1127
 
        self.message = message
 
1321
        self.msg = msg
1128
1322
 
1129
1323
 
1130
1324
class WeaveRevisionAlreadyPresent(WeaveError):
1159
1353
 
1160
1354
class WeaveParentMismatch(WeaveError):
1161
1355
 
1162
 
    _fmt = "Parents are mismatched between two revisions."
1163
 
    
 
1356
    _fmt = "Parents are mismatched between two revisions. %(msg)s"
 
1357
 
1164
1358
 
1165
1359
class WeaveInvalidChecksum(WeaveError):
1166
1360
 
1167
 
    _fmt = "Text did not match it's checksum: %(message)s"
 
1361
    _fmt = "Text did not match its checksum: %(msg)s"
1168
1362
 
1169
1363
 
1170
1364
class WeaveTextDiffers(WeaveError):
1192
1386
 
1193
1387
 
1194
1388
class VersionedFileError(BzrError):
1195
 
    
 
1389
 
1196
1390
    _fmt = "Versioned file error"
1197
1391
 
1198
1392
 
1199
1393
class RevisionNotPresent(VersionedFileError):
1200
 
    
1201
 
    _fmt = "Revision {%(revision_id)s} not present in %(file_id)s."
 
1394
 
 
1395
    _fmt = 'Revision {%(revision_id)s} not present in "%(file_id)s".'
1202
1396
 
1203
1397
    def __init__(self, revision_id, file_id):
1204
1398
        VersionedFileError.__init__(self)
1207
1401
 
1208
1402
 
1209
1403
class RevisionAlreadyPresent(VersionedFileError):
1210
 
    
1211
 
    _fmt = "Revision {%(revision_id)s} already present in %(file_id)s."
 
1404
 
 
1405
    _fmt = 'Revision {%(revision_id)s} already present in "%(file_id)s".'
1212
1406
 
1213
1407
    def __init__(self, revision_id, file_id):
1214
1408
        VersionedFileError.__init__(self)
1216
1410
        self.file_id = file_id
1217
1411
 
1218
1412
 
1219
 
class KnitError(BzrError):
1220
 
    
 
1413
class VersionedFileInvalidChecksum(VersionedFileError):
 
1414
 
 
1415
    _fmt = "Text did not match its checksum: %(msg)s"
 
1416
 
 
1417
 
 
1418
class KnitError(InternalBzrError):
 
1419
 
1221
1420
    _fmt = "Knit error"
1222
1421
 
1223
 
    internal_error = True
1224
 
 
1225
 
 
1226
 
class KnitHeaderError(KnitError):
1227
 
 
1228
 
    _fmt = "Knit header error: %(badline)r unexpected for file %(filename)s"
1229
 
 
1230
 
    def __init__(self, badline, filename):
1231
 
        KnitError.__init__(self)
1232
 
        self.badline = badline
1233
 
        self.filename = filename
1234
 
 
1235
1422
 
1236
1423
class KnitCorrupt(KnitError):
1237
1424
 
1243
1430
        self.how = how
1244
1431
 
1245
1432
 
 
1433
class SHA1KnitCorrupt(KnitCorrupt):
 
1434
 
 
1435
    _fmt = ("Knit %(filename)s corrupt: sha-1 of reconstructed text does not "
 
1436
        "match expected sha-1. key %(key)s expected sha %(expected)s actual "
 
1437
        "sha %(actual)s")
 
1438
 
 
1439
    def __init__(self, filename, actual, expected, key, content):
 
1440
        KnitError.__init__(self)
 
1441
        self.filename = filename
 
1442
        self.actual = actual
 
1443
        self.expected = expected
 
1444
        self.key = key
 
1445
        self.content = content
 
1446
 
 
1447
 
 
1448
class KnitDataStreamIncompatible(KnitError):
 
1449
    # Not raised anymore, as we can convert data streams.  In future we may
 
1450
    # need it again for more exotic cases, so we're keeping it around for now.
 
1451
 
 
1452
    _fmt = "Cannot insert knit data stream of format \"%(stream_format)s\" into knit of format \"%(target_format)s\"."
 
1453
 
 
1454
    def __init__(self, stream_format, target_format):
 
1455
        self.stream_format = stream_format
 
1456
        self.target_format = target_format
 
1457
 
 
1458
 
 
1459
class KnitDataStreamUnknown(KnitError):
 
1460
    # Indicates a data stream we don't know how to handle.
 
1461
 
 
1462
    _fmt = "Cannot parse knit data stream of format \"%(stream_format)s\"."
 
1463
 
 
1464
    def __init__(self, stream_format):
 
1465
        self.stream_format = stream_format
 
1466
 
 
1467
 
 
1468
class KnitHeaderError(KnitError):
 
1469
 
 
1470
    _fmt = 'Knit header error: %(badline)r unexpected for file "%(filename)s".'
 
1471
 
 
1472
    def __init__(self, badline, filename):
 
1473
        KnitError.__init__(self)
 
1474
        self.badline = badline
 
1475
        self.filename = filename
 
1476
 
1246
1477
class KnitIndexUnknownMethod(KnitError):
1247
1478
    """Raised when we don't understand the storage method.
1248
1479
 
1249
1480
    Currently only 'fulltext' and 'line-delta' are supported.
1250
1481
    """
1251
 
    
 
1482
 
1252
1483
    _fmt = ("Knit index %(filename)s does not have a known method"
1253
1484
            " in options: %(options)r")
1254
1485
 
1258
1489
        self.options = options
1259
1490
 
1260
1491
 
 
1492
class RetryWithNewPacks(BzrError):
 
1493
    """Raised when we realize that the packs on disk have changed.
 
1494
 
 
1495
    This is meant as more of a signaling exception, to trap between where a
 
1496
    local error occurred and the code that can actually handle the error and
 
1497
    code that can retry appropriately.
 
1498
    """
 
1499
 
 
1500
    internal_error = True
 
1501
 
 
1502
    _fmt = ("Pack files have changed, reload and retry. context: %(context)s"
 
1503
            " %(orig_error)s")
 
1504
 
 
1505
    def __init__(self, context, reload_occurred, exc_info):
 
1506
        """create a new RetryWithNewPacks error.
 
1507
 
 
1508
        :param reload_occurred: Set to True if we know that the packs have
 
1509
            already been reloaded, and we are failing because of an in-memory
 
1510
            cache miss. If set to True then we will ignore if a reload says
 
1511
            nothing has changed, because we assume it has already reloaded. If
 
1512
            False, then a reload with nothing changed will force an error.
 
1513
        :param exc_info: The original exception traceback, so if there is a
 
1514
            problem we can raise the original error (value from sys.exc_info())
 
1515
        """
 
1516
        BzrError.__init__(self)
 
1517
        self.context = context
 
1518
        self.reload_occurred = reload_occurred
 
1519
        self.exc_info = exc_info
 
1520
        self.orig_error = exc_info[1]
 
1521
        # TODO: The global error handler should probably treat this by
 
1522
        #       raising/printing the original exception with a bit about
 
1523
        #       RetryWithNewPacks also not being caught
 
1524
 
 
1525
 
 
1526
class RetryAutopack(RetryWithNewPacks):
 
1527
    """Raised when we are autopacking and we find a missing file.
 
1528
 
 
1529
    Meant as a signaling exception, to tell the autopack code it should try
 
1530
    again.
 
1531
    """
 
1532
 
 
1533
    internal_error = True
 
1534
 
 
1535
    _fmt = ("Pack files have changed, reload and try autopack again."
 
1536
            " context: %(context)s %(orig_error)s")
 
1537
 
 
1538
 
1261
1539
class NoSuchExportFormat(BzrError):
1262
 
    
 
1540
 
1263
1541
    _fmt = "Export format %(format)r not supported"
1264
1542
 
1265
1543
    def __init__(self, format):
1268
1546
 
1269
1547
 
1270
1548
class TransportError(BzrError):
1271
 
    
 
1549
 
1272
1550
    _fmt = "Transport error: %(msg)s %(orig_error)s"
1273
1551
 
1274
1552
    def __init__(self, msg=None, orig_error=None):
1283
1561
        BzrError.__init__(self)
1284
1562
 
1285
1563
 
1286
 
class TooManyConcurrentRequests(BzrError):
 
1564
class TooManyConcurrentRequests(InternalBzrError):
1287
1565
 
1288
1566
    _fmt = ("The medium '%(medium)s' has reached its concurrent request limit."
1289
1567
            " Be sure to finish_writing and finish_reading on the"
1290
1568
            " currently open request.")
1291
1569
 
1292
 
    internal_error = True
1293
 
 
1294
1570
    def __init__(self, medium):
1295
1571
        self.medium = medium
1296
1572
 
1303
1579
        self.details = details
1304
1580
 
1305
1581
 
 
1582
class UnexpectedProtocolVersionMarker(TransportError):
 
1583
 
 
1584
    _fmt = "Received bad protocol version marker: %(marker)r"
 
1585
 
 
1586
    def __init__(self, marker):
 
1587
        self.marker = marker
 
1588
 
 
1589
 
 
1590
class UnknownSmartMethod(InternalBzrError):
 
1591
 
 
1592
    _fmt = "The server does not recognise the '%(verb)s' request."
 
1593
 
 
1594
    def __init__(self, verb):
 
1595
        self.verb = verb
 
1596
 
 
1597
 
 
1598
class SmartMessageHandlerError(InternalBzrError):
 
1599
 
 
1600
    _fmt = ("The message handler raised an exception:\n"
 
1601
            "%(traceback_text)s")
 
1602
 
 
1603
    def __init__(self, exc_info):
 
1604
        import traceback
 
1605
        # GZ 2010-08-10: Cycle with exc_tb/exc_info affects at least one test
 
1606
        self.exc_type, self.exc_value, self.exc_tb = exc_info
 
1607
        self.exc_info = exc_info
 
1608
        traceback_strings = traceback.format_exception(
 
1609
                self.exc_type, self.exc_value, self.exc_tb)
 
1610
        self.traceback_text = ''.join(traceback_strings)
 
1611
 
 
1612
 
1306
1613
# A set of semi-meaningful errors which can be thrown
1307
1614
class TransportNotPossible(TransportError):
1308
1615
 
1333
1640
            self.port = ':%s' % port
1334
1641
 
1335
1642
 
 
1643
# XXX: This is also used for unexpected end of file, which is different at the
 
1644
# TCP level from "connection reset".
1336
1645
class ConnectionReset(TransportError):
1337
1646
 
1338
1647
    _fmt = "Connection closed: %(msg)s %(orig_error)s"
1339
1648
 
1340
1649
 
 
1650
class ConnectionTimeout(ConnectionError):
 
1651
 
 
1652
    _fmt = "Connection Timeout: %(msg)s%(orig_error)s"
 
1653
 
 
1654
 
1341
1655
class InvalidRange(TransportError):
1342
1656
 
1343
 
    _fmt = "Invalid range access in %(path)s at %(offset)s."
1344
 
    
1345
 
    def __init__(self, path, offset):
1346
 
        TransportError.__init__(self, ("Invalid range access in %s at %d"
1347
 
                                       % (path, offset)))
 
1657
    _fmt = "Invalid range access in %(path)s at %(offset)s: %(msg)s"
 
1658
 
 
1659
    def __init__(self, path, offset, msg=None):
 
1660
        TransportError.__init__(self, msg)
1348
1661
        self.path = path
1349
1662
        self.offset = offset
1350
1663
 
1351
1664
 
1352
1665
class InvalidHttpResponse(TransportError):
1353
1666
 
1354
 
    _fmt = "Invalid http response for %(path)s: %(msg)s"
 
1667
    _fmt = "Invalid http response for %(path)s: %(msg)s%(orig_error)s"
1355
1668
 
1356
1669
    def __init__(self, path, msg, orig_error=None):
1357
1670
        self.path = path
 
1671
        if orig_error is None:
 
1672
            orig_error = ''
 
1673
        else:
 
1674
            # This is reached for obscure and unusual errors so we want to
 
1675
            # preserve as much info as possible to ease debug.
 
1676
            orig_error = ': %r' % (orig_error,)
1358
1677
        TransportError.__init__(self, msg, orig_error=orig_error)
1359
1678
 
1360
1679
 
 
1680
class CertificateError(TransportError):
 
1681
 
 
1682
    _fmt = "Certificate error: %(error)s"
 
1683
 
 
1684
    def __init__(self, error):
 
1685
        self.error = error
 
1686
 
 
1687
 
1361
1688
class InvalidHttpRange(InvalidHttpResponse):
1362
1689
 
1363
1690
    _fmt = "Invalid http range %(range)r for %(path)s: %(msg)s"
1364
 
    
 
1691
 
1365
1692
    def __init__(self, path, range, msg):
1366
1693
        self.range = range
1367
1694
        InvalidHttpResponse.__init__(self, path, msg)
1368
1695
 
1369
1696
 
 
1697
class HttpBoundaryMissing(InvalidHttpResponse):
 
1698
    """A multipart response ends with no boundary marker.
 
1699
 
 
1700
    This is a special case caused by buggy proxies, described in
 
1701
    <https://bugs.launchpad.net/bzr/+bug/198646>.
 
1702
    """
 
1703
 
 
1704
    _fmt = "HTTP MIME Boundary missing for %(path)s: %(msg)s"
 
1705
 
 
1706
    def __init__(self, path, msg):
 
1707
        InvalidHttpResponse.__init__(self, path, msg)
 
1708
 
 
1709
 
1370
1710
class InvalidHttpContentType(InvalidHttpResponse):
1371
1711
 
1372
1712
    _fmt = 'Invalid http Content-type "%(ctype)s" for %(path)s: %(msg)s'
1373
 
    
 
1713
 
1374
1714
    def __init__(self, path, ctype, msg):
1375
1715
        self.ctype = ctype
1376
1716
        InvalidHttpResponse.__init__(self, path, msg)
1380
1720
 
1381
1721
    _fmt = '%(source)s is%(permanently)s redirected to %(target)s'
1382
1722
 
1383
 
    def __init__(self, source, target, is_permament=False, qual_proto=None):
 
1723
    def __init__(self, source, target, is_permanent=False):
1384
1724
        self.source = source
1385
1725
        self.target = target
1386
 
        if is_permament:
 
1726
        if is_permanent:
1387
1727
            self.permanently = ' permanently'
1388
1728
        else:
1389
1729
            self.permanently = ''
1390
 
        self.is_permament = is_permament
1391
 
        self._qualified_proto = qual_proto
1392
1730
        TransportError.__init__(self)
1393
1731
 
1394
 
    def _requalify_url(self, url):
1395
 
        """Restore the qualified proto in front of the url"""
1396
 
        # When this exception is raised, source and target are in
1397
 
        # user readable format. But some transports may use a
1398
 
        # different proto (http+urllib:// will present http:// to
1399
 
        # the user. If a qualified proto is specified, the code
1400
 
        # trapping the exception can get the qualified urls to
1401
 
        # properly handle the redirection themself (creating a
1402
 
        # new transport object from the target url for example).
1403
 
        # But checking that the scheme of the original and
1404
 
        # redirected urls are the same can be tricky. (see the
1405
 
        # FIXME in BzrDir.open_from_transport for the unique use
1406
 
        # case so far).
1407
 
        if self._qualified_proto is None:
1408
 
            return url
1409
 
 
1410
 
        # The TODO related to NotBranchError mention that doing
1411
 
        # that kind of manipulation on the urls may not be the
1412
 
        # exception object job. On the other hand, this object is
1413
 
        # the interface between the code and the user so
1414
 
        # presenting the urls in different ways is indeed its
1415
 
        # job...
1416
 
        import urlparse
1417
 
        proto, netloc, path, query, fragment = urlparse.urlsplit(url)
1418
 
        return urlparse.urlunsplit((self._qualified_proto, netloc, path,
1419
 
                                   query, fragment))
1420
 
 
1421
 
    def get_source_url(self):
1422
 
        return self._requalify_url(self.source)
1423
 
 
1424
 
    def get_target_url(self):
1425
 
        return self._requalify_url(self.target)
1426
 
 
1427
1732
 
1428
1733
class TooManyRedirections(TransportError):
1429
1734
 
1430
1735
    _fmt = "Too many redirections"
1431
1736
 
 
1737
 
1432
1738
class ConflictsInTree(BzrError):
1433
1739
 
1434
1740
    _fmt = "Working tree has conflicts."
1435
1741
 
1436
1742
 
 
1743
class ConfigContentError(BzrError):
 
1744
 
 
1745
    _fmt = "Config file %(filename)s is not UTF-8 encoded\n"
 
1746
 
 
1747
    def __init__(self, filename):
 
1748
        BzrError.__init__(self)
 
1749
        self.filename = filename
 
1750
 
 
1751
 
1437
1752
class ParseConfigError(BzrError):
1438
1753
 
 
1754
    _fmt = "Error(s) parsing config file %(filename)s:\n%(errors)s"
 
1755
 
1439
1756
    def __init__(self, errors, filename):
1440
 
        if filename is None:
1441
 
            filename = ""
1442
 
        message = "Error(s) parsing config file %s:\n%s" % \
1443
 
            (filename, ('\n'.join(e.message for e in errors)))
1444
 
        BzrError.__init__(self, message)
 
1757
        BzrError.__init__(self)
 
1758
        self.filename = filename
 
1759
        self.errors = '\n'.join(e.msg for e in errors)
 
1760
 
 
1761
 
 
1762
class ConfigOptionValueError(BzrError):
 
1763
 
 
1764
    _fmt = ('Bad value "%(value)s" for option "%(name)s".\n'
 
1765
            'See ``bzr help %(name)s``')
 
1766
 
 
1767
    def __init__(self, name, value):
 
1768
        BzrError.__init__(self, name=name, value=value)
1445
1769
 
1446
1770
 
1447
1771
class NoEmailInUsername(BzrError):
1455
1779
 
1456
1780
class SigningFailed(BzrError):
1457
1781
 
1458
 
    _fmt = "Failed to gpg sign data with command %(command_line)r"
 
1782
    _fmt = 'Failed to GPG sign data with command "%(command_line)s"'
1459
1783
 
1460
1784
    def __init__(self, command_line):
1461
1785
        BzrError.__init__(self, command_line=command_line)
1462
1786
 
1463
1787
 
 
1788
class SignatureVerificationFailed(BzrError):
 
1789
 
 
1790
    _fmt = 'Failed to verify GPG signature data with error "%(error)s"'
 
1791
 
 
1792
    def __init__(self, error):
 
1793
        BzrError.__init__(self, error=error)
 
1794
 
 
1795
 
 
1796
class DependencyNotPresent(BzrError):
 
1797
 
 
1798
    _fmt = 'Unable to import library "%(library)s": %(error)s'
 
1799
 
 
1800
    def __init__(self, library, error):
 
1801
        BzrError.__init__(self, library=library, error=error)
 
1802
 
 
1803
 
 
1804
class GpgmeNotInstalled(DependencyNotPresent):
 
1805
 
 
1806
    _fmt = 'python-gpgme is not installed, it is needed to verify signatures'
 
1807
 
 
1808
    def __init__(self, error):
 
1809
        DependencyNotPresent.__init__(self, 'gpgme', error)
 
1810
 
 
1811
 
1464
1812
class WorkingTreeNotRevision(BzrError):
1465
1813
 
1466
 
    _fmt = ("The working tree for %(basedir)s has changed since" 
 
1814
    _fmt = ("The working tree for %(basedir)s has changed since"
1467
1815
            " the last commit, but weave merge requires that it be"
1468
1816
            " unchanged")
1469
1817
 
1486
1834
        self.graph = graph
1487
1835
 
1488
1836
 
1489
 
class WritingCompleted(BzrError):
 
1837
class WritingCompleted(InternalBzrError):
1490
1838
 
1491
1839
    _fmt = ("The MediumRequest '%(request)s' has already had finish_writing "
1492
1840
            "called upon it - accept bytes may not be called anymore.")
1493
1841
 
1494
 
    internal_error = True
1495
 
 
1496
1842
    def __init__(self, request):
1497
1843
        self.request = request
1498
1844
 
1499
1845
 
1500
 
class WritingNotComplete(BzrError):
 
1846
class WritingNotComplete(InternalBzrError):
1501
1847
 
1502
1848
    _fmt = ("The MediumRequest '%(request)s' has not has finish_writing "
1503
1849
            "called upon it - until the write phase is complete no "
1504
1850
            "data may be read.")
1505
1851
 
1506
 
    internal_error = True
1507
 
 
1508
1852
    def __init__(self, request):
1509
1853
        self.request = request
1510
1854
 
1518
1862
        self.filename = filename
1519
1863
 
1520
1864
 
1521
 
class MediumNotConnected(BzrError):
 
1865
class MediumNotConnected(InternalBzrError):
1522
1866
 
1523
1867
    _fmt = """The medium '%(medium)s' is not connected."""
1524
1868
 
1525
 
    internal_error = True
1526
 
 
1527
1869
    def __init__(self, medium):
1528
1870
        self.medium = medium
1529
1871
 
1535
1877
 
1536
1878
class NoBundleFound(BzrError):
1537
1879
 
1538
 
    _fmt = "No bundle was found in %(filename)s"
 
1880
    _fmt = 'No bundle was found in "%(filename)s".'
1539
1881
 
1540
1882
    def __init__(self, filename):
1541
1883
        BzrError.__init__(self)
1588
1930
        self.prefix = prefix
1589
1931
 
1590
1932
 
1591
 
class MalformedTransform(BzrError):
 
1933
class MalformedTransform(InternalBzrError):
1592
1934
 
1593
1935
    _fmt = "Tree transform is malformed %(conflicts)r"
1594
1936
 
1605
1947
        self.root_trans_id = transform.root
1606
1948
 
1607
1949
 
1608
 
class BzrBadParameter(BzrError):
 
1950
class BzrBadParameter(InternalBzrError):
1609
1951
 
1610
1952
    _fmt = "Bad parameter: %(param)r"
1611
1953
 
1612
 
    internal_error = True
1613
 
 
1614
1954
    # This exception should never be thrown, but it is a base class for all
1615
1955
    # parameter-to-function errors.
1616
1956
 
1634
1974
    _fmt = "Moving the root directory is not supported at this time"
1635
1975
 
1636
1976
 
 
1977
class TransformRenameFailed(BzrError):
 
1978
 
 
1979
    _fmt = "Failed to rename %(from_path)s to %(to_path)s: %(why)s"
 
1980
 
 
1981
    def __init__(self, from_path, to_path, why, errno):
 
1982
        self.from_path = from_path
 
1983
        self.to_path = to_path
 
1984
        self.why = why
 
1985
        self.errno = errno
 
1986
 
 
1987
 
1637
1988
class BzrMoveFailedError(BzrError):
1638
1989
 
1639
 
    _fmt = "Could not move %(from_path)s%(operator)s %(to_path)s%(extra)s"
 
1990
    _fmt = ("Could not move %(from_path)s%(operator)s %(to_path)s"
 
1991
        "%(_has_extra)s%(extra)s")
1640
1992
 
1641
1993
    def __init__(self, from_path='', to_path='', extra=None):
 
1994
        from bzrlib.osutils import splitpath
1642
1995
        BzrError.__init__(self)
1643
1996
        if extra:
1644
 
            self.extra = ': ' + str(extra)
 
1997
            self.extra, self._has_extra = extra, ': '
1645
1998
        else:
1646
 
            self.extra = ''
 
1999
            self.extra = self._has_extra = ''
1647
2000
 
1648
2001
        has_from = len(from_path) > 0
1649
2002
        has_to = len(to_path) > 0
1650
2003
        if has_from:
1651
 
            self.from_path = osutils.splitpath(from_path)[-1]
 
2004
            self.from_path = splitpath(from_path)[-1]
1652
2005
        else:
1653
2006
            self.from_path = ''
1654
2007
 
1655
2008
        if has_to:
1656
 
            self.to_path = osutils.splitpath(to_path)[-1]
 
2009
            self.to_path = splitpath(to_path)[-1]
1657
2010
        else:
1658
2011
            self.to_path = ''
1659
2012
 
1670
2023
 
1671
2024
class BzrRenameFailedError(BzrMoveFailedError):
1672
2025
 
1673
 
    _fmt = "Could not rename %(from_path)s%(operator)s %(to_path)s%(extra)s"
 
2026
    _fmt = ("Could not rename %(from_path)s%(operator)s %(to_path)s"
 
2027
        "%(_has_extra)s%(extra)s")
1674
2028
 
1675
2029
    def __init__(self, from_path, to_path, extra=None):
1676
2030
        BzrMoveFailedError.__init__(self, from_path, to_path, extra)
1677
2031
 
1678
 
class BzrRemoveChangedFilesError(BzrError):
1679
 
    """Used when user is trying to remove changed files."""
1680
 
 
1681
 
    _fmt = ("Can't remove changed or unknown files:\n%(changes_as_text)s"
1682
 
        "Use --keep to not delete them, or --force to delete them regardless.")
1683
 
 
1684
 
    def __init__(self, tree_delta):
1685
 
        BzrError.__init__(self)
1686
 
        self.changes_as_text = tree_delta.get_changes_as_text()
1687
 
        #self.paths_as_string = '\n'.join(changed_files)
1688
 
        #self.paths_as_string = '\n'.join([quotefn(p) for p in changed_files])
1689
 
 
1690
2032
 
1691
2033
class BzrBadParameterNotString(BzrBadParameter):
1692
2034
 
1695
2037
 
1696
2038
class BzrBadParameterMissing(BzrBadParameter):
1697
2039
 
1698
 
    _fmt = "Parameter $(param)s is required but not present."
 
2040
    _fmt = "Parameter %(param)s is required but not present."
1699
2041
 
1700
2042
 
1701
2043
class BzrBadParameterUnicode(BzrBadParameter):
1709
2051
    _fmt = "Parameter %(param)s contains a newline."
1710
2052
 
1711
2053
 
1712
 
class DependencyNotPresent(BzrError):
1713
 
 
1714
 
    _fmt = 'Unable to import library "%(library)s": %(error)s'
1715
 
 
1716
 
    def __init__(self, library, error):
1717
 
        BzrError.__init__(self, library=library, error=error)
1718
 
 
1719
 
 
1720
2054
class ParamikoNotPresent(DependencyNotPresent):
1721
2055
 
1722
2056
    _fmt = "Unable to import paramiko (required for sftp support): %(error)s"
1741
2075
 
1742
2076
class BadConversionTarget(BzrError):
1743
2077
 
1744
 
    _fmt = "Cannot convert to format %(format)s.  %(problem)s"
 
2078
    _fmt = "Cannot convert from format %(from_format)s to format %(format)s." \
 
2079
            "    %(problem)s"
1745
2080
 
1746
 
    def __init__(self, problem, format):
 
2081
    def __init__(self, problem, format, from_format=None):
1747
2082
        BzrError.__init__(self)
1748
2083
        self.problem = problem
1749
2084
        self.format = format
 
2085
        self.from_format = from_format or '(unspecified)'
 
2086
 
 
2087
 
 
2088
class NoDiffFound(BzrError):
 
2089
 
 
2090
    _fmt = 'Could not find an appropriate Differ for file "%(path)s"'
 
2091
 
 
2092
    def __init__(self, path):
 
2093
        BzrError.__init__(self, path)
 
2094
 
 
2095
 
 
2096
class ExecutableMissing(BzrError):
 
2097
 
 
2098
    _fmt = "%(exe_name)s could not be found on this machine"
 
2099
 
 
2100
    def __init__(self, exe_name):
 
2101
        BzrError.__init__(self, exe_name=exe_name)
1750
2102
 
1751
2103
 
1752
2104
class NoDiff(BzrError):
1762
2114
    _fmt = "Diff3 is not installed on this machine."
1763
2115
 
1764
2116
 
 
2117
class ExistingContent(BzrError):
 
2118
    # Added in bzrlib 0.92, used by VersionedFile.add_lines.
 
2119
 
 
2120
    _fmt = "The content being inserted is already present."
 
2121
 
 
2122
 
1765
2123
class ExistingLimbo(BzrError):
1766
2124
 
1767
2125
    _fmt = """This tree contains left-over files from a failed operation.
1768
2126
    Please examine %(limbo_dir)s to see if it contains any files you wish to
1769
2127
    keep, and delete it when you are done."""
1770
 
    
 
2128
 
1771
2129
    def __init__(self, limbo_dir):
1772
2130
       BzrError.__init__(self)
1773
2131
       self.limbo_dir = limbo_dir
1774
2132
 
1775
2133
 
 
2134
class ExistingPendingDeletion(BzrError):
 
2135
 
 
2136
    _fmt = """This tree contains left-over files from a failed operation.
 
2137
    Please examine %(pending_deletion)s to see if it contains any files you
 
2138
    wish to keep, and delete it when you are done."""
 
2139
 
 
2140
    def __init__(self, pending_deletion):
 
2141
       BzrError.__init__(self, pending_deletion=pending_deletion)
 
2142
 
 
2143
 
1776
2144
class ImmortalLimbo(BzrError):
1777
2145
 
1778
 
    _fmt = """Unable to delete transform temporary directory $(limbo_dir)s.
 
2146
    _fmt = """Unable to delete transform temporary directory %(limbo_dir)s.
1779
2147
    Please examine %(limbo_dir)s to see if it contains any files you wish to
1780
2148
    keep, and delete it when you are done."""
1781
2149
 
1784
2152
       self.limbo_dir = limbo_dir
1785
2153
 
1786
2154
 
 
2155
class ImmortalPendingDeletion(BzrError):
 
2156
 
 
2157
    _fmt = ("Unable to delete transform temporary directory "
 
2158
    "%(pending_deletion)s.  Please examine %(pending_deletion)s to see if it "
 
2159
    "contains any files you wish to keep, and delete it when you are done.")
 
2160
 
 
2161
    def __init__(self, pending_deletion):
 
2162
       BzrError.__init__(self, pending_deletion=pending_deletion)
 
2163
 
 
2164
 
1787
2165
class OutOfDateTree(BzrError):
1788
2166
 
1789
 
    _fmt = "Working tree is out of date, please run 'bzr update'."
 
2167
    _fmt = "Working tree is out of date, please run 'bzr update'.%(more)s"
1790
2168
 
1791
 
    def __init__(self, tree):
 
2169
    def __init__(self, tree, more=None):
 
2170
        if more is None:
 
2171
            more = ''
 
2172
        else:
 
2173
            more = ' ' + more
1792
2174
        BzrError.__init__(self)
1793
2175
        self.tree = tree
 
2176
        self.more = more
1794
2177
 
1795
2178
 
1796
2179
class PublicBranchOutOfDate(BzrError):
1816
2199
    _fmt = "Format error in conflict listings"
1817
2200
 
1818
2201
 
 
2202
class CorruptDirstate(BzrError):
 
2203
 
 
2204
    _fmt = ("Inconsistency in dirstate file %(dirstate_path)s.\n"
 
2205
            "Error: %(description)s")
 
2206
 
 
2207
    def __init__(self, dirstate_path, description):
 
2208
        BzrError.__init__(self)
 
2209
        self.dirstate_path = dirstate_path
 
2210
        self.description = description
 
2211
 
 
2212
 
1819
2213
class CorruptRepository(BzrError):
1820
2214
 
1821
2215
    _fmt = ("An error has been detected in the repository %(repo_path)s.\n"
1823
2217
 
1824
2218
    def __init__(self, repo):
1825
2219
        BzrError.__init__(self)
1826
 
        self.repo_path = repo.bzrdir.root_transport.base
 
2220
        self.repo_path = repo.user_url
 
2221
 
 
2222
 
 
2223
class InconsistentDelta(BzrError):
 
2224
    """Used when we get a delta that is not valid."""
 
2225
 
 
2226
    _fmt = ("An inconsistent delta was supplied involving %(path)r,"
 
2227
            " %(file_id)r\nreason: %(reason)s")
 
2228
 
 
2229
    def __init__(self, path, file_id, reason):
 
2230
        BzrError.__init__(self)
 
2231
        self.path = path
 
2232
        self.file_id = file_id
 
2233
        self.reason = reason
 
2234
 
 
2235
 
 
2236
class InconsistentDeltaDelta(InconsistentDelta):
 
2237
    """Used when we get a delta that is not valid."""
 
2238
 
 
2239
    _fmt = ("An inconsistent delta was supplied: %(delta)r"
 
2240
            "\nreason: %(reason)s")
 
2241
 
 
2242
    def __init__(self, delta, reason):
 
2243
        BzrError.__init__(self)
 
2244
        self.delta = delta
 
2245
        self.reason = reason
1827
2246
 
1828
2247
 
1829
2248
class UpgradeRequired(BzrError):
1835
2254
        self.path = path
1836
2255
 
1837
2256
 
 
2257
class RepositoryUpgradeRequired(UpgradeRequired):
 
2258
 
 
2259
    _fmt = "To use this feature you must upgrade your repository at %(path)s."
 
2260
 
 
2261
 
 
2262
class RichRootUpgradeRequired(UpgradeRequired):
 
2263
 
 
2264
    _fmt = ("To use this feature you must upgrade your branch at %(path)s to"
 
2265
           " a format which supports rich roots.")
 
2266
 
 
2267
 
1838
2268
class LocalRequiresBoundBranch(BzrError):
1839
2269
 
1840
2270
    _fmt = "Cannot perform local-only commits on unbound branches."
1841
2271
 
1842
2272
 
1843
 
class MissingProgressBarFinish(BzrError):
1844
 
 
1845
 
    _fmt = "A nested progress bar was not 'finished' correctly."
1846
 
 
1847
 
 
1848
 
class InvalidProgressBarType(BzrError):
1849
 
 
1850
 
    _fmt = ("Environment variable BZR_PROGRESS_BAR='%(bar_type)s"
1851
 
            " is not a supported type Select one of: %(valid_types)s")
1852
 
 
1853
 
    def __init__(self, bar_type, valid_types):
1854
 
        BzrError.__init__(self, bar_type=bar_type, valid_types=valid_types)
1855
 
 
1856
 
 
1857
2273
class UnsupportedOperation(BzrError):
1858
2274
 
1859
2275
    _fmt = ("The method %(mname)s is not supported on"
1875
2291
    """
1876
2292
 
1877
2293
 
 
2294
class GhostTagsNotSupported(BzrError):
 
2295
 
 
2296
    _fmt = "Ghost tags not supported by format %(format)r."
 
2297
 
 
2298
    def __init__(self, format):
 
2299
        self.format = format
 
2300
 
 
2301
 
1878
2302
class BinaryFile(BzrError):
1879
 
    
 
2303
 
1880
2304
    _fmt = "File is binary but should be text."
1881
2305
 
1882
2306
 
1902
2326
 
1903
2327
 
1904
2328
class NotABundle(BzrError):
1905
 
    
 
2329
 
1906
2330
    _fmt = "Not a bzr revision-bundle: %(text)r"
1907
2331
 
1908
2332
    def __init__(self, text):
1910
2334
        self.text = text
1911
2335
 
1912
2336
 
1913
 
class BadBundle(BzrError): 
1914
 
    
 
2337
class BadBundle(BzrError):
 
2338
 
1915
2339
    _fmt = "Bad bzr revision-bundle: %(text)r"
1916
2340
 
1917
2341
    def __init__(self, text):
1919
2343
        self.text = text
1920
2344
 
1921
2345
 
1922
 
class MalformedHeader(BadBundle): 
1923
 
    
 
2346
class MalformedHeader(BadBundle):
 
2347
 
1924
2348
    _fmt = "Malformed bzr revision-bundle header: %(text)r"
1925
2349
 
1926
2350
 
1927
 
class MalformedPatches(BadBundle): 
1928
 
    
 
2351
class MalformedPatches(BadBundle):
 
2352
 
1929
2353
    _fmt = "Malformed patches in bzr revision-bundle: %(text)r"
1930
2354
 
1931
2355
 
1932
 
class MalformedFooter(BadBundle): 
1933
 
    
 
2356
class MalformedFooter(BadBundle):
 
2357
 
1934
2358
    _fmt = "Malformed footer in bzr revision-bundle: %(text)r"
1935
2359
 
1936
2360
 
1937
2361
class UnsupportedEOLMarker(BadBundle):
1938
 
    
1939
 
    _fmt = "End of line marker was not \\n in bzr revision-bundle"    
 
2362
 
 
2363
    _fmt = "End of line marker was not \\n in bzr revision-bundle"
1940
2364
 
1941
2365
    def __init__(self):
1942
 
        # XXX: BadBundle's constructor assumes there's explanatory text, 
 
2366
        # XXX: BadBundle's constructor assumes there's explanatory text,
1943
2367
        # but for this there is not
1944
2368
        BzrError.__init__(self)
1945
2369
 
1946
2370
 
1947
2371
class IncompatibleBundleFormat(BzrError):
1948
 
    
 
2372
 
1949
2373
    _fmt = "Bundle format %(bundle_format)s is incompatible with %(other)s"
1950
2374
 
1951
2375
    def __init__(self, bundle_format, other):
1955
2379
 
1956
2380
 
1957
2381
class BadInventoryFormat(BzrError):
1958
 
    
 
2382
 
1959
2383
    _fmt = "Root class for inventory serialization errors"
1960
2384
 
1961
2385
 
1972
2396
    _fmt = """This operation requires rich root data storage"""
1973
2397
 
1974
2398
 
1975
 
class NoSmartMedium(BzrError):
 
2399
class NoSmartMedium(InternalBzrError):
1976
2400
 
1977
2401
    _fmt = "The transport '%(transport)s' cannot tunnel the smart protocol."
1978
2402
 
1979
 
    internal_error = True
1980
 
 
1981
2403
    def __init__(self, transport):
1982
2404
        self.transport = transport
1983
2405
 
1984
2406
 
1985
 
class NoSmartServer(NotBranchError):
1986
 
 
1987
 
    _fmt = "No smart server available at %(url)s"
1988
 
 
1989
 
    def __init__(self, url):
1990
 
        self.url = url
1991
 
 
1992
 
 
1993
2407
class UnknownSSH(BzrError):
1994
2408
 
1995
2409
    _fmt = "Unrecognised value for BZR_SSH environment variable: %(vendor)s"
2005
2419
            " Please set BZR_SSH environment variable.")
2006
2420
 
2007
2421
 
 
2422
class GhostRevisionsHaveNoRevno(BzrError):
 
2423
    """When searching for revnos, if we encounter a ghost, we are stuck"""
 
2424
 
 
2425
    _fmt = ("Could not determine revno for {%(revision_id)s} because"
 
2426
            " its ancestry shows a ghost at {%(ghost_revision_id)s}")
 
2427
 
 
2428
    def __init__(self, revision_id, ghost_revision_id):
 
2429
        self.revision_id = revision_id
 
2430
        self.ghost_revision_id = ghost_revision_id
 
2431
 
 
2432
 
2008
2433
class GhostRevisionUnusableHere(BzrError):
2009
2434
 
2010
2435
    _fmt = "Ghost revision {%(revision_id)s} cannot be used here."
2014
2439
        self.revision_id = revision_id
2015
2440
 
2016
2441
 
2017
 
class IllegalUseOfScopeReplacer(BzrError):
 
2442
class IllegalUseOfScopeReplacer(InternalBzrError):
2018
2443
 
2019
2444
    _fmt = ("ScopeReplacer object %(name)r was used incorrectly:"
2020
2445
            " %(msg)s%(extra)s")
2021
2446
 
2022
 
    internal_error = True
2023
 
 
2024
2447
    def __init__(self, name, msg, extra=None):
2025
2448
        BzrError.__init__(self)
2026
2449
        self.name = name
2031
2454
            self.extra = ''
2032
2455
 
2033
2456
 
2034
 
class InvalidImportLine(BzrError):
 
2457
class InvalidImportLine(InternalBzrError):
2035
2458
 
2036
2459
    _fmt = "Not a valid import statement: %(msg)\n%(text)s"
2037
2460
 
2038
 
    internal_error = True
2039
 
 
2040
2461
    def __init__(self, text, msg):
2041
2462
        BzrError.__init__(self)
2042
2463
        self.text = text
2043
2464
        self.msg = msg
2044
2465
 
2045
2466
 
2046
 
class ImportNameCollision(BzrError):
 
2467
class ImportNameCollision(InternalBzrError):
2047
2468
 
2048
2469
    _fmt = ("Tried to import an object to the same name as"
2049
2470
            " an existing object. %(name)s")
2050
2471
 
2051
 
    internal_error = True
2052
 
 
2053
2472
    def __init__(self, name):
2054
2473
        BzrError.__init__(self)
2055
2474
        self.name = name
2068
2487
        " branch location."
2069
2488
 
2070
2489
 
 
2490
class IllegalMergeDirectivePayload(BzrError):
 
2491
    """A merge directive contained something other than a patch or bundle"""
 
2492
 
 
2493
    _fmt = "Bad merge directive payload %(start)r"
 
2494
 
 
2495
    def __init__(self, start):
 
2496
        BzrError(self)
 
2497
        self.start = start
 
2498
 
 
2499
 
 
2500
class PatchVerificationFailed(BzrError):
 
2501
    """A patch from a merge directive could not be verified"""
 
2502
 
 
2503
    _fmt = "Preview patch does not match requested changes."
 
2504
 
 
2505
 
2071
2506
class PatchMissing(BzrError):
2072
2507
    """Raise a patch type was specified but no patch supplied"""
2073
2508
 
2074
 
    _fmt = "patch_type was %(patch_type)s, but no patch was supplied."
 
2509
    _fmt = "Patch_type was %(patch_type)s, but no patch was supplied."
2075
2510
 
2076
2511
    def __init__(self, patch_type):
2077
2512
        BzrError.__init__(self)
2078
2513
        self.patch_type = patch_type
2079
2514
 
2080
2515
 
 
2516
class TargetNotBranch(BzrError):
 
2517
    """A merge directive's target branch is required, but isn't a branch"""
 
2518
 
 
2519
    _fmt = ("Your branch does not have all of the revisions required in "
 
2520
            "order to merge this merge directive and the target "
 
2521
            "location specified in the merge directive is not a branch: "
 
2522
            "%(location)s.")
 
2523
 
 
2524
    def __init__(self, location):
 
2525
        BzrError.__init__(self)
 
2526
        self.location = location
 
2527
 
 
2528
 
2081
2529
class UnsupportedInventoryKind(BzrError):
2082
 
    
 
2530
 
2083
2531
    _fmt = """Unsupported entry kind %(kind)s"""
2084
2532
 
2085
2533
    def __init__(self, kind):
2088
2536
 
2089
2537
class BadSubsumeSource(BzrError):
2090
2538
 
2091
 
    _fmt = """Can't subsume %(other_tree)s into %(tree)s.  %(reason)s"""
 
2539
    _fmt = "Can't subsume %(other_tree)s into %(tree)s. %(reason)s"
2092
2540
 
2093
2541
    def __init__(self, tree, other_tree, reason):
2094
2542
        self.tree = tree
2097
2545
 
2098
2546
 
2099
2547
class SubsumeTargetNeedsUpgrade(BzrError):
2100
 
    
 
2548
 
2101
2549
    _fmt = """Subsume target %(other_tree)s needs to be upgraded."""
2102
2550
 
2103
2551
    def __init__(self, other_tree):
2104
2552
        self.other_tree = other_tree
2105
2553
 
2106
2554
 
2107
 
class BadReferenceTarget(BzrError):
2108
 
 
2109
 
    _fmt = "Can't add reference to %(other_tree)s into %(tree)s.  %(reason)s"
2110
 
 
2111
 
    internal_error = True
 
2555
class BadReferenceTarget(InternalBzrError):
 
2556
 
 
2557
    _fmt = "Can't add reference to %(other_tree)s into %(tree)s." \
 
2558
           "%(reason)s"
2112
2559
 
2113
2560
    def __init__(self, tree, other_tree, reason):
2114
2561
        self.tree = tree
2127
2574
class TagsNotSupported(BzrError):
2128
2575
 
2129
2576
    _fmt = ("Tags not supported by %(branch)s;"
2130
 
            " you may be able to use bzr upgrade --dirstate-tags.")
 
2577
            " you may be able to use bzr upgrade.")
2131
2578
 
2132
2579
    def __init__(self, branch):
2133
2580
        self.branch = branch
2134
2581
 
2135
 
        
 
2582
 
2136
2583
class TagAlreadyExists(BzrError):
2137
2584
 
2138
2585
    _fmt = "Tag %(tag_name)s already exists."
2143
2590
 
2144
2591
class MalformedBugIdentifier(BzrError):
2145
2592
 
2146
 
    _fmt = "Did not understand bug identifier %(bug_id)s: %(reason)s"
 
2593
    _fmt = ('Did not understand bug identifier %(bug_id)s: %(reason)s. '
 
2594
            'See "bzr help bugs" for more information on this feature.')
2147
2595
 
2148
2596
    def __init__(self, bug_id, reason):
2149
2597
        self.bug_id = bug_id
2150
2598
        self.reason = reason
2151
2599
 
2152
2600
 
 
2601
class InvalidBugTrackerURL(BzrError):
 
2602
 
 
2603
    _fmt = ("The URL for bug tracker \"%(abbreviation)s\" doesn't "
 
2604
            "contain {id}: %(url)s")
 
2605
 
 
2606
    def __init__(self, abbreviation, url):
 
2607
        self.abbreviation = abbreviation
 
2608
        self.url = url
 
2609
 
 
2610
 
2153
2611
class UnknownBugTrackerAbbreviation(BzrError):
2154
2612
 
2155
2613
    _fmt = ("Cannot find registered bug tracker called %(abbreviation)s "
2160
2618
        self.branch = branch
2161
2619
 
2162
2620
 
 
2621
class InvalidLineInBugsProperty(BzrError):
 
2622
 
 
2623
    _fmt = ("Invalid line in bugs property: '%(line)s'")
 
2624
 
 
2625
    def __init__(self, line):
 
2626
        self.line = line
 
2627
 
 
2628
 
 
2629
class InvalidBugStatus(BzrError):
 
2630
 
 
2631
    _fmt = ("Invalid bug status: '%(status)s'")
 
2632
 
 
2633
    def __init__(self, status):
 
2634
        self.status = status
 
2635
 
 
2636
 
2163
2637
class UnexpectedSmartServerResponse(BzrError):
2164
2638
 
2165
2639
    _fmt = "Could not understand response from smart server: %(response_tuple)r"
2168
2642
        self.response_tuple = response_tuple
2169
2643
 
2170
2644
 
 
2645
class ErrorFromSmartServer(BzrError):
 
2646
    """An error was received from a smart server.
 
2647
 
 
2648
    :seealso: UnknownErrorFromSmartServer
 
2649
    """
 
2650
 
 
2651
    _fmt = "Error received from smart server: %(error_tuple)r"
 
2652
 
 
2653
    internal_error = True
 
2654
 
 
2655
    def __init__(self, error_tuple):
 
2656
        self.error_tuple = error_tuple
 
2657
        try:
 
2658
            self.error_verb = error_tuple[0]
 
2659
        except IndexError:
 
2660
            self.error_verb = None
 
2661
        self.error_args = error_tuple[1:]
 
2662
 
 
2663
 
 
2664
class UnknownErrorFromSmartServer(BzrError):
 
2665
    """An ErrorFromSmartServer could not be translated into a typical bzrlib
 
2666
    error.
 
2667
 
 
2668
    This is distinct from ErrorFromSmartServer so that it is possible to
 
2669
    distinguish between the following two cases:
 
2670
 
 
2671
    - ErrorFromSmartServer was uncaught.  This is logic error in the client
 
2672
      and so should provoke a traceback to the user.
 
2673
    - ErrorFromSmartServer was caught but its error_tuple could not be
 
2674
      translated.  This is probably because the server sent us garbage, and
 
2675
      should not provoke a traceback.
 
2676
    """
 
2677
 
 
2678
    _fmt = "Server sent an unexpected error: %(error_tuple)r"
 
2679
 
 
2680
    internal_error = False
 
2681
 
 
2682
    def __init__(self, error_from_smart_server):
 
2683
        """Constructor.
 
2684
 
 
2685
        :param error_from_smart_server: An ErrorFromSmartServer instance.
 
2686
        """
 
2687
        self.error_from_smart_server = error_from_smart_server
 
2688
        self.error_tuple = error_from_smart_server.error_tuple
 
2689
 
 
2690
 
2171
2691
class ContainerError(BzrError):
2172
2692
    """Base class of container errors."""
2173
2693
 
2175
2695
class UnknownContainerFormatError(ContainerError):
2176
2696
 
2177
2697
    _fmt = "Unrecognised container format: %(container_format)r"
2178
 
    
 
2698
 
2179
2699
    def __init__(self, container_format):
2180
2700
        self.container_format = container_format
2181
2701
 
2184
2704
 
2185
2705
    _fmt = "Unexpected end of container stream"
2186
2706
 
2187
 
    internal_error = False
2188
 
 
2189
2707
 
2190
2708
class UnknownRecordTypeError(ContainerError):
2191
2709
 
2213
2731
 
2214
2732
class DuplicateRecordNameError(ContainerError):
2215
2733
 
2216
 
    _fmt = "Container has multiple records with the same name: \"%(name)s\""
 
2734
    _fmt = "Container has multiple records with the same name: %(name)s"
2217
2735
 
2218
2736
    def __init__(self, name):
2219
 
        self.name = name
2220
 
 
2221
 
 
2222
 
class NoDestinationAddress(BzrError):
 
2737
        self.name = name.decode("utf-8")
 
2738
 
 
2739
 
 
2740
class NoDestinationAddress(InternalBzrError):
2223
2741
 
2224
2742
    _fmt = "Message does not have a destination address."
2225
2743
 
2226
 
    internal_error = True
 
2744
 
 
2745
class RepositoryDataStreamError(BzrError):
 
2746
 
 
2747
    _fmt = "Corrupt or incompatible data stream: %(reason)s"
 
2748
 
 
2749
    def __init__(self, reason):
 
2750
        self.reason = reason
2227
2751
 
2228
2752
 
2229
2753
class SMTPError(BzrError):
2232
2756
 
2233
2757
    def __init__(self, error):
2234
2758
        self.error = error
 
2759
 
 
2760
 
 
2761
class NoMessageSupplied(BzrError):
 
2762
 
 
2763
    _fmt = "No message supplied."
 
2764
 
 
2765
 
 
2766
class NoMailAddressSpecified(BzrError):
 
2767
 
 
2768
    _fmt = "No mail-to address (--mail-to) or output (-o) specified."
 
2769
 
 
2770
 
 
2771
class MailClientNotFound(BzrError):
 
2772
 
 
2773
    _fmt = "Unable to find mail client with the following names:"\
 
2774
        " %(mail_command_list_string)s"
 
2775
 
 
2776
    def __init__(self, mail_command_list):
 
2777
        mail_command_list_string = ', '.join(mail_command_list)
 
2778
        BzrError.__init__(self, mail_command_list=mail_command_list,
 
2779
                          mail_command_list_string=mail_command_list_string)
 
2780
 
 
2781
class SMTPConnectionRefused(SMTPError):
 
2782
 
 
2783
    _fmt = "SMTP connection to %(host)s refused"
 
2784
 
 
2785
    def __init__(self, error, host):
 
2786
        self.error = error
 
2787
        self.host = host
 
2788
 
 
2789
 
 
2790
class DefaultSMTPConnectionRefused(SMTPConnectionRefused):
 
2791
 
 
2792
    _fmt = "Please specify smtp_server.  No server at default %(host)s."
 
2793
 
 
2794
 
 
2795
class BzrDirError(BzrError):
 
2796
 
 
2797
    def __init__(self, bzrdir):
 
2798
        import bzrlib.urlutils as urlutils
 
2799
        display_url = urlutils.unescape_for_display(bzrdir.user_url,
 
2800
                                                    'ascii')
 
2801
        BzrError.__init__(self, bzrdir=bzrdir, display_url=display_url)
 
2802
 
 
2803
 
 
2804
class UnsyncedBranches(BzrDirError):
 
2805
 
 
2806
    _fmt = ("'%(display_url)s' is not in sync with %(target_url)s.  See"
 
2807
            " bzr help sync-for-reconfigure.")
 
2808
 
 
2809
    def __init__(self, bzrdir, target_branch):
 
2810
        BzrDirError.__init__(self, bzrdir)
 
2811
        import bzrlib.urlutils as urlutils
 
2812
        self.target_url = urlutils.unescape_for_display(target_branch.base,
 
2813
                                                        'ascii')
 
2814
 
 
2815
 
 
2816
class AlreadyBranch(BzrDirError):
 
2817
 
 
2818
    _fmt = "'%(display_url)s' is already a branch."
 
2819
 
 
2820
 
 
2821
class AlreadyTree(BzrDirError):
 
2822
 
 
2823
    _fmt = "'%(display_url)s' is already a tree."
 
2824
 
 
2825
 
 
2826
class AlreadyCheckout(BzrDirError):
 
2827
 
 
2828
    _fmt = "'%(display_url)s' is already a checkout."
 
2829
 
 
2830
 
 
2831
class AlreadyLightweightCheckout(BzrDirError):
 
2832
 
 
2833
    _fmt = "'%(display_url)s' is already a lightweight checkout."
 
2834
 
 
2835
 
 
2836
class AlreadyUsingShared(BzrDirError):
 
2837
 
 
2838
    _fmt = "'%(display_url)s' is already using a shared repository."
 
2839
 
 
2840
 
 
2841
class AlreadyStandalone(BzrDirError):
 
2842
 
 
2843
    _fmt = "'%(display_url)s' is already standalone."
 
2844
 
 
2845
 
 
2846
class AlreadyWithTrees(BzrDirError):
 
2847
 
 
2848
    _fmt = ("Shared repository '%(display_url)s' already creates "
 
2849
            "working trees.")
 
2850
 
 
2851
 
 
2852
class AlreadyWithNoTrees(BzrDirError):
 
2853
 
 
2854
    _fmt = ("Shared repository '%(display_url)s' already doesn't create "
 
2855
            "working trees.")
 
2856
 
 
2857
 
 
2858
class ReconfigurationNotSupported(BzrDirError):
 
2859
 
 
2860
    _fmt = "Requested reconfiguration of '%(display_url)s' is not supported."
 
2861
 
 
2862
 
 
2863
class NoBindLocation(BzrDirError):
 
2864
 
 
2865
    _fmt = "No location could be found to bind to at %(display_url)s."
 
2866
 
 
2867
 
 
2868
class UncommittedChanges(BzrError):
 
2869
 
 
2870
    _fmt = ('Working tree "%(display_url)s" has uncommitted changes'
 
2871
            ' (See bzr status).%(more)s')
 
2872
 
 
2873
    def __init__(self, tree, more=None):
 
2874
        if more is None:
 
2875
            more = ''
 
2876
        else:
 
2877
            more = ' ' + more
 
2878
        import bzrlib.urlutils as urlutils
 
2879
        user_url = getattr(tree, "user_url", None)
 
2880
        if user_url is None:
 
2881
            display_url = str(tree)
 
2882
        else:
 
2883
            display_url = urlutils.unescape_for_display(user_url, 'ascii')
 
2884
        BzrError.__init__(self, tree=tree, display_url=display_url, more=more)
 
2885
 
 
2886
 
 
2887
class ShelvedChanges(UncommittedChanges):
 
2888
 
 
2889
    _fmt = ('Working tree "%(display_url)s" has shelved changes'
 
2890
            ' (See bzr shelve --list).%(more)s')
 
2891
 
 
2892
 
 
2893
class MissingTemplateVariable(BzrError):
 
2894
 
 
2895
    _fmt = 'Variable {%(name)s} is not available.'
 
2896
 
 
2897
    def __init__(self, name):
 
2898
        self.name = name
 
2899
 
 
2900
 
 
2901
class NoTemplate(BzrError):
 
2902
 
 
2903
    _fmt = 'No template specified.'
 
2904
 
 
2905
 
 
2906
class UnableCreateSymlink(BzrError):
 
2907
 
 
2908
    _fmt = 'Unable to create symlink %(path_str)son this platform'
 
2909
 
 
2910
    def __init__(self, path=None):
 
2911
        path_str = ''
 
2912
        if path:
 
2913
            try:
 
2914
                path_str = repr(str(path))
 
2915
            except UnicodeEncodeError:
 
2916
                path_str = repr(path)
 
2917
            path_str += ' '
 
2918
        self.path_str = path_str
 
2919
 
 
2920
 
 
2921
class UnsupportedTimezoneFormat(BzrError):
 
2922
 
 
2923
    _fmt = ('Unsupported timezone format "%(timezone)s", '
 
2924
            'options are "utc", "original", "local".')
 
2925
 
 
2926
    def __init__(self, timezone):
 
2927
        self.timezone = timezone
 
2928
 
 
2929
 
 
2930
class CommandAvailableInPlugin(StandardError):
 
2931
 
 
2932
    internal_error = False
 
2933
 
 
2934
    def __init__(self, cmd_name, plugin_metadata, provider):
 
2935
 
 
2936
        self.plugin_metadata = plugin_metadata
 
2937
        self.cmd_name = cmd_name
 
2938
        self.provider = provider
 
2939
 
 
2940
    def __str__(self):
 
2941
 
 
2942
        _fmt = ('"%s" is not a standard bzr command. \n'
 
2943
                'However, the following official plugin provides this command: %s\n'
 
2944
                'You can install it by going to: %s'
 
2945
                % (self.cmd_name, self.plugin_metadata['name'],
 
2946
                    self.plugin_metadata['url']))
 
2947
 
 
2948
        return _fmt
 
2949
 
 
2950
 
 
2951
class NoPluginAvailable(BzrError):
 
2952
    pass
 
2953
 
 
2954
 
 
2955
class UnableEncodePath(BzrError):
 
2956
 
 
2957
    _fmt = ('Unable to encode %(kind)s path %(path)r in '
 
2958
            'user encoding %(user_encoding)s')
 
2959
 
 
2960
    def __init__(self, path, kind):
 
2961
        from bzrlib.osutils import get_user_encoding
 
2962
        self.path = path
 
2963
        self.kind = kind
 
2964
        self.user_encoding = get_user_encoding()
 
2965
 
 
2966
 
 
2967
class NoSuchConfig(BzrError):
 
2968
 
 
2969
    _fmt = ('The "%(config_id)s" configuration does not exist.')
 
2970
 
 
2971
    def __init__(self, config_id):
 
2972
        BzrError.__init__(self, config_id=config_id)
 
2973
 
 
2974
 
 
2975
class NoSuchConfigOption(BzrError):
 
2976
 
 
2977
    _fmt = ('The "%(option_name)s" configuration option does not exist.')
 
2978
 
 
2979
    def __init__(self, option_name):
 
2980
        BzrError.__init__(self, option_name=option_name)
 
2981
 
 
2982
 
 
2983
class NoSuchAlias(BzrError):
 
2984
 
 
2985
    _fmt = ('The alias "%(alias_name)s" does not exist.')
 
2986
 
 
2987
    def __init__(self, alias_name):
 
2988
        BzrError.__init__(self, alias_name=alias_name)
 
2989
 
 
2990
 
 
2991
class DirectoryLookupFailure(BzrError):
 
2992
    """Base type for lookup errors."""
 
2993
 
 
2994
    pass
 
2995
 
 
2996
 
 
2997
class InvalidLocationAlias(DirectoryLookupFailure):
 
2998
 
 
2999
    _fmt = '"%(alias_name)s" is not a valid location alias.'
 
3000
 
 
3001
    def __init__(self, alias_name):
 
3002
        DirectoryLookupFailure.__init__(self, alias_name=alias_name)
 
3003
 
 
3004
 
 
3005
class UnsetLocationAlias(DirectoryLookupFailure):
 
3006
 
 
3007
    _fmt = 'No %(alias_name)s location assigned.'
 
3008
 
 
3009
    def __init__(self, alias_name):
 
3010
        DirectoryLookupFailure.__init__(self, alias_name=alias_name[1:])
 
3011
 
 
3012
 
 
3013
class CannotBindAddress(BzrError):
 
3014
 
 
3015
    _fmt = 'Cannot bind address "%(host)s:%(port)i": %(orig_error)s.'
 
3016
 
 
3017
    def __init__(self, host, port, orig_error):
 
3018
        # nb: in python2.4 socket.error doesn't have a useful repr
 
3019
        BzrError.__init__(self, host=host, port=port,
 
3020
            orig_error=repr(orig_error.args))
 
3021
 
 
3022
 
 
3023
class UnknownRules(BzrError):
 
3024
 
 
3025
    _fmt = ('Unknown rules detected: %(unknowns_str)s.')
 
3026
 
 
3027
    def __init__(self, unknowns):
 
3028
        BzrError.__init__(self, unknowns_str=", ".join(unknowns))
 
3029
 
 
3030
 
 
3031
class TipChangeRejected(BzrError):
 
3032
    """A pre_change_branch_tip hook function may raise this to cleanly and
 
3033
    explicitly abort a change to a branch tip.
 
3034
    """
 
3035
 
 
3036
    _fmt = u"Tip change rejected: %(msg)s"
 
3037
 
 
3038
    def __init__(self, msg):
 
3039
        self.msg = msg
 
3040
 
 
3041
 
 
3042
class ShelfCorrupt(BzrError):
 
3043
 
 
3044
    _fmt = "Shelf corrupt."
 
3045
 
 
3046
 
 
3047
class DecompressCorruption(BzrError):
 
3048
 
 
3049
    _fmt = "Corruption while decompressing repository file%(orig_error)s"
 
3050
 
 
3051
    def __init__(self, orig_error=None):
 
3052
        if orig_error is not None:
 
3053
            self.orig_error = ", %s" % (orig_error,)
 
3054
        else:
 
3055
            self.orig_error = ""
 
3056
        BzrError.__init__(self)
 
3057
 
 
3058
 
 
3059
class NoSuchShelfId(BzrError):
 
3060
 
 
3061
    _fmt = 'No changes are shelved with id "%(shelf_id)d".'
 
3062
 
 
3063
    def __init__(self, shelf_id):
 
3064
        BzrError.__init__(self, shelf_id=shelf_id)
 
3065
 
 
3066
 
 
3067
class InvalidShelfId(BzrError):
 
3068
 
 
3069
    _fmt = '"%(invalid_id)s" is not a valid shelf id, try a number instead.'
 
3070
 
 
3071
    def __init__(self, invalid_id):
 
3072
        BzrError.__init__(self, invalid_id=invalid_id)
 
3073
 
 
3074
 
 
3075
class JailBreak(BzrError):
 
3076
 
 
3077
    _fmt = "An attempt to access a url outside the server jail was made: '%(url)s'."
 
3078
 
 
3079
    def __init__(self, url):
 
3080
        BzrError.__init__(self, url=url)
 
3081
 
 
3082
 
 
3083
class UserAbort(BzrError):
 
3084
 
 
3085
    _fmt = 'The user aborted the operation.'
 
3086
 
 
3087
 
 
3088
class MustHaveWorkingTree(BzrError):
 
3089
 
 
3090
    _fmt = ("Branching '%(url)s'(%(format)s) must create a working tree.")
 
3091
 
 
3092
    def __init__(self, format, url):
 
3093
        BzrError.__init__(self, format=format, url=url)
 
3094
 
 
3095
 
 
3096
class NoSuchView(BzrError):
 
3097
    """A view does not exist.
 
3098
    """
 
3099
 
 
3100
    _fmt = u"No such view: %(view_name)s."
 
3101
 
 
3102
    def __init__(self, view_name):
 
3103
        self.view_name = view_name
 
3104
 
 
3105
 
 
3106
class ViewsNotSupported(BzrError):
 
3107
    """Views are not supported by a tree format.
 
3108
    """
 
3109
 
 
3110
    _fmt = ("Views are not supported by %(tree)s;"
 
3111
            " use 'bzr upgrade' to change your tree to a later format.")
 
3112
 
 
3113
    def __init__(self, tree):
 
3114
        self.tree = tree
 
3115
 
 
3116
 
 
3117
class FileOutsideView(BzrError):
 
3118
 
 
3119
    _fmt = ('Specified file "%(file_name)s" is outside the current view: '
 
3120
            '%(view_str)s')
 
3121
 
 
3122
    def __init__(self, file_name, view_files):
 
3123
        self.file_name = file_name
 
3124
        self.view_str = ", ".join(view_files)
 
3125
 
 
3126
 
 
3127
class UnresumableWriteGroup(BzrError):
 
3128
 
 
3129
    _fmt = ("Repository %(repository)s cannot resume write group "
 
3130
            "%(write_groups)r: %(reason)s")
 
3131
 
 
3132
    internal_error = True
 
3133
 
 
3134
    def __init__(self, repository, write_groups, reason):
 
3135
        self.repository = repository
 
3136
        self.write_groups = write_groups
 
3137
        self.reason = reason
 
3138
 
 
3139
 
 
3140
class UnsuspendableWriteGroup(BzrError):
 
3141
 
 
3142
    _fmt = ("Repository %(repository)s cannot suspend a write group.")
 
3143
 
 
3144
    internal_error = True
 
3145
 
 
3146
    def __init__(self, repository):
 
3147
        self.repository = repository
 
3148
 
 
3149
 
 
3150
class LossyPushToSameVCS(BzrError):
 
3151
 
 
3152
    _fmt = ("Lossy push not possible between %(source_branch)r and "
 
3153
            "%(target_branch)r that are in the same VCS.")
 
3154
 
 
3155
    internal_error = True
 
3156
 
 
3157
    def __init__(self, source_branch, target_branch):
 
3158
        self.source_branch = source_branch
 
3159
        self.target_branch = target_branch
 
3160
 
 
3161
 
 
3162
class NoRoundtrippingSupport(BzrError):
 
3163
 
 
3164
    _fmt = ("Roundtripping is not supported between %(source_branch)r and "
 
3165
            "%(target_branch)r.")
 
3166
 
 
3167
    internal_error = True
 
3168
 
 
3169
    def __init__(self, source_branch, target_branch):
 
3170
        self.source_branch = source_branch
 
3171
        self.target_branch = target_branch
 
3172
 
 
3173
 
 
3174
class FileTimestampUnavailable(BzrError):
 
3175
 
 
3176
    _fmt = "The filestamp for %(path)s is not available."
 
3177
 
 
3178
    internal_error = True
 
3179
 
 
3180
    def __init__(self, path):
 
3181
        self.path = path
 
3182
 
 
3183
 
 
3184
class NoColocatedBranchSupport(BzrError):
 
3185
 
 
3186
    _fmt = ("%(bzrdir)r does not support co-located branches.")
 
3187
 
 
3188
    def __init__(self, bzrdir):
 
3189
        self.bzrdir = bzrdir
 
3190
 
 
3191
 
 
3192
class NoWhoami(BzrError):
 
3193
 
 
3194
    _fmt = ('Unable to determine your name.\n'
 
3195
        "Please, set your name with the 'whoami' command.\n"
 
3196
        'E.g. bzr whoami "Your Name <name@example.com>"')
 
3197
 
 
3198
 
 
3199
class InvalidPattern(BzrError):
 
3200
 
 
3201
    _fmt = ('Invalid pattern(s) found. %(msg)s')
 
3202
 
 
3203
    def __init__(self, msg):
 
3204
        self.msg = msg
 
3205
 
 
3206
 
 
3207
class RecursiveBind(BzrError):
 
3208
 
 
3209
    _fmt = ('Branch "%(branch_url)s" appears to be bound to itself. '
 
3210
        'Please use `bzr unbind` to fix.')
 
3211
 
 
3212
    def __init__(self, branch_url):
 
3213
        self.branch_url = branch_url
 
3214
 
 
3215
 
 
3216
# FIXME: I would prefer to define the config related exception classes in
 
3217
# config.py but the lazy import mechanism proscribes this -- vila 20101222
 
3218
class OptionExpansionLoop(BzrError):
 
3219
 
 
3220
    _fmt = 'Loop involving %(refs)r while expanding "%(string)s".'
 
3221
 
 
3222
    def __init__(self, string, refs):
 
3223
        self.string = string
 
3224
        self.refs = '->'.join(refs)
 
3225
 
 
3226
 
 
3227
class ExpandingUnknownOption(BzrError):
 
3228
 
 
3229
    _fmt = 'Option %(name)s is not defined while expanding "%(string)s".'
 
3230
 
 
3231
    def __init__(self, name, string):
 
3232
        self.name = name
 
3233
        self.string = string
 
3234
 
 
3235
 
 
3236
class NoCompatibleInter(BzrError):
 
3237
 
 
3238
    _fmt = ('No compatible object available for operations from %(source)r '
 
3239
            'to %(target)r.')
 
3240
 
 
3241
    def __init__(self, source, target):
 
3242
        self.source = source
 
3243
        self.target = target
 
3244
 
 
3245
 
 
3246
class HpssVfsRequestNotAllowed(BzrError):
 
3247
 
 
3248
    _fmt = ("VFS requests over the smart server are not allowed. Encountered: "
 
3249
            "%(method)s, %(arguments)s.")
 
3250
 
 
3251
    def __init__(self, method, arguments):
 
3252
        self.method = method
 
3253
        self.arguments = arguments
 
3254
 
 
3255
 
 
3256
class UnsupportedKindChange(BzrError):
 
3257
 
 
3258
    _fmt = ("Kind change from %(from_kind)s to %(to_kind)s for "
 
3259
            "%(path)s not supported by format %(format)r")
 
3260
 
 
3261
    def __init__(self, path, from_kind, to_kind, format):
 
3262
        self.path = path
 
3263
        self.from_kind = from_kind
 
3264
        self.to_kind = to_kind
 
3265
        self.format = format
 
3266
 
 
3267
 
 
3268
class MissingFeature(BzrError):
 
3269
 
 
3270
    _fmt = ("Missing feature %(feature)s not provided by this "
 
3271
            "version of Bazaar or any plugin.")
 
3272
 
 
3273
    def __init__(self, feature):
 
3274
        self.feature = feature
 
3275
 
 
3276
 
 
3277
class PatchSyntax(BzrError):
 
3278
    """Base class for patch syntax errors."""
 
3279
 
 
3280
 
 
3281
class BinaryFiles(BzrError):
 
3282
 
 
3283
    _fmt = 'Binary files section encountered.'
 
3284
 
 
3285
    def __init__(self, orig_name, mod_name):
 
3286
        self.orig_name = orig_name
 
3287
        self.mod_name = mod_name
 
3288
 
 
3289
 
 
3290
class MalformedPatchHeader(PatchSyntax):
 
3291
 
 
3292
    _fmt = "Malformed patch header.  %(desc)s\n%(line)r"
 
3293
 
 
3294
    def __init__(self, desc, line):
 
3295
        self.desc = desc
 
3296
        self.line = line
 
3297
 
 
3298
 
 
3299
class MalformedHunkHeader(PatchSyntax):
 
3300
 
 
3301
    _fmt = "Malformed hunk header.  %(desc)s\n%(line)r"
 
3302
 
 
3303
    def __init__(self, desc, line):
 
3304
        self.desc = desc
 
3305
        self.line = line
 
3306
 
 
3307
 
 
3308
class MalformedLine(PatchSyntax):
 
3309
 
 
3310
    _fmt = "Malformed line.  %(desc)s\n%(line)r"
 
3311
 
 
3312
    def __init__(self, desc, line):
 
3313
        self.desc = desc
 
3314
        self.line = line
 
3315
 
 
3316
 
 
3317
class PatchConflict(BzrError):
 
3318
 
 
3319
    _fmt = ('Text contents mismatch at line %(line_no)d.  Original has '
 
3320
            '"%(orig_line)s", but patch says it should be "%(patch_line)s"')
 
3321
 
 
3322
    def __init__(self, line_no, orig_line, patch_line):
 
3323
        self.line_no = line_no
 
3324
        self.orig_line = orig_line.rstrip('\n')
 
3325
        self.patch_line = patch_line.rstrip('\n')
 
3326
 
 
3327
 
 
3328
class FeatureAlreadyRegistered(BzrError):
 
3329
 
 
3330
    _fmt = 'The feature %(feature)s has already been registered.'
 
3331
 
 
3332
    def __init__(self, feature):
 
3333
        self.feature = feature