← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/errors.py

  • Committer: Canonical.com Patch Queue Manager
  • Date: 2008-03-16 16:58:03 UTC
  • mfrom: (3224.3.1 news-typo)
  • Revision ID: pqm@pqm.ubuntu.com-20080316165803-tisoc9mpob9z544o
(Matt Nordhoff) Trivial NEWS typo fix

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/errors.py
1
 
# Copyright (C) 2005-2011 Canonical Ltd
 
1
# Copyright (C) 2005, 2006, 2007, 2008 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
16
16
 
17
17
"""Exceptions for bzr, and reporting of them.
18
18
"""
19
19
 
 
20
 
20
21
from bzrlib import (
21
22
    osutils,
22
23
    symbol_versioning,
23
 
    i18n,
24
 
    trace,
25
24
    )
26
 
from bzrlib.i18n import gettext
27
25
from bzrlib.patches import (
28
26
    MalformedHunkHeader,
29
27
    MalformedLine,
34
32
 
35
33
 
36
34
# TODO: is there any value in providing the .args field used by standard
37
 
# python exceptions?   A list of values with no names seems less useful
 
35
# python exceptions?   A list of values with no names seems less useful 
38
36
# to me.
39
37
 
40
 
# TODO: Perhaps convert the exception to a string at the moment it's
 
38
# TODO: Perhaps convert the exception to a string at the moment it's 
41
39
# constructed to make sure it will succeed.  But that says nothing about
42
40
# exceptions that are never raised.
43
41
 
57
55
    Base class for errors raised by bzrlib.
58
56
 
59
57
    :cvar internal_error: if True this was probably caused by a bzr bug and
60
 
        should be displayed with a traceback; if False (or absent) this was
61
 
        probably a user or environment error and they don't need the gory
62
 
        details.  (That can be overridden by -Derror on the command line.)
 
58
    should be displayed with a traceback; if False (or absent) this was
 
59
    probably a user or environment error and they don't need the gory details.
 
60
    (That can be overridden by -Derror on the command line.)
63
61
 
64
62
    :cvar _fmt: Format string to display the error; this is expanded
65
 
        by the instance's dict.
 
63
    by the instance's dict.
66
64
    """
67
 
 
 
65
    
68
66
    internal_error = False
69
67
 
70
68
    def __init__(self, msg=None, **kwds):
75
73
        arguments can be given.  The first is for generic "user" errors which
76
74
        are not intended to be caught and so do not need a specific subclass.
77
75
        The second case is for use with subclasses that provide a _fmt format
78
 
        string to print the arguments.
 
76
        string to print the arguments.  
79
77
 
80
 
        Keyword arguments are taken as parameters to the error, which can
81
 
        be inserted into the format string template.  It's recommended
82
 
        that subclasses override the __init__ method to require specific
 
78
        Keyword arguments are taken as parameters to the error, which can 
 
79
        be inserted into the format string template.  It's recommended 
 
80
        that subclasses override the __init__ method to require specific 
83
81
        parameters.
84
82
 
85
83
        :param msg: If given, this is the literal complete text for the error,
86
 
           not subject to expansion. 'msg' is used instead of 'message' because
87
 
           python evolved and, in 2.6, forbids the use of 'message'.
 
84
        not subject to expansion.
88
85
        """
89
86
        StandardError.__init__(self)
90
87
        if msg is not None:
96
93
            for key, value in kwds.items():
97
94
                setattr(self, key, value)
98
95
 
99
 
    def _format(self):
 
96
    def __str__(self):
100
97
        s = getattr(self, '_preformatted_string', None)
101
98
        if s is not None:
102
 
            # contains a preformatted message
103
 
            return s
 
99
            # contains a preformatted message; must be cast to plain str
 
100
            return str(s)
104
101
        try:
105
102
            fmt = self._get_format_string()
106
103
            if fmt:
107
104
                d = dict(self.__dict__)
 
105
                # special case: python2.5 puts the 'message' attribute in a
 
106
                # slot, so it isn't seen in __dict__
 
107
                d['message'] = getattr(self, 'message', 'no message')
108
108
                s = fmt % d
109
109
                # __str__() should always return a 'str' object
110
110
                # never a 'unicode' object.
 
111
                if isinstance(s, unicode):
 
112
                    return s.encode('utf8')
111
113
                return s
112
114
        except (AttributeError, TypeError, NameError, ValueError, KeyError), e:
113
115
            return 'Unprintable exception %s: dict=%r, fmt=%r, error=%r' \
116
118
                   getattr(self, '_fmt', None),
117
119
                   e)
118
120
 
119
 
    def __unicode__(self):
120
 
        u = self._format()
121
 
        if isinstance(u, str):
122
 
            # Try decoding the str using the default encoding.
123
 
            u = unicode(u)
124
 
        elif not isinstance(u, unicode):
125
 
            # Try to make a unicode object from it, because __unicode__ must
126
 
            # return a unicode object.
127
 
            u = unicode(u)
128
 
        return u
129
 
 
130
 
    def __str__(self):
131
 
        s = self._format()
132
 
        if isinstance(s, unicode):
133
 
            s = s.encode('utf8')
134
 
        else:
135
 
            # __str__ must return a str.
136
 
            s = str(s)
137
 
        return s
138
 
 
139
 
    def __repr__(self):
140
 
        return '%s(%s)' % (self.__class__.__name__, str(self))
141
 
 
142
121
    def _get_format_string(self):
143
122
        """Return format string for this exception or None"""
144
123
        fmt = getattr(self, '_fmt', None)
145
124
        if fmt is not None:
146
 
            i18n.install()
147
 
            unicode_fmt = unicode(fmt) #_fmt strings should be ascii
148
 
            if type(fmt) == unicode:
149
 
                trace.mutter("Unicode strings in error.fmt are deprecated")
150
 
            return gettext(unicode_fmt)
 
125
            return fmt
151
126
        fmt = getattr(self, '__doc__', None)
152
127
        if fmt is not None:
153
128
            symbol_versioning.warn("%s uses its docstring as a format, "
160
135
               getattr(self, '_fmt', None),
161
136
               )
162
137
 
163
 
    def __eq__(self, other):
164
 
        if self.__class__ is not other.__class__:
165
 
            return NotImplemented
166
 
        return self.__dict__ == other.__dict__
167
 
 
168
138
 
169
139
class InternalBzrError(BzrError):
170
140
    """Base class for errors that are internal in nature.
211
181
 
212
182
 
213
183
class AlreadyBuilding(BzrError):
214
 
 
 
184
    
215
185
    _fmt = "The tree builder is already building a tree."
216
186
 
217
187
 
218
 
class BranchError(BzrError):
219
 
    """Base class for concrete 'errors about a branch'."""
220
 
 
221
 
    def __init__(self, branch):
222
 
        BzrError.__init__(self, branch=branch)
223
 
 
224
 
 
225
188
class BzrCheckError(InternalBzrError):
226
 
 
227
 
    _fmt = "Internal check failed: %(msg)s"
228
 
 
229
 
    def __init__(self, msg):
230
 
        BzrError.__init__(self)
231
 
        self.msg = msg
232
 
 
233
 
 
234
 
class DirstateCorrupt(BzrError):
235
 
 
236
 
    _fmt = "The dirstate file (%(state)s) appears to be corrupt: %(msg)s"
237
 
 
238
 
    def __init__(self, state, msg):
239
 
        BzrError.__init__(self)
240
 
        self.state = state
241
 
        self.msg = msg
 
189
    
 
190
    _fmt = "Internal check failed: %(message)s"
 
191
 
 
192
    def __init__(self, message):
 
193
        BzrError.__init__(self)
 
194
        self.message = message
242
195
 
243
196
 
244
197
class DisabledMethod(InternalBzrError):
272
225
 
273
226
 
274
227
class InvalidEntryName(InternalBzrError):
275
 
 
 
228
    
276
229
    _fmt = "Invalid entry name: %(name)s"
277
230
 
278
231
    def __init__(self, name):
281
234
 
282
235
 
283
236
class InvalidRevisionNumber(BzrError):
284
 
 
 
237
    
285
238
    _fmt = "Invalid revision number %(revno)s"
286
239
 
287
240
    def __init__(self, revno):
311
264
class RootMissing(InternalBzrError):
312
265
 
313
266
    _fmt = ("The root entry of a tree must be the first entry supplied to "
314
 
        "the commit builder.")
 
267
        "record_entry_contents.")
315
268
 
316
269
 
317
270
class NoPublicBranch(BzrError):
336
289
class NoSuchId(BzrError):
337
290
 
338
291
    _fmt = 'The file id "%(file_id)s" is not present in the tree %(tree)s.'
339
 
 
 
292
    
340
293
    def __init__(self, tree, file_id):
341
294
        BzrError.__init__(self)
342
295
        self.file_id = file_id
352
305
        BzrError.__init__(self, repository=repository, file_id=file_id)
353
306
 
354
307
 
355
 
class NotStacked(BranchError):
356
 
 
357
 
    _fmt = "The branch '%(branch)s' is not stacked."
358
 
 
359
 
 
360
308
class InventoryModified(InternalBzrError):
361
309
 
362
310
    _fmt = ("The current inventory for the tree %(tree)r has been modified,"
369
317
class NoWorkingTree(BzrError):
370
318
 
371
319
    _fmt = 'No WorkingTree exists for "%(base)s".'
372
 
 
 
320
    
373
321
    def __init__(self, base):
374
322
        BzrError.__init__(self)
375
323
        self.base = base
406
354
    # are not intended to be caught anyway.  UI code need not subclass
407
355
    # BzrCommandError, and non-UI code should not throw a subclass of
408
356
    # BzrCommandError.  ADHB 20051211
 
357
    def __init__(self, msg):
 
358
        # Object.__str__() must return a real string
 
359
        # returning a Unicode string is a python error.
 
360
        if isinstance(msg, unicode):
 
361
            self.msg = msg.encode('utf8')
 
362
        else:
 
363
            self.msg = msg
 
364
 
 
365
    def __str__(self):
 
366
        return self.msg
409
367
 
410
368
 
411
369
class NotWriteLocked(BzrError):
484
442
    def __init__(self, name, value):
485
443
        BzrError.__init__(self, name=name, value=value)
486
444
 
487
 
 
 
445
    
488
446
class StrictCommitFailed(BzrError):
489
447
 
490
448
    _fmt = "Commit refused because there are unknown files in the tree"
493
451
# XXX: Should be unified with TransportError; they seem to represent the
494
452
# same thing
495
453
# RBC 20060929: I think that unifiying with TransportError would be a mistake
496
 
# - this is finer than a TransportError - and more useful as such. It
 
454
# - this is finer than a TransportError - and more useful as such. It 
497
455
# differentiates between 'transport has failed' and 'operation on a transport
498
456
# has failed.'
499
457
class PathError(BzrError):
500
 
 
 
458
    
501
459
    _fmt = "Generic path error: %(path)r%(extra)s)"
502
460
 
503
461
    def __init__(self, path, extra=None):
557
515
 
558
516
 
559
517
class ReadingCompleted(InternalBzrError):
560
 
 
 
518
    
561
519
    _fmt = ("The MediumRequest '%(request)s' has already had finish_reading "
562
520
            "called upon it - the request has been completed and no more "
563
521
            "data may be read.")
583
541
 
584
542
class InvalidURLJoin(PathError):
585
543
 
586
 
    _fmt = "Invalid URL join request: %(reason)s: %(base)r + %(join_args)r"
587
 
 
588
 
    def __init__(self, reason, base, join_args):
589
 
        self.reason = reason
590
 
        self.base = base
591
 
        self.join_args = join_args
592
 
        PathError.__init__(self, base, reason)
593
 
 
594
 
 
595
 
class InvalidRebaseURLs(PathError):
596
 
 
597
 
    _fmt = "URLs differ by more than path: %(from_)r and %(to)r"
598
 
 
599
 
    def __init__(self, from_, to):
600
 
        self.from_ = from_
601
 
        self.to = to
602
 
        PathError.__init__(self, from_, 'URLs differ by more than path.')
603
 
 
604
 
 
605
 
class UnavailableRepresentation(InternalBzrError):
606
 
 
607
 
    _fmt = ("The encoding '%(wanted)s' is not available for key %(key)s which "
608
 
        "is encoded as '%(native)s'.")
609
 
 
610
 
    def __init__(self, key, wanted, native):
611
 
        InternalBzrError.__init__(self)
612
 
        self.wanted = wanted
613
 
        self.native = native
614
 
        self.key = key
 
544
    _fmt = 'Invalid URL join request: "%(args)s"%(extra)s'
 
545
 
 
546
    def __init__(self, msg, base, args):
 
547
        PathError.__init__(self, base, msg)
 
548
        self.args = [base] + list(args)
615
549
 
616
550
 
617
551
class UnknownHook(BzrError):
628
562
 
629
563
    _fmt = 'Unsupported protocol for url "%(path)s"%(extra)s'
630
564
 
631
 
    def __init__(self, url, extra=""):
 
565
    def __init__(self, url, extra):
632
566
        PathError.__init__(self, url, extra=extra)
633
567
 
634
568
 
635
 
class UnstackableBranchFormat(BzrError):
636
 
 
637
 
    _fmt = ("The branch '%(url)s'(%(format)s) is not a stackable format. "
638
 
        "You will need to upgrade the branch to permit branch stacking.")
639
 
 
640
 
    def __init__(self, format, url):
641
 
        BzrError.__init__(self)
642
 
        self.format = format
643
 
        self.url = url
644
 
 
645
 
 
646
 
class UnstackableLocationError(BzrError):
647
 
 
648
 
    _fmt = "The branch '%(branch_url)s' cannot be stacked on '%(target_url)s'."
649
 
 
650
 
    def __init__(self, branch_url, target_url):
651
 
        BzrError.__init__(self)
652
 
        self.branch_url = branch_url
653
 
        self.target_url = target_url
654
 
 
655
 
 
656
 
class UnstackableRepositoryFormat(BzrError):
657
 
 
658
 
    _fmt = ("The repository '%(url)s'(%(format)s) is not a stackable format. "
659
 
        "You will need to upgrade the repository to permit branch stacking.")
660
 
 
661
 
    def __init__(self, format, url):
662
 
        BzrError.__init__(self)
663
 
        self.format = format
664
 
        self.url = url
665
 
 
666
 
 
667
569
class ReadError(PathError):
668
 
 
 
570
    
669
571
    _fmt = """Error reading from %(path)r."""
670
572
 
671
573
 
687
589
 
688
590
    _fmt = 'Path "%(path)s" is not a child of path "%(base)s"%(extra)s'
689
591
 
690
 
    internal_error = False
 
592
    internal_error = True
691
593
 
692
594
    def __init__(self, path, base, extra=None):
693
595
        BzrError.__init__(self)
706
608
 
707
609
# TODO: This is given a URL; we try to unescape it but doing that from inside
708
610
# the exception object is a bit undesirable.
709
 
# TODO: Probably this behavior of should be a common superclass
 
611
# TODO: Probably this behavior of should be a common superclass 
710
612
class NotBranchError(PathError):
711
613
 
712
 
    _fmt = 'Not a branch: "%(path)s"%(detail)s.'
 
614
    _fmt = 'Not a branch: "%(path)s".'
713
615
 
714
 
    def __init__(self, path, detail=None, bzrdir=None):
 
616
    def __init__(self, path):
715
617
       import bzrlib.urlutils as urlutils
716
 
       path = urlutils.unescape_for_display(path, 'ascii')
717
 
       if detail is not None:
718
 
           detail = ': ' + detail
719
 
       self.detail = detail
720
 
       self.bzrdir = bzrdir
721
 
       PathError.__init__(self, path=path)
722
 
 
723
 
    def __repr__(self):
724
 
        return '<%s %r>' % (self.__class__.__name__, self.__dict__)
725
 
 
726
 
    def _format(self):
727
 
        # XXX: Ideally self.detail would be a property, but Exceptions in
728
 
        # Python 2.4 have to be old-style classes so properties don't work.
729
 
        # Instead we override _format.
730
 
        if self.detail is None:
731
 
            if self.bzrdir is not None:
732
 
                try:
733
 
                    self.bzrdir.open_repository()
734
 
                except NoRepositoryPresent:
735
 
                    self.detail = ''
736
 
                except Exception:
737
 
                    # Just ignore unexpected errors.  Raising arbitrary errors
738
 
                    # during str(err) can provoke strange bugs.  Concretely
739
 
                    # Launchpad's codehosting managed to raise NotBranchError
740
 
                    # here, and then get stuck in an infinite loop/recursion
741
 
                    # trying to str() that error.  All this error really cares
742
 
                    # about that there's no working repository there, and if
743
 
                    # open_repository() fails, there probably isn't.
744
 
                    self.detail = ''
745
 
                else:
746
 
                    self.detail = ': location is a repository'
747
 
            else:
748
 
                self.detail = ''
749
 
        return PathError._format(self)
 
618
       self.path = urlutils.unescape_for_display(path, 'ascii')
750
619
 
751
620
 
752
621
class NoSubmitBranch(PathError):
801
670
 
802
671
    _fmt = 'File "%(path)s" is not in branch %(branch_base)s.'
803
672
 
804
 
    # use PathNotChild instead
805
 
    @symbol_versioning.deprecated_method(symbol_versioning.deprecated_in((2, 3, 0)))
806
673
    def __init__(self, branch, path):
807
674
        BzrError.__init__(self)
808
675
        self.branch = branch
816
683
 
817
684
 
818
685
class UnknownFormatError(BzrError):
819
 
 
 
686
    
820
687
    _fmt = "Unknown %(kind)s format: %(format)r"
821
688
 
822
689
    def __init__(self, format, kind='branch'):
825
692
 
826
693
 
827
694
class IncompatibleFormat(BzrError):
828
 
 
 
695
    
829
696
    _fmt = "Format %(format)s is not compatible with .bzr version %(bzrdir)s."
830
697
 
831
698
    def __init__(self, format, bzrdir_format):
835
702
 
836
703
 
837
704
class IncompatibleRepositories(BzrError):
838
 
    """Report an error that two repositories are not compatible.
839
 
 
840
 
    Note that the source and target repositories are permitted to be strings:
841
 
    this exception is thrown from the smart server and may refer to a
842
 
    repository the client hasn't opened.
843
 
    """
844
 
 
845
 
    _fmt = "%(target)s\n" \
846
 
            "is not compatible with\n" \
847
 
            "%(source)s\n" \
848
 
            "%(details)s"
849
 
 
850
 
    def __init__(self, source, target, details=None):
851
 
        if details is None:
852
 
            details = "(no details)"
853
 
        BzrError.__init__(self, target=target, source=source, details=details)
 
705
 
 
706
    _fmt = "Repository %(target)s is not compatible with repository"\
 
707
        " %(source)s"
 
708
 
 
709
    def __init__(self, source, target):
 
710
        BzrError.__init__(self, target=target, source=source)
854
711
 
855
712
 
856
713
class IncompatibleRevision(BzrError):
857
 
 
 
714
    
858
715
    _fmt = "Revision is not compatible with %(repo_format)s"
859
716
 
860
717
    def __init__(self, repo_format):
871
728
        """Construct a new AlreadyVersionedError.
872
729
 
873
730
        :param path: This is the path which is versioned,
874
 
            which should be in a user friendly form.
 
731
        which should be in a user friendly form.
875
732
        :param context_info: If given, this is information about the context,
876
 
            which could explain why this is expected to not be versioned.
 
733
        which could explain why this is expected to not be versioned.
877
734
        """
878
735
        BzrError.__init__(self)
879
736
        self.path = path
892
749
        """Construct a new NotVersionedError.
893
750
 
894
751
        :param path: This is the path which is not versioned,
895
 
            which should be in a user friendly form.
 
752
        which should be in a user friendly form.
896
753
        :param context_info: If given, this is information about the context,
897
 
            which could explain why this is expected to be versioned.
 
754
        which could explain why this is expected to be versioned.
898
755
        """
899
756
        BzrError.__init__(self)
900
757
        self.path = path
943
800
        BzrError.__init__(self, filename=filename, kind=kind)
944
801
 
945
802
 
946
 
class BadFilenameEncoding(BzrError):
947
 
 
948
 
    _fmt = ('Filename %(filename)r is not valid in your current filesystem'
949
 
            ' encoding %(fs_encoding)s')
950
 
 
951
 
    def __init__(self, filename, fs_encoding):
952
 
        BzrError.__init__(self)
953
 
        self.filename = filename
954
 
        self.fs_encoding = fs_encoding
955
 
 
956
 
 
957
803
class ForbiddenControlFileError(BzrError):
958
804
 
959
805
    _fmt = 'Cannot operate on "%(filename)s" because it is a control file'
968
814
    # original exception is available as e.original_error
969
815
    #
970
816
    # New code should prefer to raise specific subclasses
971
 
    def __init__(self, msg):
972
 
        self.msg = msg
 
817
    def __init__(self, message):
 
818
        # Python 2.5 uses a slot for StandardError.message,
 
819
        # so use a different variable name.  We now work around this in
 
820
        # BzrError.__str__, but this member name is kept for compatability.
 
821
        self.msg = message
973
822
 
974
823
 
975
824
class LockActive(LockError):
1009
858
        self.obj = obj
1010
859
 
1011
860
 
 
861
class ReadOnlyLockError(LockError):
 
862
 
 
863
    _fmt = "Cannot acquire write lock on %(fname)s. %(msg)s"
 
864
 
 
865
    @symbol_versioning.deprecated_method(symbol_versioning.zero_ninetytwo)
 
866
    def __init__(self, fname, msg):
 
867
        LockError.__init__(self, '')
 
868
        self.fname = fname
 
869
        self.msg = msg
 
870
 
 
871
 
1012
872
class LockFailed(LockError):
1013
873
 
1014
874
    internal_error = False
1058
918
 
1059
919
class LockContention(LockError):
1060
920
 
1061
 
    _fmt = 'Could not acquire lock "%(lock)s": %(msg)s'
 
921
    _fmt = 'Could not acquire lock "%(lock)s"'
 
922
    # TODO: show full url for lock, combining the transport and relative
 
923
    # bits?
1062
924
 
1063
925
    internal_error = False
1064
926
 
1065
 
    def __init__(self, lock, msg=''):
 
927
    def __init__(self, lock):
1066
928
        self.lock = lock
1067
 
        self.msg = msg
1068
929
 
1069
930
 
1070
931
class LockBroken(LockError):
1091
952
        self.target = target
1092
953
 
1093
954
 
1094
 
class LockCorrupt(LockError):
1095
 
 
1096
 
    _fmt = ("Lock is apparently held, but corrupted: %(corruption_info)s\n"
1097
 
            "Use 'bzr break-lock' to clear it")
1098
 
 
1099
 
    internal_error = False
1100
 
 
1101
 
    def __init__(self, corruption_info, file_data=None):
1102
 
        self.corruption_info = corruption_info
1103
 
        self.file_data = file_data
1104
 
 
1105
 
 
1106
955
class LockNotHeld(LockError):
1107
956
 
1108
957
    _fmt = "Lock not held: %(lock)s"
1147
996
        BzrError.__init__(self, files=files, files_str=files_str)
1148
997
 
1149
998
 
1150
 
class ExcludesUnsupported(BzrError):
1151
 
 
1152
 
    _fmt = ('Excluding paths during commit is not supported by '
1153
 
            'repository at %(repository)r.')
1154
 
 
1155
 
    def __init__(self, repository):
1156
 
        BzrError.__init__(self, repository=repository)
1157
 
 
1158
 
 
1159
999
class BadCommitMessageEncoding(BzrError):
1160
1000
 
1161
1001
    _fmt = 'The specified commit message contains characters unsupported by '\
1190
1030
        BzrError.__init__(self, branch=branch, revision=revision)
1191
1031
 
1192
1032
 
 
1033
# zero_ninetyone: this exception is no longer raised and should be removed
 
1034
class NotLeftParentDescendant(InternalBzrError):
 
1035
 
 
1036
    _fmt = ("Revision %(old_revision)s is not the left parent of"
 
1037
            " %(new_revision)s, but branch %(branch_location)s expects this")
 
1038
 
 
1039
    def __init__(self, branch, old_revision, new_revision):
 
1040
        BzrError.__init__(self, branch_location=branch.base,
 
1041
                          old_revision=old_revision,
 
1042
                          new_revision=new_revision)
 
1043
 
 
1044
 
1193
1045
class RangeInChangeOption(BzrError):
1194
1046
 
1195
1047
    _fmt = "Option --change does not accept revision ranges"
1205
1057
 
1206
1058
class NoSuchRevisionInTree(NoSuchRevision):
1207
1059
    """When using Tree.revision_tree, and the revision is not accessible."""
1208
 
 
 
1060
    
1209
1061
    _fmt = "The revision id {%(revision_id)s} is not present in the tree %(tree)s."
1210
1062
 
1211
1063
    def __init__(self, tree, revision_id):
1216
1068
 
1217
1069
class InvalidRevisionSpec(BzrError):
1218
1070
 
1219
 
    _fmt = ("Requested revision: '%(spec)s' does not exist in branch:"
1220
 
            " %(branch_url)s%(extra)s")
 
1071
    _fmt = ("Requested revision: %(spec)r does not exist in branch:"
 
1072
            " %(branch)s%(extra)s")
1221
1073
 
1222
1074
    def __init__(self, spec, branch, extra=None):
1223
1075
        BzrError.__init__(self, branch=branch, spec=spec)
1224
 
        self.branch_url = getattr(branch, 'user_url', str(branch))
1225
1076
        if extra:
1226
1077
            self.extra = '\n' + str(extra)
1227
1078
        else:
1248
1099
class DivergedBranches(BzrError):
1249
1100
 
1250
1101
    _fmt = ("These branches have diverged."
1251
 
            " Use the missing command to see how.\n"
1252
 
            "Use the merge command to reconcile them.")
 
1102
            " Use the merge command to reconcile them.")
1253
1103
 
1254
1104
    def __init__(self, branch1, branch2):
1255
1105
        self.branch1 = branch1
1277
1127
 
1278
1128
 
1279
1129
class NoCommonAncestor(BzrError):
1280
 
 
 
1130
    
1281
1131
    _fmt = "Revisions have no common ancestor: %(revision_a)s %(revision_b)s"
1282
1132
 
1283
1133
    def __init__(self, revision_a, revision_b):
1303
1153
            not_ancestor_id=not_ancestor_id)
1304
1154
 
1305
1155
 
 
1156
class InstallFailed(BzrError):
 
1157
 
 
1158
    def __init__(self, revisions):
 
1159
        revision_str = ", ".join(str(r) for r in revisions)
 
1160
        msg = "Could not install revisions:\n%s" % revision_str
 
1161
        BzrError.__init__(self, msg)
 
1162
        self.revisions = revisions
 
1163
 
 
1164
 
1306
1165
class AmbiguousBase(BzrError):
1307
1166
 
1308
1167
    def __init__(self, bases):
1309
 
        symbol_versioning.warn("BzrError AmbiguousBase has been deprecated "
1310
 
            "as of bzrlib 0.8.", DeprecationWarning, stacklevel=2)
 
1168
        warn("BzrError AmbiguousBase has been deprecated as of bzrlib 0.8.",
 
1169
                DeprecationWarning)
1311
1170
        msg = ("The correct base is unclear, because %s are all equally close"
1312
1171
                % ", ".join(bases))
1313
1172
        BzrError.__init__(self, msg)
1314
1173
        self.bases = bases
1315
1174
 
1316
1175
 
1317
 
class NoCommits(BranchError):
 
1176
class NoCommits(BzrError):
1318
1177
 
1319
1178
    _fmt = "Branch %(branch)s has no commits."
1320
1179
 
 
1180
    def __init__(self, branch):
 
1181
        BzrError.__init__(self, branch=branch)
 
1182
 
1321
1183
 
1322
1184
class UnlistableStore(BzrError):
1323
1185
 
1335
1197
class BoundBranchOutOfDate(BzrError):
1336
1198
 
1337
1199
    _fmt = ("Bound branch %(branch)s is out of date with master branch"
1338
 
            " %(master)s.%(extra_help)s")
 
1200
            " %(master)s.")
1339
1201
 
1340
1202
    def __init__(self, branch, master):
1341
1203
        BzrError.__init__(self)
1342
1204
        self.branch = branch
1343
1205
        self.master = master
1344
 
        self.extra_help = ''
1345
 
 
1346
 
 
 
1206
 
 
1207
        
1347
1208
class CommitToDoubleBoundBranch(BzrError):
1348
1209
 
1349
1210
    _fmt = ("Cannot commit to branch %(branch)s."
1379
1240
 
1380
1241
class WeaveError(BzrError):
1381
1242
 
1382
 
    _fmt = "Error in processing weave: %(msg)s"
 
1243
    _fmt = "Error in processing weave: %(message)s"
1383
1244
 
1384
 
    def __init__(self, msg=None):
 
1245
    def __init__(self, message=None):
1385
1246
        BzrError.__init__(self)
1386
 
        self.msg = msg
 
1247
        self.message = message
1387
1248
 
1388
1249
 
1389
1250
class WeaveRevisionAlreadyPresent(WeaveError):
1418
1279
 
1419
1280
class WeaveParentMismatch(WeaveError):
1420
1281
 
1421
 
    _fmt = "Parents are mismatched between two revisions. %(msg)s"
1422
 
 
 
1282
    _fmt = "Parents are mismatched between two revisions. %(message)s"
 
1283
    
1423
1284
 
1424
1285
class WeaveInvalidChecksum(WeaveError):
1425
1286
 
1426
 
    _fmt = "Text did not match its checksum: %(msg)s"
 
1287
    _fmt = "Text did not match it's checksum: %(message)s"
1427
1288
 
1428
1289
 
1429
1290
class WeaveTextDiffers(WeaveError):
1451
1312
 
1452
1313
 
1453
1314
class VersionedFileError(BzrError):
1454
 
 
 
1315
    
1455
1316
    _fmt = "Versioned file error"
1456
1317
 
1457
1318
 
1458
1319
class RevisionNotPresent(VersionedFileError):
1459
 
 
 
1320
    
1460
1321
    _fmt = 'Revision {%(revision_id)s} not present in "%(file_id)s".'
1461
1322
 
1462
1323
    def __init__(self, revision_id, file_id):
1466
1327
 
1467
1328
 
1468
1329
class RevisionAlreadyPresent(VersionedFileError):
1469
 
 
 
1330
    
1470
1331
    _fmt = 'Revision {%(revision_id)s} already present in "%(file_id)s".'
1471
1332
 
1472
1333
    def __init__(self, revision_id, file_id):
1477
1338
 
1478
1339
class VersionedFileInvalidChecksum(VersionedFileError):
1479
1340
 
1480
 
    _fmt = "Text did not match its checksum: %(msg)s"
 
1341
    _fmt = "Text did not match its checksum: %(message)s"
1481
1342
 
1482
1343
 
1483
1344
class KnitError(InternalBzrError):
1484
 
 
 
1345
    
1485
1346
    _fmt = "Knit error"
1486
1347
 
1487
1348
 
1495
1356
        self.how = how
1496
1357
 
1497
1358
 
1498
 
class SHA1KnitCorrupt(KnitCorrupt):
1499
 
 
1500
 
    _fmt = ("Knit %(filename)s corrupt: sha-1 of reconstructed text does not "
1501
 
        "match expected sha-1. key %(key)s expected sha %(expected)s actual "
1502
 
        "sha %(actual)s")
1503
 
 
1504
 
    def __init__(self, filename, actual, expected, key, content):
1505
 
        KnitError.__init__(self)
1506
 
        self.filename = filename
1507
 
        self.actual = actual
1508
 
        self.expected = expected
1509
 
        self.key = key
1510
 
        self.content = content
1511
 
 
1512
 
 
1513
1359
class KnitDataStreamIncompatible(KnitError):
1514
1360
    # Not raised anymore, as we can convert data streams.  In future we may
1515
1361
    # need it again for more exotic cases, so we're keeping it around for now.
1519
1365
    def __init__(self, stream_format, target_format):
1520
1366
        self.stream_format = stream_format
1521
1367
        self.target_format = target_format
1522
 
 
 
1368
        
1523
1369
 
1524
1370
class KnitDataStreamUnknown(KnitError):
1525
1371
    # Indicates a data stream we don't know how to handle.
1528
1374
 
1529
1375
    def __init__(self, stream_format):
1530
1376
        self.stream_format = stream_format
1531
 
 
 
1377
        
1532
1378
 
1533
1379
class KnitHeaderError(KnitError):
1534
1380
 
1544
1390
 
1545
1391
    Currently only 'fulltext' and 'line-delta' are supported.
1546
1392
    """
1547
 
 
 
1393
    
1548
1394
    _fmt = ("Knit index %(filename)s does not have a known method"
1549
1395
            " in options: %(options)r")
1550
1396
 
1554
1400
        self.options = options
1555
1401
 
1556
1402
 
1557
 
class RetryWithNewPacks(BzrError):
1558
 
    """Raised when we realize that the packs on disk have changed.
1559
 
 
1560
 
    This is meant as more of a signaling exception, to trap between where a
1561
 
    local error occurred and the code that can actually handle the error and
1562
 
    code that can retry appropriately.
1563
 
    """
1564
 
 
1565
 
    internal_error = True
1566
 
 
1567
 
    _fmt = ("Pack files have changed, reload and retry. context: %(context)s"
1568
 
            " %(orig_error)s")
1569
 
 
1570
 
    def __init__(self, context, reload_occurred, exc_info):
1571
 
        """create a new RetryWithNewPacks error.
1572
 
 
1573
 
        :param reload_occurred: Set to True if we know that the packs have
1574
 
            already been reloaded, and we are failing because of an in-memory
1575
 
            cache miss. If set to True then we will ignore if a reload says
1576
 
            nothing has changed, because we assume it has already reloaded. If
1577
 
            False, then a reload with nothing changed will force an error.
1578
 
        :param exc_info: The original exception traceback, so if there is a
1579
 
            problem we can raise the original error (value from sys.exc_info())
1580
 
        """
1581
 
        BzrError.__init__(self)
1582
 
        self.reload_occurred = reload_occurred
1583
 
        self.exc_info = exc_info
1584
 
        self.orig_error = exc_info[1]
1585
 
        # TODO: The global error handler should probably treat this by
1586
 
        #       raising/printing the original exception with a bit about
1587
 
        #       RetryWithNewPacks also not being caught
1588
 
 
1589
 
 
1590
 
class RetryAutopack(RetryWithNewPacks):
1591
 
    """Raised when we are autopacking and we find a missing file.
1592
 
 
1593
 
    Meant as a signaling exception, to tell the autopack code it should try
1594
 
    again.
1595
 
    """
1596
 
 
1597
 
    internal_error = True
1598
 
 
1599
 
    _fmt = ("Pack files have changed, reload and try autopack again."
1600
 
            " context: %(context)s %(orig_error)s")
1601
 
 
1602
 
 
1603
1403
class NoSuchExportFormat(BzrError):
1604
 
 
 
1404
    
1605
1405
    _fmt = "Export format %(format)r not supported"
1606
1406
 
1607
1407
    def __init__(self, format):
1610
1410
 
1611
1411
 
1612
1412
class TransportError(BzrError):
1613
 
 
 
1413
    
1614
1414
    _fmt = "Transport error: %(msg)s %(orig_error)s"
1615
1415
 
1616
1416
    def __init__(self, msg=None, orig_error=None):
1643
1443
        self.details = details
1644
1444
 
1645
1445
 
1646
 
class UnexpectedProtocolVersionMarker(TransportError):
1647
 
 
1648
 
    _fmt = "Received bad protocol version marker: %(marker)r"
1649
 
 
1650
 
    def __init__(self, marker):
1651
 
        self.marker = marker
1652
 
 
1653
 
 
1654
 
class UnknownSmartMethod(InternalBzrError):
1655
 
 
1656
 
    _fmt = "The server does not recognise the '%(verb)s' request."
1657
 
 
1658
 
    def __init__(self, verb):
1659
 
        self.verb = verb
1660
 
 
1661
 
 
1662
 
class SmartMessageHandlerError(InternalBzrError):
1663
 
 
1664
 
    _fmt = ("The message handler raised an exception:\n"
1665
 
            "%(traceback_text)s")
1666
 
 
1667
 
    def __init__(self, exc_info):
1668
 
        import traceback
1669
 
        # GZ 2010-08-10: Cycle with exc_tb/exc_info affects at least one test
1670
 
        self.exc_type, self.exc_value, self.exc_tb = exc_info
1671
 
        self.exc_info = exc_info
1672
 
        traceback_strings = traceback.format_exception(
1673
 
                self.exc_type, self.exc_value, self.exc_tb)
1674
 
        self.traceback_text = ''.join(traceback_strings)
1675
 
 
1676
 
 
1677
1446
# A set of semi-meaningful errors which can be thrown
1678
1447
class TransportNotPossible(TransportError):
1679
1448
 
1704
1473
            self.port = ':%s' % port
1705
1474
 
1706
1475
 
1707
 
# XXX: This is also used for unexpected end of file, which is different at the
1708
 
# TCP level from "connection reset".
1709
1476
class ConnectionReset(TransportError):
1710
1477
 
1711
1478
    _fmt = "Connection closed: %(msg)s %(orig_error)s"
1712
1479
 
1713
1480
 
1714
 
class ConnectionTimeout(ConnectionError):
1715
 
 
1716
 
    _fmt = "Connection Timeout: %(msg)s%(orig_error)s"
1717
 
 
1718
 
 
1719
1481
class InvalidRange(TransportError):
1720
1482
 
1721
1483
    _fmt = "Invalid range access in %(path)s at %(offset)s: %(msg)s"
1728
1490
 
1729
1491
class InvalidHttpResponse(TransportError):
1730
1492
 
1731
 
    _fmt = "Invalid http response for %(path)s: %(msg)s%(orig_error)s"
 
1493
    _fmt = "Invalid http response for %(path)s: %(msg)s"
1732
1494
 
1733
1495
    def __init__(self, path, msg, orig_error=None):
1734
1496
        self.path = path
1735
 
        if orig_error is None:
1736
 
            orig_error = ''
1737
 
        else:
1738
 
            # This is reached for obscure and unusual errors so we want to
1739
 
            # preserve as much info as possible to ease debug.
1740
 
            orig_error = ': %r' % (orig_error,)
1741
1497
        TransportError.__init__(self, msg, orig_error=orig_error)
1742
1498
 
1743
1499
 
1750
1506
        InvalidHttpResponse.__init__(self, path, msg)
1751
1507
 
1752
1508
 
1753
 
class HttpBoundaryMissing(InvalidHttpResponse):
1754
 
    """A multipart response ends with no boundary marker.
1755
 
 
1756
 
    This is a special case caused by buggy proxies, described in
1757
 
    <https://bugs.launchpad.net/bzr/+bug/198646>.
1758
 
    """
1759
 
 
1760
 
    _fmt = "HTTP MIME Boundary missing for %(path)s: %(msg)s"
1761
 
 
1762
 
    def __init__(self, path, msg):
1763
 
        InvalidHttpResponse.__init__(self, path, msg)
1764
 
 
1765
 
 
1766
1509
class InvalidHttpContentType(InvalidHttpResponse):
1767
1510
 
1768
1511
    _fmt = 'Invalid http Content-type "%(ctype)s" for %(path)s: %(msg)s'
1776
1519
 
1777
1520
    _fmt = '%(source)s is%(permanently)s redirected to %(target)s'
1778
1521
 
1779
 
    def __init__(self, source, target, is_permanent=False):
 
1522
    def __init__(self, source, target, is_permanent=False, qual_proto=None):
1780
1523
        self.source = source
1781
1524
        self.target = target
1782
1525
        if is_permanent:
1783
1526
            self.permanently = ' permanently'
1784
1527
        else:
1785
1528
            self.permanently = ''
 
1529
        self._qualified_proto = qual_proto
1786
1530
        TransportError.__init__(self)
1787
1531
 
 
1532
    def _requalify_url(self, url):
 
1533
        """Restore the qualified proto in front of the url"""
 
1534
        # When this exception is raised, source and target are in
 
1535
        # user readable format. But some transports may use a
 
1536
        # different proto (http+urllib:// will present http:// to
 
1537
        # the user. If a qualified proto is specified, the code
 
1538
        # trapping the exception can get the qualified urls to
 
1539
        # properly handle the redirection themself (creating a
 
1540
        # new transport object from the target url for example).
 
1541
        # But checking that the scheme of the original and
 
1542
        # redirected urls are the same can be tricky. (see the
 
1543
        # FIXME in BzrDir.open_from_transport for the unique use
 
1544
        # case so far).
 
1545
        if self._qualified_proto is None:
 
1546
            return url
 
1547
 
 
1548
        # The TODO related to NotBranchError mention that doing
 
1549
        # that kind of manipulation on the urls may not be the
 
1550
        # exception object job. On the other hand, this object is
 
1551
        # the interface between the code and the user so
 
1552
        # presenting the urls in different ways is indeed its
 
1553
        # job...
 
1554
        import urlparse
 
1555
        proto, netloc, path, query, fragment = urlparse.urlsplit(url)
 
1556
        return urlparse.urlunsplit((self._qualified_proto, netloc, path,
 
1557
                                   query, fragment))
 
1558
 
 
1559
    def get_source_url(self):
 
1560
        return self._requalify_url(self.source)
 
1561
 
 
1562
    def get_target_url(self):
 
1563
        return self._requalify_url(self.target)
 
1564
 
1788
1565
 
1789
1566
class TooManyRedirections(TransportError):
1790
1567
 
1796
1573
    _fmt = "Working tree has conflicts."
1797
1574
 
1798
1575
 
1799
 
class ConfigContentError(BzrError):
1800
 
 
1801
 
    _fmt = "Config file %(filename)s is not UTF-8 encoded\n"
1802
 
 
1803
 
    def __init__(self, filename):
1804
 
        BzrError.__init__(self)
1805
 
        self.filename = filename
1806
 
 
1807
 
 
1808
1576
class ParseConfigError(BzrError):
1809
1577
 
1810
 
    _fmt = "Error(s) parsing config file %(filename)s:\n%(errors)s"
1811
 
 
1812
1578
    def __init__(self, errors, filename):
1813
 
        BzrError.__init__(self)
1814
 
        self.filename = filename
1815
 
        self.errors = '\n'.join(e.msg for e in errors)
1816
 
 
1817
 
 
1818
 
class ConfigOptionValueError(BzrError):
1819
 
 
1820
 
    _fmt = """Bad value "%(value)s" for option "%(name)s"."""
1821
 
 
1822
 
    def __init__(self, name, value):
1823
 
        BzrError.__init__(self, name=name, value=value)
 
1579
        if filename is None:
 
1580
            filename = ""
 
1581
        message = "Error(s) parsing config file %s:\n%s" % \
 
1582
            (filename, ('\n'.join(e.message for e in errors)))
 
1583
        BzrError.__init__(self, message)
1824
1584
 
1825
1585
 
1826
1586
class NoEmailInUsername(BzrError):
1834
1594
 
1835
1595
class SigningFailed(BzrError):
1836
1596
 
1837
 
    _fmt = 'Failed to GPG sign data with command "%(command_line)s"'
 
1597
    _fmt = 'Failed to gpg sign data with command "%(command_line)s"'
1838
1598
 
1839
1599
    def __init__(self, command_line):
1840
1600
        BzrError.__init__(self, command_line=command_line)
1841
1601
 
1842
1602
 
1843
 
class SignatureVerificationFailed(BzrError):
1844
 
 
1845
 
    _fmt = 'Failed to verify GPG signature data with error "%(error)s"'
1846
 
 
1847
 
    def __init__(self, error):
1848
 
        BzrError.__init__(self, error=error)
1849
 
 
1850
 
 
1851
 
class DependencyNotPresent(BzrError):
1852
 
 
1853
 
    _fmt = 'Unable to import library "%(library)s": %(error)s'
1854
 
 
1855
 
    def __init__(self, library, error):
1856
 
        BzrError.__init__(self, library=library, error=error)
1857
 
 
1858
 
 
1859
 
class GpgmeNotInstalled(DependencyNotPresent):
1860
 
 
1861
 
    _fmt = 'python-gpgme is not installed, it is needed to verify signatures'
1862
 
 
1863
 
    def __init__(self, error):
1864
 
        DependencyNotPresent.__init__(self, 'gpgme', error)
1865
 
 
1866
 
 
1867
1603
class WorkingTreeNotRevision(BzrError):
1868
1604
 
1869
 
    _fmt = ("The working tree for %(basedir)s has changed since"
 
1605
    _fmt = ("The working tree for %(basedir)s has changed since" 
1870
1606
            " the last commit, but weave merge requires that it be"
1871
1607
            " unchanged")
1872
1608
 
2029
1765
    _fmt = "Moving the root directory is not supported at this time"
2030
1766
 
2031
1767
 
2032
 
class TransformRenameFailed(BzrError):
2033
 
 
2034
 
    _fmt = "Failed to rename %(from_path)s to %(to_path)s: %(why)s"
2035
 
 
2036
 
    def __init__(self, from_path, to_path, why, errno):
2037
 
        self.from_path = from_path
2038
 
        self.to_path = to_path
2039
 
        self.why = why
2040
 
        self.errno = errno
2041
 
 
2042
 
 
2043
1768
class BzrMoveFailedError(BzrError):
2044
1769
 
2045
 
    _fmt = ("Could not move %(from_path)s%(operator)s %(to_path)s"
2046
 
        "%(_has_extra)s%(extra)s")
 
1770
    _fmt = "Could not move %(from_path)s%(operator)s %(to_path)s%(extra)s"
2047
1771
 
2048
1772
    def __init__(self, from_path='', to_path='', extra=None):
2049
 
        from bzrlib.osutils import splitpath
2050
1773
        BzrError.__init__(self)
2051
1774
        if extra:
2052
 
            self.extra, self._has_extra = extra, ': '
 
1775
            self.extra = ': ' + str(extra)
2053
1776
        else:
2054
 
            self.extra = self._has_extra = ''
 
1777
            self.extra = ''
2055
1778
 
2056
1779
        has_from = len(from_path) > 0
2057
1780
        has_to = len(to_path) > 0
2058
1781
        if has_from:
2059
 
            self.from_path = splitpath(from_path)[-1]
 
1782
            self.from_path = osutils.splitpath(from_path)[-1]
2060
1783
        else:
2061
1784
            self.from_path = ''
2062
1785
 
2063
1786
        if has_to:
2064
 
            self.to_path = splitpath(to_path)[-1]
 
1787
            self.to_path = osutils.splitpath(to_path)[-1]
2065
1788
        else:
2066
1789
            self.to_path = ''
2067
1790
 
2078
1801
 
2079
1802
class BzrRenameFailedError(BzrMoveFailedError):
2080
1803
 
2081
 
    _fmt = ("Could not rename %(from_path)s%(operator)s %(to_path)s"
2082
 
        "%(_has_extra)s%(extra)s")
 
1804
    _fmt = "Could not rename %(from_path)s%(operator)s %(to_path)s%(extra)s"
2083
1805
 
2084
1806
    def __init__(self, from_path, to_path, extra=None):
2085
1807
        BzrMoveFailedError.__init__(self, from_path, to_path, extra)
2086
1808
 
2087
 
 
2088
1809
class BzrRemoveChangedFilesError(BzrError):
2089
1810
    """Used when user is trying to remove changed files."""
2090
1811
 
2093
1814
        "Use --keep to not delete them, or --force to delete them regardless.")
2094
1815
 
2095
1816
    def __init__(self, tree_delta):
2096
 
        symbol_versioning.warn(symbol_versioning.deprecated_in((2, 3, 0)) %
2097
 
            "BzrRemoveChangedFilesError", DeprecationWarning, stacklevel=2)
2098
1817
        BzrError.__init__(self)
2099
1818
        self.changes_as_text = tree_delta.get_changes_as_text()
2100
1819
        #self.paths_as_string = '\n'.join(changed_files)
2108
1827
 
2109
1828
class BzrBadParameterMissing(BzrBadParameter):
2110
1829
 
2111
 
    _fmt = "Parameter %(param)s is required but not present."
 
1830
    _fmt = "Parameter $(param)s is required but not present."
2112
1831
 
2113
1832
 
2114
1833
class BzrBadParameterUnicode(BzrBadParameter):
2122
1841
    _fmt = "Parameter %(param)s contains a newline."
2123
1842
 
2124
1843
 
 
1844
class DependencyNotPresent(BzrError):
 
1845
 
 
1846
    _fmt = 'Unable to import library "%(library)s": %(error)s'
 
1847
 
 
1848
    def __init__(self, library, error):
 
1849
        BzrError.__init__(self, library=library, error=error)
 
1850
 
 
1851
 
2125
1852
class ParamikoNotPresent(DependencyNotPresent):
2126
1853
 
2127
1854
    _fmt = "Unable to import paramiko (required for sftp support): %(error)s"
2146
1873
 
2147
1874
class BadConversionTarget(BzrError):
2148
1875
 
2149
 
    _fmt = "Cannot convert from format %(from_format)s to format %(format)s." \
2150
 
            "    %(problem)s"
 
1876
    _fmt = "Cannot convert to format %(format)s.  %(problem)s"
2151
1877
 
2152
 
    def __init__(self, problem, format, from_format=None):
 
1878
    def __init__(self, problem, format):
2153
1879
        BzrError.__init__(self)
2154
1880
        self.problem = problem
2155
1881
        self.format = format
2156
 
        self.from_format = from_format or '(unspecified)'
2157
1882
 
2158
1883
 
2159
1884
class NoDiffFound(BzrError):
2196
1921
    _fmt = """This tree contains left-over files from a failed operation.
2197
1922
    Please examine %(limbo_dir)s to see if it contains any files you wish to
2198
1923
    keep, and delete it when you are done."""
2199
 
 
 
1924
    
2200
1925
    def __init__(self, limbo_dir):
2201
1926
       BzrError.__init__(self)
2202
1927
       self.limbo_dir = limbo_dir
2235
1960
 
2236
1961
class OutOfDateTree(BzrError):
2237
1962
 
2238
 
    _fmt = "Working tree is out of date, please run 'bzr update'.%(more)s"
 
1963
    _fmt = "Working tree is out of date, please run 'bzr update'."
2239
1964
 
2240
 
    def __init__(self, tree, more=None):
2241
 
        if more is None:
2242
 
            more = ''
2243
 
        else:
2244
 
            more = ' ' + more
 
1965
    def __init__(self, tree):
2245
1966
        BzrError.__init__(self)
2246
1967
        self.tree = tree
2247
 
        self.more = more
2248
1968
 
2249
1969
 
2250
1970
class PublicBranchOutOfDate(BzrError):
2288
2008
 
2289
2009
    def __init__(self, repo):
2290
2010
        BzrError.__init__(self)
2291
 
        self.repo_path = repo.user_url
 
2011
        self.repo_path = repo.bzrdir.root_transport.base
2292
2012
 
2293
2013
 
2294
2014
class InconsistentDelta(BzrError):
2304
2024
        self.reason = reason
2305
2025
 
2306
2026
 
2307
 
class InconsistentDeltaDelta(InconsistentDelta):
2308
 
    """Used when we get a delta that is not valid."""
2309
 
 
2310
 
    _fmt = ("An inconsistent delta was supplied: %(delta)r"
2311
 
            "\nreason: %(reason)s")
2312
 
 
2313
 
    def __init__(self, delta, reason):
2314
 
        BzrError.__init__(self)
2315
 
        self.delta = delta
2316
 
        self.reason = reason
2317
 
 
2318
 
 
2319
2027
class UpgradeRequired(BzrError):
2320
2028
 
2321
2029
    _fmt = "To use this feature you must upgrade your branch at %(path)s."
2325
2033
        self.path = path
2326
2034
 
2327
2035
 
2328
 
class RepositoryUpgradeRequired(UpgradeRequired):
2329
 
 
2330
 
    _fmt = "To use this feature you must upgrade your repository at %(path)s."
2331
 
 
2332
 
 
2333
 
class RichRootUpgradeRequired(UpgradeRequired):
2334
 
 
2335
 
    _fmt = ("To use this feature you must upgrade your branch at %(path)s to"
2336
 
           " a format which supports rich roots.")
2337
 
 
2338
 
 
2339
2036
class LocalRequiresBoundBranch(BzrError):
2340
2037
 
2341
2038
    _fmt = "Cannot perform local-only commits on unbound branches."
2342
2039
 
2343
2040
 
 
2041
class MissingProgressBarFinish(BzrError):
 
2042
 
 
2043
    _fmt = "A nested progress bar was not 'finished' correctly."
 
2044
 
 
2045
 
 
2046
class InvalidProgressBarType(BzrError):
 
2047
 
 
2048
    _fmt = ("Environment variable BZR_PROGRESS_BAR='%(bar_type)s"
 
2049
            " is not a supported type Select one of: %(valid_types)s")
 
2050
 
 
2051
    def __init__(self, bar_type, valid_types):
 
2052
        BzrError.__init__(self, bar_type=bar_type, valid_types=valid_types)
 
2053
 
 
2054
 
2344
2055
class UnsupportedOperation(BzrError):
2345
2056
 
2346
2057
    _fmt = ("The method %(mname)s is not supported on"
2362
2073
    """
2363
2074
 
2364
2075
 
2365
 
class GhostTagsNotSupported(BzrError):
2366
 
 
2367
 
    _fmt = "Ghost tags not supported by format %(format)r."
2368
 
 
2369
 
    def __init__(self, format):
2370
 
        self.format = format
2371
 
 
2372
 
 
2373
2076
class BinaryFile(BzrError):
2374
 
 
 
2077
    
2375
2078
    _fmt = "File is binary but should be text."
2376
2079
 
2377
2080
 
2397
2100
 
2398
2101
 
2399
2102
class NotABundle(BzrError):
2400
 
 
 
2103
    
2401
2104
    _fmt = "Not a bzr revision-bundle: %(text)r"
2402
2105
 
2403
2106
    def __init__(self, text):
2405
2108
        self.text = text
2406
2109
 
2407
2110
 
2408
 
class BadBundle(BzrError):
2409
 
 
 
2111
class BadBundle(BzrError): 
 
2112
    
2410
2113
    _fmt = "Bad bzr revision-bundle: %(text)r"
2411
2114
 
2412
2115
    def __init__(self, text):
2414
2117
        self.text = text
2415
2118
 
2416
2119
 
2417
 
class MalformedHeader(BadBundle):
2418
 
 
 
2120
class MalformedHeader(BadBundle): 
 
2121
    
2419
2122
    _fmt = "Malformed bzr revision-bundle header: %(text)r"
2420
2123
 
2421
2124
 
2422
 
class MalformedPatches(BadBundle):
2423
 
 
 
2125
class MalformedPatches(BadBundle): 
 
2126
    
2424
2127
    _fmt = "Malformed patches in bzr revision-bundle: %(text)r"
2425
2128
 
2426
2129
 
2427
 
class MalformedFooter(BadBundle):
2428
 
 
 
2130
class MalformedFooter(BadBundle): 
 
2131
    
2429
2132
    _fmt = "Malformed footer in bzr revision-bundle: %(text)r"
2430
2133
 
2431
2134
 
2432
2135
class UnsupportedEOLMarker(BadBundle):
2433
 
 
2434
 
    _fmt = "End of line marker was not \\n in bzr revision-bundle"
 
2136
    
 
2137
    _fmt = "End of line marker was not \\n in bzr revision-bundle"    
2435
2138
 
2436
2139
    def __init__(self):
2437
 
        # XXX: BadBundle's constructor assumes there's explanatory text,
 
2140
        # XXX: BadBundle's constructor assumes there's explanatory text, 
2438
2141
        # but for this there is not
2439
2142
        BzrError.__init__(self)
2440
2143
 
2441
2144
 
2442
2145
class IncompatibleBundleFormat(BzrError):
2443
 
 
 
2146
    
2444
2147
    _fmt = "Bundle format %(bundle_format)s is incompatible with %(other)s"
2445
2148
 
2446
2149
    def __init__(self, bundle_format, other):
2450
2153
 
2451
2154
 
2452
2155
class BadInventoryFormat(BzrError):
2453
 
 
 
2156
    
2454
2157
    _fmt = "Root class for inventory serialization errors"
2455
2158
 
2456
2159
 
2475
2178
        self.transport = transport
2476
2179
 
2477
2180
 
 
2181
class NoSmartServer(NotBranchError):
 
2182
 
 
2183
    _fmt = "No smart server available at %(url)s"
 
2184
 
 
2185
    def __init__(self, url):
 
2186
        self.url = url
 
2187
 
 
2188
 
2478
2189
class UnknownSSH(BzrError):
2479
2190
 
2480
2191
    _fmt = "Unrecognised value for BZR_SSH environment variable: %(vendor)s"
2490
2201
            " Please set BZR_SSH environment variable.")
2491
2202
 
2492
2203
 
2493
 
class GhostRevisionsHaveNoRevno(BzrError):
2494
 
    """When searching for revnos, if we encounter a ghost, we are stuck"""
2495
 
 
2496
 
    _fmt = ("Could not determine revno for {%(revision_id)s} because"
2497
 
            " its ancestry shows a ghost at {%(ghost_revision_id)s}")
2498
 
 
2499
 
    def __init__(self, revision_id, ghost_revision_id):
2500
 
        self.revision_id = revision_id
2501
 
        self.ghost_revision_id = ghost_revision_id
2502
 
 
2503
 
 
2504
2204
class GhostRevisionUnusableHere(BzrError):
2505
2205
 
2506
2206
    _fmt = "Ghost revision {%(revision_id)s} cannot be used here."
2584
2284
        self.patch_type = patch_type
2585
2285
 
2586
2286
 
2587
 
class TargetNotBranch(BzrError):
2588
 
    """A merge directive's target branch is required, but isn't a branch"""
2589
 
 
2590
 
    _fmt = ("Your branch does not have all of the revisions required in "
2591
 
            "order to merge this merge directive and the target "
2592
 
            "location specified in the merge directive is not a branch: "
2593
 
            "%(location)s.")
2594
 
 
2595
 
    def __init__(self, location):
2596
 
        BzrError.__init__(self)
2597
 
        self.location = location
2598
 
 
2599
 
 
2600
2287
class UnsupportedInventoryKind(BzrError):
2601
 
 
 
2288
    
2602
2289
    _fmt = """Unsupported entry kind %(kind)s"""
2603
2290
 
2604
2291
    def __init__(self, kind):
2616
2303
 
2617
2304
 
2618
2305
class SubsumeTargetNeedsUpgrade(BzrError):
2619
 
 
 
2306
    
2620
2307
    _fmt = """Subsume target %(other_tree)s needs to be upgraded."""
2621
2308
 
2622
2309
    def __init__(self, other_tree):
2645
2332
class TagsNotSupported(BzrError):
2646
2333
 
2647
2334
    _fmt = ("Tags not supported by %(branch)s;"
2648
 
            " you may be able to use bzr upgrade.")
 
2335
            " you may be able to use bzr upgrade --dirstate-tags.")
2649
2336
 
2650
2337
    def __init__(self, branch):
2651
2338
        self.branch = branch
2652
2339
 
2653
 
 
 
2340
        
2654
2341
class TagAlreadyExists(BzrError):
2655
2342
 
2656
2343
    _fmt = "Tag %(tag_name)s already exists."
2661
2348
 
2662
2349
class MalformedBugIdentifier(BzrError):
2663
2350
 
2664
 
    _fmt = ('Did not understand bug identifier %(bug_id)s: %(reason)s. '
2665
 
            'See "bzr help bugs" for more information on this feature.')
 
2351
    _fmt = "Did not understand bug identifier %(bug_id)s: %(reason)s"
2666
2352
 
2667
2353
    def __init__(self, bug_id, reason):
2668
2354
        self.bug_id = bug_id
2689
2375
        self.branch = branch
2690
2376
 
2691
2377
 
2692
 
class InvalidLineInBugsProperty(BzrError):
2693
 
 
2694
 
    _fmt = ("Invalid line in bugs property: '%(line)s'")
2695
 
 
2696
 
    def __init__(self, line):
2697
 
        self.line = line
2698
 
 
2699
 
 
2700
 
class InvalidBugStatus(BzrError):
2701
 
 
2702
 
    _fmt = ("Invalid bug status: '%(status)s'")
2703
 
 
2704
 
    def __init__(self, status):
2705
 
        self.status = status
2706
 
 
2707
 
 
2708
2378
class UnexpectedSmartServerResponse(BzrError):
2709
2379
 
2710
2380
    _fmt = "Could not understand response from smart server: %(response_tuple)r"
2713
2383
        self.response_tuple = response_tuple
2714
2384
 
2715
2385
 
2716
 
class ErrorFromSmartServer(BzrError):
2717
 
    """An error was received from a smart server.
2718
 
 
2719
 
    :seealso: UnknownErrorFromSmartServer
2720
 
    """
2721
 
 
2722
 
    _fmt = "Error received from smart server: %(error_tuple)r"
2723
 
 
2724
 
    internal_error = True
2725
 
 
2726
 
    def __init__(self, error_tuple):
2727
 
        self.error_tuple = error_tuple
2728
 
        try:
2729
 
            self.error_verb = error_tuple[0]
2730
 
        except IndexError:
2731
 
            self.error_verb = None
2732
 
        self.error_args = error_tuple[1:]
2733
 
 
2734
 
 
2735
 
class UnknownErrorFromSmartServer(BzrError):
2736
 
    """An ErrorFromSmartServer could not be translated into a typical bzrlib
2737
 
    error.
2738
 
 
2739
 
    This is distinct from ErrorFromSmartServer so that it is possible to
2740
 
    distinguish between the following two cases:
2741
 
 
2742
 
    - ErrorFromSmartServer was uncaught.  This is logic error in the client
2743
 
      and so should provoke a traceback to the user.
2744
 
    - ErrorFromSmartServer was caught but its error_tuple could not be
2745
 
      translated.  This is probably because the server sent us garbage, and
2746
 
      should not provoke a traceback.
2747
 
    """
2748
 
 
2749
 
    _fmt = "Server sent an unexpected error: %(error_tuple)r"
2750
 
 
2751
 
    internal_error = False
2752
 
 
2753
 
    def __init__(self, error_from_smart_server):
2754
 
        """Constructor.
2755
 
 
2756
 
        :param error_from_smart_server: An ErrorFromSmartServer instance.
2757
 
        """
2758
 
        self.error_from_smart_server = error_from_smart_server
2759
 
        self.error_tuple = error_from_smart_server.error_tuple
2760
 
 
2761
 
 
2762
2386
class ContainerError(BzrError):
2763
2387
    """Base class of container errors."""
2764
2388
 
2766
2390
class UnknownContainerFormatError(ContainerError):
2767
2391
 
2768
2392
    _fmt = "Unrecognised container format: %(container_format)r"
2769
 
 
 
2393
    
2770
2394
    def __init__(self, container_format):
2771
2395
        self.container_format = container_format
2772
2396
 
2805
2429
    _fmt = "Container has multiple records with the same name: %(name)s"
2806
2430
 
2807
2431
    def __init__(self, name):
2808
 
        self.name = name.decode("utf-8")
 
2432
        self.name = name
2809
2433
 
2810
2434
 
2811
2435
class NoDestinationAddress(InternalBzrError):
2836
2460
 
2837
2461
class NoMailAddressSpecified(BzrError):
2838
2462
 
2839
 
    _fmt = "No mail-to address (--mail-to) or output (-o) specified."
 
2463
    _fmt = "No mail-to address specified."
2840
2464
 
2841
2465
 
2842
2466
class UnknownMailClient(BzrError):
2875
2499
 
2876
2500
    def __init__(self, bzrdir):
2877
2501
        import bzrlib.urlutils as urlutils
2878
 
        display_url = urlutils.unescape_for_display(bzrdir.user_url,
 
2502
        display_url = urlutils.unescape_for_display(bzrdir.root_transport.base,
2879
2503
                                                    'ascii')
2880
2504
        BzrError.__init__(self, bzrdir=bzrdir, display_url=display_url)
2881
2505
 
2882
2506
 
2883
 
class UnsyncedBranches(BzrDirError):
2884
 
 
2885
 
    _fmt = ("'%(display_url)s' is not in sync with %(target_url)s.  See"
2886
 
            " bzr help sync-for-reconfigure.")
2887
 
 
2888
 
    def __init__(self, bzrdir, target_branch):
2889
 
        BzrDirError.__init__(self, bzrdir)
2890
 
        import bzrlib.urlutils as urlutils
2891
 
        self.target_url = urlutils.unescape_for_display(target_branch.base,
2892
 
                                                        'ascii')
2893
 
 
2894
 
 
2895
2507
class AlreadyBranch(BzrDirError):
2896
2508
 
2897
2509
    _fmt = "'%(display_url)s' is already a branch."
2912
2524
    _fmt = "'%(display_url)s' is already a lightweight checkout."
2913
2525
 
2914
2526
 
2915
 
class AlreadyUsingShared(BzrDirError):
2916
 
 
2917
 
    _fmt = "'%(display_url)s' is already using a shared repository."
2918
 
 
2919
 
 
2920
 
class AlreadyStandalone(BzrDirError):
2921
 
 
2922
 
    _fmt = "'%(display_url)s' is already standalone."
2923
 
 
2924
 
 
2925
 
class AlreadyWithTrees(BzrDirError):
2926
 
 
2927
 
    _fmt = ("Shared repository '%(display_url)s' already creates "
2928
 
            "working trees.")
2929
 
 
2930
 
 
2931
 
class AlreadyWithNoTrees(BzrDirError):
2932
 
 
2933
 
    _fmt = ("Shared repository '%(display_url)s' already doesn't create "
2934
 
            "working trees.")
2935
 
 
2936
 
 
2937
2527
class ReconfigurationNotSupported(BzrDirError):
2938
2528
 
2939
2529
    _fmt = "Requested reconfiguration of '%(display_url)s' is not supported."
2946
2536
 
2947
2537
class UncommittedChanges(BzrError):
2948
2538
 
2949
 
    _fmt = ('Working tree "%(display_url)s" has uncommitted changes'
2950
 
            ' (See bzr status).%(more)s')
 
2539
    _fmt = 'Working tree "%(display_url)s" has uncommitted changes.'
2951
2540
 
2952
 
    def __init__(self, tree, more=None):
2953
 
        if more is None:
2954
 
            more = ''
2955
 
        else:
2956
 
            more = ' ' + more
 
2541
    def __init__(self, tree):
2957
2542
        import bzrlib.urlutils as urlutils
2958
 
        user_url = getattr(tree, "user_url", None)
2959
 
        if user_url is None:
2960
 
            display_url = str(tree)
2961
 
        else:
2962
 
            display_url = urlutils.unescape_for_display(user_url, 'ascii')
2963
 
        BzrError.__init__(self, tree=tree, display_url=display_url, more=more)
2964
 
 
2965
 
 
2966
 
class ShelvedChanges(UncommittedChanges):
2967
 
 
2968
 
    _fmt = ('Working tree "%(display_url)s" has shelved changes'
2969
 
            ' (See bzr shelve --list).%(more)s')
 
2543
        display_url = urlutils.unescape_for_display(
 
2544
            tree.bzrdir.root_transport.base, 'ascii')
 
2545
        BzrError.__init__(self, tree=tree, display_url=display_url)
2970
2546
 
2971
2547
 
2972
2548
class MissingTemplateVariable(BzrError):
3006
2582
        self.timezone = timezone
3007
2583
 
3008
2584
 
3009
 
class CommandAvailableInPlugin(StandardError):
3010
 
 
3011
 
    internal_error = False
3012
 
 
3013
 
    def __init__(self, cmd_name, plugin_metadata, provider):
3014
 
 
3015
 
        self.plugin_metadata = plugin_metadata
3016
 
        self.cmd_name = cmd_name
3017
 
        self.provider = provider
3018
 
 
3019
 
    def __str__(self):
3020
 
 
3021
 
        _fmt = ('"%s" is not a standard bzr command. \n'
3022
 
                'However, the following official plugin provides this command: %s\n'
3023
 
                'You can install it by going to: %s'
3024
 
                % (self.cmd_name, self.plugin_metadata['name'],
3025
 
                    self.plugin_metadata['url']))
3026
 
 
3027
 
        return _fmt
3028
 
 
3029
 
 
3030
 
class NoPluginAvailable(BzrError):
3031
 
    pass
3032
 
 
3033
 
 
3034
2585
class UnableEncodePath(BzrError):
3035
2586
 
3036
2587
    _fmt = ('Unable to encode %(kind)s path %(path)r in '
3037
2588
            'user encoding %(user_encoding)s')
3038
2589
 
3039
2590
    def __init__(self, path, kind):
3040
 
        from bzrlib.osutils import get_user_encoding
3041
2591
        self.path = path
3042
2592
        self.kind = kind
3043
2593
        self.user_encoding = osutils.get_user_encoding()
3044
 
 
3045
 
 
3046
 
class NoSuchConfig(BzrError):
3047
 
 
3048
 
    _fmt = ('The "%(config_id)s" configuration does not exist.')
3049
 
 
3050
 
    def __init__(self, config_id):
3051
 
        BzrError.__init__(self, config_id=config_id)
3052
 
 
3053
 
 
3054
 
class NoSuchConfigOption(BzrError):
3055
 
 
3056
 
    _fmt = ('The "%(option_name)s" configuration option does not exist.')
3057
 
 
3058
 
    def __init__(self, option_name):
3059
 
        BzrError.__init__(self, option_name=option_name)
3060
 
 
3061
 
 
3062
 
class NoSuchAlias(BzrError):
3063
 
 
3064
 
    _fmt = ('The alias "%(alias_name)s" does not exist.')
3065
 
 
3066
 
    def __init__(self, alias_name):
3067
 
        BzrError.__init__(self, alias_name=alias_name)
3068
 
 
3069
 
 
3070
 
class DirectoryLookupFailure(BzrError):
3071
 
    """Base type for lookup errors."""
3072
 
 
3073
 
    pass
3074
 
 
3075
 
 
3076
 
class InvalidLocationAlias(DirectoryLookupFailure):
3077
 
 
3078
 
    _fmt = '"%(alias_name)s" is not a valid location alias.'
3079
 
 
3080
 
    def __init__(self, alias_name):
3081
 
        DirectoryLookupFailure.__init__(self, alias_name=alias_name)
3082
 
 
3083
 
 
3084
 
class UnsetLocationAlias(DirectoryLookupFailure):
3085
 
 
3086
 
    _fmt = 'No %(alias_name)s location assigned.'
3087
 
 
3088
 
    def __init__(self, alias_name):
3089
 
        DirectoryLookupFailure.__init__(self, alias_name=alias_name[1:])
3090
 
 
3091
 
 
3092
 
class CannotBindAddress(BzrError):
3093
 
 
3094
 
    _fmt = 'Cannot bind address "%(host)s:%(port)i": %(orig_error)s.'
3095
 
 
3096
 
    def __init__(self, host, port, orig_error):
3097
 
        # nb: in python2.4 socket.error doesn't have a useful repr
3098
 
        BzrError.__init__(self, host=host, port=port,
3099
 
            orig_error=repr(orig_error.args))
3100
 
 
3101
 
 
3102
 
class UnknownRules(BzrError):
3103
 
 
3104
 
    _fmt = ('Unknown rules detected: %(unknowns_str)s.')
3105
 
 
3106
 
    def __init__(self, unknowns):
3107
 
        BzrError.__init__(self, unknowns_str=", ".join(unknowns))
3108
 
 
3109
 
 
3110
 
class HookFailed(BzrError):
3111
 
    """Raised when a pre_change_branch_tip hook function fails anything other
3112
 
    than TipChangeRejected.
3113
 
 
3114
 
    Note that this exception is no longer raised, and the import is only left
3115
 
    to be nice to code which might catch it in a plugin.
3116
 
    """
3117
 
 
3118
 
    _fmt = ("Hook '%(hook_name)s' during %(hook_stage)s failed:\n"
3119
 
            "%(traceback_text)s%(exc_value)s")
3120
 
 
3121
 
    def __init__(self, hook_stage, hook_name, exc_info, warn=True):
3122
 
        if warn:
3123
 
            symbol_versioning.warn("BzrError HookFailed has been deprecated "
3124
 
                "as of bzrlib 2.1.", DeprecationWarning, stacklevel=2)
3125
 
        import traceback
3126
 
        self.hook_stage = hook_stage
3127
 
        self.hook_name = hook_name
3128
 
        self.exc_info = exc_info
3129
 
        self.exc_type = exc_info[0]
3130
 
        self.exc_value = exc_info[1]
3131
 
        self.exc_tb = exc_info[2]
3132
 
        self.traceback_text = ''.join(traceback.format_tb(self.exc_tb))
3133
 
 
3134
 
 
3135
 
class TipChangeRejected(BzrError):
3136
 
    """A pre_change_branch_tip hook function may raise this to cleanly and
3137
 
    explicitly abort a change to a branch tip.
3138
 
    """
3139
 
 
3140
 
    _fmt = u"Tip change rejected: %(msg)s"
3141
 
 
3142
 
    def __init__(self, msg):
3143
 
        self.msg = msg
3144
 
 
3145
 
 
3146
 
class ShelfCorrupt(BzrError):
3147
 
 
3148
 
    _fmt = "Shelf corrupt."
3149
 
 
3150
 
 
3151
 
class DecompressCorruption(BzrError):
3152
 
 
3153
 
    _fmt = "Corruption while decompressing repository file%(orig_error)s"
3154
 
 
3155
 
    def __init__(self, orig_error=None):
3156
 
        if orig_error is not None:
3157
 
            self.orig_error = ", %s" % (orig_error,)
3158
 
        else:
3159
 
            self.orig_error = ""
3160
 
        BzrError.__init__(self)
3161
 
 
3162
 
 
3163
 
class NoSuchShelfId(BzrError):
3164
 
 
3165
 
    _fmt = 'No changes are shelved with id "%(shelf_id)d".'
3166
 
 
3167
 
    def __init__(self, shelf_id):
3168
 
        BzrError.__init__(self, shelf_id=shelf_id)
3169
 
 
3170
 
 
3171
 
class InvalidShelfId(BzrError):
3172
 
 
3173
 
    _fmt = '"%(invalid_id)s" is not a valid shelf id, try a number instead.'
3174
 
 
3175
 
    def __init__(self, invalid_id):
3176
 
        BzrError.__init__(self, invalid_id=invalid_id)
3177
 
 
3178
 
 
3179
 
class JailBreak(BzrError):
3180
 
 
3181
 
    _fmt = "An attempt to access a url outside the server jail was made: '%(url)s'."
3182
 
 
3183
 
    def __init__(self, url):
3184
 
        BzrError.__init__(self, url=url)
3185
 
 
3186
 
 
3187
 
class UserAbort(BzrError):
3188
 
 
3189
 
    _fmt = 'The user aborted the operation.'
3190
 
 
3191
 
 
3192
 
class MustHaveWorkingTree(BzrError):
3193
 
 
3194
 
    _fmt = ("Branching '%(url)s'(%(format)s) must create a working tree.")
3195
 
 
3196
 
    def __init__(self, format, url):
3197
 
        BzrError.__init__(self, format=format, url=url)
3198
 
 
3199
 
 
3200
 
class NoSuchView(BzrError):
3201
 
    """A view does not exist.
3202
 
    """
3203
 
 
3204
 
    _fmt = u"No such view: %(view_name)s."
3205
 
 
3206
 
    def __init__(self, view_name):
3207
 
        self.view_name = view_name
3208
 
 
3209
 
 
3210
 
class ViewsNotSupported(BzrError):
3211
 
    """Views are not supported by a tree format.
3212
 
    """
3213
 
 
3214
 
    _fmt = ("Views are not supported by %(tree)s;"
3215
 
            " use 'bzr upgrade' to change your tree to a later format.")
3216
 
 
3217
 
    def __init__(self, tree):
3218
 
        self.tree = tree
3219
 
 
3220
 
 
3221
 
class FileOutsideView(BzrError):
3222
 
 
3223
 
    _fmt = ('Specified file "%(file_name)s" is outside the current view: '
3224
 
            '%(view_str)s')
3225
 
 
3226
 
    def __init__(self, file_name, view_files):
3227
 
        self.file_name = file_name
3228
 
        self.view_str = ", ".join(view_files)
3229
 
 
3230
 
 
3231
 
class UnresumableWriteGroup(BzrError):
3232
 
 
3233
 
    _fmt = ("Repository %(repository)s cannot resume write group "
3234
 
            "%(write_groups)r: %(reason)s")
3235
 
 
3236
 
    internal_error = True
3237
 
 
3238
 
    def __init__(self, repository, write_groups, reason):
3239
 
        self.repository = repository
3240
 
        self.write_groups = write_groups
3241
 
        self.reason = reason
3242
 
 
3243
 
 
3244
 
class UnsuspendableWriteGroup(BzrError):
3245
 
 
3246
 
    _fmt = ("Repository %(repository)s cannot suspend a write group.")
3247
 
 
3248
 
    internal_error = True
3249
 
 
3250
 
    def __init__(self, repository):
3251
 
        self.repository = repository
3252
 
 
3253
 
 
3254
 
class LossyPushToSameVCS(BzrError):
3255
 
 
3256
 
    _fmt = ("Lossy push not possible between %(source_branch)r and "
3257
 
            "%(target_branch)r that are in the same VCS.")
3258
 
 
3259
 
    internal_error = True
3260
 
 
3261
 
    def __init__(self, source_branch, target_branch):
3262
 
        self.source_branch = source_branch
3263
 
        self.target_branch = target_branch
3264
 
 
3265
 
 
3266
 
class NoRoundtrippingSupport(BzrError):
3267
 
 
3268
 
    _fmt = ("Roundtripping is not supported between %(source_branch)r and "
3269
 
            "%(target_branch)r.")
3270
 
 
3271
 
    internal_error = True
3272
 
 
3273
 
    def __init__(self, source_branch, target_branch):
3274
 
        self.source_branch = source_branch
3275
 
        self.target_branch = target_branch
3276
 
 
3277
 
 
3278
 
class FileTimestampUnavailable(BzrError):
3279
 
 
3280
 
    _fmt = "The filestamp for %(path)s is not available."
3281
 
 
3282
 
    internal_error = True
3283
 
 
3284
 
    def __init__(self, path):
3285
 
        self.path = path
3286
 
 
3287
 
 
3288
 
class NoColocatedBranchSupport(BzrError):
3289
 
 
3290
 
    _fmt = ("%(bzrdir)r does not support co-located branches.")
3291
 
 
3292
 
    def __init__(self, bzrdir):
3293
 
        self.bzrdir = bzrdir
3294
 
 
3295
 
 
3296
 
class NoWhoami(BzrError):
3297
 
 
3298
 
    _fmt = ('Unable to determine your name.\n'
3299
 
        "Please, set your name with the 'whoami' command.\n"
3300
 
        'E.g. bzr whoami "Your Name <name@example.com>"')
3301
 
 
3302
 
 
3303
 
class InvalidPattern(BzrError):
3304
 
 
3305
 
    _fmt = ('Invalid pattern(s) found. %(msg)s')
3306
 
 
3307
 
    def __init__(self, msg):
3308
 
        self.msg = msg
3309
 
 
3310
 
 
3311
 
class RecursiveBind(BzrError):
3312
 
 
3313
 
    _fmt = ('Branch "%(branch_url)s" appears to be bound to itself. '
3314
 
        'Please use `bzr unbind` to fix.')
3315
 
 
3316
 
    def __init__(self, branch_url):
3317
 
        self.branch_url = branch_url
3318
 
 
3319
 
 
3320
 
# FIXME: I would prefer to define the config related exception classes in
3321
 
# config.py but the lazy import mechanism proscribes this -- vila 20101222
3322
 
class OptionExpansionLoop(BzrError):
3323
 
 
3324
 
    _fmt = 'Loop involving %(refs)r while expanding "%(string)s".'
3325
 
 
3326
 
    def __init__(self, string, refs):
3327
 
        self.string = string
3328
 
        self.refs = '->'.join(refs)
3329
 
 
3330
 
 
3331
 
class ExpandingUnknownOption(BzrError):
3332
 
 
3333
 
    _fmt = 'Option %(name)s is not defined while expanding "%(string)s".'
3334
 
 
3335
 
    def __init__(self, name, string):
3336
 
        self.name = name
3337
 
        self.string = string
3338
 
 
3339
 
 
3340
 
class NoCompatibleInter(BzrError):
3341
 
 
3342
 
    _fmt = ('No compatible object available for operations from %(source)r '
3343
 
            'to %(target)r.')
3344
 
 
3345
 
    def __init__(self, source, target):
3346
 
        self.source = source
3347
 
        self.target = target
3348
 
 
3349
 
 
3350
 
class HpssVfsRequestNotAllowed(BzrError):
3351
 
 
3352
 
    _fmt = ("VFS requests over the smart server are not allowed. Encountered: "
3353
 
            "%(method)s, %(arguments)s.")
3354
 
 
3355
 
    def __init__(self, method, arguments):
3356
 
        self.method = method
3357
 
        self.arguments = arguments