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
17
17
"""Exceptions for bzr, and reporting of them.
19
There are 3 different classes of error:
21
* KeyboardInterrupt, and OSError with EPIPE - the program terminates
22
with an appropriate short message
24
* User errors, indicating a problem caused by the user such as a bad URL.
25
These are printed in a short form.
27
* Internal unexpected errors, including most Python builtin errors
28
and some raised from inside bzr. These are printed with a full
29
traceback and an invitation to report the bug.
31
Exceptions are caught at a high level to report errors to the user, and
32
might also be caught inside the program. Therefore it needs to be
33
possible to convert them to a meaningful string, and also for them to be
34
interrogated by the program.
36
Exceptions are defined such that the arguments given to the constructor
37
are stored in the object as properties of the same name. When the
38
object is printed as a string, the doc string of the class is used as
39
a format string with the property dictionary available to it.
41
This means that exceptions can used like this:
45
... raise NotBranchError(path='/foo/bar')
47
... print sys.exc_type
48
... print sys.exc_value
49
... path = getattr(sys.exc_value, 'path', None)
50
... if path is not None:
52
bzrlib.errors.NotBranchError
53
Not a branch: /foo/bar
58
* create a new exception class for any class of error that can be
59
usefully distinguished. If no callers are likely to want to catch
60
one but not another, don't worry about them.
62
* the __str__ method should generate something useful; BzrError provides
63
a good default implementation
65
Exception strings should start with a capital letter and should not have a
20
from __future__ import absolute_import
69
from warnings import warn
71
from bzrlib.patches import (PatchSyntax,
78
# based on Scott James Remnant's hct error classes
22
80
# TODO: is there any value in providing the .args field used by standard
23
# python exceptions? A list of values with no names seems less useful
81
# python exceptions? A list of values with no names seems less useful
26
# TODO: Perhaps convert the exception to a string at the moment it's
84
# TODO: Perhaps convert the exception to a string at the moment it's
27
85
# constructed to make sure it will succeed. But that says nothing about
28
86
# exceptions that are never raised.
30
# TODO: selftest assertRaises should probably also check that every error
31
# raised can be formatted as a string successfully, and without giving
35
# return codes from the bzr program
38
EXIT_INTERNAL_ERROR = 4
88
# TODO: Convert all the other error classes here to BzrNewError, and eliminate
91
# TODO: The pattern (from hct) of using classes docstrings as message
92
# templates is cute but maybe not such a great idea - perhaps should have a
93
# separate static message_template.
41
96
class BzrError(StandardError):
43
Base class for errors raised by bzrlib.
45
:cvar internal_error: if True this was probably caused by a bzr bug and
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.)
50
:cvar _fmt: Format string to display the error; this is expanded
51
by the instance's dict.
54
internal_error = False
56
def __init__(self, msg=None, **kwds):
57
"""Construct a new BzrError.
59
There are two alternative forms for constructing these objects.
60
Either a preformatted string may be passed, or a set of named
61
arguments can be given. The first is for generic "user" errors which
62
are not intended to be caught and so do not need a specific subclass.
63
The second case is for use with subclasses that provide a _fmt format
64
string to print the arguments.
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
71
:param msg: If given, this is the literal complete text for the error,
72
not subject to expansion. 'msg' is used instead of 'message' because
73
python evolved and, in 2.6, forbids the use of 'message'.
75
StandardError.__init__(self)
77
# I was going to deprecate this, but it actually turns out to be
78
# quite handy - mbp 20061103.
79
self._preformatted_string = msg
101
# XXX: Should we show the exception class in
102
# exceptions that don't provide their own message?
103
# maybe it should be done at a higher level
104
## n = self.__class__.__name__ + ': '
106
if len(self.args) == 1:
107
return str(self.args[0])
108
elif len(self.args) == 2:
109
# further explanation or suggestions
111
return n + '\n '.join([self.args[0]] + self.args[1])
113
return n + "%r" % self
81
self._preformatted_string = None
82
for key, value in kwds.items():
83
setattr(self, key, value)
86
s = getattr(self, '_preformatted_string', None)
88
# contains a preformatted message
115
return n + `self.args`
118
class BzrNewError(BzrError):
120
# base classes should override the docstring with their human-
121
# readable explanation
123
def __init__(self, **kwds):
124
for key, value in kwds.items():
125
setattr(self, key, value)
91
fmt = self._get_format_string()
93
d = dict(self.__dict__)
95
# __str__() should always return a 'str' object
96
# never a 'unicode' object.
99
pass # just bind to 'e' for formatting below
102
return 'Unprintable exception %s: dict=%r, fmt=%r, error=%r' \
103
% (self.__class__.__name__,
105
getattr(self, '_fmt', None),
108
def __unicode__(self):
110
if isinstance(u, str):
111
# Try decoding the str using the default encoding.
113
elif not isinstance(u, unicode):
114
# Try to make a unicode object from it, because __unicode__ must
115
# return a unicode object.
121
if isinstance(s, unicode):
124
# __str__ must return a str.
129
return '%s(%s)' % (self.__class__.__name__, str(self))
131
def _get_format_string(self):
132
"""Return format string for this exception or None"""
133
fmt = getattr(self, '_fmt', None)
135
from bzrlib.i18n import gettext
136
return gettext(unicode(fmt)) # _fmt strings should be ascii
138
def __eq__(self, other):
139
if self.__class__ is not other.__class__:
140
return NotImplemented
141
return self.__dict__ == other.__dict__
144
class InternalBzrError(BzrError):
145
"""Base class for errors that are internal in nature.
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.
152
internal_error = True
155
class AlreadyBuilding(BzrError):
157
_fmt = "The tree builder is already building a tree."
160
class BranchError(BzrError):
161
"""Base class for concrete 'errors about a branch'."""
163
def __init__(self, branch):
164
BzrError.__init__(self, branch=branch)
167
class BzrCheckError(InternalBzrError):
169
_fmt = "Internal check failed: %(msg)s"
171
def __init__(self, msg):
172
BzrError.__init__(self)
176
class DirstateCorrupt(BzrError):
178
_fmt = "The dirstate file (%(state)s) appears to be corrupt: %(msg)s"
180
def __init__(self, state, msg):
181
BzrError.__init__(self)
186
class DisabledMethod(InternalBzrError):
188
_fmt = "The smart server method '%(class_name)s' is disabled."
190
def __init__(self, class_name):
191
BzrError.__init__(self)
192
self.class_name = class_name
195
class IncompatibleAPI(BzrError):
197
_fmt = 'The API for "%(api)s" is not compatible with "%(wanted)s". '\
198
'It supports versions "%(minimum)s" to "%(current)s".'
200
def __init__(self, api, wanted, minimum, current):
203
self.minimum = minimum
204
self.current = current
207
class InProcessTransport(BzrError):
209
_fmt = "The transport '%(transport)s' is only accessible within this " \
212
def __init__(self, transport):
213
self.transport = transport
216
class InvalidEntryName(InternalBzrError):
218
_fmt = "Invalid entry name: %(name)s"
129
return self.__doc__ % self.__dict__
130
except (NameError, ValueError, KeyError), e:
131
return 'Unprintable exception %s: %s' \
132
% (self.__class__.__name__, str(e))
135
class BzrCheckError(BzrNewError):
136
"""Internal check failed: %(message)s"""
138
is_user_error = False
140
def __init__(self, message):
141
BzrNewError.__init__(self)
142
self.message = message
145
class InvalidEntryName(BzrNewError):
146
"""Invalid entry name: %(name)s"""
148
is_user_error = False
220
150
def __init__(self, name):
221
BzrError.__init__(self)
151
BzrNewError.__init__(self)
225
class InvalidRevisionNumber(BzrError):
227
_fmt = "Invalid revision number %(revno)s"
155
class InvalidRevisionNumber(BzrNewError):
156
"""Invalid revision number %(revno)d"""
229
157
def __init__(self, revno):
230
BzrError.__init__(self)
158
BzrNewError.__init__(self)
231
159
self.revno = revno
234
class InvalidRevisionId(BzrError):
236
_fmt = "Invalid revision-id {%(revision_id)s} in %(branch)s"
162
class InvalidRevisionId(BzrNewError):
163
"""Invalid revision-id {%(revision_id)s} in %(branch)s"""
238
164
def __init__(self, revision_id, branch):
239
165
# branch can be any string or object with __str__ defined
240
BzrError.__init__(self)
166
BzrNewError.__init__(self)
241
167
self.revision_id = revision_id
242
168
self.branch = branch
245
class ReservedId(BzrError):
247
_fmt = "Reserved revision-id {%(revision_id)s}"
249
def __init__(self, revision_id):
250
self.revision_id = revision_id
253
class RootMissing(InternalBzrError):
255
_fmt = ("The root entry of a tree must be the first entry supplied to "
256
"the commit builder.")
259
class NoPublicBranch(BzrError):
261
_fmt = 'There is no public branch set for "%(branch_url)s".'
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)
269
class NoHelpTopic(BzrError):
271
_fmt = ("No help could be found for '%(topic)s'. "
272
"Please use 'bzr help topics' to obtain a list of topics.")
274
def __init__(self, topic):
278
class NoSuchId(BzrError):
280
_fmt = 'The file id "%(file_id)s" is not present in the tree %(tree)s.'
282
def __init__(self, tree, file_id):
283
BzrError.__init__(self)
284
self.file_id = file_id
288
class NoSuchIdInRepository(NoSuchId):
290
_fmt = ('The file id "%(file_id)s" is not present in the repository'
293
def __init__(self, repository, file_id):
294
BzrError.__init__(self, repository=repository, file_id=file_id)
297
class NotStacked(BranchError):
299
_fmt = "The branch '%(branch)s' is not stacked."
302
class InventoryModified(InternalBzrError):
304
_fmt = ("The current inventory for the tree %(tree)r has been modified,"
305
" so a clean inventory cannot be read without data loss.")
307
def __init__(self, tree):
311
class NoWorkingTree(BzrError):
313
_fmt = 'No WorkingTree exists for "%(base)s".'
171
class NoWorkingTree(BzrNewError):
172
"""No WorkingTree exists for %(base)s."""
315
174
def __init__(self, base):
316
BzrError.__init__(self)
175
BzrNewError.__init__(self)
320
class NotBuilding(BzrError):
322
_fmt = "Not currently building a tree."
325
class NotLocalUrl(BzrError):
327
_fmt = "%(url)s is not a local path."
179
class NotLocalUrl(BzrNewError):
180
"""%(url)s is not a local path."""
329
182
def __init__(self, url):
183
BzrNewError.__init__(self)
333
class WorkingTreeAlreadyPopulated(InternalBzrError):
335
_fmt = 'Working tree already populated in "%(base)s"'
337
def __init__(self, base):
341
class BzrCommandError(BzrError):
187
class BzrCommandError(BzrNewError):
342
188
"""Error from user command"""
344
192
# Error from malformed user command; please avoid raising this as a
345
193
# generic exception not caused by user input.
644
283
class InvalidNormalization(PathError):
646
_fmt = 'Path "%(path)s" is not unicode normalized'
284
"""Path %(path)r is not unicode normalized"""
649
287
# TODO: This is given a URL; we try to unescape it but doing that from inside
650
288
# the exception object is a bit undesirable.
651
# TODO: Probably this behavior of should be a common superclass
289
# TODO: Probably this behavior of should be a common superclass
652
290
class NotBranchError(PathError):
654
_fmt = 'Not a branch: "%(path)s"%(detail)s.'
656
def __init__(self, path, detail=None, bzrdir=None):
657
import bzrlib.urlutils as urlutils
658
path = urlutils.unescape_for_display(path, 'ascii')
659
if detail is not None:
660
detail = ': ' + detail
663
PathError.__init__(self, path=path)
666
return '<%s %r>' % (self.__class__.__name__, self.__dict__)
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:
675
self.bzrdir.open_repository()
676
except NoRepositoryPresent:
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.
688
self.detail = ': location is a repository'
691
return PathError._format(self)
694
class NoSubmitBranch(PathError):
696
_fmt = 'No submit branch available for branch "%(path)s"'
698
def __init__(self, branch):
699
import bzrlib.urlutils as urlutils
700
self.path = urlutils.unescape_for_display(branch.base, 'ascii')
703
class AlreadyControlDirError(PathError):
705
_fmt = 'A control directory already exists: "%(path)s".'
291
"""Not a branch: %(path)s"""
293
def __init__(self, path):
294
import bzrlib.urlutils as urlutils
295
self.path = urlutils.unescape_for_display(path, 'ascii')
708
298
class AlreadyBranchError(PathError):
710
_fmt = 'Already a branch: "%(path)s".'
713
class InvalidBranchName(PathError):
715
_fmt = "Invalid branch name: %(name)s"
717
def __init__(self, name):
718
BzrError.__init__(self)
722
class ParentBranchExists(AlreadyBranchError):
724
_fmt = 'Parent branch already exists: "%(path)s".'
299
"""Already a branch: %(path)s."""
727
302
class BranchExistsWithoutWorkingTree(PathError):
729
_fmt = 'Directory contains a branch, but no working tree \
730
(use bzr checkout if you wish to build a working tree): "%(path)s"'
733
class AtomicFileAlreadyClosed(PathError):
735
_fmt = ('"%(function)s" called on an AtomicFile after it was closed:'
738
def __init__(self, path, function):
739
PathError.__init__(self, path=path, extra=None)
740
self.function = function
743
class InaccessibleParent(PathError):
745
_fmt = ('Parent not accessible given base "%(base)s" and'
746
' relative path "%(path)s"')
748
def __init__(self, path, base):
749
PathError.__init__(self, path)
753
class NoRepositoryPresent(BzrError):
755
_fmt = 'No repository present: "%(path)s"'
303
"""Directory contains a branch, but no working tree \
304
(use bzr checkout if you wish to build a working tree): %(path)s"""
307
class NoRepositoryPresent(BzrNewError):
308
"""No repository present: %(path)r"""
756
309
def __init__(self, bzrdir):
757
BzrError.__init__(self)
310
BzrNewError.__init__(self)
758
311
self.path = bzrdir.transport.clone('..').base
761
class UnsupportedFormatError(BzrError):
763
_fmt = "Unsupported branch format: %(format)s\nPlease run 'bzr upgrade'"
766
class UnknownFormatError(BzrError):
768
_fmt = "Unknown %(kind)s format: %(format)r"
770
def __init__(self, format, kind='branch'):
775
class IncompatibleFormat(BzrError):
777
_fmt = "Format %(format)s is not compatible with .bzr version %(bzrdir)s."
314
class FileInWrongBranch(BzrNewError):
315
"""File %(path)s in not in branch %(branch_base)s."""
317
def __init__(self, branch, path):
318
BzrNewError.__init__(self)
320
self.branch_base = branch.base
324
class UnsupportedFormatError(BzrNewError):
325
"""Unsupported branch format: %(format)s"""
328
class UnknownFormatError(BzrNewError):
329
"""Unknown branch format: %(format)r"""
332
class IncompatibleFormat(BzrNewError):
333
"""Format %(format)s is not compatible with .bzr version %(bzrdir)s."""
779
335
def __init__(self, format, bzrdir_format):
780
BzrError.__init__(self)
336
BzrNewError.__init__(self)
781
337
self.format = format
782
338
self.bzrdir = bzrdir_format
785
class ParseFormatError(BzrError):
787
_fmt = "Parse error on line %(lineno)d of %(format)s format: %(line)s"
789
def __init__(self, format, lineno, line, text):
790
BzrError.__init__(self)
797
class IncompatibleRepositories(BzrError):
798
"""Report an error that two repositories are not compatible.
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.
805
_fmt = "%(target)s\n" \
806
"is not compatible with\n" \
810
def __init__(self, source, target, details=None):
812
details = "(no details)"
813
BzrError.__init__(self, target=target, source=source, details=details)
816
class IncompatibleRevision(BzrError):
818
_fmt = "Revision is not compatible with %(repo_format)s"
820
def __init__(self, repo_format):
821
BzrError.__init__(self)
822
self.repo_format = repo_format
825
class AlreadyVersionedError(BzrError):
826
"""Used when a path is expected not to be versioned, but it is."""
828
_fmt = "%(context_info)s%(path)s is already versioned."
830
def __init__(self, path, context_info=None):
831
"""Construct a new AlreadyVersionedError.
833
:param path: This is the path which is versioned,
834
which should be in a user friendly form.
835
:param context_info: If given, this is information about the context,
836
which could explain why this is expected to not be versioned.
838
BzrError.__init__(self)
840
if context_info is None:
841
self.context_info = ''
843
self.context_info = context_info + ". "
846
class NotVersionedError(BzrError):
847
"""Used when a path is expected to be versioned, but it is not."""
849
_fmt = "%(context_info)s%(path)s is not versioned."
851
def __init__(self, path, context_info=None):
852
"""Construct a new NotVersionedError.
854
:param path: This is the path which is not versioned,
855
which should be in a user friendly form.
856
:param context_info: If given, this is information about the context,
857
which could explain why this is expected to be versioned.
859
BzrError.__init__(self)
861
if context_info is None:
862
self.context_info = ''
864
self.context_info = context_info + ". "
867
class PathsNotVersionedError(BzrError):
868
"""Used when reporting several paths which are not versioned"""
870
_fmt = "Path(s) are not versioned: %(paths_as_string)s"
341
class NotVersionedError(BzrNewError):
342
"""%(path)s is not versioned"""
343
def __init__(self, path):
344
BzrNewError.__init__(self)
348
class PathsNotVersionedError(BzrNewError):
349
# used when reporting several paths are not versioned
350
"""Path(s) are not versioned: %(paths_as_string)s"""
872
352
def __init__(self, paths):
873
353
from bzrlib.osutils import quotefn
874
BzrError.__init__(self)
354
BzrNewError.__init__(self)
875
355
self.paths = paths
876
356
self.paths_as_string = ' '.join([quotefn(p) for p in paths])
879
class PathsDoNotExist(BzrError):
881
_fmt = "Path(s) do not exist: %(paths_as_string)s%(extra)s"
359
class PathsDoNotExist(BzrNewError):
360
"""Path(s) do not exist: %(paths_as_string)s"""
883
362
# used when reporting that paths are neither versioned nor in the working
886
def __init__(self, paths, extra=None):
365
def __init__(self, paths):
887
366
# circular import
888
367
from bzrlib.osutils import quotefn
889
BzrError.__init__(self)
368
BzrNewError.__init__(self)
890
369
self.paths = paths
891
370
self.paths_as_string = ' '.join([quotefn(p) for p in paths])
893
self.extra = ': ' + str(extra)
898
class BadFileKindError(BzrError):
900
_fmt = 'Cannot operate on "%(filename)s" of unsupported kind "%(kind)s"'
902
def __init__(self, filename, kind):
903
BzrError.__init__(self, filename=filename, kind=kind)
906
class BadFilenameEncoding(BzrError):
908
_fmt = ('Filename %(filename)r is not valid in your current filesystem'
909
' encoding %(fs_encoding)s')
911
def __init__(self, filename, fs_encoding):
912
BzrError.__init__(self)
913
self.filename = filename
914
self.fs_encoding = fs_encoding
917
class ForbiddenControlFileError(BzrError):
919
_fmt = 'Cannot operate on "%(filename)s" because it is a control file'
922
class LockError(InternalBzrError):
924
_fmt = "Lock error: %(msg)s"
373
class BadFileKindError(BzrNewError):
374
"""Cannot operate on %(filename)s of unsupported kind %(kind)s"""
377
class ForbiddenControlFileError(BzrNewError):
378
"""Cannot operate on %(filename)s because it is a control file"""
381
class LockError(BzrNewError):
382
"""Lock error: %(message)s"""
926
383
# All exceptions from the lock/unlock functions should be from
927
384
# this exception class. They will be translated as necessary. The
928
385
# original exception is available as e.original_error
930
387
# New code should prefer to raise specific subclasses
931
def __init__(self, msg):
935
class LockActive(LockError):
937
_fmt = "The lock for '%(lock_description)s' is in use and cannot be broken."
939
internal_error = False
941
def __init__(self, lock_description):
942
self.lock_description = lock_description
388
def __init__(self, message):
389
self.message = message
945
392
class CommitNotPossible(LockError):
947
_fmt = "A commit was attempted but we do not have a write lock open."
393
"""A commit was attempted but we do not have a write lock open."""
949
394
def __init__(self):
953
398
class AlreadyCommitted(LockError):
955
_fmt = "A rollback was requested, but is not able to be accomplished."
399
"""A rollback was requested, but is not able to be accomplished."""
957
400
def __init__(self):
961
404
class ReadOnlyError(LockError):
963
_fmt = "A write attempt was made in a read only transaction on %(obj)s"
965
# TODO: There should also be an error indicating that you need a write
966
# lock and don't have any lock at all... mbp 20070226
405
"""A write attempt was made in a read only transaction on %(obj)s"""
968
406
def __init__(self, obj):
972
class LockFailed(LockError):
974
internal_error = False
976
_fmt = "Cannot lock %(lock)s: %(why)s"
978
def __init__(self, lock, why):
979
LockError.__init__(self, '')
984
class OutSideTransaction(BzrError):
986
_fmt = ("A transaction related operation was attempted after"
987
" the transaction finished.")
410
class OutSideTransaction(BzrNewError):
411
"""A transaction related operation was attempted after the transaction finished."""
990
414
class ObjectNotLocked(LockError):
415
"""%(obj)r is not locked"""
992
_fmt = "%(obj)r is not locked"
417
is_user_error = False
994
419
# this can indicate that any particular object is not locked; see also
995
420
# LockNotHeld which means that a particular *lock* object is not held by
1569
735
self.orig_error = orig_error
1570
BzrError.__init__(self)
1573
class TooManyConcurrentRequests(InternalBzrError):
1575
_fmt = ("The medium '%(medium)s' has reached its concurrent request limit."
1576
" Be sure to finish_writing and finish_reading on the"
1577
" currently open request.")
1579
def __init__(self, medium):
1580
self.medium = medium
1583
class SmartProtocolError(TransportError):
1585
_fmt = "Generic bzr smart protocol error: %(details)s"
1587
def __init__(self, details):
1588
self.details = details
1591
class UnexpectedProtocolVersionMarker(TransportError):
1593
_fmt = "Received bad protocol version marker: %(marker)r"
1595
def __init__(self, marker):
1596
self.marker = marker
1599
class UnknownSmartMethod(InternalBzrError):
1601
_fmt = "The server does not recognise the '%(verb)s' request."
1603
def __init__(self, verb):
1607
class SmartMessageHandlerError(InternalBzrError):
1609
_fmt = ("The message handler raised an exception:\n"
1610
"%(traceback_text)s")
1612
def __init__(self, exc_info):
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)
736
BzrNewError.__init__(self)
1622
739
# A set of semi-meaningful errors which can be thrown
1623
740
class TransportNotPossible(TransportError):
1625
_fmt = "Transport operation not possible: %(msg)s %(orig_error)s"
741
"""Transport operation not possible: %(msg)s %(orig_error)%"""
1628
744
class ConnectionError(TransportError):
1630
_fmt = "Connection error: %(msg)s %(orig_error)s"
1633
class SocketConnectionError(ConnectionError):
1635
_fmt = "%(msg)s %(host)s%(port)s%(orig_error)s"
1637
def __init__(self, host, port=None, msg=None, orig_error=None):
1639
msg = 'Failed to connect to'
1640
if orig_error is None:
1643
orig_error = '; ' + str(orig_error)
1644
ConnectionError.__init__(self, msg=msg, orig_error=orig_error)
1649
self.port = ':%s' % port
1652
# XXX: This is also used for unexpected end of file, which is different at the
1653
# TCP level from "connection reset".
745
"""Connection error: %(msg)s %(orig_error)s"""
1654
748
class ConnectionReset(TransportError):
1656
_fmt = "Connection closed: %(msg)s %(orig_error)s"
1659
class ConnectionTimeout(ConnectionError):
1661
_fmt = "Connection Timeout: %(msg)s%(orig_error)s"
749
"""Connection closed: %(msg)s %(orig_error)s"""
1664
752
class InvalidRange(TransportError):
1666
_fmt = "Invalid range access in %(path)s at %(offset)s: %(msg)s"
1668
def __init__(self, path, offset, msg=None):
1669
TransportError.__init__(self, msg)
1671
self.offset = offset
753
"""Invalid range access."""
755
def __init__(self, path, offset):
756
TransportError.__init__(self, ("Invalid range access in %s at %d"
1674
760
class InvalidHttpResponse(TransportError):
1676
_fmt = "Invalid http response for %(path)s: %(msg)s%(orig_error)s"
761
"""Invalid http response for %(path)s: %(msg)s"""
1678
763
def __init__(self, path, msg, orig_error=None):
1679
764
self.path = path
1680
if orig_error is None:
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,)
1686
765
TransportError.__init__(self, msg, orig_error=orig_error)
1689
class CertificateError(TransportError):
1691
_fmt = "Certificate error: %(error)s"
1693
def __init__(self, error):
1697
768
class InvalidHttpRange(InvalidHttpResponse):
1699
_fmt = "Invalid http range %(range)r for %(path)s: %(msg)s"
769
"""Invalid http range "%(range)s" for %(path)s: %(msg)s"""
1701
771
def __init__(self, path, range, msg):
1702
772
self.range = range
1703
773
InvalidHttpResponse.__init__(self, path, msg)
1706
class HttpBoundaryMissing(InvalidHttpResponse):
1707
"""A multipart response ends with no boundary marker.
1709
This is a special case caused by buggy proxies, described in
1710
<https://bugs.launchpad.net/bzr/+bug/198646>.
1713
_fmt = "HTTP MIME Boundary missing for %(path)s: %(msg)s"
1715
def __init__(self, path, msg):
1716
InvalidHttpResponse.__init__(self, path, msg)
1719
776
class InvalidHttpContentType(InvalidHttpResponse):
1721
_fmt = 'Invalid http Content-type "%(ctype)s" for %(path)s: %(msg)s'
777
"""Invalid http Content-type "%(ctype)s" for %(path)s: %(msg)s"""
1723
779
def __init__(self, path, ctype, msg):
1724
780
self.ctype = ctype
1725
781
InvalidHttpResponse.__init__(self, path, msg)
1728
class RedirectRequested(TransportError):
1730
_fmt = '%(source)s is%(permanently)s redirected to %(target)s'
1732
def __init__(self, source, target, is_permanent=False):
1733
self.source = source
1734
self.target = target
1736
self.permanently = ' permanently'
1738
self.permanently = ''
1739
TransportError.__init__(self)
1742
class TooManyRedirections(TransportError):
1744
_fmt = "Too many redirections"
1747
784
class ConflictsInTree(BzrError):
1749
_fmt = "Working tree has conflicts."
1752
class ConfigContentError(BzrError):
1754
_fmt = "Config file %(filename)s is not UTF-8 encoded\n"
1756
def __init__(self, filename):
1757
BzrError.__init__(self)
1758
self.filename = filename
786
BzrError.__init__(self, "Working tree has conflicts.")
1761
789
class ParseConfigError(BzrError):
1763
_fmt = "Error(s) parsing config file %(filename)s:\n%(errors)s"
1765
790
def __init__(self, errors, filename):
1766
BzrError.__init__(self)
1767
self.filename = filename
1768
self.errors = '\n'.join(e.msg for e in errors)
1771
class ConfigOptionValueError(BzrError):
1773
_fmt = ('Bad value "%(value)s" for option "%(name)s".\n'
1774
'See ``bzr help %(name)s``')
1776
def __init__(self, name, value):
1777
BzrError.__init__(self, name=name, value=value)
1780
class NoEmailInUsername(BzrError):
1782
_fmt = "%(username)r does not seem to contain a reasonable email address"
1784
def __init__(self, username):
1785
BzrError.__init__(self)
1786
self.username = username
793
message = "Error(s) parsing config file %s:\n%s" % \
794
(filename, ('\n'.join(e.message for e in errors)))
795
BzrError.__init__(self, message)
1789
798
class SigningFailed(BzrError):
1791
_fmt = 'Failed to GPG sign data with command "%(command_line)s"'
1793
799
def __init__(self, command_line):
1794
BzrError.__init__(self, command_line=command_line)
1797
class SignatureVerificationFailed(BzrError):
1799
_fmt = 'Failed to verify GPG signature data with error "%(error)s"'
1801
def __init__(self, error):
1802
BzrError.__init__(self, error=error)
1805
class DependencyNotPresent(BzrError):
1807
_fmt = 'Unable to import library "%(library)s": %(error)s'
1809
def __init__(self, library, error):
1810
BzrError.__init__(self, library=library, error=error)
1813
class GpgmeNotInstalled(DependencyNotPresent):
1815
_fmt = 'python-gpgme is not installed, it is needed to verify signatures'
1817
def __init__(self, error):
1818
DependencyNotPresent.__init__(self, 'gpgme', error)
800
BzrError.__init__(self, "Failed to gpg sign data with command '%s'"
1821
804
class WorkingTreeNotRevision(BzrError):
1823
_fmt = ("The working tree for %(basedir)s has changed since"
1824
" the last commit, but weave merge requires that it be"
1827
805
def __init__(self, tree):
1828
BzrError.__init__(self, basedir=tree.basedir)
1831
class CantReprocessAndShowBase(BzrError):
1833
_fmt = ("Can't reprocess and show base, because reprocessing obscures "
1834
"the relationship of conflicting lines to the base")
1837
class GraphCycleError(BzrError):
1839
_fmt = "Cycle in graph %(graph)r"
806
BzrError.__init__(self, "The working tree for %s has changed since"
807
" last commit, but weave merge requires that it be"
808
" unchanged." % tree.basedir)
811
class CantReprocessAndShowBase(BzrNewError):
812
"""Can't reprocess and show base.
813
Reprocessing obscures relationship of conflicting lines to base."""
816
class GraphCycleError(BzrNewError):
817
"""Cycle in graph %(graph)r"""
1841
818
def __init__(self, graph):
1842
BzrError.__init__(self)
819
BzrNewError.__init__(self)
1843
820
self.graph = graph
1846
class WritingCompleted(InternalBzrError):
1848
_fmt = ("The MediumRequest '%(request)s' has already had finish_writing "
1849
"called upon it - accept bytes may not be called anymore.")
1851
def __init__(self, request):
1852
self.request = request
1855
class WritingNotComplete(InternalBzrError):
1857
_fmt = ("The MediumRequest '%(request)s' has not has finish_writing "
1858
"called upon it - until the write phase is complete no "
1859
"data may be read.")
1861
def __init__(self, request):
1862
self.request = request
1865
class NotConflicted(BzrError):
1867
_fmt = "File %(filename)s is not conflicted."
823
class NotConflicted(BzrNewError):
824
"""File %(filename)s is not conflicted."""
1869
826
def __init__(self, filename):
1870
BzrError.__init__(self)
827
BzrNewError.__init__(self)
1871
828
self.filename = filename
1874
class MediumNotConnected(InternalBzrError):
1876
_fmt = """The medium '%(medium)s' is not connected."""
1878
def __init__(self, medium):
1879
self.medium = medium
1882
831
class MustUseDecorated(Exception):
1884
_fmt = "A decorating function has requested its original command be used."
1887
class NoBundleFound(BzrError):
1889
_fmt = 'No bundle was found in "%(filename)s".'
832
"""A decorating function has requested its original command be used.
834
This should never escape bzr, so does not need to be printable.
838
class NoBundleFound(BzrNewError):
839
"""No bundle was found in %(filename)s"""
1891
840
def __init__(self, filename):
1892
BzrError.__init__(self)
841
BzrNewError.__init__(self)
1893
842
self.filename = filename
1896
class BundleNotSupported(BzrError):
1898
_fmt = "Unable to handle bundle version %(version)s: %(msg)s"
845
class BundleNotSupported(BzrNewError):
846
"""Unable to handle bundle version %(version)s: %(msg)s"""
1900
847
def __init__(self, version, msg):
1901
BzrError.__init__(self)
848
BzrNewError.__init__(self)
1902
849
self.version = version
1906
class MissingText(BzrError):
1908
_fmt = ("Branch %(base)s is missing revision"
1909
" %(text_revision)s of %(file_id)s")
853
class MissingText(BzrNewError):
854
"""Branch %(base)s is missing revision %(text_revision)s of %(file_id)s"""
1911
856
def __init__(self, branch, text_revision, file_id):
1912
BzrError.__init__(self)
857
BzrNewError.__init__(self)
1913
858
self.branch = branch
1914
859
self.base = branch.base
1915
860
self.text_revision = text_revision
1916
861
self.file_id = file_id
1919
class DuplicateFileId(BzrError):
1921
_fmt = "File id {%(file_id)s} already exists in inventory as %(entry)s"
1923
def __init__(self, file_id, entry):
1924
BzrError.__init__(self)
1925
self.file_id = file_id
1929
class DuplicateKey(BzrError):
1931
_fmt = "Key %(key)s is already present in map"
1934
class DuplicateHelpPrefix(BzrError):
1936
_fmt = "The prefix %(prefix)s is in the help search path twice."
1938
def __init__(self, prefix):
1939
self.prefix = prefix
1942
class MalformedTransform(InternalBzrError):
1944
_fmt = "Tree transform is malformed %(conflicts)r"
1947
class NoFinalPath(BzrError):
1949
_fmt = ("No final name for trans_id %(trans_id)r\n"
1950
"file-id: %(file_id)r\n"
1951
"root trans-id: %(root_trans_id)r\n")
1953
def __init__(self, trans_id, transform):
1954
self.trans_id = trans_id
1955
self.file_id = transform.final_file_id(trans_id)
1956
self.root_trans_id = transform.root
1959
class BzrBadParameter(InternalBzrError):
1961
_fmt = "Bad parameter: %(param)r"
1963
# This exception should never be thrown, but it is a base class for all
1964
# parameter-to-function errors.
864
class DuplicateKey(BzrNewError):
865
"""Key %(key)s is already present in map"""
868
class MalformedTransform(BzrNewError):
869
"""Tree transform is malformed %(conflicts)r"""
872
class BzrBadParameter(BzrNewError):
873
"""A bad parameter : %(param)s is not usable.
875
This exception should never be thrown, but it is a base class for all
876
parameter-to-function errors.
1966
878
def __init__(self, param):
1967
BzrError.__init__(self)
879
BzrNewError.__init__(self)
1968
880
self.param = param
1971
883
class BzrBadParameterNotUnicode(BzrBadParameter):
1973
_fmt = "Parameter %(param)s is neither unicode nor utf8."
1976
class ReusingTransform(BzrError):
1978
_fmt = "Attempt to reuse a transform that has already been applied."
1981
class CantMoveRoot(BzrError):
1983
_fmt = "Moving the root directory is not supported at this time"
1986
class TransformRenameFailed(BzrError):
1988
_fmt = "Failed to rename %(from_path)s to %(to_path)s: %(why)s"
1990
def __init__(self, from_path, to_path, why, errno):
1991
self.from_path = from_path
1992
self.to_path = to_path
1997
class BzrMoveFailedError(BzrError):
1999
_fmt = ("Could not move %(from_path)s%(operator)s %(to_path)s"
2000
"%(_has_extra)s%(extra)s")
2002
def __init__(self, from_path='', to_path='', extra=None):
2003
from bzrlib.osutils import splitpath
2004
BzrError.__init__(self)
2006
self.extra, self._has_extra = extra, ': '
2008
self.extra = self._has_extra = ''
2010
has_from = len(from_path) > 0
2011
has_to = len(to_path) > 0
2013
self.from_path = splitpath(from_path)[-1]
2018
self.to_path = splitpath(to_path)[-1]
2023
if has_from and has_to:
2024
self.operator = " =>"
2026
self.from_path = "from " + from_path
2028
self.operator = "to"
2030
self.operator = "file"
2033
class BzrRenameFailedError(BzrMoveFailedError):
2035
_fmt = ("Could not rename %(from_path)s%(operator)s %(to_path)s"
2036
"%(_has_extra)s%(extra)s")
2038
def __init__(self, from_path, to_path, extra=None):
2039
BzrMoveFailedError.__init__(self, from_path, to_path, extra)
884
"""Parameter %(param)s is neither unicode nor utf8."""
887
class ReusingTransform(BzrNewError):
888
"""Attempt to reuse a transform that has already been applied."""
891
class CantMoveRoot(BzrNewError):
892
"""Moving the root directory is not supported at this time"""
2042
895
class BzrBadParameterNotString(BzrBadParameter):
2044
_fmt = "Parameter %(param)s is not a string or unicode string."
896
"""Parameter %(param)s is not a string or unicode string."""
2047
899
class BzrBadParameterMissing(BzrBadParameter):
2049
_fmt = "Parameter %(param)s is required but not present."
900
"""Parameter $(param)s is required but not present."""
2052
903
class BzrBadParameterUnicode(BzrBadParameter):
2054
_fmt = ("Parameter %(param)s is unicode but"
2055
" only byte-strings are permitted.")
904
"""Parameter %(param)s is unicode but only byte-strings are permitted."""
2058
907
class BzrBadParameterContainsNewline(BzrBadParameter):
2060
_fmt = "Parameter %(param)s contains a newline."
908
"""Parameter %(param)s contains a newline."""
911
class DependencyNotPresent(BzrNewError):
912
"""Unable to import library "%(library)s": %(error)s"""
914
def __init__(self, library, error):
915
BzrNewError.__init__(self, library=library, error=error)
2063
918
class ParamikoNotPresent(DependencyNotPresent):
2065
_fmt = "Unable to import paramiko (required for sftp support): %(error)s"
919
"""Unable to import paramiko (required for sftp support): %(error)s"""
2067
921
def __init__(self, error):
2068
922
DependencyNotPresent.__init__(self, 'paramiko', error)
2071
class PointlessMerge(BzrError):
2073
_fmt = "Nothing to merge."
2076
class UninitializableFormat(BzrError):
2078
_fmt = "Format %(format)s cannot be initialised by this version of bzr."
925
class UninitializableFormat(BzrNewError):
926
"""Format %(format)s cannot be initialised by this version of bzr."""
2080
928
def __init__(self, format):
2081
BzrError.__init__(self)
2082
self.format = format
2085
class BadConversionTarget(BzrError):
2087
_fmt = "Cannot convert from format %(from_format)s to format %(format)s." \
2090
def __init__(self, problem, format, from_format=None):
2091
BzrError.__init__(self)
2092
self.problem = problem
2093
self.format = format
2094
self.from_format = from_format or '(unspecified)'
2097
class NoDiffFound(BzrError):
2099
_fmt = 'Could not find an appropriate Differ for file "%(path)s"'
2101
def __init__(self, path):
2102
BzrError.__init__(self, path)
2105
class ExecutableMissing(BzrError):
2107
_fmt = "%(exe_name)s could not be found on this machine"
2109
def __init__(self, exe_name):
2110
BzrError.__init__(self, exe_name=exe_name)
2113
class NoDiff(BzrError):
2115
_fmt = "Diff is not installed on this machine: %(msg)s"
929
BzrNewError.__init__(self)
933
class NoDiff(BzrNewError):
934
"""Diff is not installed on this machine: %(msg)s"""
2117
936
def __init__(self, msg):
2118
BzrError.__init__(self, msg=msg)
2121
class NoDiff3(BzrError):
2123
_fmt = "Diff3 is not installed on this machine."
2126
class ExistingContent(BzrError):
2127
# Added in bzrlib 0.92, used by VersionedFile.add_lines.
2129
_fmt = "The content being inserted is already present."
2132
class ExistingLimbo(BzrError):
2134
_fmt = """This tree contains left-over files from a failed operation.
2135
Please examine %(limbo_dir)s to see if it contains any files you wish to
2136
keep, and delete it when you are done."""
2138
def __init__(self, limbo_dir):
2139
BzrError.__init__(self)
2140
self.limbo_dir = limbo_dir
2143
class ExistingPendingDeletion(BzrError):
2145
_fmt = """This tree contains left-over files from a failed operation.
2146
Please examine %(pending_deletion)s to see if it contains any files you
2147
wish to keep, and delete it when you are done."""
2149
def __init__(self, pending_deletion):
2150
BzrError.__init__(self, pending_deletion=pending_deletion)
2153
class ImmortalLimbo(BzrError):
2155
_fmt = """Unable to delete transform temporary directory %(limbo_dir)s.
2156
Please examine %(limbo_dir)s to see if it contains any files you wish to
2157
keep, and delete it when you are done."""
2159
def __init__(self, limbo_dir):
2160
BzrError.__init__(self)
2161
self.limbo_dir = limbo_dir
2164
class ImmortalPendingDeletion(BzrError):
2166
_fmt = ("Unable to delete transform temporary directory "
2167
"%(pending_deletion)s. Please examine %(pending_deletion)s to see if it "
2168
"contains any files you wish to keep, and delete it when you are done.")
2170
def __init__(self, pending_deletion):
2171
BzrError.__init__(self, pending_deletion=pending_deletion)
2174
class OutOfDateTree(BzrError):
2176
_fmt = "Working tree is out of date, please run 'bzr update'.%(more)s"
2178
def __init__(self, tree, more=None):
2183
BzrError.__init__(self)
937
super(NoDiff, self).__init__(msg=msg)
940
class NoDiff3(BzrNewError):
941
"""Diff3 is not installed on this machine."""
944
class ExistingLimbo(BzrNewError):
945
"""This tree contains left-over files from a failed operation.
946
Please examine %(limbo_dir)s to see if it contains any files you wish to
947
keep, and delete it when you are done.
949
def __init__(self, limbo_dir):
950
BzrNewError.__init__(self)
951
self.limbo_dir = limbo_dir
954
class ImmortalLimbo(BzrNewError):
955
"""Unable to delete transform temporary directory $(limbo_dir)s.
956
Please examine %(limbo_dir)s to see if it contains any files you wish to
957
keep, and delete it when you are done.
959
def __init__(self, limbo_dir):
960
BzrNewError.__init__(self)
961
self.limbo_dir = limbo_dir
964
class OutOfDateTree(BzrNewError):
965
"""Working tree is out of date, please run 'bzr update'."""
967
def __init__(self, tree):
968
BzrNewError.__init__(self)
2184
969
self.tree = tree
2188
class PublicBranchOutOfDate(BzrError):
2190
_fmt = 'Public branch "%(public_location)s" lacks revision '\
2193
def __init__(self, public_location, revstring):
2194
import bzrlib.urlutils as urlutils
2195
public_location = urlutils.unescape_for_display(public_location,
2197
BzrError.__init__(self, public_location=public_location,
2198
revstring=revstring)
2201
class MergeModifiedFormatError(BzrError):
2203
_fmt = "Error in merge modified format"
2206
class ConflictFormatError(BzrError):
2208
_fmt = "Format error in conflict listings"
2211
class CorruptDirstate(BzrError):
2213
_fmt = ("Inconsistency in dirstate file %(dirstate_path)s.\n"
2214
"Error: %(description)s")
2216
def __init__(self, dirstate_path, description):
2217
BzrError.__init__(self)
2218
self.dirstate_path = dirstate_path
2219
self.description = description
2222
class CorruptRepository(BzrError):
2224
_fmt = ("An error has been detected in the repository %(repo_path)s.\n"
2225
"Please run bzr reconcile on this repository.")
972
class MergeModifiedFormatError(BzrNewError):
973
"""Error in merge modified format"""
976
class ConflictFormatError(BzrNewError):
977
"""Format error in conflict listings"""
980
class CorruptRepository(BzrNewError):
981
"""An error has been detected in the repository %(repo_path)s.
982
Please run bzr reconcile on this repository."""
2227
984
def __init__(self, repo):
2228
BzrError.__init__(self)
2229
self.repo_path = repo.user_url
2232
class InconsistentDelta(BzrError):
2233
"""Used when we get a delta that is not valid."""
2235
_fmt = ("An inconsistent delta was supplied involving %(path)r,"
2236
" %(file_id)r\nreason: %(reason)s")
2238
def __init__(self, path, file_id, reason):
2239
BzrError.__init__(self)
2241
self.file_id = file_id
2242
self.reason = reason
2245
class InconsistentDeltaDelta(InconsistentDelta):
2246
"""Used when we get a delta that is not valid."""
2248
_fmt = ("An inconsistent delta was supplied: %(delta)r"
2249
"\nreason: %(reason)s")
2251
def __init__(self, delta, reason):
2252
BzrError.__init__(self)
2254
self.reason = reason
2257
class UpgradeRequired(BzrError):
2259
_fmt = "To use this feature you must upgrade your branch at %(path)s."
985
BzrNewError.__init__(self)
986
self.repo_path = repo.bzrdir.root_transport.base
989
class UpgradeRequired(BzrNewError):
990
"""To use this feature you must upgrade your branch at %(path)s."""
2261
992
def __init__(self, path):
2262
BzrError.__init__(self)
993
BzrNewError.__init__(self)
2263
994
self.path = path
2266
class RepositoryUpgradeRequired(UpgradeRequired):
2268
_fmt = "To use this feature you must upgrade your repository at %(path)s."
2271
class RichRootUpgradeRequired(UpgradeRequired):
2273
_fmt = ("To use this feature you must upgrade your branch at %(path)s to"
2274
" a format which supports rich roots.")
2277
class LocalRequiresBoundBranch(BzrError):
2279
_fmt = "Cannot perform local-only commits on unbound branches."
2282
class UnsupportedOperation(BzrError):
2284
_fmt = ("The method %(mname)s is not supported on"
2285
" objects of type %(tname)s.")
997
class LocalRequiresBoundBranch(BzrNewError):
998
"""Cannot perform local-only commits on unbound branches."""
1001
class MissingProgressBarFinish(BzrNewError):
1002
"""A nested progress bar was not 'finished' correctly."""
1005
class InvalidProgressBarType(BzrNewError):
1006
"""Environment variable BZR_PROGRESS_BAR='%(bar_type)s is not a supported type
1007
Select one of: %(valid_types)s"""
1009
def __init__(self, bar_type, valid_types):
1010
BzrNewError.__init__(self, bar_type=bar_type, valid_types=valid_types)
1013
class UnsupportedOperation(BzrNewError):
1014
"""The method %(mname)s is not supported on objects of type %(tname)s."""
2287
1015
def __init__(self, method, method_self):
2288
1016
self.method = method
2289
1017
self.mname = method.__name__
2290
1018
self.tname = type(method_self).__name__
2293
class CannotSetRevisionId(UnsupportedOperation):
2294
"""Raised when a commit is attempting to set a revision id but cant."""
2297
class NonAsciiRevisionId(UnsupportedOperation):
2298
"""Raised when a commit is attempting to set a non-ascii revision id
2303
class GhostTagsNotSupported(BzrError):
2305
_fmt = "Ghost tags not supported by format %(format)r."
2307
def __init__(self, format):
2308
self.format = format
2311
class BinaryFile(BzrError):
2313
_fmt = "File is binary but should be text."
2316
class IllegalPath(BzrError):
2318
_fmt = "The path %(path)s is not permitted on this platform"
1021
class BinaryFile(BzrNewError):
1022
"""File is binary but should be text."""
1025
class IllegalPath(BzrNewError):
1026
"""The path %(path)s is not permitted on this platform"""
2320
1028
def __init__(self, path):
2321
BzrError.__init__(self)
1029
BzrNewError.__init__(self)
2322
1030
self.path = path
2325
class TestamentMismatch(BzrError):
2327
_fmt = """Testament did not match expected value.
2328
For revision_id {%(revision_id)s}, expected {%(expected)s}, measured
1033
class TestamentMismatch(BzrNewError):
1034
"""Testament did not match expected value.
1035
For revision_id {%(revision_id)s}, expected {%(expected)s}, measured
2331
1038
def __init__(self, revision_id, expected, measured):
2332
1039
self.revision_id = revision_id
2333
1040
self.expected = expected
2334
1041
self.measured = measured
2337
class NotABundle(BzrError):
2339
_fmt = "Not a bzr revision-bundle: %(text)r"
2341
def __init__(self, text):
2342
BzrError.__init__(self)
2346
class BadBundle(BzrError):
2348
_fmt = "Bad bzr revision-bundle: %(text)r"
2350
def __init__(self, text):
2351
BzrError.__init__(self)
2355
class MalformedHeader(BadBundle):
2357
_fmt = "Malformed bzr revision-bundle header: %(text)r"
2360
class MalformedPatches(BadBundle):
2362
_fmt = "Malformed patches in bzr revision-bundle: %(text)r"
2365
class MalformedFooter(BadBundle):
2367
_fmt = "Malformed footer in bzr revision-bundle: %(text)r"
2370
class UnsupportedEOLMarker(BadBundle):
2372
_fmt = "End of line marker was not \\n in bzr revision-bundle"
2375
# XXX: BadBundle's constructor assumes there's explanatory text,
2376
# but for this there is not
2377
BzrError.__init__(self)
2380
class IncompatibleBundleFormat(BzrError):
2382
_fmt = "Bundle format %(bundle_format)s is incompatible with %(other)s"
2384
def __init__(self, bundle_format, other):
2385
BzrError.__init__(self)
2386
self.bundle_format = bundle_format
2390
class BadInventoryFormat(BzrError):
2392
_fmt = "Root class for inventory serialization errors"
2395
class UnexpectedInventoryFormat(BadInventoryFormat):
2397
_fmt = "The inventory was not in the expected format:\n %(msg)s"
2399
def __init__(self, msg):
2400
BadInventoryFormat.__init__(self, msg=msg)
2403
class RootNotRich(BzrError):
2405
_fmt = """This operation requires rich root data storage"""
2408
class NoSmartMedium(InternalBzrError):
2410
_fmt = "The transport '%(transport)s' cannot tunnel the smart protocol."
2412
def __init__(self, transport):
2413
self.transport = transport
2416
class UnknownSSH(BzrError):
2418
_fmt = "Unrecognised value for BZR_SSH environment variable: %(vendor)s"
2420
def __init__(self, vendor):
2421
BzrError.__init__(self)
2422
self.vendor = vendor
2425
class SSHVendorNotFound(BzrError):
2427
_fmt = ("Don't know how to handle SSH connections."
2428
" Please set BZR_SSH environment variable.")
2431
class GhostRevisionsHaveNoRevno(BzrError):
2432
"""When searching for revnos, if we encounter a ghost, we are stuck"""
2434
_fmt = ("Could not determine revno for {%(revision_id)s} because"
2435
" its ancestry shows a ghost at {%(ghost_revision_id)s}")
2437
def __init__(self, revision_id, ghost_revision_id):
2438
self.revision_id = revision_id
2439
self.ghost_revision_id = ghost_revision_id
2442
class GhostRevisionUnusableHere(BzrError):
2444
_fmt = "Ghost revision {%(revision_id)s} cannot be used here."
2446
def __init__(self, revision_id):
2447
BzrError.__init__(self)
2448
self.revision_id = revision_id
2451
class IllegalUseOfScopeReplacer(InternalBzrError):
2453
_fmt = ("ScopeReplacer object %(name)r was used incorrectly:"
2454
" %(msg)s%(extra)s")
2456
def __init__(self, name, msg, extra=None):
2457
BzrError.__init__(self)
2461
self.extra = ': ' + str(extra)
2466
class InvalidImportLine(InternalBzrError):
2468
_fmt = "Not a valid import statement: %(msg)\n%(text)s"
2470
def __init__(self, text, msg):
2471
BzrError.__init__(self)
2476
class ImportNameCollision(InternalBzrError):
2478
_fmt = ("Tried to import an object to the same name as"
2479
" an existing object. %(name)s")
2481
def __init__(self, name):
2482
BzrError.__init__(self)
2486
class NotAMergeDirective(BzrError):
2487
"""File starting with %(firstline)r is not a merge directive"""
2488
def __init__(self, firstline):
2489
BzrError.__init__(self, firstline=firstline)
2492
class NoMergeSource(BzrError):
2493
"""Raise if no merge source was specified for a merge directive"""
2495
_fmt = "A merge directive must provide either a bundle or a public"\
2499
class IllegalMergeDirectivePayload(BzrError):
2500
"""A merge directive contained something other than a patch or bundle"""
2502
_fmt = "Bad merge directive payload %(start)r"
2504
def __init__(self, start):
2509
class PatchVerificationFailed(BzrError):
2510
"""A patch from a merge directive could not be verified"""
2512
_fmt = "Preview patch does not match requested changes."
2515
class PatchMissing(BzrError):
2516
"""Raise a patch type was specified but no patch supplied"""
2518
_fmt = "Patch_type was %(patch_type)s, but no patch was supplied."
2520
def __init__(self, patch_type):
2521
BzrError.__init__(self)
2522
self.patch_type = patch_type
2525
class TargetNotBranch(BzrError):
2526
"""A merge directive's target branch is required, but isn't a branch"""
2528
_fmt = ("Your branch does not have all of the revisions required in "
2529
"order to merge this merge directive and the target "
2530
"location specified in the merge directive is not a branch: "
2533
def __init__(self, location):
2534
BzrError.__init__(self)
2535
self.location = location
2538
class UnsupportedInventoryKind(BzrError):
2540
_fmt = """Unsupported entry kind %(kind)s"""
2542
def __init__(self, kind):
2546
class BadSubsumeSource(BzrError):
2548
_fmt = "Can't subsume %(other_tree)s into %(tree)s. %(reason)s"
2550
def __init__(self, tree, other_tree, reason):
2552
self.other_tree = other_tree
2553
self.reason = reason
2556
class SubsumeTargetNeedsUpgrade(BzrError):
2558
_fmt = """Subsume target %(other_tree)s needs to be upgraded."""
2560
def __init__(self, other_tree):
2561
self.other_tree = other_tree
2564
class BadReferenceTarget(InternalBzrError):
2566
_fmt = "Can't add reference to %(other_tree)s into %(tree)s." \
2569
def __init__(self, tree, other_tree, reason):
2571
self.other_tree = other_tree
2572
self.reason = reason
2575
class NoSuchTag(BzrError):
2577
_fmt = "No such tag: %(tag_name)s"
2579
def __init__(self, tag_name):
2580
self.tag_name = tag_name
2583
class TagsNotSupported(BzrError):
2585
_fmt = ("Tags not supported by %(branch)s;"
2586
" you may be able to use bzr upgrade.")
2588
def __init__(self, branch):
2589
self.branch = branch
2592
class TagAlreadyExists(BzrError):
2594
_fmt = "Tag %(tag_name)s already exists."
2596
def __init__(self, tag_name):
2597
self.tag_name = tag_name
2600
class MalformedBugIdentifier(BzrError):
2602
_fmt = ('Did not understand bug identifier %(bug_id)s: %(reason)s. '
2603
'See "bzr help bugs" for more information on this feature.')
2605
def __init__(self, bug_id, reason):
2606
self.bug_id = bug_id
2607
self.reason = reason
2610
class InvalidBugTrackerURL(BzrError):
2612
_fmt = ("The URL for bug tracker \"%(abbreviation)s\" doesn't "
2613
"contain {id}: %(url)s")
2615
def __init__(self, abbreviation, url):
2616
self.abbreviation = abbreviation
2620
class UnknownBugTrackerAbbreviation(BzrError):
2622
_fmt = ("Cannot find registered bug tracker called %(abbreviation)s "
2625
def __init__(self, abbreviation, branch):
2626
self.abbreviation = abbreviation
2627
self.branch = branch
2630
class InvalidLineInBugsProperty(BzrError):
2632
_fmt = ("Invalid line in bugs property: '%(line)s'")
2634
def __init__(self, line):
2638
class InvalidBugStatus(BzrError):
2640
_fmt = ("Invalid bug status: '%(status)s'")
2642
def __init__(self, status):
2643
self.status = status
2646
class UnexpectedSmartServerResponse(BzrError):
2648
_fmt = "Could not understand response from smart server: %(response_tuple)r"
2650
def __init__(self, response_tuple):
2651
self.response_tuple = response_tuple
2654
class ErrorFromSmartServer(BzrError):
2655
"""An error was received from a smart server.
2657
:seealso: UnknownErrorFromSmartServer
2660
_fmt = "Error received from smart server: %(error_tuple)r"
2662
internal_error = True
2664
def __init__(self, error_tuple):
2665
self.error_tuple = error_tuple
2667
self.error_verb = error_tuple[0]
2669
self.error_verb = None
2670
self.error_args = error_tuple[1:]
2673
class UnknownErrorFromSmartServer(BzrError):
2674
"""An ErrorFromSmartServer could not be translated into a typical bzrlib
2677
This is distinct from ErrorFromSmartServer so that it is possible to
2678
distinguish between the following two cases:
2680
- ErrorFromSmartServer was uncaught. This is logic error in the client
2681
and so should provoke a traceback to the user.
2682
- ErrorFromSmartServer was caught but its error_tuple could not be
2683
translated. This is probably because the server sent us garbage, and
2684
should not provoke a traceback.
2687
_fmt = "Server sent an unexpected error: %(error_tuple)r"
2689
internal_error = False
2691
def __init__(self, error_from_smart_server):
2694
:param error_from_smart_server: An ErrorFromSmartServer instance.
2696
self.error_from_smart_server = error_from_smart_server
2697
self.error_tuple = error_from_smart_server.error_tuple
2700
class ContainerError(BzrError):
2701
"""Base class of container errors."""
2704
class UnknownContainerFormatError(ContainerError):
2706
_fmt = "Unrecognised container format: %(container_format)r"
2708
def __init__(self, container_format):
2709
self.container_format = container_format
2712
class UnexpectedEndOfContainerError(ContainerError):
2714
_fmt = "Unexpected end of container stream"
2717
class UnknownRecordTypeError(ContainerError):
2719
_fmt = "Unknown record type: %(record_type)r"
2721
def __init__(self, record_type):
2722
self.record_type = record_type
2725
class InvalidRecordError(ContainerError):
2727
_fmt = "Invalid record: %(reason)s"
2729
def __init__(self, reason):
2730
self.reason = reason
2733
class ContainerHasExcessDataError(ContainerError):
2735
_fmt = "Container has data after end marker: %(excess)r"
2737
def __init__(self, excess):
2738
self.excess = excess
2741
class DuplicateRecordNameError(ContainerError):
2743
_fmt = "Container has multiple records with the same name: %(name)s"
2745
def __init__(self, name):
2746
self.name = name.decode("utf-8")
2749
class NoDestinationAddress(InternalBzrError):
2751
_fmt = "Message does not have a destination address."
2754
class RepositoryDataStreamError(BzrError):
2756
_fmt = "Corrupt or incompatible data stream: %(reason)s"
2758
def __init__(self, reason):
2759
self.reason = reason
2762
class SMTPError(BzrError):
2764
_fmt = "SMTP error: %(error)s"
2766
def __init__(self, error):
2770
class NoMessageSupplied(BzrError):
2772
_fmt = "No message supplied."
2775
class NoMailAddressSpecified(BzrError):
2777
_fmt = "No mail-to address (--mail-to) or output (-o) specified."
2780
class MailClientNotFound(BzrError):
2782
_fmt = "Unable to find mail client with the following names:"\
2783
" %(mail_command_list_string)s"
2785
def __init__(self, mail_command_list):
2786
mail_command_list_string = ', '.join(mail_command_list)
2787
BzrError.__init__(self, mail_command_list=mail_command_list,
2788
mail_command_list_string=mail_command_list_string)
2790
class SMTPConnectionRefused(SMTPError):
2792
_fmt = "SMTP connection to %(host)s refused"
2794
def __init__(self, error, host):
2799
class DefaultSMTPConnectionRefused(SMTPConnectionRefused):
2801
_fmt = "Please specify smtp_server. No server at default %(host)s."
2804
class BzrDirError(BzrError):
2806
def __init__(self, bzrdir):
2807
import bzrlib.urlutils as urlutils
2808
display_url = urlutils.unescape_for_display(bzrdir.user_url,
2810
BzrError.__init__(self, bzrdir=bzrdir, display_url=display_url)
2813
class UnsyncedBranches(BzrDirError):
2815
_fmt = ("'%(display_url)s' is not in sync with %(target_url)s. See"
2816
" bzr help sync-for-reconfigure.")
2818
def __init__(self, bzrdir, target_branch):
2819
BzrDirError.__init__(self, bzrdir)
2820
import bzrlib.urlutils as urlutils
2821
self.target_url = urlutils.unescape_for_display(target_branch.base,
2825
class AlreadyBranch(BzrDirError):
2827
_fmt = "'%(display_url)s' is already a branch."
2830
class AlreadyTree(BzrDirError):
2832
_fmt = "'%(display_url)s' is already a tree."
2835
class AlreadyCheckout(BzrDirError):
2837
_fmt = "'%(display_url)s' is already a checkout."
2840
class AlreadyLightweightCheckout(BzrDirError):
2842
_fmt = "'%(display_url)s' is already a lightweight checkout."
2845
class AlreadyUsingShared(BzrDirError):
2847
_fmt = "'%(display_url)s' is already using a shared repository."
2850
class AlreadyStandalone(BzrDirError):
2852
_fmt = "'%(display_url)s' is already standalone."
2855
class AlreadyWithTrees(BzrDirError):
2857
_fmt = ("Shared repository '%(display_url)s' already creates "
2861
class AlreadyWithNoTrees(BzrDirError):
2863
_fmt = ("Shared repository '%(display_url)s' already doesn't create "
2867
class ReconfigurationNotSupported(BzrDirError):
2869
_fmt = "Requested reconfiguration of '%(display_url)s' is not supported."
2872
class NoBindLocation(BzrDirError):
2874
_fmt = "No location could be found to bind to at %(display_url)s."
2877
class UncommittedChanges(BzrError):
2879
_fmt = ('Working tree "%(display_url)s" has uncommitted changes'
2880
' (See bzr status).%(more)s')
2882
def __init__(self, tree, more=None):
2887
import bzrlib.urlutils as urlutils
2888
user_url = getattr(tree, "user_url", None)
2889
if user_url is None:
2890
display_url = str(tree)
2892
display_url = urlutils.unescape_for_display(user_url, 'ascii')
2893
BzrError.__init__(self, tree=tree, display_url=display_url, more=more)
2896
class ShelvedChanges(UncommittedChanges):
2898
_fmt = ('Working tree "%(display_url)s" has shelved changes'
2899
' (See bzr shelve --list).%(more)s')
2902
class MissingTemplateVariable(BzrError):
2904
_fmt = 'Variable {%(name)s} is not available.'
2906
def __init__(self, name):
2910
class NoTemplate(BzrError):
2912
_fmt = 'No template specified.'
2915
class UnableCreateSymlink(BzrError):
2917
_fmt = 'Unable to create symlink %(path_str)son this platform'
2919
def __init__(self, path=None):
2923
path_str = repr(str(path))
2924
except UnicodeEncodeError:
2925
path_str = repr(path)
2927
self.path_str = path_str
2930
class UnsupportedTimezoneFormat(BzrError):
2932
_fmt = ('Unsupported timezone format "%(timezone)s", '
2933
'options are "utc", "original", "local".')
2935
def __init__(self, timezone):
2936
self.timezone = timezone
2939
class CommandAvailableInPlugin(StandardError):
2941
internal_error = False
2943
def __init__(self, cmd_name, plugin_metadata, provider):
2945
self.plugin_metadata = plugin_metadata
2946
self.cmd_name = cmd_name
2947
self.provider = provider
2951
_fmt = ('"%s" is not a standard bzr command. \n'
2952
'However, the following official plugin provides this command: %s\n'
2953
'You can install it by going to: %s'
2954
% (self.cmd_name, self.plugin_metadata['name'],
2955
self.plugin_metadata['url']))
2960
class NoPluginAvailable(BzrError):
2964
class UnableEncodePath(BzrError):
2966
_fmt = ('Unable to encode %(kind)s path %(path)r in '
2967
'user encoding %(user_encoding)s')
2969
def __init__(self, path, kind):
2970
from bzrlib.osutils import get_user_encoding
2973
self.user_encoding = get_user_encoding()
2976
class NoSuchConfig(BzrError):
2978
_fmt = ('The "%(config_id)s" configuration does not exist.')
2980
def __init__(self, config_id):
2981
BzrError.__init__(self, config_id=config_id)
2984
class NoSuchConfigOption(BzrError):
2986
_fmt = ('The "%(option_name)s" configuration option does not exist.')
2988
def __init__(self, option_name):
2989
BzrError.__init__(self, option_name=option_name)
2992
class NoSuchAlias(BzrError):
2994
_fmt = ('The alias "%(alias_name)s" does not exist.')
2996
def __init__(self, alias_name):
2997
BzrError.__init__(self, alias_name=alias_name)
3000
class DirectoryLookupFailure(BzrError):
3001
"""Base type for lookup errors."""
3006
class InvalidLocationAlias(DirectoryLookupFailure):
3008
_fmt = '"%(alias_name)s" is not a valid location alias.'
3010
def __init__(self, alias_name):
3011
DirectoryLookupFailure.__init__(self, alias_name=alias_name)
3014
class UnsetLocationAlias(DirectoryLookupFailure):
3016
_fmt = 'No %(alias_name)s location assigned.'
3018
def __init__(self, alias_name):
3019
DirectoryLookupFailure.__init__(self, alias_name=alias_name[1:])
3022
class CannotBindAddress(BzrError):
3024
_fmt = 'Cannot bind address "%(host)s:%(port)i": %(orig_error)s.'
3026
def __init__(self, host, port, orig_error):
3027
# nb: in python2.4 socket.error doesn't have a useful repr
3028
BzrError.__init__(self, host=host, port=port,
3029
orig_error=repr(orig_error.args))
3032
class UnknownRules(BzrError):
3034
_fmt = ('Unknown rules detected: %(unknowns_str)s.')
3036
def __init__(self, unknowns):
3037
BzrError.__init__(self, unknowns_str=", ".join(unknowns))
3040
class TipChangeRejected(BzrError):
3041
"""A pre_change_branch_tip hook function may raise this to cleanly and
3042
explicitly abort a change to a branch tip.
3045
_fmt = u"Tip change rejected: %(msg)s"
3047
def __init__(self, msg):
3051
class ShelfCorrupt(BzrError):
3053
_fmt = "Shelf corrupt."
3056
class DecompressCorruption(BzrError):
3058
_fmt = "Corruption while decompressing repository file%(orig_error)s"
3060
def __init__(self, orig_error=None):
3061
if orig_error is not None:
3062
self.orig_error = ", %s" % (orig_error,)
3064
self.orig_error = ""
3065
BzrError.__init__(self)
3068
class NoSuchShelfId(BzrError):
3070
_fmt = 'No changes are shelved with id "%(shelf_id)d".'
3072
def __init__(self, shelf_id):
3073
BzrError.__init__(self, shelf_id=shelf_id)
3076
class InvalidShelfId(BzrError):
3078
_fmt = '"%(invalid_id)s" is not a valid shelf id, try a number instead.'
3080
def __init__(self, invalid_id):
3081
BzrError.__init__(self, invalid_id=invalid_id)
3084
class JailBreak(BzrError):
3086
_fmt = "An attempt to access a url outside the server jail was made: '%(url)s'."
3088
def __init__(self, url):
3089
BzrError.__init__(self, url=url)
3092
class UserAbort(BzrError):
3094
_fmt = 'The user aborted the operation.'
3097
class MustHaveWorkingTree(BzrError):
3099
_fmt = ("Branching '%(url)s'(%(format)s) must create a working tree.")
3101
def __init__(self, format, url):
3102
BzrError.__init__(self, format=format, url=url)
3105
class NoSuchView(BzrError):
3106
"""A view does not exist.
3109
_fmt = u"No such view: %(view_name)s."
3111
def __init__(self, view_name):
3112
self.view_name = view_name
3115
class ViewsNotSupported(BzrError):
3116
"""Views are not supported by a tree format.
3119
_fmt = ("Views are not supported by %(tree)s;"
3120
" use 'bzr upgrade' to change your tree to a later format.")
3122
def __init__(self, tree):
3126
class FileOutsideView(BzrError):
3128
_fmt = ('Specified file "%(file_name)s" is outside the current view: '
3131
def __init__(self, file_name, view_files):
3132
self.file_name = file_name
3133
self.view_str = ", ".join(view_files)
3136
class UnresumableWriteGroup(BzrError):
3138
_fmt = ("Repository %(repository)s cannot resume write group "
3139
"%(write_groups)r: %(reason)s")
3141
internal_error = True
3143
def __init__(self, repository, write_groups, reason):
3144
self.repository = repository
3145
self.write_groups = write_groups
3146
self.reason = reason
3149
class UnsuspendableWriteGroup(BzrError):
3151
_fmt = ("Repository %(repository)s cannot suspend a write group.")
3153
internal_error = True
3155
def __init__(self, repository):
3156
self.repository = repository
3159
class LossyPushToSameVCS(BzrError):
3161
_fmt = ("Lossy push not possible between %(source_branch)r and "
3162
"%(target_branch)r that are in the same VCS.")
3164
internal_error = True
3166
def __init__(self, source_branch, target_branch):
3167
self.source_branch = source_branch
3168
self.target_branch = target_branch
3171
class NoRoundtrippingSupport(BzrError):
3173
_fmt = ("Roundtripping is not supported between %(source_branch)r and "
3174
"%(target_branch)r.")
3176
internal_error = True
3178
def __init__(self, source_branch, target_branch):
3179
self.source_branch = source_branch
3180
self.target_branch = target_branch
3183
class FileTimestampUnavailable(BzrError):
3185
_fmt = "The filestamp for %(path)s is not available."
3187
internal_error = True
3189
def __init__(self, path):
3193
class NoColocatedBranchSupport(BzrError):
3195
_fmt = ("%(bzrdir)r does not support co-located branches.")
3197
def __init__(self, bzrdir):
3198
self.bzrdir = bzrdir
3201
class NoWhoami(BzrError):
3203
_fmt = ('Unable to determine your name.\n'
3204
"Please, set your name with the 'whoami' command.\n"
3205
'E.g. bzr whoami "Your Name <name@example.com>"')
3208
class InvalidPattern(BzrError):
3210
_fmt = ('Invalid pattern(s) found. %(msg)s')
3212
def __init__(self, msg):
3216
class RecursiveBind(BzrError):
3218
_fmt = ('Branch "%(branch_url)s" appears to be bound to itself. '
3219
'Please use `bzr unbind` to fix.')
3221
def __init__(self, branch_url):
3222
self.branch_url = branch_url
3225
# FIXME: I would prefer to define the config related exception classes in
3226
# config.py but the lazy import mechanism proscribes this -- vila 20101222
3227
class OptionExpansionLoop(BzrError):
3229
_fmt = 'Loop involving %(refs)r while expanding "%(string)s".'
3231
def __init__(self, string, refs):
3232
self.string = string
3233
self.refs = '->'.join(refs)
3236
class ExpandingUnknownOption(BzrError):
3238
_fmt = 'Option %(name)s is not defined while expanding "%(string)s".'
3240
def __init__(self, name, string):
3242
self.string = string
3245
class NoCompatibleInter(BzrError):
3247
_fmt = ('No compatible object available for operations from %(source)r '
3250
def __init__(self, source, target):
3251
self.source = source
3252
self.target = target
3255
class HpssVfsRequestNotAllowed(BzrError):
3257
_fmt = ("VFS requests over the smart server are not allowed. Encountered: "
3258
"%(method)s, %(arguments)s.")
3260
def __init__(self, method, arguments):
3261
self.method = method
3262
self.arguments = arguments
3265
class UnsupportedKindChange(BzrError):
3267
_fmt = ("Kind change from %(from_kind)s to %(to_kind)s for "
3268
"%(path)s not supported by format %(format)r")
3270
def __init__(self, path, from_kind, to_kind, format):
3272
self.from_kind = from_kind
3273
self.to_kind = to_kind
3274
self.format = format
3277
class MissingFeature(BzrError):
3279
_fmt = ("Missing feature %(feature)s not provided by this "
3280
"version of Bazaar or any plugin.")
3282
def __init__(self, feature):
3283
self.feature = feature
3286
class PatchSyntax(BzrError):
3287
"""Base class for patch syntax errors."""
3290
class BinaryFiles(BzrError):
3292
_fmt = 'Binary files section encountered.'
3294
def __init__(self, orig_name, mod_name):
3295
self.orig_name = orig_name
3296
self.mod_name = mod_name
3299
class MalformedPatchHeader(PatchSyntax):
3301
_fmt = "Malformed patch header. %(desc)s\n%(line)r"
3303
def __init__(self, desc, line):
3308
class MalformedHunkHeader(PatchSyntax):
3310
_fmt = "Malformed hunk header. %(desc)s\n%(line)r"
3312
def __init__(self, desc, line):
3317
class MalformedLine(PatchSyntax):
3319
_fmt = "Malformed line. %(desc)s\n%(line)r"
3321
def __init__(self, desc, line):
3326
class PatchConflict(BzrError):
3328
_fmt = ('Text contents mismatch at line %(line_no)d. Original has '
3329
'"%(orig_line)s", but patch says it should be "%(patch_line)s"')
3331
def __init__(self, line_no, orig_line, patch_line):
3332
self.line_no = line_no
3333
self.orig_line = orig_line.rstrip('\n')
3334
self.patch_line = patch_line.rstrip('\n')
3337
class FeatureAlreadyRegistered(BzrError):
3339
_fmt = 'The feature %(feature)s has already been registered.'
3341
def __init__(self, feature):
3342
self.feature = feature
1044
class NotABundle(BzrNewError):
1045
"""Not a bzr revision-bundle: %(text)r"""
1047
def __init__(self, text):
1051
class BadBundle(Exception): pass
1054
class MalformedHeader(BadBundle): pass
1057
class MalformedPatches(BadBundle): pass
1060
class MalformedFooter(BadBundle): pass
added
removed
bzrlib/errors.py
