← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/errors.py

  • Committer: Tarmac
  • Author(s): Vincent Ladeuil
  • Date: 2017-01-30 14:42:05 UTC
  • mfrom: (6620.1.1 trunk)
  • Revision ID: tarmac-20170130144205-r8fh2xpmiuxyozpv
Merge  2.7 into trunk including fix for bug #1657238 [r=vila]

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-2013, 2016 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'. "
257
278
class NoSuchId(BzrError):
258
279
 
259
280
    _fmt = 'The file id "%(file_id)s" is not present in the tree %(tree)s.'
260
 
    
 
281
 
261
282
    def __init__(self, tree, file_id):
262
283
        BzrError.__init__(self)
263
284
        self.file_id = file_id
273
294
        BzrError.__init__(self, repository=repository, file_id=file_id)
274
295
 
275
296
 
276
 
class InventoryModified(BzrError):
 
297
class NotStacked(BranchError):
 
298
 
 
299
    _fmt = "The branch '%(branch)s' is not stacked."
 
300
 
 
301
 
 
302
class InventoryModified(InternalBzrError):
277
303
 
278
304
    _fmt = ("The current inventory for the tree %(tree)r has been modified,"
279
305
            " so a clean inventory cannot be read without data loss.")
280
306
 
281
 
    internal_error = True
282
 
 
283
307
    def __init__(self, tree):
284
308
        self.tree = tree
285
309
 
287
311
class NoWorkingTree(BzrError):
288
312
 
289
313
    _fmt = 'No WorkingTree exists for "%(base)s".'
290
 
    
 
314
 
291
315
    def __init__(self, base):
292
316
        BzrError.__init__(self)
293
317
        self.base = base
306
330
        self.url = url
307
331
 
308
332
 
309
 
class WorkingTreeAlreadyPopulated(BzrError):
 
333
class WorkingTreeAlreadyPopulated(InternalBzrError):
310
334
 
311
335
    _fmt = 'Working tree already populated in "%(base)s"'
312
336
 
313
 
    internal_error = True
314
 
 
315
337
    def __init__(self, base):
316
338
        self.base = base
317
339
 
 
340
 
318
341
class BzrCommandError(BzrError):
319
342
    """Error from user command"""
320
343
 
321
 
    internal_error = False
322
 
 
323
344
    # Error from malformed user command; please avoid raising this as a
324
345
    # generic exception not caused by user input.
325
346
    #
327
348
    # are not intended to be caught anyway.  UI code need not subclass
328
349
    # BzrCommandError, and non-UI code should not throw a subclass of
329
350
    # BzrCommandError.  ADHB 20051211
330
 
    def __init__(self, msg):
331
 
        # Object.__str__() must return a real string
332
 
        # returning a Unicode string is a python error.
333
 
        if isinstance(msg, unicode):
334
 
            self.msg = msg.encode('utf8')
335
 
        else:
336
 
            self.msg = msg
337
 
 
338
 
    def __str__(self):
339
 
        return self.msg
340
351
 
341
352
 
342
353
class NotWriteLocked(BzrError):
415
426
    def __init__(self, name, value):
416
427
        BzrError.__init__(self, name=name, value=value)
417
428
 
418
 
    
 
429
 
419
430
class StrictCommitFailed(BzrError):
420
431
 
421
432
    _fmt = "Commit refused because there are unknown files in the tree"
424
435
# XXX: Should be unified with TransportError; they seem to represent the
425
436
# same thing
426
437
# RBC 20060929: I think that unifiying with TransportError would be a mistake
427
 
# - 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
428
439
# differentiates between 'transport has failed' and 'operation on a transport
429
440
# has failed.'
430
441
class PathError(BzrError):
431
 
    
 
442
 
432
443
    _fmt = "Generic path error: %(path)r%(extra)s)"
433
444
 
434
445
    def __init__(self, path, extra=None):
454
465
    """Used when renaming and both source and dest exist."""
455
466
 
456
467
    _fmt = ("Could not rename %(source)s => %(dest)s because both files exist."
457
 
            "%(extra)s")
 
468
            " (Use --after to tell bzr about a rename that has already"
 
469
            " happened)%(extra)s")
458
470
 
459
471
    def __init__(self, source, dest, extra=None):
460
472
        BzrError.__init__(self)
481
493
    _fmt = 'Directory not empty: "%(path)s"%(extra)s'
482
494
 
483
495
 
484
 
class ReadingCompleted(BzrError):
485
 
    
 
496
class HardLinkNotSupported(PathError):
 
497
 
 
498
    _fmt = 'Hard-linking "%(path)s" is not supported'
 
499
 
 
500
 
 
501
class ReadingCompleted(InternalBzrError):
 
502
 
486
503
    _fmt = ("The MediumRequest '%(request)s' has already had finish_reading "
487
504
            "called upon it - the request has been completed and no more "
488
505
            "data may be read.")
489
506
 
490
 
    internal_error = True
491
 
 
492
507
    def __init__(self, request):
493
508
        self.request = request
494
509
 
510
525
 
511
526
class InvalidURLJoin(PathError):
512
527
 
513
 
    _fmt = 'Invalid URL join request: "%(args)s"%(extra)s'
514
 
 
515
 
    def __init__(self, msg, base, args):
516
 
        PathError.__init__(self, base, msg)
517
 
        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
518
557
 
519
558
 
520
559
class UnknownHook(BzrError):
531
570
 
532
571
    _fmt = 'Unsupported protocol for url "%(path)s"%(extra)s'
533
572
 
534
 
    def __init__(self, url, extra):
 
573
    def __init__(self, url, extra=""):
535
574
        PathError.__init__(self, url, extra=extra)
536
575
 
537
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
 
538
609
class ReadError(PathError):
539
 
    
 
610
 
540
611
    _fmt = """Error reading from %(path)r."""
541
612
 
542
613
 
558
629
 
559
630
    _fmt = 'Path "%(path)s" is not a child of path "%(base)s"%(extra)s'
560
631
 
561
 
    internal_error = True
 
632
    internal_error = False
562
633
 
563
634
    def __init__(self, path, base, extra=None):
564
635
        BzrError.__init__(self)
577
648
 
578
649
# TODO: This is given a URL; we try to unescape it but doing that from inside
579
650
# the exception object is a bit undesirable.
580
 
# TODO: Probably this behavior of should be a common superclass 
 
651
# TODO: Probably this behavior of should be a common superclass
581
652
class NotBranchError(PathError):
582
653
 
583
 
    _fmt = 'Not a branch: "%(path)s".'
 
654
    _fmt = 'Not a branch: "%(path)s"%(detail)s.'
584
655
 
585
 
    def __init__(self, path):
 
656
    def __init__(self, path, detail=None, bzrdir=None):
586
657
       import bzrlib.urlutils as urlutils
587
 
       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)
588
692
 
589
693
 
590
694
class NoSubmitBranch(PathError):
596
700
       self.path = urlutils.unescape_for_display(branch.base, 'ascii')
597
701
 
598
702
 
 
703
class AlreadyControlDirError(PathError):
 
704
 
 
705
    _fmt = 'A control directory already exists: "%(path)s".'
 
706
 
 
707
 
599
708
class AlreadyBranchError(PathError):
600
709
 
601
710
    _fmt = 'Already a branch: "%(path)s".'
602
711
 
603
712
 
 
713
class InvalidBranchName(PathError):
 
714
 
 
715
    _fmt = "Invalid branch name: %(name)s"
 
716
 
 
717
    def __init__(self, name):
 
718
        BzrError.__init__(self)
 
719
        self.name = name
 
720
 
 
721
 
 
722
class ParentBranchExists(AlreadyBranchError):
 
723
 
 
724
    _fmt = 'Parent branch already exists: "%(path)s".'
 
725
 
 
726
 
604
727
class BranchExistsWithoutWorkingTree(PathError):
605
728
 
606
729
    _fmt = 'Directory contains a branch, but no working tree \
635
758
        self.path = bzrdir.transport.clone('..').base
636
759
 
637
760
 
638
 
class FileInWrongBranch(BzrError):
639
 
 
640
 
    _fmt = 'File "%(path)s" in not in branch %(branch_base)s.'
641
 
 
642
 
    def __init__(self, branch, path):
643
 
        BzrError.__init__(self)
644
 
        self.branch = branch
645
 
        self.branch_base = branch.base
646
 
        self.path = path
647
 
 
648
 
 
649
761
class UnsupportedFormatError(BzrError):
650
762
 
651
763
    _fmt = "Unsupported branch format: %(format)s\nPlease run 'bzr upgrade'"
652
764
 
653
765
 
654
766
class UnknownFormatError(BzrError):
655
 
    
656
 
    _fmt = "Unknown branch format: %(format)r"
 
767
 
 
768
    _fmt = "Unknown %(kind)s format: %(format)r"
 
769
 
 
770
    def __init__(self, format, kind='branch'):
 
771
        self.kind = kind
 
772
        self.format = format
657
773
 
658
774
 
659
775
class IncompatibleFormat(BzrError):
660
 
    
 
776
 
661
777
    _fmt = "Format %(format)s is not compatible with .bzr version %(bzrdir)s."
662
778
 
663
779
    def __init__(self, format, bzrdir_format):
666
782
        self.bzrdir = bzrdir_format
667
783
 
668
784
 
 
785
class ParseFormatError(BzrError):
 
786
 
 
787
    _fmt = "Parse error on line %(lineno)d of %(format)s format: %(line)s"
 
788
 
 
789
    def __init__(self, format, lineno, line, text):
 
790
        BzrError.__init__(self)
 
791
        self.format = format
 
792
        self.lineno = lineno
 
793
        self.line = line
 
794
        self.text = text
 
795
 
 
796
 
669
797
class IncompatibleRepositories(BzrError):
670
 
 
671
 
    _fmt = "Repository %(target)s is not compatible with repository"\
672
 
        " %(source)s"
673
 
 
674
 
    def __init__(self, source, target):
675
 
        BzrError.__init__(self, target=target, source=source)
 
798
    """Report an error that two repositories are not compatible.
 
799
 
 
800
    Note that the source and target repositories are permitted to be strings:
 
801
    this exception is thrown from the smart server and may refer to a
 
802
    repository the client hasn't opened.
 
803
    """
 
804
 
 
805
    _fmt = "%(target)s\n" \
 
806
            "is not compatible with\n" \
 
807
            "%(source)s\n" \
 
808
            "%(details)s"
 
809
 
 
810
    def __init__(self, source, target, details=None):
 
811
        if details is None:
 
812
            details = "(no details)"
 
813
        BzrError.__init__(self, target=target, source=source, details=details)
676
814
 
677
815
 
678
816
class IncompatibleRevision(BzrError):
679
 
    
 
817
 
680
818
    _fmt = "Revision is not compatible with %(repo_format)s"
681
819
 
682
820
    def __init__(self, repo_format):
693
831
        """Construct a new AlreadyVersionedError.
694
832
 
695
833
        :param path: This is the path which is versioned,
696
 
        which should be in a user friendly form.
 
834
            which should be in a user friendly form.
697
835
        :param context_info: If given, this is information about the context,
698
 
        which could explain why this is expected to not be versioned.
 
836
            which could explain why this is expected to not be versioned.
699
837
        """
700
838
        BzrError.__init__(self)
701
839
        self.path = path
714
852
        """Construct a new NotVersionedError.
715
853
 
716
854
        :param path: This is the path which is not versioned,
717
 
        which should be in a user friendly form.
 
855
            which should be in a user friendly form.
718
856
        :param context_info: If given, this is information about the context,
719
 
        which could explain why this is expected to be versioned.
 
857
            which could explain why this is expected to be versioned.
720
858
        """
721
859
        BzrError.__init__(self)
722
860
        self.path = path
765
903
        BzrError.__init__(self, filename=filename, kind=kind)
766
904
 
767
905
 
 
906
class BadFilenameEncoding(BzrError):
 
907
 
 
908
    _fmt = ('Filename %(filename)r is not valid in your current filesystem'
 
909
            ' encoding %(fs_encoding)s')
 
910
 
 
911
    def __init__(self, filename, fs_encoding):
 
912
        BzrError.__init__(self)
 
913
        self.filename = filename
 
914
        self.fs_encoding = fs_encoding
 
915
 
 
916
 
768
917
class ForbiddenControlFileError(BzrError):
769
918
 
770
919
    _fmt = 'Cannot operate on "%(filename)s" because it is a control file'
771
920
 
772
921
 
773
 
class LockError(BzrError):
 
922
class LockError(InternalBzrError):
774
923
 
775
924
    _fmt = "Lock error: %(msg)s"
776
925
 
777
 
    internal_error = True
778
 
 
779
926
    # All exceptions from the lock/unlock functions should be from
780
927
    # this exception class.  They will be translated as necessary. The
781
928
    # original exception is available as e.original_error
782
929
    #
783
930
    # New code should prefer to raise specific subclasses
784
 
    def __init__(self, message):
785
 
        # Python 2.5 uses a slot for StandardError.message,
786
 
        # so use a different variable name
787
 
        # so it is exposed in self.__dict__
788
 
        self.msg = message
 
931
    def __init__(self, msg):
 
932
        self.msg = msg
789
933
 
790
934
 
791
935
class LockActive(LockError):
825
969
        self.obj = obj
826
970
 
827
971
 
828
 
class ReadOnlyLockError(LockError):
829
 
 
830
 
    _fmt = "Cannot acquire write lock on %(fname)s. %(msg)s"
831
 
 
832
 
    def __init__(self, fname, msg):
 
972
class LockFailed(LockError):
 
973
 
 
974
    internal_error = False
 
975
 
 
976
    _fmt = "Cannot lock %(lock)s: %(why)s"
 
977
 
 
978
    def __init__(self, lock, why):
833
979
        LockError.__init__(self, '')
834
 
        self.fname = fname
835
 
        self.msg = msg
 
980
        self.lock = lock
 
981
        self.why = why
836
982
 
837
983
 
838
984
class OutSideTransaction(BzrError):
862
1008
 
863
1009
class UnlockableTransport(LockError):
864
1010
 
 
1011
    internal_error = False
 
1012
 
865
1013
    _fmt = "Cannot lock: transport is read only: %(transport)s"
866
1014
 
867
1015
    def __init__(self, transport):
870
1018
 
871
1019
class LockContention(LockError):
872
1020
 
873
 
    _fmt = 'Could not acquire lock "%(lock)s"'
874
 
    # TODO: show full url for lock, combining the transport and relative
875
 
    # bits?
 
1021
    _fmt = 'Could not acquire lock "%(lock)s": %(msg)s'
876
1022
 
877
1023
    internal_error = False
878
1024
 
879
 
    def __init__(self, lock):
 
1025
    def __init__(self, lock, msg=''):
880
1026
        self.lock = lock
 
1027
        self.msg = msg
881
1028
 
882
1029
 
883
1030
class LockBroken(LockError):
904
1051
        self.target = target
905
1052
 
906
1053
 
 
1054
class LockCorrupt(LockError):
 
1055
 
 
1056
    _fmt = ("Lock is apparently held, but corrupted: %(corruption_info)s\n"
 
1057
            "Use 'bzr break-lock' to clear it")
 
1058
 
 
1059
    internal_error = False
 
1060
 
 
1061
    def __init__(self, corruption_info, file_data=None):
 
1062
        self.corruption_info = corruption_info
 
1063
        self.file_data = file_data
 
1064
 
 
1065
 
907
1066
class LockNotHeld(LockError):
908
1067
 
909
1068
    _fmt = "Lock not held: %(lock)s"
918
1077
 
919
1078
    _fmt = "The object %(obj)s does not support token specifying a token when locking."
920
1079
 
921
 
    internal_error = True
922
 
 
923
1080
    def __init__(self, obj):
924
1081
        self.obj = obj
925
1082
 
950
1107
        BzrError.__init__(self, files=files, files_str=files_str)
951
1108
 
952
1109
 
 
1110
class ExcludesUnsupported(BzrError):
 
1111
 
 
1112
    _fmt = ('Excluding paths during commit is not supported by '
 
1113
            'repository at %(repository)r.')
 
1114
 
 
1115
    def __init__(self, repository):
 
1116
        BzrError.__init__(self, repository=repository)
 
1117
 
 
1118
 
953
1119
class BadCommitMessageEncoding(BzrError):
954
1120
 
955
1121
    _fmt = 'The specified commit message contains characters unsupported by '\
975
1141
    _fmt = "Commit refused because there are unknowns in the tree."
976
1142
 
977
1143
 
978
 
class NoSuchRevision(BzrError):
 
1144
class NoSuchRevision(InternalBzrError):
979
1145
 
980
1146
    _fmt = "%(branch)s has no revision %(revision)s"
981
1147
 
982
 
    internal_error = True
983
 
 
984
1148
    def __init__(self, branch, revision):
985
1149
        # 'branch' may sometimes be an internal object like a KnitRevisionStore
986
1150
        BzrError.__init__(self, branch=branch, revision=revision)
987
1151
 
988
1152
 
989
 
# zero_ninetyone: this exception is no longer raised and should be removed
990
 
class NotLeftParentDescendant(BzrError):
991
 
 
992
 
    _fmt = ("Revision %(old_revision)s is not the left parent of"
993
 
            " %(new_revision)s, but branch %(branch_location)s expects this")
994
 
 
995
 
    internal_error = True
996
 
 
997
 
    def __init__(self, branch, old_revision, new_revision):
998
 
        BzrError.__init__(self, branch_location=branch.base,
999
 
                          old_revision=old_revision,
1000
 
                          new_revision=new_revision)
1001
 
 
1002
 
 
1003
1153
class RangeInChangeOption(BzrError):
1004
1154
 
1005
1155
    _fmt = "Option --change does not accept revision ranges"
1015
1165
 
1016
1166
class NoSuchRevisionInTree(NoSuchRevision):
1017
1167
    """When using Tree.revision_tree, and the revision is not accessible."""
1018
 
    
 
1168
 
1019
1169
    _fmt = "The revision id {%(revision_id)s} is not present in the tree %(tree)s."
1020
1170
 
1021
1171
    def __init__(self, tree, revision_id):
1026
1176
 
1027
1177
class InvalidRevisionSpec(BzrError):
1028
1178
 
1029
 
    _fmt = ("Requested revision: %(spec)r does not exist in branch:"
1030
 
            " %(branch)s%(extra)s")
 
1179
    _fmt = ("Requested revision: '%(spec)s' does not exist in branch:"
 
1180
            " %(branch_url)s%(extra)s")
1031
1181
 
1032
1182
    def __init__(self, spec, branch, extra=None):
1033
1183
        BzrError.__init__(self, branch=branch, spec=spec)
 
1184
        self.branch_url = getattr(branch, 'user_url', str(branch))
1034
1185
        if extra:
1035
1186
            self.extra = '\n' + str(extra)
1036
1187
        else:
1037
1188
            self.extra = ''
1038
1189
 
1039
1190
 
1040
 
class HistoryMissing(BzrError):
1041
 
 
1042
 
    _fmt = "%(branch)s is missing %(object_type)s {%(object_id)s}"
1043
 
 
1044
 
 
1045
1191
class AppendRevisionsOnlyViolation(BzrError):
1046
1192
 
1047
1193
    _fmt = ('Operation denied because it would change the main history,'
1057
1203
class DivergedBranches(BzrError):
1058
1204
 
1059
1205
    _fmt = ("These branches have diverged."
1060
 
            " Use the merge command to reconcile them.")
1061
 
 
1062
 
    internal_error = False
 
1206
            " Use the missing command to see how.\n"
 
1207
            "Use the merge command to reconcile them.")
1063
1208
 
1064
1209
    def __init__(self, branch1, branch2):
1065
1210
        self.branch1 = branch1
1066
1211
        self.branch2 = branch2
1067
1212
 
1068
1213
 
1069
 
class NotLefthandHistory(BzrError):
 
1214
class NotLefthandHistory(InternalBzrError):
1070
1215
 
1071
1216
    _fmt = "Supplied history does not follow left-hand parents"
1072
1217
 
1073
 
    internal_error = True
1074
 
 
1075
1218
    def __init__(self, history):
1076
1219
        BzrError.__init__(self, history=history)
1077
1220
 
1081
1224
    _fmt = ("Branches have no common ancestor, and"
1082
1225
            " no merge base revision was specified.")
1083
1226
 
1084
 
    internal_error = False
 
1227
 
 
1228
class CannotReverseCherrypick(BzrError):
 
1229
 
 
1230
    _fmt = ('Selected merge cannot perform reverse cherrypicks.  Try merge3'
 
1231
            ' or diff3.')
1085
1232
 
1086
1233
 
1087
1234
class NoCommonAncestor(BzrError):
1088
 
    
 
1235
 
1089
1236
    _fmt = "Revisions have no common ancestor: %(revision_a)s %(revision_b)s"
1090
1237
 
1091
1238
    def __init__(self, revision_a, revision_b):
1111
1258
            not_ancestor_id=not_ancestor_id)
1112
1259
 
1113
1260
 
1114
 
class InstallFailed(BzrError):
1115
 
 
1116
 
    def __init__(self, revisions):
1117
 
        revision_str = ", ".join(str(r) for r in revisions)
1118
 
        msg = "Could not install revisions:\n%s" % revision_str
1119
 
        BzrError.__init__(self, msg)
1120
 
        self.revisions = revisions
1121
 
 
1122
 
 
1123
 
class AmbiguousBase(BzrError):
1124
 
 
1125
 
    def __init__(self, bases):
1126
 
        warn("BzrError AmbiguousBase has been deprecated as of bzrlib 0.8.",
1127
 
                DeprecationWarning)
1128
 
        msg = ("The correct base is unclear, because %s are all equally close"
1129
 
                % ", ".join(bases))
1130
 
        BzrError.__init__(self, msg)
1131
 
        self.bases = bases
1132
 
 
1133
 
 
1134
 
class NoCommits(BzrError):
 
1261
class NoCommits(BranchError):
1135
1262
 
1136
1263
    _fmt = "Branch %(branch)s has no commits."
1137
1264
 
1138
 
    def __init__(self, branch):
1139
 
        BzrError.__init__(self, branch=branch)
1140
 
 
1141
1265
 
1142
1266
class UnlistableStore(BzrError):
1143
1267
 
1155
1279
class BoundBranchOutOfDate(BzrError):
1156
1280
 
1157
1281
    _fmt = ("Bound branch %(branch)s is out of date with master branch"
1158
 
            " %(master)s.")
 
1282
            " %(master)s.%(extra_help)s")
1159
1283
 
1160
1284
    def __init__(self, branch, master):
1161
1285
        BzrError.__init__(self)
1162
1286
        self.branch = branch
1163
1287
        self.master = master
1164
 
 
1165
 
        
 
1288
        self.extra_help = ''
 
1289
 
 
1290
 
1166
1291
class CommitToDoubleBoundBranch(BzrError):
1167
1292
 
1168
1293
    _fmt = ("Cannot commit to branch %(branch)s."
1198
1323
 
1199
1324
class WeaveError(BzrError):
1200
1325
 
1201
 
    _fmt = "Error in processing weave: %(message)s"
 
1326
    _fmt = "Error in processing weave: %(msg)s"
1202
1327
 
1203
 
    def __init__(self, message=None):
 
1328
    def __init__(self, msg=None):
1204
1329
        BzrError.__init__(self)
1205
 
        self.message = message
 
1330
        self.msg = msg
1206
1331
 
1207
1332
 
1208
1333
class WeaveRevisionAlreadyPresent(WeaveError):
1237
1362
 
1238
1363
class WeaveParentMismatch(WeaveError):
1239
1364
 
1240
 
    _fmt = "Parents are mismatched between two revisions."
1241
 
    
 
1365
    _fmt = "Parents are mismatched between two revisions. %(msg)s"
 
1366
 
1242
1367
 
1243
1368
class WeaveInvalidChecksum(WeaveError):
1244
1369
 
1245
 
    _fmt = "Text did not match it's checksum: %(message)s"
 
1370
    _fmt = "Text did not match its checksum: %(msg)s"
1246
1371
 
1247
1372
 
1248
1373
class WeaveTextDiffers(WeaveError):
1270
1395
 
1271
1396
 
1272
1397
class VersionedFileError(BzrError):
1273
 
    
 
1398
 
1274
1399
    _fmt = "Versioned file error"
1275
1400
 
1276
1401
 
1277
1402
class RevisionNotPresent(VersionedFileError):
1278
 
    
 
1403
 
1279
1404
    _fmt = 'Revision {%(revision_id)s} not present in "%(file_id)s".'
1280
1405
 
1281
1406
    def __init__(self, revision_id, file_id):
1285
1410
 
1286
1411
 
1287
1412
class RevisionAlreadyPresent(VersionedFileError):
1288
 
    
 
1413
 
1289
1414
    _fmt = 'Revision {%(revision_id)s} already present in "%(file_id)s".'
1290
1415
 
1291
1416
    def __init__(self, revision_id, file_id):
1296
1421
 
1297
1422
class VersionedFileInvalidChecksum(VersionedFileError):
1298
1423
 
1299
 
    _fmt = "Text did not match its checksum: %(message)s"
1300
 
 
1301
 
 
1302
 
class KnitError(BzrError):
1303
 
    
 
1424
    _fmt = "Text did not match its checksum: %(msg)s"
 
1425
 
 
1426
 
 
1427
class KnitError(InternalBzrError):
 
1428
 
1304
1429
    _fmt = "Knit error"
1305
1430
 
1306
 
    internal_error = True
1307
 
 
1308
1431
 
1309
1432
class KnitCorrupt(KnitError):
1310
1433
 
1316
1439
        self.how = how
1317
1440
 
1318
1441
 
 
1442
class SHA1KnitCorrupt(KnitCorrupt):
 
1443
 
 
1444
    _fmt = ("Knit %(filename)s corrupt: sha-1 of reconstructed text does not "
 
1445
        "match expected sha-1. key %(key)s expected sha %(expected)s actual "
 
1446
        "sha %(actual)s")
 
1447
 
 
1448
    def __init__(self, filename, actual, expected, key, content):
 
1449
        KnitError.__init__(self)
 
1450
        self.filename = filename
 
1451
        self.actual = actual
 
1452
        self.expected = expected
 
1453
        self.key = key
 
1454
        self.content = content
 
1455
 
 
1456
 
1319
1457
class KnitDataStreamIncompatible(KnitError):
 
1458
    # Not raised anymore, as we can convert data streams.  In future we may
 
1459
    # need it again for more exotic cases, so we're keeping it around for now.
1320
1460
 
1321
1461
    _fmt = "Cannot insert knit data stream of format \"%(stream_format)s\" into knit of format \"%(target_format)s\"."
1322
1462
 
1323
1463
    def __init__(self, stream_format, target_format):
1324
1464
        self.stream_format = stream_format
1325
1465
        self.target_format = target_format
1326
 
        
 
1466
 
 
1467
 
 
1468
class KnitDataStreamUnknown(KnitError):
 
1469
    # Indicates a data stream we don't know how to handle.
 
1470
 
 
1471
    _fmt = "Cannot parse knit data stream of format \"%(stream_format)s\"."
 
1472
 
 
1473
    def __init__(self, stream_format):
 
1474
        self.stream_format = stream_format
 
1475
 
1327
1476
 
1328
1477
class KnitHeaderError(KnitError):
1329
1478
 
1339
1488
 
1340
1489
    Currently only 'fulltext' and 'line-delta' are supported.
1341
1490
    """
1342
 
    
 
1491
 
1343
1492
    _fmt = ("Knit index %(filename)s does not have a known method"
1344
1493
            " in options: %(options)r")
1345
1494
 
1349
1498
        self.options = options
1350
1499
 
1351
1500
 
 
1501
class RetryWithNewPacks(BzrError):
 
1502
    """Raised when we realize that the packs on disk have changed.
 
1503
 
 
1504
    This is meant as more of a signaling exception, to trap between where a
 
1505
    local error occurred and the code that can actually handle the error and
 
1506
    code that can retry appropriately.
 
1507
    """
 
1508
 
 
1509
    internal_error = True
 
1510
 
 
1511
    _fmt = ("Pack files have changed, reload and retry. context: %(context)s"
 
1512
            " %(orig_error)s")
 
1513
 
 
1514
    def __init__(self, context, reload_occurred, exc_info):
 
1515
        """create a new RetryWithNewPacks error.
 
1516
 
 
1517
        :param reload_occurred: Set to True if we know that the packs have
 
1518
            already been reloaded, and we are failing because of an in-memory
 
1519
            cache miss. If set to True then we will ignore if a reload says
 
1520
            nothing has changed, because we assume it has already reloaded. If
 
1521
            False, then a reload with nothing changed will force an error.
 
1522
        :param exc_info: The original exception traceback, so if there is a
 
1523
            problem we can raise the original error (value from sys.exc_info())
 
1524
        """
 
1525
        BzrError.__init__(self)
 
1526
        self.context = context
 
1527
        self.reload_occurred = reload_occurred
 
1528
        self.exc_info = exc_info
 
1529
        self.orig_error = exc_info[1]
 
1530
        # TODO: The global error handler should probably treat this by
 
1531
        #       raising/printing the original exception with a bit about
 
1532
        #       RetryWithNewPacks also not being caught
 
1533
 
 
1534
 
 
1535
class RetryAutopack(RetryWithNewPacks):
 
1536
    """Raised when we are autopacking and we find a missing file.
 
1537
 
 
1538
    Meant as a signaling exception, to tell the autopack code it should try
 
1539
    again.
 
1540
    """
 
1541
 
 
1542
    internal_error = True
 
1543
 
 
1544
    _fmt = ("Pack files have changed, reload and try autopack again."
 
1545
            " context: %(context)s %(orig_error)s")
 
1546
 
 
1547
 
1352
1548
class NoSuchExportFormat(BzrError):
1353
 
    
 
1549
 
1354
1550
    _fmt = "Export format %(format)r not supported"
1355
1551
 
1356
1552
    def __init__(self, format):
1359
1555
 
1360
1556
 
1361
1557
class TransportError(BzrError):
1362
 
    
 
1558
 
1363
1559
    _fmt = "Transport error: %(msg)s %(orig_error)s"
1364
1560
 
1365
1561
    def __init__(self, msg=None, orig_error=None):
1374
1570
        BzrError.__init__(self)
1375
1571
 
1376
1572
 
1377
 
class TooManyConcurrentRequests(BzrError):
 
1573
class TooManyConcurrentRequests(InternalBzrError):
1378
1574
 
1379
1575
    _fmt = ("The medium '%(medium)s' has reached its concurrent request limit."
1380
1576
            " Be sure to finish_writing and finish_reading on the"
1381
1577
            " currently open request.")
1382
1578
 
1383
 
    internal_error = True
1384
 
 
1385
1579
    def __init__(self, medium):
1386
1580
        self.medium = medium
1387
1581
 
1394
1588
        self.details = details
1395
1589
 
1396
1590
 
 
1591
class UnexpectedProtocolVersionMarker(TransportError):
 
1592
 
 
1593
    _fmt = "Received bad protocol version marker: %(marker)r"
 
1594
 
 
1595
    def __init__(self, marker):
 
1596
        self.marker = marker
 
1597
 
 
1598
 
 
1599
class UnknownSmartMethod(InternalBzrError):
 
1600
 
 
1601
    _fmt = "The server does not recognise the '%(verb)s' request."
 
1602
 
 
1603
    def __init__(self, verb):
 
1604
        self.verb = verb
 
1605
 
 
1606
 
 
1607
class SmartMessageHandlerError(InternalBzrError):
 
1608
 
 
1609
    _fmt = ("The message handler raised an exception:\n"
 
1610
            "%(traceback_text)s")
 
1611
 
 
1612
    def __init__(self, exc_info):
 
1613
        import traceback
 
1614
        # GZ 2010-08-10: Cycle with exc_tb/exc_info affects at least one test
 
1615
        self.exc_type, self.exc_value, self.exc_tb = exc_info
 
1616
        self.exc_info = exc_info
 
1617
        traceback_strings = traceback.format_exception(
 
1618
                self.exc_type, self.exc_value, self.exc_tb)
 
1619
        self.traceback_text = ''.join(traceback_strings)
 
1620
 
 
1621
 
1397
1622
# A set of semi-meaningful errors which can be thrown
1398
1623
class TransportNotPossible(TransportError):
1399
1624
 
1424
1649
            self.port = ':%s' % port
1425
1650
 
1426
1651
 
 
1652
# XXX: This is also used for unexpected end of file, which is different at the
 
1653
# TCP level from "connection reset".
1427
1654
class ConnectionReset(TransportError):
1428
1655
 
1429
1656
    _fmt = "Connection closed: %(msg)s %(orig_error)s"
1430
1657
 
1431
1658
 
 
1659
class ConnectionTimeout(ConnectionError):
 
1660
 
 
1661
    _fmt = "Connection Timeout: %(msg)s%(orig_error)s"
 
1662
 
 
1663
 
1432
1664
class InvalidRange(TransportError):
1433
1665
 
1434
 
    _fmt = "Invalid range access in %(path)s at %(offset)s."
1435
 
    
1436
 
    def __init__(self, path, offset):
1437
 
        TransportError.__init__(self, ("Invalid range access in %s at %d"
1438
 
                                       % (path, offset)))
 
1666
    _fmt = "Invalid range access in %(path)s at %(offset)s: %(msg)s"
 
1667
 
 
1668
    def __init__(self, path, offset, msg=None):
 
1669
        TransportError.__init__(self, msg)
1439
1670
        self.path = path
1440
1671
        self.offset = offset
1441
1672
 
1442
1673
 
1443
1674
class InvalidHttpResponse(TransportError):
1444
1675
 
1445
 
    _fmt = "Invalid http response for %(path)s: %(msg)s"
 
1676
    _fmt = "Invalid http response for %(path)s: %(msg)s%(orig_error)s"
1446
1677
 
1447
1678
    def __init__(self, path, msg, orig_error=None):
1448
1679
        self.path = path
 
1680
        if orig_error is None:
 
1681
            orig_error = ''
 
1682
        else:
 
1683
            # This is reached for obscure and unusual errors so we want to
 
1684
            # preserve as much info as possible to ease debug.
 
1685
            orig_error = ': %r' % (orig_error,)
1449
1686
        TransportError.__init__(self, msg, orig_error=orig_error)
1450
1687
 
1451
1688
 
1452
1689
class InvalidHttpRange(InvalidHttpResponse):
1453
1690
 
1454
1691
    _fmt = "Invalid http range %(range)r for %(path)s: %(msg)s"
1455
 
    
 
1692
 
1456
1693
    def __init__(self, path, range, msg):
1457
1694
        self.range = range
1458
1695
        InvalidHttpResponse.__init__(self, path, msg)
1459
1696
 
1460
1697
 
 
1698
class HttpBoundaryMissing(InvalidHttpResponse):
 
1699
    """A multipart response ends with no boundary marker.
 
1700
 
 
1701
    This is a special case caused by buggy proxies, described in
 
1702
    <https://bugs.launchpad.net/bzr/+bug/198646>.
 
1703
    """
 
1704
 
 
1705
    _fmt = "HTTP MIME Boundary missing for %(path)s: %(msg)s"
 
1706
 
 
1707
    def __init__(self, path, msg):
 
1708
        InvalidHttpResponse.__init__(self, path, msg)
 
1709
 
 
1710
 
1461
1711
class InvalidHttpContentType(InvalidHttpResponse):
1462
1712
 
1463
1713
    _fmt = 'Invalid http Content-type "%(ctype)s" for %(path)s: %(msg)s'
1464
 
    
 
1714
 
1465
1715
    def __init__(self, path, ctype, msg):
1466
1716
        self.ctype = ctype
1467
1717
        InvalidHttpResponse.__init__(self, path, msg)
1471
1721
 
1472
1722
    _fmt = '%(source)s is%(permanently)s redirected to %(target)s'
1473
1723
 
1474
 
    def __init__(self, source, target, is_permament=False, qual_proto=None):
 
1724
    def __init__(self, source, target, is_permanent=False):
1475
1725
        self.source = source
1476
1726
        self.target = target
1477
 
        if is_permament:
 
1727
        if is_permanent:
1478
1728
            self.permanently = ' permanently'
1479
1729
        else:
1480
1730
            self.permanently = ''
1481
 
        self.is_permament = is_permament
1482
 
        self._qualified_proto = qual_proto
1483
1731
        TransportError.__init__(self)
1484
1732
 
1485
 
    def _requalify_url(self, url):
1486
 
        """Restore the qualified proto in front of the url"""
1487
 
        # When this exception is raised, source and target are in
1488
 
        # user readable format. But some transports may use a
1489
 
        # different proto (http+urllib:// will present http:// to
1490
 
        # the user. If a qualified proto is specified, the code
1491
 
        # trapping the exception can get the qualified urls to
1492
 
        # properly handle the redirection themself (creating a
1493
 
        # new transport object from the target url for example).
1494
 
        # But checking that the scheme of the original and
1495
 
        # redirected urls are the same can be tricky. (see the
1496
 
        # FIXME in BzrDir.open_from_transport for the unique use
1497
 
        # case so far).
1498
 
        if self._qualified_proto is None:
1499
 
            return url
1500
 
 
1501
 
        # The TODO related to NotBranchError mention that doing
1502
 
        # that kind of manipulation on the urls may not be the
1503
 
        # exception object job. On the other hand, this object is
1504
 
        # the interface between the code and the user so
1505
 
        # presenting the urls in different ways is indeed its
1506
 
        # job...
1507
 
        import urlparse
1508
 
        proto, netloc, path, query, fragment = urlparse.urlsplit(url)
1509
 
        return urlparse.urlunsplit((self._qualified_proto, netloc, path,
1510
 
                                   query, fragment))
1511
 
 
1512
 
    def get_source_url(self):
1513
 
        return self._requalify_url(self.source)
1514
 
 
1515
 
    def get_target_url(self):
1516
 
        return self._requalify_url(self.target)
1517
 
 
1518
1733
 
1519
1734
class TooManyRedirections(TransportError):
1520
1735
 
1521
1736
    _fmt = "Too many redirections"
1522
1737
 
 
1738
 
1523
1739
class ConflictsInTree(BzrError):
1524
1740
 
1525
1741
    _fmt = "Working tree has conflicts."
1526
1742
 
1527
1743
 
 
1744
class ConfigContentError(BzrError):
 
1745
 
 
1746
    _fmt = "Config file %(filename)s is not UTF-8 encoded\n"
 
1747
 
 
1748
    def __init__(self, filename):
 
1749
        BzrError.__init__(self)
 
1750
        self.filename = filename
 
1751
 
 
1752
 
1528
1753
class ParseConfigError(BzrError):
1529
1754
 
 
1755
    _fmt = "Error(s) parsing config file %(filename)s:\n%(errors)s"
 
1756
 
1530
1757
    def __init__(self, errors, filename):
1531
 
        if filename is None:
1532
 
            filename = ""
1533
 
        message = "Error(s) parsing config file %s:\n%s" % \
1534
 
            (filename, ('\n'.join(e.message for e in errors)))
1535
 
        BzrError.__init__(self, message)
 
1758
        BzrError.__init__(self)
 
1759
        self.filename = filename
 
1760
        self.errors = '\n'.join(e.msg for e in errors)
 
1761
 
 
1762
 
 
1763
class ConfigOptionValueError(BzrError):
 
1764
 
 
1765
    _fmt = ('Bad value "%(value)s" for option "%(name)s".\n'
 
1766
            'See ``bzr help %(name)s``')
 
1767
 
 
1768
    def __init__(self, name, value):
 
1769
        BzrError.__init__(self, name=name, value=value)
1536
1770
 
1537
1771
 
1538
1772
class NoEmailInUsername(BzrError):
1546
1780
 
1547
1781
class SigningFailed(BzrError):
1548
1782
 
1549
 
    _fmt = 'Failed to gpg sign data with command "%(command_line)s"'
 
1783
    _fmt = 'Failed to GPG sign data with command "%(command_line)s"'
1550
1784
 
1551
1785
    def __init__(self, command_line):
1552
1786
        BzrError.__init__(self, command_line=command_line)
1553
1787
 
1554
1788
 
 
1789
class SignatureVerificationFailed(BzrError):
 
1790
 
 
1791
    _fmt = 'Failed to verify GPG signature data with error "%(error)s"'
 
1792
 
 
1793
    def __init__(self, error):
 
1794
        BzrError.__init__(self, error=error)
 
1795
 
 
1796
 
 
1797
class DependencyNotPresent(BzrError):
 
1798
 
 
1799
    _fmt = 'Unable to import library "%(library)s": %(error)s'
 
1800
 
 
1801
    def __init__(self, library, error):
 
1802
        BzrError.__init__(self, library=library, error=error)
 
1803
 
 
1804
 
 
1805
class GpgmeNotInstalled(DependencyNotPresent):
 
1806
 
 
1807
    _fmt = 'python-gpgme is not installed, it is needed to verify signatures'
 
1808
 
 
1809
    def __init__(self, error):
 
1810
        DependencyNotPresent.__init__(self, 'gpgme', error)
 
1811
 
 
1812
 
1555
1813
class WorkingTreeNotRevision(BzrError):
1556
1814
 
1557
 
    _fmt = ("The working tree for %(basedir)s has changed since" 
 
1815
    _fmt = ("The working tree for %(basedir)s has changed since"
1558
1816
            " the last commit, but weave merge requires that it be"
1559
1817
            " unchanged")
1560
1818
 
1577
1835
        self.graph = graph
1578
1836
 
1579
1837
 
1580
 
class WritingCompleted(BzrError):
 
1838
class WritingCompleted(InternalBzrError):
1581
1839
 
1582
1840
    _fmt = ("The MediumRequest '%(request)s' has already had finish_writing "
1583
1841
            "called upon it - accept bytes may not be called anymore.")
1584
1842
 
1585
 
    internal_error = True
1586
 
 
1587
1843
    def __init__(self, request):
1588
1844
        self.request = request
1589
1845
 
1590
1846
 
1591
 
class WritingNotComplete(BzrError):
 
1847
class WritingNotComplete(InternalBzrError):
1592
1848
 
1593
1849
    _fmt = ("The MediumRequest '%(request)s' has not has finish_writing "
1594
1850
            "called upon it - until the write phase is complete no "
1595
1851
            "data may be read.")
1596
1852
 
1597
 
    internal_error = True
1598
 
 
1599
1853
    def __init__(self, request):
1600
1854
        self.request = request
1601
1855
 
1609
1863
        self.filename = filename
1610
1864
 
1611
1865
 
1612
 
class MediumNotConnected(BzrError):
 
1866
class MediumNotConnected(InternalBzrError):
1613
1867
 
1614
1868
    _fmt = """The medium '%(medium)s' is not connected."""
1615
1869
 
1616
 
    internal_error = True
1617
 
 
1618
1870
    def __init__(self, medium):
1619
1871
        self.medium = medium
1620
1872
 
1679
1931
        self.prefix = prefix
1680
1932
 
1681
1933
 
1682
 
class MalformedTransform(BzrError):
 
1934
class MalformedTransform(InternalBzrError):
1683
1935
 
1684
1936
    _fmt = "Tree transform is malformed %(conflicts)r"
1685
1937
 
1696
1948
        self.root_trans_id = transform.root
1697
1949
 
1698
1950
 
1699
 
class BzrBadParameter(BzrError):
 
1951
class BzrBadParameter(InternalBzrError):
1700
1952
 
1701
1953
    _fmt = "Bad parameter: %(param)r"
1702
1954
 
1703
 
    internal_error = True
1704
 
 
1705
1955
    # This exception should never be thrown, but it is a base class for all
1706
1956
    # parameter-to-function errors.
1707
1957
 
1725
1975
    _fmt = "Moving the root directory is not supported at this time"
1726
1976
 
1727
1977
 
 
1978
class TransformRenameFailed(BzrError):
 
1979
 
 
1980
    _fmt = "Failed to rename %(from_path)s to %(to_path)s: %(why)s"
 
1981
 
 
1982
    def __init__(self, from_path, to_path, why, errno):
 
1983
        self.from_path = from_path
 
1984
        self.to_path = to_path
 
1985
        self.why = why
 
1986
        self.errno = errno
 
1987
 
 
1988
 
1728
1989
class BzrMoveFailedError(BzrError):
1729
1990
 
1730
 
    _fmt = "Could not move %(from_path)s%(operator)s %(to_path)s%(extra)s"
 
1991
    _fmt = ("Could not move %(from_path)s%(operator)s %(to_path)s"
 
1992
        "%(_has_extra)s%(extra)s")
1731
1993
 
1732
1994
    def __init__(self, from_path='', to_path='', extra=None):
 
1995
        from bzrlib.osutils import splitpath
1733
1996
        BzrError.__init__(self)
1734
1997
        if extra:
1735
 
            self.extra = ': ' + str(extra)
 
1998
            self.extra, self._has_extra = extra, ': '
1736
1999
        else:
1737
 
            self.extra = ''
 
2000
            self.extra = self._has_extra = ''
1738
2001
 
1739
2002
        has_from = len(from_path) > 0
1740
2003
        has_to = len(to_path) > 0
1741
2004
        if has_from:
1742
 
            self.from_path = osutils.splitpath(from_path)[-1]
 
2005
            self.from_path = splitpath(from_path)[-1]
1743
2006
        else:
1744
2007
            self.from_path = ''
1745
2008
 
1746
2009
        if has_to:
1747
 
            self.to_path = osutils.splitpath(to_path)[-1]
 
2010
            self.to_path = splitpath(to_path)[-1]
1748
2011
        else:
1749
2012
            self.to_path = ''
1750
2013
 
1761
2024
 
1762
2025
class BzrRenameFailedError(BzrMoveFailedError):
1763
2026
 
1764
 
    _fmt = "Could not rename %(from_path)s%(operator)s %(to_path)s%(extra)s"
 
2027
    _fmt = ("Could not rename %(from_path)s%(operator)s %(to_path)s"
 
2028
        "%(_has_extra)s%(extra)s")
1765
2029
 
1766
2030
    def __init__(self, from_path, to_path, extra=None):
1767
2031
        BzrMoveFailedError.__init__(self, from_path, to_path, extra)
1768
2032
 
1769
 
class BzrRemoveChangedFilesError(BzrError):
1770
 
    """Used when user is trying to remove changed files."""
1771
 
 
1772
 
    _fmt = ("Can't safely remove modified or unknown files:\n"
1773
 
        "%(changes_as_text)s"
1774
 
        "Use --keep to not delete them, or --force to delete them regardless.")
1775
 
 
1776
 
    def __init__(self, tree_delta):
1777
 
        BzrError.__init__(self)
1778
 
        self.changes_as_text = tree_delta.get_changes_as_text()
1779
 
        #self.paths_as_string = '\n'.join(changed_files)
1780
 
        #self.paths_as_string = '\n'.join([quotefn(p) for p in changed_files])
1781
 
 
1782
2033
 
1783
2034
class BzrBadParameterNotString(BzrBadParameter):
1784
2035
 
1787
2038
 
1788
2039
class BzrBadParameterMissing(BzrBadParameter):
1789
2040
 
1790
 
    _fmt = "Parameter $(param)s is required but not present."
 
2041
    _fmt = "Parameter %(param)s is required but not present."
1791
2042
 
1792
2043
 
1793
2044
class BzrBadParameterUnicode(BzrBadParameter):
1801
2052
    _fmt = "Parameter %(param)s contains a newline."
1802
2053
 
1803
2054
 
1804
 
class DependencyNotPresent(BzrError):
1805
 
 
1806
 
    _fmt = 'Unable to import library "%(library)s": %(error)s'
1807
 
 
1808
 
    def __init__(self, library, error):
1809
 
        BzrError.__init__(self, library=library, error=error)
1810
 
 
1811
 
 
1812
2055
class ParamikoNotPresent(DependencyNotPresent):
1813
2056
 
1814
2057
    _fmt = "Unable to import paramiko (required for sftp support): %(error)s"
1833
2076
 
1834
2077
class BadConversionTarget(BzrError):
1835
2078
 
1836
 
    _fmt = "Cannot convert to format %(format)s.  %(problem)s"
 
2079
    _fmt = "Cannot convert from format %(from_format)s to format %(format)s." \
 
2080
            "    %(problem)s"
1837
2081
 
1838
 
    def __init__(self, problem, format):
 
2082
    def __init__(self, problem, format, from_format=None):
1839
2083
        BzrError.__init__(self)
1840
2084
        self.problem = problem
1841
2085
        self.format = format
 
2086
        self.from_format = from_format or '(unspecified)'
 
2087
 
 
2088
 
 
2089
class NoDiffFound(BzrError):
 
2090
 
 
2091
    _fmt = 'Could not find an appropriate Differ for file "%(path)s"'
 
2092
 
 
2093
    def __init__(self, path):
 
2094
        BzrError.__init__(self, path)
 
2095
 
 
2096
 
 
2097
class ExecutableMissing(BzrError):
 
2098
 
 
2099
    _fmt = "%(exe_name)s could not be found on this machine"
 
2100
 
 
2101
    def __init__(self, exe_name):
 
2102
        BzrError.__init__(self, exe_name=exe_name)
1842
2103
 
1843
2104
 
1844
2105
class NoDiff(BzrError):
1865
2126
    _fmt = """This tree contains left-over files from a failed operation.
1866
2127
    Please examine %(limbo_dir)s to see if it contains any files you wish to
1867
2128
    keep, and delete it when you are done."""
1868
 
    
 
2129
 
1869
2130
    def __init__(self, limbo_dir):
1870
2131
       BzrError.__init__(self)
1871
2132
       self.limbo_dir = limbo_dir
1894
2155
 
1895
2156
class ImmortalPendingDeletion(BzrError):
1896
2157
 
1897
 
    _fmt = """Unable to delete transform temporary directory
1898
 
    %(pending_deletion)s.  Please examine %(pending_deletions)s to see if it
1899
 
    contains any files you wish to keep, and delete it when you are done."""
 
2158
    _fmt = ("Unable to delete transform temporary directory "
 
2159
    "%(pending_deletion)s.  Please examine %(pending_deletion)s to see if it "
 
2160
    "contains any files you wish to keep, and delete it when you are done.")
1900
2161
 
1901
2162
    def __init__(self, pending_deletion):
1902
2163
       BzrError.__init__(self, pending_deletion=pending_deletion)
1904
2165
 
1905
2166
class OutOfDateTree(BzrError):
1906
2167
 
1907
 
    _fmt = "Working tree is out of date, please run 'bzr update'."
 
2168
    _fmt = "Working tree is out of date, please run 'bzr update'.%(more)s"
1908
2169
 
1909
 
    def __init__(self, tree):
 
2170
    def __init__(self, tree, more=None):
 
2171
        if more is None:
 
2172
            more = ''
 
2173
        else:
 
2174
            more = ' ' + more
1910
2175
        BzrError.__init__(self)
1911
2176
        self.tree = tree
 
2177
        self.more = more
1912
2178
 
1913
2179
 
1914
2180
class PublicBranchOutOfDate(BzrError):
1934
2200
    _fmt = "Format error in conflict listings"
1935
2201
 
1936
2202
 
 
2203
class CorruptDirstate(BzrError):
 
2204
 
 
2205
    _fmt = ("Inconsistency in dirstate file %(dirstate_path)s.\n"
 
2206
            "Error: %(description)s")
 
2207
 
 
2208
    def __init__(self, dirstate_path, description):
 
2209
        BzrError.__init__(self)
 
2210
        self.dirstate_path = dirstate_path
 
2211
        self.description = description
 
2212
 
 
2213
 
1937
2214
class CorruptRepository(BzrError):
1938
2215
 
1939
2216
    _fmt = ("An error has been detected in the repository %(repo_path)s.\n"
1941
2218
 
1942
2219
    def __init__(self, repo):
1943
2220
        BzrError.__init__(self)
1944
 
        self.repo_path = repo.bzrdir.root_transport.base
 
2221
        self.repo_path = repo.user_url
 
2222
 
 
2223
 
 
2224
class InconsistentDelta(BzrError):
 
2225
    """Used when we get a delta that is not valid."""
 
2226
 
 
2227
    _fmt = ("An inconsistent delta was supplied involving %(path)r,"
 
2228
            " %(file_id)r\nreason: %(reason)s")
 
2229
 
 
2230
    def __init__(self, path, file_id, reason):
 
2231
        BzrError.__init__(self)
 
2232
        self.path = path
 
2233
        self.file_id = file_id
 
2234
        self.reason = reason
 
2235
 
 
2236
 
 
2237
class InconsistentDeltaDelta(InconsistentDelta):
 
2238
    """Used when we get a delta that is not valid."""
 
2239
 
 
2240
    _fmt = ("An inconsistent delta was supplied: %(delta)r"
 
2241
            "\nreason: %(reason)s")
 
2242
 
 
2243
    def __init__(self, delta, reason):
 
2244
        BzrError.__init__(self)
 
2245
        self.delta = delta
 
2246
        self.reason = reason
1945
2247
 
1946
2248
 
1947
2249
class UpgradeRequired(BzrError):
1953
2255
        self.path = path
1954
2256
 
1955
2257
 
 
2258
class RepositoryUpgradeRequired(UpgradeRequired):
 
2259
 
 
2260
    _fmt = "To use this feature you must upgrade your repository at %(path)s."
 
2261
 
 
2262
 
 
2263
class RichRootUpgradeRequired(UpgradeRequired):
 
2264
 
 
2265
    _fmt = ("To use this feature you must upgrade your branch at %(path)s to"
 
2266
           " a format which supports rich roots.")
 
2267
 
 
2268
 
1956
2269
class LocalRequiresBoundBranch(BzrError):
1957
2270
 
1958
2271
    _fmt = "Cannot perform local-only commits on unbound branches."
1959
2272
 
1960
2273
 
1961
 
class MissingProgressBarFinish(BzrError):
1962
 
 
1963
 
    _fmt = "A nested progress bar was not 'finished' correctly."
1964
 
 
1965
 
 
1966
 
class InvalidProgressBarType(BzrError):
1967
 
 
1968
 
    _fmt = ("Environment variable BZR_PROGRESS_BAR='%(bar_type)s"
1969
 
            " is not a supported type Select one of: %(valid_types)s")
1970
 
 
1971
 
    def __init__(self, bar_type, valid_types):
1972
 
        BzrError.__init__(self, bar_type=bar_type, valid_types=valid_types)
1973
 
 
1974
 
 
1975
2274
class UnsupportedOperation(BzrError):
1976
2275
 
1977
2276
    _fmt = ("The method %(mname)s is not supported on"
1993
2292
    """
1994
2293
 
1995
2294
 
 
2295
class GhostTagsNotSupported(BzrError):
 
2296
 
 
2297
    _fmt = "Ghost tags not supported by format %(format)r."
 
2298
 
 
2299
    def __init__(self, format):
 
2300
        self.format = format
 
2301
 
 
2302
 
1996
2303
class BinaryFile(BzrError):
1997
 
    
 
2304
 
1998
2305
    _fmt = "File is binary but should be text."
1999
2306
 
2000
2307
 
2020
2327
 
2021
2328
 
2022
2329
class NotABundle(BzrError):
2023
 
    
 
2330
 
2024
2331
    _fmt = "Not a bzr revision-bundle: %(text)r"
2025
2332
 
2026
2333
    def __init__(self, text):
2028
2335
        self.text = text
2029
2336
 
2030
2337
 
2031
 
class BadBundle(BzrError): 
2032
 
    
 
2338
class BadBundle(BzrError):
 
2339
 
2033
2340
    _fmt = "Bad bzr revision-bundle: %(text)r"
2034
2341
 
2035
2342
    def __init__(self, text):
2037
2344
        self.text = text
2038
2345
 
2039
2346
 
2040
 
class MalformedHeader(BadBundle): 
2041
 
    
 
2347
class MalformedHeader(BadBundle):
 
2348
 
2042
2349
    _fmt = "Malformed bzr revision-bundle header: %(text)r"
2043
2350
 
2044
2351
 
2045
 
class MalformedPatches(BadBundle): 
2046
 
    
 
2352
class MalformedPatches(BadBundle):
 
2353
 
2047
2354
    _fmt = "Malformed patches in bzr revision-bundle: %(text)r"
2048
2355
 
2049
2356
 
2050
 
class MalformedFooter(BadBundle): 
2051
 
    
 
2357
class MalformedFooter(BadBundle):
 
2358
 
2052
2359
    _fmt = "Malformed footer in bzr revision-bundle: %(text)r"
2053
2360
 
2054
2361
 
2055
2362
class UnsupportedEOLMarker(BadBundle):
2056
 
    
2057
 
    _fmt = "End of line marker was not \\n in bzr revision-bundle"    
 
2363
 
 
2364
    _fmt = "End of line marker was not \\n in bzr revision-bundle"
2058
2365
 
2059
2366
    def __init__(self):
2060
 
        # XXX: BadBundle's constructor assumes there's explanatory text, 
 
2367
        # XXX: BadBundle's constructor assumes there's explanatory text,
2061
2368
        # but for this there is not
2062
2369
        BzrError.__init__(self)
2063
2370
 
2064
2371
 
2065
2372
class IncompatibleBundleFormat(BzrError):
2066
 
    
 
2373
 
2067
2374
    _fmt = "Bundle format %(bundle_format)s is incompatible with %(other)s"
2068
2375
 
2069
2376
    def __init__(self, bundle_format, other):
2073
2380
 
2074
2381
 
2075
2382
class BadInventoryFormat(BzrError):
2076
 
    
 
2383
 
2077
2384
    _fmt = "Root class for inventory serialization errors"
2078
2385
 
2079
2386
 
2090
2397
    _fmt = """This operation requires rich root data storage"""
2091
2398
 
2092
2399
 
2093
 
class NoSmartMedium(BzrError):
 
2400
class NoSmartMedium(InternalBzrError):
2094
2401
 
2095
2402
    _fmt = "The transport '%(transport)s' cannot tunnel the smart protocol."
2096
2403
 
2097
 
    internal_error = True
2098
 
 
2099
2404
    def __init__(self, transport):
2100
2405
        self.transport = transport
2101
2406
 
2102
2407
 
2103
 
class NoSmartServer(NotBranchError):
2104
 
 
2105
 
    _fmt = "No smart server available at %(url)s"
2106
 
 
2107
 
    def __init__(self, url):
2108
 
        self.url = url
2109
 
 
2110
 
 
2111
2408
class UnknownSSH(BzrError):
2112
2409
 
2113
2410
    _fmt = "Unrecognised value for BZR_SSH environment variable: %(vendor)s"
2123
2420
            " Please set BZR_SSH environment variable.")
2124
2421
 
2125
2422
 
 
2423
class GhostRevisionsHaveNoRevno(BzrError):
 
2424
    """When searching for revnos, if we encounter a ghost, we are stuck"""
 
2425
 
 
2426
    _fmt = ("Could not determine revno for {%(revision_id)s} because"
 
2427
            " its ancestry shows a ghost at {%(ghost_revision_id)s}")
 
2428
 
 
2429
    def __init__(self, revision_id, ghost_revision_id):
 
2430
        self.revision_id = revision_id
 
2431
        self.ghost_revision_id = ghost_revision_id
 
2432
 
 
2433
 
2126
2434
class GhostRevisionUnusableHere(BzrError):
2127
2435
 
2128
2436
    _fmt = "Ghost revision {%(revision_id)s} cannot be used here."
2132
2440
        self.revision_id = revision_id
2133
2441
 
2134
2442
 
2135
 
class IllegalUseOfScopeReplacer(BzrError):
 
2443
class IllegalUseOfScopeReplacer(InternalBzrError):
2136
2444
 
2137
2445
    _fmt = ("ScopeReplacer object %(name)r was used incorrectly:"
2138
2446
            " %(msg)s%(extra)s")
2139
2447
 
2140
 
    internal_error = True
2141
 
 
2142
2448
    def __init__(self, name, msg, extra=None):
2143
2449
        BzrError.__init__(self)
2144
2450
        self.name = name
2149
2455
            self.extra = ''
2150
2456
 
2151
2457
 
2152
 
class InvalidImportLine(BzrError):
 
2458
class InvalidImportLine(InternalBzrError):
2153
2459
 
2154
2460
    _fmt = "Not a valid import statement: %(msg)\n%(text)s"
2155
2461
 
2156
 
    internal_error = True
2157
 
 
2158
2462
    def __init__(self, text, msg):
2159
2463
        BzrError.__init__(self)
2160
2464
        self.text = text
2161
2465
        self.msg = msg
2162
2466
 
2163
2467
 
2164
 
class ImportNameCollision(BzrError):
 
2468
class ImportNameCollision(InternalBzrError):
2165
2469
 
2166
2470
    _fmt = ("Tried to import an object to the same name as"
2167
2471
            " an existing object. %(name)s")
2168
2472
 
2169
 
    internal_error = True
2170
 
 
2171
2473
    def __init__(self, name):
2172
2474
        BzrError.__init__(self)
2173
2475
        self.name = name
2205
2507
class PatchMissing(BzrError):
2206
2508
    """Raise a patch type was specified but no patch supplied"""
2207
2509
 
2208
 
    _fmt = "patch_type was %(patch_type)s, but no patch was supplied."
 
2510
    _fmt = "Patch_type was %(patch_type)s, but no patch was supplied."
2209
2511
 
2210
2512
    def __init__(self, patch_type):
2211
2513
        BzrError.__init__(self)
2212
2514
        self.patch_type = patch_type
2213
2515
 
2214
2516
 
 
2517
class TargetNotBranch(BzrError):
 
2518
    """A merge directive's target branch is required, but isn't a branch"""
 
2519
 
 
2520
    _fmt = ("Your branch does not have all of the revisions required in "
 
2521
            "order to merge this merge directive and the target "
 
2522
            "location specified in the merge directive is not a branch: "
 
2523
            "%(location)s.")
 
2524
 
 
2525
    def __init__(self, location):
 
2526
        BzrError.__init__(self)
 
2527
        self.location = location
 
2528
 
 
2529
 
2215
2530
class UnsupportedInventoryKind(BzrError):
2216
 
    
 
2531
 
2217
2532
    _fmt = """Unsupported entry kind %(kind)s"""
2218
2533
 
2219
2534
    def __init__(self, kind):
2231
2546
 
2232
2547
 
2233
2548
class SubsumeTargetNeedsUpgrade(BzrError):
2234
 
    
 
2549
 
2235
2550
    _fmt = """Subsume target %(other_tree)s needs to be upgraded."""
2236
2551
 
2237
2552
    def __init__(self, other_tree):
2238
2553
        self.other_tree = other_tree
2239
2554
 
2240
2555
 
2241
 
class BadReferenceTarget(BzrError):
 
2556
class BadReferenceTarget(InternalBzrError):
2242
2557
 
2243
2558
    _fmt = "Can't add reference to %(other_tree)s into %(tree)s." \
2244
2559
           "%(reason)s"
2245
2560
 
2246
 
    internal_error = True
2247
 
 
2248
2561
    def __init__(self, tree, other_tree, reason):
2249
2562
        self.tree = tree
2250
2563
        self.other_tree = other_tree
2262
2575
class TagsNotSupported(BzrError):
2263
2576
 
2264
2577
    _fmt = ("Tags not supported by %(branch)s;"
2265
 
            " you may be able to use bzr upgrade --dirstate-tags.")
 
2578
            " you may be able to use bzr upgrade.")
2266
2579
 
2267
2580
    def __init__(self, branch):
2268
2581
        self.branch = branch
2269
2582
 
2270
 
        
 
2583
 
2271
2584
class TagAlreadyExists(BzrError):
2272
2585
 
2273
2586
    _fmt = "Tag %(tag_name)s already exists."
2278
2591
 
2279
2592
class MalformedBugIdentifier(BzrError):
2280
2593
 
2281
 
    _fmt = "Did not understand bug identifier %(bug_id)s: %(reason)s"
 
2594
    _fmt = ('Did not understand bug identifier %(bug_id)s: %(reason)s. '
 
2595
            'See "bzr help bugs" for more information on this feature.')
2282
2596
 
2283
2597
    def __init__(self, bug_id, reason):
2284
2598
        self.bug_id = bug_id
2285
2599
        self.reason = reason
2286
2600
 
2287
2601
 
 
2602
class InvalidBugTrackerURL(BzrError):
 
2603
 
 
2604
    _fmt = ("The URL for bug tracker \"%(abbreviation)s\" doesn't "
 
2605
            "contain {id}: %(url)s")
 
2606
 
 
2607
    def __init__(self, abbreviation, url):
 
2608
        self.abbreviation = abbreviation
 
2609
        self.url = url
 
2610
 
 
2611
 
2288
2612
class UnknownBugTrackerAbbreviation(BzrError):
2289
2613
 
2290
2614
    _fmt = ("Cannot find registered bug tracker called %(abbreviation)s "
2295
2619
        self.branch = branch
2296
2620
 
2297
2621
 
 
2622
class InvalidLineInBugsProperty(BzrError):
 
2623
 
 
2624
    _fmt = ("Invalid line in bugs property: '%(line)s'")
 
2625
 
 
2626
    def __init__(self, line):
 
2627
        self.line = line
 
2628
 
 
2629
 
 
2630
class InvalidBugStatus(BzrError):
 
2631
 
 
2632
    _fmt = ("Invalid bug status: '%(status)s'")
 
2633
 
 
2634
    def __init__(self, status):
 
2635
        self.status = status
 
2636
 
 
2637
 
2298
2638
class UnexpectedSmartServerResponse(BzrError):
2299
2639
 
2300
2640
    _fmt = "Could not understand response from smart server: %(response_tuple)r"
2303
2643
        self.response_tuple = response_tuple
2304
2644
 
2305
2645
 
 
2646
class ErrorFromSmartServer(BzrError):
 
2647
    """An error was received from a smart server.
 
2648
 
 
2649
    :seealso: UnknownErrorFromSmartServer
 
2650
    """
 
2651
 
 
2652
    _fmt = "Error received from smart server: %(error_tuple)r"
 
2653
 
 
2654
    internal_error = True
 
2655
 
 
2656
    def __init__(self, error_tuple):
 
2657
        self.error_tuple = error_tuple
 
2658
        try:
 
2659
            self.error_verb = error_tuple[0]
 
2660
        except IndexError:
 
2661
            self.error_verb = None
 
2662
        self.error_args = error_tuple[1:]
 
2663
 
 
2664
 
 
2665
class UnknownErrorFromSmartServer(BzrError):
 
2666
    """An ErrorFromSmartServer could not be translated into a typical bzrlib
 
2667
    error.
 
2668
 
 
2669
    This is distinct from ErrorFromSmartServer so that it is possible to
 
2670
    distinguish between the following two cases:
 
2671
 
 
2672
    - ErrorFromSmartServer was uncaught.  This is logic error in the client
 
2673
      and so should provoke a traceback to the user.
 
2674
    - ErrorFromSmartServer was caught but its error_tuple could not be
 
2675
      translated.  This is probably because the server sent us garbage, and
 
2676
      should not provoke a traceback.
 
2677
    """
 
2678
 
 
2679
    _fmt = "Server sent an unexpected error: %(error_tuple)r"
 
2680
 
 
2681
    internal_error = False
 
2682
 
 
2683
    def __init__(self, error_from_smart_server):
 
2684
        """Constructor.
 
2685
 
 
2686
        :param error_from_smart_server: An ErrorFromSmartServer instance.
 
2687
        """
 
2688
        self.error_from_smart_server = error_from_smart_server
 
2689
        self.error_tuple = error_from_smart_server.error_tuple
 
2690
 
 
2691
 
2306
2692
class ContainerError(BzrError):
2307
2693
    """Base class of container errors."""
2308
2694
 
2310
2696
class UnknownContainerFormatError(ContainerError):
2311
2697
 
2312
2698
    _fmt = "Unrecognised container format: %(container_format)r"
2313
 
    
 
2699
 
2314
2700
    def __init__(self, container_format):
2315
2701
        self.container_format = container_format
2316
2702
 
2319
2705
 
2320
2706
    _fmt = "Unexpected end of container stream"
2321
2707
 
2322
 
    internal_error = False
2323
 
 
2324
2708
 
2325
2709
class UnknownRecordTypeError(ContainerError):
2326
2710
 
2351
2735
    _fmt = "Container has multiple records with the same name: %(name)s"
2352
2736
 
2353
2737
    def __init__(self, name):
2354
 
        self.name = name
2355
 
 
2356
 
 
2357
 
class NoDestinationAddress(BzrError):
 
2738
        self.name = name.decode("utf-8")
 
2739
 
 
2740
 
 
2741
class NoDestinationAddress(InternalBzrError):
2358
2742
 
2359
2743
    _fmt = "Message does not have a destination address."
2360
2744
 
2361
 
    internal_error = True
 
2745
 
 
2746
class RepositoryDataStreamError(BzrError):
 
2747
 
 
2748
    _fmt = "Corrupt or incompatible data stream: %(reason)s"
 
2749
 
 
2750
    def __init__(self, reason):
 
2751
        self.reason = reason
2362
2752
 
2363
2753
 
2364
2754
class SMTPError(BzrError):
2374
2764
    _fmt = "No message supplied."
2375
2765
 
2376
2766
 
2377
 
class UnknownMailClient(BzrError):
2378
 
 
2379
 
    _fmt = "Unknown mail client: %(mail_client)s"
2380
 
 
2381
 
    def __init__(self, mail_client):
2382
 
        BzrError.__init__(self, mail_client=mail_client)
 
2767
class NoMailAddressSpecified(BzrError):
 
2768
 
 
2769
    _fmt = "No mail-to address (--mail-to) or output (-o) specified."
2383
2770
 
2384
2771
 
2385
2772
class MailClientNotFound(BzrError):
2404
2791
class DefaultSMTPConnectionRefused(SMTPConnectionRefused):
2405
2792
 
2406
2793
    _fmt = "Please specify smtp_server.  No server at default %(host)s."
 
2794
 
 
2795
 
 
2796
class BzrDirError(BzrError):
 
2797
 
 
2798
    def __init__(self, bzrdir):
 
2799
        import bzrlib.urlutils as urlutils
 
2800
        display_url = urlutils.unescape_for_display(bzrdir.user_url,
 
2801
                                                    'ascii')
 
2802
        BzrError.__init__(self, bzrdir=bzrdir, display_url=display_url)
 
2803
 
 
2804
 
 
2805
class UnsyncedBranches(BzrDirError):
 
2806
 
 
2807
    _fmt = ("'%(display_url)s' is not in sync with %(target_url)s.  See"
 
2808
            " bzr help sync-for-reconfigure.")
 
2809
 
 
2810
    def __init__(self, bzrdir, target_branch):
 
2811
        BzrDirError.__init__(self, bzrdir)
 
2812
        import bzrlib.urlutils as urlutils
 
2813
        self.target_url = urlutils.unescape_for_display(target_branch.base,
 
2814
                                                        'ascii')
 
2815
 
 
2816
 
 
2817
class AlreadyBranch(BzrDirError):
 
2818
 
 
2819
    _fmt = "'%(display_url)s' is already a branch."
 
2820
 
 
2821
 
 
2822
class AlreadyTree(BzrDirError):
 
2823
 
 
2824
    _fmt = "'%(display_url)s' is already a tree."
 
2825
 
 
2826
 
 
2827
class AlreadyCheckout(BzrDirError):
 
2828
 
 
2829
    _fmt = "'%(display_url)s' is already a checkout."
 
2830
 
 
2831
 
 
2832
class AlreadyLightweightCheckout(BzrDirError):
 
2833
 
 
2834
    _fmt = "'%(display_url)s' is already a lightweight checkout."
 
2835
 
 
2836
 
 
2837
class AlreadyUsingShared(BzrDirError):
 
2838
 
 
2839
    _fmt = "'%(display_url)s' is already using a shared repository."
 
2840
 
 
2841
 
 
2842
class AlreadyStandalone(BzrDirError):
 
2843
 
 
2844
    _fmt = "'%(display_url)s' is already standalone."
 
2845
 
 
2846
 
 
2847
class AlreadyWithTrees(BzrDirError):
 
2848
 
 
2849
    _fmt = ("Shared repository '%(display_url)s' already creates "
 
2850
            "working trees.")
 
2851
 
 
2852
 
 
2853
class AlreadyWithNoTrees(BzrDirError):
 
2854
 
 
2855
    _fmt = ("Shared repository '%(display_url)s' already doesn't create "
 
2856
            "working trees.")
 
2857
 
 
2858
 
 
2859
class ReconfigurationNotSupported(BzrDirError):
 
2860
 
 
2861
    _fmt = "Requested reconfiguration of '%(display_url)s' is not supported."
 
2862
 
 
2863
 
 
2864
class NoBindLocation(BzrDirError):
 
2865
 
 
2866
    _fmt = "No location could be found to bind to at %(display_url)s."
 
2867
 
 
2868
 
 
2869
class UncommittedChanges(BzrError):
 
2870
 
 
2871
    _fmt = ('Working tree "%(display_url)s" has uncommitted changes'
 
2872
            ' (See bzr status).%(more)s')
 
2873
 
 
2874
    def __init__(self, tree, more=None):
 
2875
        if more is None:
 
2876
            more = ''
 
2877
        else:
 
2878
            more = ' ' + more
 
2879
        import bzrlib.urlutils as urlutils
 
2880
        user_url = getattr(tree, "user_url", None)
 
2881
        if user_url is None:
 
2882
            display_url = str(tree)
 
2883
        else:
 
2884
            display_url = urlutils.unescape_for_display(user_url, 'ascii')
 
2885
        BzrError.__init__(self, tree=tree, display_url=display_url, more=more)
 
2886
 
 
2887
 
 
2888
class StoringUncommittedNotSupported(BzrError):
 
2889
 
 
2890
    _fmt = ('Branch "%(display_url)s" does not support storing uncommitted'
 
2891
            ' changes.')
 
2892
 
 
2893
    def __init__(self, branch):
 
2894
        import bzrlib.urlutils as urlutils
 
2895
        user_url = getattr(branch, "user_url", None)
 
2896
        if user_url is None:
 
2897
            display_url = str(branch)
 
2898
        else:
 
2899
            display_url = urlutils.unescape_for_display(user_url, 'ascii')
 
2900
        BzrError.__init__(self, branch=branch, display_url=display_url)
 
2901
 
 
2902
 
 
2903
class ShelvedChanges(UncommittedChanges):
 
2904
 
 
2905
    _fmt = ('Working tree "%(display_url)s" has shelved changes'
 
2906
            ' (See bzr shelve --list).%(more)s')
 
2907
 
 
2908
 
 
2909
class MissingTemplateVariable(BzrError):
 
2910
 
 
2911
    _fmt = 'Variable {%(name)s} is not available.'
 
2912
 
 
2913
    def __init__(self, name):
 
2914
        self.name = name
 
2915
 
 
2916
 
 
2917
class NoTemplate(BzrError):
 
2918
 
 
2919
    _fmt = 'No template specified.'
 
2920
 
 
2921
 
 
2922
class UnableCreateSymlink(BzrError):
 
2923
 
 
2924
    _fmt = 'Unable to create symlink %(path_str)son this platform'
 
2925
 
 
2926
    def __init__(self, path=None):
 
2927
        path_str = ''
 
2928
        if path:
 
2929
            try:
 
2930
                path_str = repr(str(path))
 
2931
            except UnicodeEncodeError:
 
2932
                path_str = repr(path)
 
2933
            path_str += ' '
 
2934
        self.path_str = path_str
 
2935
 
 
2936
 
 
2937
class UnsupportedTimezoneFormat(BzrError):
 
2938
 
 
2939
    _fmt = ('Unsupported timezone format "%(timezone)s", '
 
2940
            'options are "utc", "original", "local".')
 
2941
 
 
2942
    def __init__(self, timezone):
 
2943
        self.timezone = timezone
 
2944
 
 
2945
 
 
2946
class CommandAvailableInPlugin(StandardError):
 
2947
 
 
2948
    internal_error = False
 
2949
 
 
2950
    def __init__(self, cmd_name, plugin_metadata, provider):
 
2951
 
 
2952
        self.plugin_metadata = plugin_metadata
 
2953
        self.cmd_name = cmd_name
 
2954
        self.provider = provider
 
2955
 
 
2956
    def __str__(self):
 
2957
 
 
2958
        _fmt = ('"%s" is not a standard bzr command. \n'
 
2959
                'However, the following official plugin provides this command: %s\n'
 
2960
                'You can install it by going to: %s'
 
2961
                % (self.cmd_name, self.plugin_metadata['name'],
 
2962
                    self.plugin_metadata['url']))
 
2963
 
 
2964
        return _fmt
 
2965
 
 
2966
 
 
2967
class NoPluginAvailable(BzrError):
 
2968
    pass
 
2969
 
 
2970
 
 
2971
class UnableEncodePath(BzrError):
 
2972
 
 
2973
    _fmt = ('Unable to encode %(kind)s path %(path)r in '
 
2974
            'user encoding %(user_encoding)s')
 
2975
 
 
2976
    def __init__(self, path, kind):
 
2977
        from bzrlib.osutils import get_user_encoding
 
2978
        self.path = path
 
2979
        self.kind = kind
 
2980
        self.user_encoding = get_user_encoding()
 
2981
 
 
2982
 
 
2983
class NoSuchConfig(BzrError):
 
2984
 
 
2985
    _fmt = ('The "%(config_id)s" configuration does not exist.')
 
2986
 
 
2987
    def __init__(self, config_id):
 
2988
        BzrError.__init__(self, config_id=config_id)
 
2989
 
 
2990
 
 
2991
class NoSuchConfigOption(BzrError):
 
2992
 
 
2993
    _fmt = ('The "%(option_name)s" configuration option does not exist.')
 
2994
 
 
2995
    def __init__(self, option_name):
 
2996
        BzrError.__init__(self, option_name=option_name)
 
2997
 
 
2998
 
 
2999
class NoSuchAlias(BzrError):
 
3000
 
 
3001
    _fmt = ('The alias "%(alias_name)s" does not exist.')
 
3002
 
 
3003
    def __init__(self, alias_name):
 
3004
        BzrError.__init__(self, alias_name=alias_name)
 
3005
 
 
3006
 
 
3007
class DirectoryLookupFailure(BzrError):
 
3008
    """Base type for lookup errors."""
 
3009
 
 
3010
    pass
 
3011
 
 
3012
 
 
3013
class InvalidLocationAlias(DirectoryLookupFailure):
 
3014
 
 
3015
    _fmt = '"%(alias_name)s" is not a valid location alias.'
 
3016
 
 
3017
    def __init__(self, alias_name):
 
3018
        DirectoryLookupFailure.__init__(self, alias_name=alias_name)
 
3019
 
 
3020
 
 
3021
class UnsetLocationAlias(DirectoryLookupFailure):
 
3022
 
 
3023
    _fmt = 'No %(alias_name)s location assigned.'
 
3024
 
 
3025
    def __init__(self, alias_name):
 
3026
        DirectoryLookupFailure.__init__(self, alias_name=alias_name[1:])
 
3027
 
 
3028
 
 
3029
class CannotBindAddress(BzrError):
 
3030
 
 
3031
    _fmt = 'Cannot bind address "%(host)s:%(port)i": %(orig_error)s.'
 
3032
 
 
3033
    def __init__(self, host, port, orig_error):
 
3034
        # nb: in python2.4 socket.error doesn't have a useful repr
 
3035
        BzrError.__init__(self, host=host, port=port,
 
3036
            orig_error=repr(orig_error.args))
 
3037
 
 
3038
 
 
3039
class UnknownRules(BzrError):
 
3040
 
 
3041
    _fmt = ('Unknown rules detected: %(unknowns_str)s.')
 
3042
 
 
3043
    def __init__(self, unknowns):
 
3044
        BzrError.__init__(self, unknowns_str=", ".join(unknowns))
 
3045
 
 
3046
 
 
3047
class TipChangeRejected(BzrError):
 
3048
    """A pre_change_branch_tip hook function may raise this to cleanly and
 
3049
    explicitly abort a change to a branch tip.
 
3050
    """
 
3051
 
 
3052
    _fmt = u"Tip change rejected: %(msg)s"
 
3053
 
 
3054
    def __init__(self, msg):
 
3055
        self.msg = msg
 
3056
 
 
3057
 
 
3058
class ShelfCorrupt(BzrError):
 
3059
 
 
3060
    _fmt = "Shelf corrupt."
 
3061
 
 
3062
 
 
3063
class DecompressCorruption(BzrError):
 
3064
 
 
3065
    _fmt = "Corruption while decompressing repository file%(orig_error)s"
 
3066
 
 
3067
    def __init__(self, orig_error=None):
 
3068
        if orig_error is not None:
 
3069
            self.orig_error = ", %s" % (orig_error,)
 
3070
        else:
 
3071
            self.orig_error = ""
 
3072
        BzrError.__init__(self)
 
3073
 
 
3074
 
 
3075
class NoSuchShelfId(BzrError):
 
3076
 
 
3077
    _fmt = 'No changes are shelved with id "%(shelf_id)d".'
 
3078
 
 
3079
    def __init__(self, shelf_id):
 
3080
        BzrError.__init__(self, shelf_id=shelf_id)
 
3081
 
 
3082
 
 
3083
class InvalidShelfId(BzrError):
 
3084
 
 
3085
    _fmt = '"%(invalid_id)s" is not a valid shelf id, try a number instead.'
 
3086
 
 
3087
    def __init__(self, invalid_id):
 
3088
        BzrError.__init__(self, invalid_id=invalid_id)
 
3089
 
 
3090
 
 
3091
class JailBreak(BzrError):
 
3092
 
 
3093
    _fmt = "An attempt to access a url outside the server jail was made: '%(url)s'."
 
3094
 
 
3095
    def __init__(self, url):
 
3096
        BzrError.__init__(self, url=url)
 
3097
 
 
3098
 
 
3099
class UserAbort(BzrError):
 
3100
 
 
3101
    _fmt = 'The user aborted the operation.'
 
3102
 
 
3103
 
 
3104
class MustHaveWorkingTree(BzrError):
 
3105
 
 
3106
    _fmt = ("Branching '%(url)s'(%(format)s) must create a working tree.")
 
3107
 
 
3108
    def __init__(self, format, url):
 
3109
        BzrError.__init__(self, format=format, url=url)
 
3110
 
 
3111
 
 
3112
class NoSuchView(BzrError):
 
3113
    """A view does not exist.
 
3114
    """
 
3115
 
 
3116
    _fmt = u"No such view: %(view_name)s."
 
3117
 
 
3118
    def __init__(self, view_name):
 
3119
        self.view_name = view_name
 
3120
 
 
3121
 
 
3122
class ViewsNotSupported(BzrError):
 
3123
    """Views are not supported by a tree format.
 
3124
    """
 
3125
 
 
3126
    _fmt = ("Views are not supported by %(tree)s;"
 
3127
            " use 'bzr upgrade' to change your tree to a later format.")
 
3128
 
 
3129
    def __init__(self, tree):
 
3130
        self.tree = tree
 
3131
 
 
3132
 
 
3133
class FileOutsideView(BzrError):
 
3134
 
 
3135
    _fmt = ('Specified file "%(file_name)s" is outside the current view: '
 
3136
            '%(view_str)s')
 
3137
 
 
3138
    def __init__(self, file_name, view_files):
 
3139
        self.file_name = file_name
 
3140
        self.view_str = ", ".join(view_files)
 
3141
 
 
3142
 
 
3143
class UnresumableWriteGroup(BzrError):
 
3144
 
 
3145
    _fmt = ("Repository %(repository)s cannot resume write group "
 
3146
            "%(write_groups)r: %(reason)s")
 
3147
 
 
3148
    internal_error = True
 
3149
 
 
3150
    def __init__(self, repository, write_groups, reason):
 
3151
        self.repository = repository
 
3152
        self.write_groups = write_groups
 
3153
        self.reason = reason
 
3154
 
 
3155
 
 
3156
class UnsuspendableWriteGroup(BzrError):
 
3157
 
 
3158
    _fmt = ("Repository %(repository)s cannot suspend a write group.")
 
3159
 
 
3160
    internal_error = True
 
3161
 
 
3162
    def __init__(self, repository):
 
3163
        self.repository = repository
 
3164
 
 
3165
 
 
3166
class LossyPushToSameVCS(BzrError):
 
3167
 
 
3168
    _fmt = ("Lossy push not possible between %(source_branch)r and "
 
3169
            "%(target_branch)r that are in the same VCS.")
 
3170
 
 
3171
    internal_error = True
 
3172
 
 
3173
    def __init__(self, source_branch, target_branch):
 
3174
        self.source_branch = source_branch
 
3175
        self.target_branch = target_branch
 
3176
 
 
3177
 
 
3178
class NoRoundtrippingSupport(BzrError):
 
3179
 
 
3180
    _fmt = ("Roundtripping is not supported between %(source_branch)r and "
 
3181
            "%(target_branch)r.")
 
3182
 
 
3183
    internal_error = True
 
3184
 
 
3185
    def __init__(self, source_branch, target_branch):
 
3186
        self.source_branch = source_branch
 
3187
        self.target_branch = target_branch
 
3188
 
 
3189
 
 
3190
class FileTimestampUnavailable(BzrError):
 
3191
 
 
3192
    _fmt = "The filestamp for %(path)s is not available."
 
3193
 
 
3194
    internal_error = True
 
3195
 
 
3196
    def __init__(self, path):
 
3197
        self.path = path
 
3198
 
 
3199
 
 
3200
class NoColocatedBranchSupport(BzrError):
 
3201
 
 
3202
    _fmt = ("%(bzrdir)r does not support co-located branches.")
 
3203
 
 
3204
    def __init__(self, bzrdir):
 
3205
        self.bzrdir = bzrdir
 
3206
 
 
3207
 
 
3208
class NoWhoami(BzrError):
 
3209
 
 
3210
    _fmt = ('Unable to determine your name.\n'
 
3211
        "Please, set your name with the 'whoami' command.\n"
 
3212
        'E.g. bzr whoami "Your Name <name@example.com>"')
 
3213
 
 
3214
 
 
3215
class InvalidPattern(BzrError):
 
3216
 
 
3217
    _fmt = ('Invalid pattern(s) found. %(msg)s')
 
3218
 
 
3219
    def __init__(self, msg):
 
3220
        self.msg = msg
 
3221
 
 
3222
 
 
3223
class RecursiveBind(BzrError):
 
3224
 
 
3225
    _fmt = ('Branch "%(branch_url)s" appears to be bound to itself. '
 
3226
        'Please use `bzr unbind` to fix.')
 
3227
 
 
3228
    def __init__(self, branch_url):
 
3229
        self.branch_url = branch_url
 
3230
 
 
3231
 
 
3232
# FIXME: I would prefer to define the config related exception classes in
 
3233
# config.py but the lazy import mechanism proscribes this -- vila 20101222
 
3234
class OptionExpansionLoop(BzrError):
 
3235
 
 
3236
    _fmt = 'Loop involving %(refs)r while expanding "%(string)s".'
 
3237
 
 
3238
    def __init__(self, string, refs):
 
3239
        self.string = string
 
3240
        self.refs = '->'.join(refs)
 
3241
 
 
3242
 
 
3243
class ExpandingUnknownOption(BzrError):
 
3244
 
 
3245
    _fmt = 'Option "%(name)s" is not defined while expanding "%(string)s".'
 
3246
 
 
3247
    def __init__(self, name, string):
 
3248
        self.name = name
 
3249
        self.string = string
 
3250
 
 
3251
 
 
3252
class IllegalOptionName(BzrError):
 
3253
 
 
3254
    _fmt = 'Option "%(name)s" is not allowed.'
 
3255
 
 
3256
    def __init__(self, name):
 
3257
        self.name = name
 
3258
 
 
3259
 
 
3260
class NoCompatibleInter(BzrError):
 
3261
 
 
3262
    _fmt = ('No compatible object available for operations from %(source)r '
 
3263
            'to %(target)r.')
 
3264
 
 
3265
    def __init__(self, source, target):
 
3266
        self.source = source
 
3267
        self.target = target
 
3268
 
 
3269
 
 
3270
class HpssVfsRequestNotAllowed(BzrError):
 
3271
 
 
3272
    _fmt = ("VFS requests over the smart server are not allowed. Encountered: "
 
3273
            "%(method)s, %(arguments)s.")
 
3274
 
 
3275
    def __init__(self, method, arguments):
 
3276
        self.method = method
 
3277
        self.arguments = arguments
 
3278
 
 
3279
 
 
3280
class UnsupportedKindChange(BzrError):
 
3281
 
 
3282
    _fmt = ("Kind change from %(from_kind)s to %(to_kind)s for "
 
3283
            "%(path)s not supported by format %(format)r")
 
3284
 
 
3285
    def __init__(self, path, from_kind, to_kind, format):
 
3286
        self.path = path
 
3287
        self.from_kind = from_kind
 
3288
        self.to_kind = to_kind
 
3289
        self.format = format
 
3290
 
 
3291
 
 
3292
class MissingFeature(BzrError):
 
3293
 
 
3294
    _fmt = ("Missing feature %(feature)s not provided by this "
 
3295
            "version of Bazaar or any plugin.")
 
3296
 
 
3297
    def __init__(self, feature):
 
3298
        self.feature = feature
 
3299
 
 
3300
 
 
3301
class PatchSyntax(BzrError):
 
3302
    """Base class for patch syntax errors."""
 
3303
 
 
3304
 
 
3305
class BinaryFiles(BzrError):
 
3306
 
 
3307
    _fmt = 'Binary files section encountered.'
 
3308
 
 
3309
    def __init__(self, orig_name, mod_name):
 
3310
        self.orig_name = orig_name
 
3311
        self.mod_name = mod_name
 
3312
 
 
3313
 
 
3314
class MalformedPatchHeader(PatchSyntax):
 
3315
 
 
3316
    _fmt = "Malformed patch header.  %(desc)s\n%(line)r"
 
3317
 
 
3318
    def __init__(self, desc, line):
 
3319
        self.desc = desc
 
3320
        self.line = line
 
3321
 
 
3322
 
 
3323
class MalformedHunkHeader(PatchSyntax):
 
3324
 
 
3325
    _fmt = "Malformed hunk header.  %(desc)s\n%(line)r"
 
3326
 
 
3327
    def __init__(self, desc, line):
 
3328
        self.desc = desc
 
3329
        self.line = line
 
3330
 
 
3331
 
 
3332
class MalformedLine(PatchSyntax):
 
3333
 
 
3334
    _fmt = "Malformed line.  %(desc)s\n%(line)r"
 
3335
 
 
3336
    def __init__(self, desc, line):
 
3337
        self.desc = desc
 
3338
        self.line = line
 
3339
 
 
3340
 
 
3341
class PatchConflict(BzrError):
 
3342
 
 
3343
    _fmt = ('Text contents mismatch at line %(line_no)d.  Original has '
 
3344
            '"%(orig_line)s", but patch says it should be "%(patch_line)s"')
 
3345
 
 
3346
    def __init__(self, line_no, orig_line, patch_line):
 
3347
        self.line_no = line_no
 
3348
        self.orig_line = orig_line.rstrip('\n')
 
3349
        self.patch_line = patch_line.rstrip('\n')
 
3350
 
 
3351
 
 
3352
class FeatureAlreadyRegistered(BzrError):
 
3353
 
 
3354
    _fmt = 'The feature %(feature)s has already been registered.'
 
3355
 
 
3356
    def __init__(self, feature):
 
3357
        self.feature = feature
 
3358
 
 
3359
 
 
3360
class ChangesAlreadyStored(BzrCommandError):
 
3361
 
 
3362
    _fmt = ('Cannot store uncommitted changes because this branch already'
 
3363
            ' stores uncommitted changes.')