1
# Copyright (C) 2005, 2006, 2007 Canonical Ltd
2
# -*- coding: UTF-8 -*-
3
4
# This program is free software; you can redistribute it and/or modify
4
5
# it under the terms of the GNU General Public License as published by
5
6
# the Free Software Foundation; either version 2 of the License, or
6
7
# (at your option) any later version.
8
9
# This program is distributed in the hope that it will be useful,
9
10
# but WITHOUT ANY WARRANTY; without even the implied warranty of
10
11
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
11
12
# GNU General Public License for more details.
13
14
# You should have received a copy of the GNU General Public License
14
15
# along with this program; if not, write to the Free Software
15
16
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
17
"""Exceptions for bzr, and reporting of them.
25
from bzrlib.patches import (
34
# TODO: is there any value in providing the .args field used by standard
35
# python exceptions? A list of values with no names seems less useful
38
# TODO: Perhaps convert the exception to a string at the moment it's
39
# constructed to make sure it will succeed. But that says nothing about
40
# exceptions that are never raised.
42
# TODO: selftest assertRaises should probably also check that every error
43
# raised can be formatted as a string successfully, and without giving
19
__copyright__ = "Copyright (C) 2005 Canonical Ltd."
20
__author__ = "Martin Pool <mbp@canonical.com>"
23
######################################################################
47
25
class BzrError(StandardError):
49
Base class for errors raised by bzrlib.
51
:cvar internal_error: if True this was probably caused by a bzr bug and
52
should be displayed with a traceback; if False (or absent) this was
53
probably a user or environment error and they don't need the gory details.
54
(That can be overridden by -Derror on the command line.)
56
:cvar _fmt: Format string to display the error; this is expanded
57
by the instance's dict.
60
internal_error = False
62
def __init__(self, msg=None, **kwds):
63
"""Construct a new BzrError.
65
There are two alternative forms for constructing these objects.
66
Either a preformatted string may be passed, or a set of named
67
arguments can be given. The first is for generic "user" errors which
68
are not intended to be caught and so do not need a specific subclass.
69
The second case is for use with subclasses that provide a _fmt format
70
string to print the arguments.
72
Keyword arguments are taken as parameters to the error, which can
73
be inserted into the format string template. It's recommended
74
that subclasses override the __init__ method to require specific
77
:param msg: If given, this is the literal complete text for the error,
78
not subject to expansion.
80
StandardError.__init__(self)
82
# I was going to deprecate this, but it actually turns out to be
83
# quite handy - mbp 20061103.
84
self._preformatted_string = msg
86
self._preformatted_string = None
87
for key, value in kwds.items():
88
setattr(self, key, value)
91
s = getattr(self, '_preformatted_string', None)
93
# contains a preformatted message; must be cast to plain str
96
fmt = self._get_format_string()
98
s = fmt % self.__dict__
99
# __str__() should always return a 'str' object
100
# never a 'unicode' object.
101
if isinstance(s, unicode):
102
return s.encode('utf8')
104
except (AttributeError, TypeError, NameError, ValueError, KeyError), e:
105
return 'Unprintable exception %s: dict=%r, fmt=%r, error=%r' \
106
% (self.__class__.__name__,
108
getattr(self, '_fmt', None),
111
def _get_format_string(self):
112
"""Return format string for this exception or None"""
113
fmt = getattr(self, '_fmt', None)
116
fmt = getattr(self, '__doc__', None)
118
symbol_versioning.warn("%s uses its docstring as a format, "
119
"it should use _fmt instead" % self.__class__.__name__,
122
return 'Unprintable exception %s: dict=%r, fmt=%r' \
123
% (self.__class__.__name__,
125
getattr(self, '_fmt', None),
129
class BzrNewError(BzrError):
130
"""Deprecated error base class."""
131
# base classes should override the docstring with their human-
132
# readable explanation
134
def __init__(self, *args, **kwds):
135
# XXX: Use the underlying BzrError to always generate the args
136
# attribute if it doesn't exist. We can't use super here, because
137
# exceptions are old-style classes in python2.4 (but new in 2.5).
139
symbol_versioning.warn('BzrNewError was deprecated in bzr 0.13; '
140
'please convert %s to use BzrError instead'
141
% self.__class__.__name__,
144
BzrError.__init__(self, *args)
145
for key, value in kwds.items():
146
setattr(self, key, value)
150
# __str__() should always return a 'str' object
151
# never a 'unicode' object.
152
s = self.__doc__ % self.__dict__
153
if isinstance(s, unicode):
154
return s.encode('utf8')
156
except (TypeError, NameError, ValueError, KeyError), e:
157
return 'Unprintable exception %s(%r): %r' \
158
% (self.__class__.__name__,
162
class AlreadyBuilding(BzrError):
164
_fmt = "The tree builder is already building a tree."
167
28
class BzrCheckError(BzrError):
169
_fmt = "Internal check failed: %(message)s"
171
internal_error = True
173
def __init__(self, message):
174
BzrError.__init__(self)
175
self.message = message
178
class DisabledMethod(BzrError):
180
_fmt = "The smart server method '%(class_name)s' is disabled."
182
internal_error = True
184
def __init__(self, class_name):
185
BzrError.__init__(self)
186
self.class_name = class_name
189
class IncompatibleAPI(BzrError):
191
_fmt = 'The API for "%(api)s" is not compatible with "%(wanted)s". '\
192
'It supports versions "%(minimum)s" to "%(current)s".'
194
def __init__(self, api, wanted, minimum, current):
197
self.minimum = minimum
198
self.current = current
201
class InProcessTransport(BzrError):
203
_fmt = "The transport '%(transport)s' is only accessible within this " \
206
def __init__(self, transport):
207
self.transport = transport
210
class InvalidEntryName(BzrError):
212
_fmt = "Invalid entry name: %(name)s"
214
internal_error = True
216
def __init__(self, name):
217
BzrError.__init__(self)
221
32
class InvalidRevisionNumber(BzrError):
223
_fmt = "Invalid revision number %(revno)s"
225
33
def __init__(self, revno):
226
BzrError.__init__(self)
37
return 'invalid revision number: %r' % self.args[0]
230
40
class InvalidRevisionId(BzrError):
232
_fmt = "Invalid revision-id {%(revision_id)s} in %(branch)s"
234
def __init__(self, revision_id, branch):
235
# branch can be any string or object with __str__ defined
236
BzrError.__init__(self)
237
self.revision_id = revision_id
240
class ReservedId(BzrError):
242
_fmt = "Reserved revision-id {%(revision_id)s}"
244
def __init__(self, revision_id):
245
self.revision_id = revision_id
248
class NoHelpTopic(BzrError):
250
_fmt = ("No help could be found for '%(topic)s'. "
251
"Please use 'bzr help topics' to obtain a list of topics.")
253
def __init__(self, topic):
257
class NoSuchId(BzrError):
259
_fmt = 'The file id "%(file_id)s" is not present in the tree %(tree)s.'
261
def __init__(self, tree, file_id):
262
BzrError.__init__(self)
263
self.file_id = file_id
267
class NoSuchIdInRepository(NoSuchId):
269
_fmt = ('The file id "%(file_id)s" is not present in the repository'
272
def __init__(self, repository, file_id):
273
BzrError.__init__(self, repository=repository, file_id=file_id)
276
class InventoryModified(BzrError):
278
_fmt = ("The current inventory for the tree %(tree)r has been modified,"
279
" so a clean inventory cannot be read without data loss.")
281
internal_error = True
283
def __init__(self, tree):
287
class NoWorkingTree(BzrError):
289
_fmt = 'No WorkingTree exists for "%(base)s".'
291
def __init__(self, base):
292
BzrError.__init__(self)
296
class NotBuilding(BzrError):
298
_fmt = "Not currently building a tree."
301
class NotLocalUrl(BzrError):
303
_fmt = "%(url)s is not a local path."
305
def __init__(self, url):
309
class WorkingTreeAlreadyPopulated(BzrError):
311
_fmt = 'Working tree already populated in "%(base)s"'
313
internal_error = True
315
def __init__(self, base):
318
44
class BzrCommandError(BzrError):
319
"""Error from user command"""
321
internal_error = False
323
# Error from malformed user command; please avoid raising this as a
324
# generic exception not caused by user input.
326
# I think it's a waste of effort to differentiate between errors that
327
# are not intended to be caught anyway. UI code need not subclass
328
# BzrCommandError, and non-UI code should not throw a subclass of
329
# BzrCommandError. ADHB 20051211
330
def __init__(self, msg):
331
# Object.__str__() must return a real string
332
# returning a Unicode string is a python error.
333
if isinstance(msg, unicode):
334
self.msg = msg.encode('utf8')
342
class NotWriteLocked(BzrError):
344
_fmt = """%(not_locked)r is not write locked but needs to be."""
346
def __init__(self, not_locked):
347
self.not_locked = not_locked
350
class BzrOptionError(BzrCommandError):
352
_fmt = "Error in command line options"
355
class BadIndexFormatSignature(BzrError):
357
_fmt = "%(value)s is not an index of type %(_type)s."
359
def __init__(self, value, _type):
360
BzrError.__init__(self)
365
class BadIndexData(BzrError):
367
_fmt = "Error in data for index %(value)s."
369
def __init__(self, value):
370
BzrError.__init__(self)
374
class BadIndexDuplicateKey(BzrError):
376
_fmt = "The key '%(key)s' is already in index '%(index)s'."
378
def __init__(self, key, index):
379
BzrError.__init__(self)
384
class BadIndexKey(BzrError):
386
_fmt = "The key '%(key)s' is not a valid key."
388
def __init__(self, key):
389
BzrError.__init__(self)
393
class BadIndexOptions(BzrError):
395
_fmt = "Could not parse options for index %(value)s."
397
def __init__(self, value):
398
BzrError.__init__(self)
402
class BadIndexValue(BzrError):
404
_fmt = "The value '%(value)s' is not a valid value."
406
def __init__(self, value):
407
BzrError.__init__(self)
411
class BadOptionValue(BzrError):
413
_fmt = """Bad value "%(value)s" for option "%(name)s"."""
415
def __init__(self, name, value):
416
BzrError.__init__(self, name=name, value=value)
419
class StrictCommitFailed(BzrError):
421
_fmt = "Commit refused because there are unknown files in the tree"
424
# XXX: Should be unified with TransportError; they seem to represent the
426
# RBC 20060929: I think that unifiying with TransportError would be a mistake
427
# - this is finer than a TransportError - and more useful as such. It
428
# differentiates between 'transport has failed' and 'operation on a transport
430
class PathError(BzrError):
432
_fmt = "Generic path error: %(path)r%(extra)s)"
434
def __init__(self, path, extra=None):
435
BzrError.__init__(self)
438
self.extra = ': ' + str(extra)
443
class NoSuchFile(PathError):
445
_fmt = "No such file: %(path)r%(extra)s"
448
class FileExists(PathError):
450
_fmt = "File exists: %(path)r%(extra)s"
453
class RenameFailedFilesExist(BzrError):
454
"""Used when renaming and both source and dest exist."""
456
_fmt = ("Could not rename %(source)s => %(dest)s because both files exist."
459
def __init__(self, source, dest, extra=None):
460
BzrError.__init__(self)
461
self.source = str(source)
462
self.dest = str(dest)
464
self.extra = ' ' + str(extra)
469
class NotADirectory(PathError):
471
_fmt = '"%(path)s" is not a directory %(extra)s'
474
class NotInWorkingDirectory(PathError):
476
_fmt = '"%(path)s" is not in the working directory %(extra)s'
479
class DirectoryNotEmpty(PathError):
481
_fmt = 'Directory not empty: "%(path)s"%(extra)s'
484
class ReadingCompleted(BzrError):
486
_fmt = ("The MediumRequest '%(request)s' has already had finish_reading "
487
"called upon it - the request has been completed and no more "
490
internal_error = True
492
def __init__(self, request):
493
self.request = request
496
class ResourceBusy(PathError):
498
_fmt = 'Device or resource busy: "%(path)s"%(extra)s'
501
class PermissionDenied(PathError):
503
_fmt = 'Permission denied: "%(path)s"%(extra)s'
506
class InvalidURL(PathError):
508
_fmt = 'Invalid url supplied to transport: "%(path)s"%(extra)s'
511
class InvalidURLJoin(PathError):
513
_fmt = 'Invalid URL join request: "%(args)s"%(extra)s'
515
def __init__(self, msg, base, args):
516
PathError.__init__(self, base, msg)
517
self.args = [base] + list(args)
520
class UnknownHook(BzrError):
522
_fmt = "The %(type)s hook '%(hook)s' is unknown in this version of bzrlib."
524
def __init__(self, hook_type, hook_name):
525
BzrError.__init__(self)
526
self.type = hook_type
527
self.hook = hook_name
530
class UnsupportedProtocol(PathError):
532
_fmt = 'Unsupported protocol for url "%(path)s"%(extra)s'
534
def __init__(self, url, extra):
535
PathError.__init__(self, url, extra=extra)
538
class ReadError(PathError):
540
_fmt = """Error reading from %(path)r."""
543
class ShortReadvError(PathError):
545
_fmt = ('readv() read %(actual)s bytes rather than %(length)s bytes'
546
' at %(offset)s for "%(path)s"%(extra)s')
548
internal_error = True
550
def __init__(self, path, offset, length, actual, extra=None):
551
PathError.__init__(self, path, extra=extra)
557
class PathNotChild(PathError):
559
_fmt = 'Path "%(path)s" is not a child of path "%(base)s"%(extra)s'
561
internal_error = True
563
def __init__(self, path, base, extra=None):
564
BzrError.__init__(self)
568
self.extra = ': ' + str(extra)
573
class InvalidNormalization(PathError):
575
_fmt = 'Path "%(path)s" is not unicode normalized'
578
# TODO: This is given a URL; we try to unescape it but doing that from inside
579
# the exception object is a bit undesirable.
580
# TODO: Probably this behavior of should be a common superclass
581
class NotBranchError(PathError):
583
_fmt = 'Not a branch: "%(path)s".'
585
def __init__(self, path):
586
import bzrlib.urlutils as urlutils
587
self.path = urlutils.unescape_for_display(path, 'ascii')
590
class NoSubmitBranch(PathError):
592
_fmt = 'No submit branch available for branch "%(path)s"'
594
def __init__(self, branch):
595
import bzrlib.urlutils as urlutils
596
self.path = urlutils.unescape_for_display(branch.base, 'ascii')
599
class AlreadyBranchError(PathError):
601
_fmt = 'Already a branch: "%(path)s".'
604
class BranchExistsWithoutWorkingTree(PathError):
606
_fmt = 'Directory contains a branch, but no working tree \
607
(use bzr checkout if you wish to build a working tree): "%(path)s"'
610
class AtomicFileAlreadyClosed(PathError):
612
_fmt = ('"%(function)s" called on an AtomicFile after it was closed:'
615
def __init__(self, path, function):
616
PathError.__init__(self, path=path, extra=None)
617
self.function = function
620
class InaccessibleParent(PathError):
622
_fmt = ('Parent not accessible given base "%(base)s" and'
623
' relative path "%(path)s"')
625
def __init__(self, path, base):
626
PathError.__init__(self, path)
630
class NoRepositoryPresent(BzrError):
632
_fmt = 'No repository present: "%(path)s"'
633
def __init__(self, bzrdir):
634
BzrError.__init__(self)
635
self.path = bzrdir.transport.clone('..').base
638
class FileInWrongBranch(BzrError):
640
_fmt = 'File "%(path)s" in not in branch %(branch_base)s.'
642
def __init__(self, branch, path):
643
BzrError.__init__(self)
645
self.branch_base = branch.base
649
class UnsupportedFormatError(BzrError):
651
_fmt = "Unsupported branch format: %(format)s\nPlease run 'bzr upgrade'"
654
class UnknownFormatError(BzrError):
656
_fmt = "Unknown branch format: %(format)r"
659
class IncompatibleFormat(BzrError):
661
_fmt = "Format %(format)s is not compatible with .bzr version %(bzrdir)s."
663
def __init__(self, format, bzrdir_format):
664
BzrError.__init__(self)
666
self.bzrdir = bzrdir_format
669
class IncompatibleRepositories(BzrError):
671
_fmt = "Repository %(target)s is not compatible with repository"\
674
def __init__(self, source, target):
675
BzrError.__init__(self, target=target, source=source)
678
class IncompatibleRevision(BzrError):
680
_fmt = "Revision is not compatible with %(repo_format)s"
682
def __init__(self, repo_format):
683
BzrError.__init__(self)
684
self.repo_format = repo_format
687
class AlreadyVersionedError(BzrError):
688
"""Used when a path is expected not to be versioned, but it is."""
690
_fmt = "%(context_info)s%(path)s is already versioned."
692
def __init__(self, path, context_info=None):
693
"""Construct a new AlreadyVersionedError.
695
:param path: This is the path which is versioned,
696
which should be in a user friendly form.
697
:param context_info: If given, this is information about the context,
698
which could explain why this is expected to not be versioned.
700
BzrError.__init__(self)
702
if context_info is None:
703
self.context_info = ''
705
self.context_info = context_info + ". "
45
# Error from malformed user command
49
class NotBranchError(BzrError):
50
"""Specified path is not in a branch"""
708
54
class NotVersionedError(BzrError):
709
"""Used when a path is expected to be versioned, but it is not."""
711
_fmt = "%(context_info)s%(path)s is not versioned."
713
def __init__(self, path, context_info=None):
714
"""Construct a new NotVersionedError.
716
:param path: This is the path which is not versioned,
717
which should be in a user friendly form.
718
:param context_info: If given, this is information about the context,
719
which could explain why this is expected to be versioned.
721
BzrError.__init__(self)
723
if context_info is None:
724
self.context_info = ''
726
self.context_info = context_info + ". "
729
class PathsNotVersionedError(BzrError):
730
"""Used when reporting several paths which are not versioned"""
732
_fmt = "Path(s) are not versioned: %(paths_as_string)s"
734
def __init__(self, paths):
735
from bzrlib.osutils import quotefn
736
BzrError.__init__(self)
738
self.paths_as_string = ' '.join([quotefn(p) for p in paths])
741
class PathsDoNotExist(BzrError):
743
_fmt = "Path(s) do not exist: %(paths_as_string)s%(extra)s"
745
# used when reporting that paths are neither versioned nor in the working
748
def __init__(self, paths, extra=None):
750
from bzrlib.osutils import quotefn
751
BzrError.__init__(self)
753
self.paths_as_string = ' '.join([quotefn(p) for p in paths])
755
self.extra = ': ' + str(extra)
55
"""Specified object is not versioned."""
760
58
class BadFileKindError(BzrError):
762
_fmt = 'Cannot operate on "%(filename)s" of unsupported kind "%(kind)s"'
764
def __init__(self, filename, kind):
765
BzrError.__init__(self, filename=filename, kind=kind)
768
class ForbiddenControlFileError(BzrError):
770
_fmt = 'Cannot operate on "%(filename)s" because it is a control file'
773
class LockError(BzrError):
775
_fmt = "Lock error: %(msg)s"
777
internal_error = True
779
# All exceptions from the lock/unlock functions should be from
780
# this exception class. They will be translated as necessary. The
781
# original exception is available as e.original_error
783
# New code should prefer to raise specific subclasses
784
def __init__(self, message):
785
# Python 2.5 uses a slot for StandardError.message,
786
# so use a different variable name
787
# so it is exposed in self.__dict__
791
class LockActive(LockError):
793
_fmt = "The lock for '%(lock_description)s' is in use and cannot be broken."
795
internal_error = False
797
def __init__(self, lock_description):
798
self.lock_description = lock_description
801
class CommitNotPossible(LockError):
803
_fmt = "A commit was attempted but we do not have a write lock open."
809
class AlreadyCommitted(LockError):
811
_fmt = "A rollback was requested, but is not able to be accomplished."
817
class ReadOnlyError(LockError):
819
_fmt = "A write attempt was made in a read only transaction on %(obj)s"
821
# TODO: There should also be an error indicating that you need a write
822
# lock and don't have any lock at all... mbp 20070226
824
def __init__(self, obj):
828
class ReadOnlyLockError(LockError):
830
_fmt = "Cannot acquire write lock on %(fname)s. %(msg)s"
832
def __init__(self, fname, msg):
833
LockError.__init__(self, '')
838
class OutSideTransaction(BzrError):
840
_fmt = ("A transaction related operation was attempted after"
841
" the transaction finished.")
844
class ObjectNotLocked(LockError):
846
_fmt = "%(obj)r is not locked"
848
# this can indicate that any particular object is not locked; see also
849
# LockNotHeld which means that a particular *lock* object is not held by
850
# the caller -- perhaps they should be unified.
851
def __init__(self, obj):
855
class ReadOnlyObjectDirtiedError(ReadOnlyError):
857
_fmt = "Cannot change object %(obj)r in read only transaction"
859
def __init__(self, obj):
863
class UnlockableTransport(LockError):
865
_fmt = "Cannot lock: transport is read only: %(transport)s"
867
def __init__(self, transport):
868
self.transport = transport
871
class LockContention(LockError):
873
_fmt = 'Could not acquire lock "%(lock)s"'
874
# TODO: show full url for lock, combining the transport and relative
877
internal_error = False
879
def __init__(self, lock):
883
class LockBroken(LockError):
885
_fmt = ("Lock was broken while still open: %(lock)s"
886
" - check storage consistency!")
888
internal_error = False
890
def __init__(self, lock):
894
class LockBreakMismatch(LockError):
896
_fmt = ("Lock was released and re-acquired before being broken:"
897
" %(lock)s: held by %(holder)r, wanted to break %(target)r")
899
internal_error = False
901
def __init__(self, lock, holder, target):
907
class LockNotHeld(LockError):
909
_fmt = "Lock not held: %(lock)s"
911
internal_error = False
913
def __init__(self, lock):
917
class TokenLockingNotSupported(LockError):
919
_fmt = "The object %(obj)s does not support token specifying a token when locking."
921
internal_error = True
923
def __init__(self, obj):
927
class TokenMismatch(LockBroken):
929
_fmt = "The lock token %(given_token)r does not match lock token %(lock_token)r."
931
internal_error = True
933
def __init__(self, given_token, lock_token):
934
self.given_token = given_token
935
self.lock_token = lock_token
938
class PointlessCommit(BzrError):
940
_fmt = "No changes to commit"
943
class CannotCommitSelectedFileMerge(BzrError):
945
_fmt = 'Selected-file commit of merges is not supported yet:'\
946
' files %(files_str)s'
948
def __init__(self, files):
949
files_str = ', '.join(files)
950
BzrError.__init__(self, files=files, files_str=files_str)
953
class BadCommitMessageEncoding(BzrError):
955
_fmt = 'The specified commit message contains characters unsupported by '\
956
'the current encoding.'
959
class UpgradeReadonly(BzrError):
961
_fmt = "Upgrade URL cannot work with readonly URLs."
964
class UpToDateFormat(BzrError):
966
_fmt = "The branch format %(format)s is already at the most recent format."
968
def __init__(self, format):
969
BzrError.__init__(self)
973
class StrictCommitFailed(Exception):
975
_fmt = "Commit refused because there are unknowns in the tree."
59
"""Specified file is of a kind that cannot be added.
61
(For example a symlink or device file.)"""
65
class ForbiddenFileError(BzrError):
66
"""Cannot operate on a file because it is a control file."""
70
class LockError(Exception):
71
"""All exceptions from the lock/unlock functions should be from
72
this exception class. They will be translated as necessary. The
73
original exception is available as e.original_error
75
def __init__(self, e=None):
76
self.original_error = e
78
Exception.__init__(self, e)
80
Exception.__init__(self)
83
class PointlessCommit(Exception):
84
"""Commit failed because nothing was changed."""
978
87
class NoSuchRevision(BzrError):
980
_fmt = "%(branch)s has no revision %(revision)s"
982
internal_error = True
984
88
def __init__(self, branch, revision):
985
# 'branch' may sometimes be an internal object like a KnitRevisionStore
986
BzrError.__init__(self, branch=branch, revision=revision)
989
# zero_ninetyone: this exception is no longer raised and should be removed
990
class NotLeftParentDescendant(BzrError):
992
_fmt = ("Revision %(old_revision)s is not the left parent of"
993
" %(new_revision)s, but branch %(branch_location)s expects this")
995
internal_error = True
997
def __init__(self, branch, old_revision, new_revision):
998
BzrError.__init__(self, branch_location=branch.base,
999
old_revision=old_revision,
1000
new_revision=new_revision)
1003
class RangeInChangeOption(BzrError):
1005
_fmt = "Option --change does not accept revision ranges"
1008
class NoSuchRevisionSpec(BzrError):
1010
_fmt = "No namespace registered for string: %(spec)r"
1012
def __init__(self, spec):
1013
BzrError.__init__(self, spec=spec)
1016
class NoSuchRevisionInTree(NoSuchRevision):
1017
"""When using Tree.revision_tree, and the revision is not accessible."""
1019
_fmt = "The revision id {%(revision_id)s} is not present in the tree %(tree)s."
1021
def __init__(self, tree, revision_id):
1022
BzrError.__init__(self)
1024
self.revision_id = revision_id
1027
class InvalidRevisionSpec(BzrError):
1029
_fmt = ("Requested revision: %(spec)r does not exist in branch:"
1030
" %(branch)s%(extra)s")
1032
def __init__(self, spec, branch, extra=None):
1033
BzrError.__init__(self, branch=branch, spec=spec)
1035
self.extra = '\n' + str(extra)
1040
class HistoryMissing(BzrError):
1042
_fmt = "%(branch)s is missing %(object_type)s {%(object_id)s}"
1045
class AppendRevisionsOnlyViolation(BzrError):
1047
_fmt = ('Operation denied because it would change the main history,'
1048
' which is not permitted by the append_revisions_only setting on'
1049
' branch "%(location)s".')
1051
def __init__(self, location):
1052
import bzrlib.urlutils as urlutils
1053
location = urlutils.unescape_for_display(location, 'ascii')
1054
BzrError.__init__(self, location=location)
90
self.revision = revision
91
msg = "Branch %s has no revision %s" % (branch, revision)
92
BzrError.__init__(self, msg)
1057
95
class DivergedBranches(BzrError):
1059
_fmt = ("These branches have diverged."
1060
" Use the merge command to reconcile them.")
1062
internal_error = False
1064
96
def __init__(self, branch1, branch2):
1065
97
self.branch1 = branch1
1066
98
self.branch2 = branch2
1069
class NotLefthandHistory(BzrError):
1071
_fmt = "Supplied history does not follow left-hand parents"
1073
internal_error = True
1075
def __init__(self, history):
1076
BzrError.__init__(self, history=history)
1079
class UnrelatedBranches(BzrError):
1081
_fmt = ("Branches have no common ancestor, and"
1082
" no merge base revision was specified.")
1084
internal_error = False
1087
class NoCommonAncestor(BzrError):
1089
_fmt = "Revisions have no common ancestor: %(revision_a)s %(revision_b)s"
1091
def __init__(self, revision_a, revision_b):
1092
self.revision_a = revision_a
1093
self.revision_b = revision_b
1096
class NoCommonRoot(BzrError):
1098
_fmt = ("Revisions are not derived from the same root: "
1099
"%(revision_a)s %(revision_b)s.")
1101
def __init__(self, revision_a, revision_b):
1102
BzrError.__init__(self, revision_a=revision_a, revision_b=revision_b)
99
BzrError.__init__(self, "These branches have diverged.")
101
class UnrelatedBranches(BzrCommandError):
103
msg = "Branches have no common ancestor, and no base revision"\
105
BzrCommandError.__init__(self, msg)
1105
108
class NotAncestor(BzrError):
1107
_fmt = "Revision %(rev_id)s is not an ancestor of %(not_ancestor_id)s"
1109
109
def __init__(self, rev_id, not_ancestor_id):
1110
BzrError.__init__(self, rev_id=rev_id,
1111
not_ancestor_id=not_ancestor_id)
111
self.not_ancestor_id = not_ancestor_id
112
msg = "Revision %s is not an ancestor of %s" % (not_ancestor_id,
114
BzrError.__init__(self, msg)
1114
117
class InstallFailed(BzrError):
1116
118
def __init__(self, revisions):
1117
revision_str = ", ".join(str(r) for r in revisions)
1118
msg = "Could not install revisions:\n%s" % revision_str
1119
BzrError.__init__(self, msg)
1120
119
self.revisions = revisions
120
msg = "Could not install revisions:\n%s" % " ,".join(revisions)
121
BzrError.__init__(self, msg)
1123
124
class AmbiguousBase(BzrError):
1125
125
def __init__(self, bases):
1126
warn("BzrError AmbiguousBase has been deprecated as of bzrlib 0.8.",
1128
msg = ("The correct base is unclear, because %s are all equally close"
126
msg = "The correct base is unclear, becase %s are all equally close" %\
1130
128
BzrError.__init__(self, msg)
1131
129
self.bases = bases
1134
class NoCommits(BzrError):
1136
_fmt = "Branch %(branch)s has no commits."
1138
def __init__(self, branch):
1139
BzrError.__init__(self, branch=branch)
1142
class UnlistableStore(BzrError):
1144
def __init__(self, store):
1145
BzrError.__init__(self, "Store %s is not listable" % store)
1149
class UnlistableBranch(BzrError):
1151
def __init__(self, br):
1152
BzrError.__init__(self, "Stores for branch %s are not listable" % br)
1155
class BoundBranchOutOfDate(BzrError):
1157
_fmt = ("Bound branch %(branch)s is out of date with master branch"
1160
def __init__(self, branch, master):
1161
BzrError.__init__(self)
1162
self.branch = branch
1163
self.master = master
1166
class CommitToDoubleBoundBranch(BzrError):
1168
_fmt = ("Cannot commit to branch %(branch)s."
1169
" It is bound to %(master)s, which is bound to %(remote)s.")
1171
def __init__(self, branch, master, remote):
1172
BzrError.__init__(self)
1173
self.branch = branch
1174
self.master = master
1175
self.remote = remote
1178
class OverwriteBoundBranch(BzrError):
1180
_fmt = "Cannot pull --overwrite to a branch which is bound %(branch)s"
1182
def __init__(self, branch):
1183
BzrError.__init__(self)
1184
self.branch = branch
1187
class BoundBranchConnectionFailure(BzrError):
1189
_fmt = ("Unable to connect to target of bound branch %(branch)s"
1190
" => %(target)s: %(error)s")
1192
def __init__(self, branch, target, error):
1193
BzrError.__init__(self)
1194
self.branch = branch
1195
self.target = target
1199
class WeaveError(BzrError):
1201
_fmt = "Error in processing weave: %(message)s"
1203
def __init__(self, message=None):
1204
BzrError.__init__(self)
1205
self.message = message
1208
class WeaveRevisionAlreadyPresent(WeaveError):
1210
_fmt = "Revision {%(revision_id)s} already present in %(weave)s"
1212
def __init__(self, revision_id, weave):
1214
WeaveError.__init__(self)
1215
self.revision_id = revision_id
1219
class WeaveRevisionNotPresent(WeaveError):
1221
_fmt = "Revision {%(revision_id)s} not present in %(weave)s"
1223
def __init__(self, revision_id, weave):
1224
WeaveError.__init__(self)
1225
self.revision_id = revision_id
1229
class WeaveFormatError(WeaveError):
1231
_fmt = "Weave invariant violated: %(what)s"
1233
def __init__(self, what):
1234
WeaveError.__init__(self)
1238
class WeaveParentMismatch(WeaveError):
1240
_fmt = "Parents are mismatched between two revisions."
1243
class WeaveInvalidChecksum(WeaveError):
1245
_fmt = "Text did not match it's checksum: %(message)s"
1248
class WeaveTextDiffers(WeaveError):
1250
_fmt = ("Weaves differ on text content. Revision:"
1251
" {%(revision_id)s}, %(weave_a)s, %(weave_b)s")
1253
def __init__(self, revision_id, weave_a, weave_b):
1254
WeaveError.__init__(self)
1255
self.revision_id = revision_id
1256
self.weave_a = weave_a
1257
self.weave_b = weave_b
1260
class WeaveTextDiffers(WeaveError):
1262
_fmt = ("Weaves differ on text content. Revision:"
1263
" {%(revision_id)s}, %(weave_a)s, %(weave_b)s")
1265
def __init__(self, revision_id, weave_a, weave_b):
1266
WeaveError.__init__(self)
1267
self.revision_id = revision_id
1268
self.weave_a = weave_a
1269
self.weave_b = weave_b
1272
class VersionedFileError(BzrError):
1274
_fmt = "Versioned file error"
1277
class RevisionNotPresent(VersionedFileError):
1279
_fmt = 'Revision {%(revision_id)s} not present in "%(file_id)s".'
1281
def __init__(self, revision_id, file_id):
1282
VersionedFileError.__init__(self)
1283
self.revision_id = revision_id
1284
self.file_id = file_id
1287
class RevisionAlreadyPresent(VersionedFileError):
1289
_fmt = 'Revision {%(revision_id)s} already present in "%(file_id)s".'
1291
def __init__(self, revision_id, file_id):
1292
VersionedFileError.__init__(self)
1293
self.revision_id = revision_id
1294
self.file_id = file_id
1297
class VersionedFileInvalidChecksum(VersionedFileError):
1299
_fmt = "Text did not match its checksum: %(message)s"
1302
class KnitError(BzrError):
1306
internal_error = True
1309
class KnitCorrupt(KnitError):
1311
_fmt = "Knit %(filename)s corrupt: %(how)s"
1313
def __init__(self, filename, how):
1314
KnitError.__init__(self)
1315
self.filename = filename
1319
class KnitDataStreamIncompatible(KnitError):
1321
_fmt = "Cannot insert knit data stream of format \"%(stream_format)s\" into knit of format \"%(target_format)s\"."
1323
def __init__(self, stream_format, target_format):
1324
self.stream_format = stream_format
1325
self.target_format = target_format
1328
class KnitHeaderError(KnitError):
1330
_fmt = 'Knit header error: %(badline)r unexpected for file "%(filename)s".'
1332
def __init__(self, badline, filename):
1333
KnitError.__init__(self)
1334
self.badline = badline
1335
self.filename = filename
1338
class KnitIndexUnknownMethod(KnitError):
1339
"""Raised when we don't understand the storage method.
1341
Currently only 'fulltext' and 'line-delta' are supported.
1344
_fmt = ("Knit index %(filename)s does not have a known method"
1345
" in options: %(options)r")
1347
def __init__(self, filename, options):
1348
KnitError.__init__(self)
1349
self.filename = filename
1350
self.options = options
1353
class NoSuchExportFormat(BzrError):
1355
_fmt = "Export format %(format)r not supported"
1357
def __init__(self, format):
1358
BzrError.__init__(self)
1359
self.format = format
1362
class TransportError(BzrError):
1364
_fmt = "Transport error: %(msg)s %(orig_error)s"
1366
def __init__(self, msg=None, orig_error=None):
1367
if msg is None and orig_error is not None:
1368
msg = str(orig_error)
1369
if orig_error is None:
1374
self.orig_error = orig_error
1375
BzrError.__init__(self)
1378
class TooManyConcurrentRequests(BzrError):
1380
_fmt = ("The medium '%(medium)s' has reached its concurrent request limit."
1381
" Be sure to finish_writing and finish_reading on the"
1382
" currently open request.")
1384
internal_error = True
1386
def __init__(self, medium):
1387
self.medium = medium
1390
class SmartProtocolError(TransportError):
1392
_fmt = "Generic bzr smart protocol error: %(details)s"
1394
def __init__(self, details):
1395
self.details = details
1398
# A set of semi-meaningful errors which can be thrown
1399
class TransportNotPossible(TransportError):
1401
_fmt = "Transport operation not possible: %(msg)s %(orig_error)s"
1404
class ConnectionError(TransportError):
1406
_fmt = "Connection error: %(msg)s %(orig_error)s"
1409
class SocketConnectionError(ConnectionError):
1411
_fmt = "%(msg)s %(host)s%(port)s%(orig_error)s"
1413
def __init__(self, host, port=None, msg=None, orig_error=None):
1415
msg = 'Failed to connect to'
1416
if orig_error is None:
1419
orig_error = '; ' + str(orig_error)
1420
ConnectionError.__init__(self, msg=msg, orig_error=orig_error)
1425
self.port = ':%s' % port
1428
class ConnectionReset(TransportError):
1430
_fmt = "Connection closed: %(msg)s %(orig_error)s"
1433
class InvalidRange(TransportError):
1435
_fmt = "Invalid range access in %(path)s at %(offset)s."
1437
def __init__(self, path, offset):
1438
TransportError.__init__(self, ("Invalid range access in %s at %d"
1441
self.offset = offset
1444
class InvalidHttpResponse(TransportError):
1446
_fmt = "Invalid http response for %(path)s: %(msg)s"
1448
def __init__(self, path, msg, orig_error=None):
1450
TransportError.__init__(self, msg, orig_error=orig_error)
1453
class InvalidHttpRange(InvalidHttpResponse):
1455
_fmt = "Invalid http range %(range)r for %(path)s: %(msg)s"
1457
def __init__(self, path, range, msg):
1459
InvalidHttpResponse.__init__(self, path, msg)
1462
class InvalidHttpContentType(InvalidHttpResponse):
1464
_fmt = 'Invalid http Content-type "%(ctype)s" for %(path)s: %(msg)s'
1466
def __init__(self, path, ctype, msg):
1468
InvalidHttpResponse.__init__(self, path, msg)
1471
class RedirectRequested(TransportError):
1473
_fmt = '%(source)s is%(permanently)s redirected to %(target)s'
1475
def __init__(self, source, target, is_permament=False, qual_proto=None):
1476
self.source = source
1477
self.target = target
1479
self.permanently = ' permanently'
1481
self.permanently = ''
1482
self.is_permament = is_permament
1483
self._qualified_proto = qual_proto
1484
TransportError.__init__(self)
1486
def _requalify_url(self, url):
1487
"""Restore the qualified proto in front of the url"""
1488
# When this exception is raised, source and target are in
1489
# user readable format. But some transports may use a
1490
# different proto (http+urllib:// will present http:// to
1491
# the user. If a qualified proto is specified, the code
1492
# trapping the exception can get the qualified urls to
1493
# properly handle the redirection themself (creating a
1494
# new transport object from the target url for example).
1495
# But checking that the scheme of the original and
1496
# redirected urls are the same can be tricky. (see the
1497
# FIXME in BzrDir.open_from_transport for the unique use
1499
if self._qualified_proto is None:
1502
# The TODO related to NotBranchError mention that doing
1503
# that kind of manipulation on the urls may not be the
1504
# exception object job. On the other hand, this object is
1505
# the interface between the code and the user so
1506
# presenting the urls in different ways is indeed its
1509
proto, netloc, path, query, fragment = urlparse.urlsplit(url)
1510
return urlparse.urlunsplit((self._qualified_proto, netloc, path,
1513
def get_source_url(self):
1514
return self._requalify_url(self.source)
1516
def get_target_url(self):
1517
return self._requalify_url(self.target)
1520
class TooManyRedirections(TransportError):
1522
_fmt = "Too many redirections"
1524
class ConflictsInTree(BzrError):
1526
_fmt = "Working tree has conflicts."
1529
class ParseConfigError(BzrError):
1531
def __init__(self, errors, filename):
1532
if filename is None:
1534
message = "Error(s) parsing config file %s:\n%s" % \
1535
(filename, ('\n'.join(e.message for e in errors)))
1536
BzrError.__init__(self, message)
1539
class NoEmailInUsername(BzrError):
1541
_fmt = "%(username)r does not seem to contain a reasonable email address"
1543
def __init__(self, username):
1544
BzrError.__init__(self)
1545
self.username = username
1548
class SigningFailed(BzrError):
1550
_fmt = 'Failed to gpg sign data with command "%(command_line)s"'
1552
def __init__(self, command_line):
1553
BzrError.__init__(self, command_line=command_line)
1556
class WorkingTreeNotRevision(BzrError):
1558
_fmt = ("The working tree for %(basedir)s has changed since"
1559
" the last commit, but weave merge requires that it be"
1562
def __init__(self, tree):
1563
BzrError.__init__(self, basedir=tree.basedir)
1566
class CantReprocessAndShowBase(BzrError):
1568
_fmt = ("Can't reprocess and show base, because reprocessing obscures "
1569
"the relationship of conflicting lines to the base")
1572
class GraphCycleError(BzrError):
1574
_fmt = "Cycle in graph %(graph)r"
1576
def __init__(self, graph):
1577
BzrError.__init__(self)
1581
class WritingCompleted(BzrError):
1583
_fmt = ("The MediumRequest '%(request)s' has already had finish_writing "
1584
"called upon it - accept bytes may not be called anymore.")
1586
internal_error = True
1588
def __init__(self, request):
1589
self.request = request
1592
class WritingNotComplete(BzrError):
1594
_fmt = ("The MediumRequest '%(request)s' has not has finish_writing "
1595
"called upon it - until the write phase is complete no "
1596
"data may be read.")
1598
internal_error = True
1600
def __init__(self, request):
1601
self.request = request
1604
class NotConflicted(BzrError):
1606
_fmt = "File %(filename)s is not conflicted."
1608
def __init__(self, filename):
1609
BzrError.__init__(self)
1610
self.filename = filename
1613
class MediumNotConnected(BzrError):
1615
_fmt = """The medium '%(medium)s' is not connected."""
1617
internal_error = True
1619
def __init__(self, medium):
1620
self.medium = medium
1623
class MustUseDecorated(Exception):
1625
_fmt = "A decorating function has requested its original command be used."
1628
class NoBundleFound(BzrError):
1630
_fmt = 'No bundle was found in "%(filename)s".'
1632
def __init__(self, filename):
1633
BzrError.__init__(self)
1634
self.filename = filename
1637
class BundleNotSupported(BzrError):
1639
_fmt = "Unable to handle bundle version %(version)s: %(msg)s"
1641
def __init__(self, version, msg):
1642
BzrError.__init__(self)
1643
self.version = version
1647
class MissingText(BzrError):
1649
_fmt = ("Branch %(base)s is missing revision"
1650
" %(text_revision)s of %(file_id)s")
1652
def __init__(self, branch, text_revision, file_id):
1653
BzrError.__init__(self)
1654
self.branch = branch
1655
self.base = branch.base
1656
self.text_revision = text_revision
1657
self.file_id = file_id
1660
class DuplicateFileId(BzrError):
1662
_fmt = "File id {%(file_id)s} already exists in inventory as %(entry)s"
1664
def __init__(self, file_id, entry):
1665
BzrError.__init__(self)
1666
self.file_id = file_id
1670
class DuplicateKey(BzrError):
1672
_fmt = "Key %(key)s is already present in map"
1675
class DuplicateHelpPrefix(BzrError):
1677
_fmt = "The prefix %(prefix)s is in the help search path twice."
1679
def __init__(self, prefix):
1680
self.prefix = prefix
1683
class MalformedTransform(BzrError):
1685
_fmt = "Tree transform is malformed %(conflicts)r"
1688
class NoFinalPath(BzrError):
1690
_fmt = ("No final name for trans_id %(trans_id)r\n"
1691
"file-id: %(file_id)r\n"
1692
"root trans-id: %(root_trans_id)r\n")
1694
def __init__(self, trans_id, transform):
1695
self.trans_id = trans_id
1696
self.file_id = transform.final_file_id(trans_id)
1697
self.root_trans_id = transform.root
1700
class BzrBadParameter(BzrError):
1702
_fmt = "Bad parameter: %(param)r"
1704
internal_error = True
1706
# This exception should never be thrown, but it is a base class for all
1707
# parameter-to-function errors.
1709
def __init__(self, param):
1710
BzrError.__init__(self)
1714
class BzrBadParameterNotUnicode(BzrBadParameter):
1716
_fmt = "Parameter %(param)s is neither unicode nor utf8."
1719
class ReusingTransform(BzrError):
1721
_fmt = "Attempt to reuse a transform that has already been applied."
1724
class CantMoveRoot(BzrError):
1726
_fmt = "Moving the root directory is not supported at this time"
1729
class BzrMoveFailedError(BzrError):
1731
_fmt = "Could not move %(from_path)s%(operator)s %(to_path)s%(extra)s"
1733
def __init__(self, from_path='', to_path='', extra=None):
1734
BzrError.__init__(self)
1736
self.extra = ': ' + str(extra)
1740
has_from = len(from_path) > 0
1741
has_to = len(to_path) > 0
1743
self.from_path = osutils.splitpath(from_path)[-1]
1748
self.to_path = osutils.splitpath(to_path)[-1]
1753
if has_from and has_to:
1754
self.operator = " =>"
1756
self.from_path = "from " + from_path
1758
self.operator = "to"
1760
self.operator = "file"
1763
class BzrRenameFailedError(BzrMoveFailedError):
1765
_fmt = "Could not rename %(from_path)s%(operator)s %(to_path)s%(extra)s"
1767
def __init__(self, from_path, to_path, extra=None):
1768
BzrMoveFailedError.__init__(self, from_path, to_path, extra)
1770
class BzrRemoveChangedFilesError(BzrError):
1771
"""Used when user is trying to remove changed files."""
1773
_fmt = ("Can't remove changed or unknown files:\n%(changes_as_text)s"
1774
"Use --keep to not delete them, or --force to delete them regardless.")
1776
def __init__(self, tree_delta):
1777
BzrError.__init__(self)
1778
self.changes_as_text = tree_delta.get_changes_as_text()
1779
#self.paths_as_string = '\n'.join(changed_files)
1780
#self.paths_as_string = '\n'.join([quotefn(p) for p in changed_files])
1783
class BzrBadParameterNotString(BzrBadParameter):
1785
_fmt = "Parameter %(param)s is not a string or unicode string."
1788
class BzrBadParameterMissing(BzrBadParameter):
1790
_fmt = "Parameter $(param)s is required but not present."
1793
class BzrBadParameterUnicode(BzrBadParameter):
1795
_fmt = ("Parameter %(param)s is unicode but"
1796
" only byte-strings are permitted.")
1799
class BzrBadParameterContainsNewline(BzrBadParameter):
1801
_fmt = "Parameter %(param)s contains a newline."
1804
class DependencyNotPresent(BzrError):
1806
_fmt = 'Unable to import library "%(library)s": %(error)s'
1808
def __init__(self, library, error):
1809
BzrError.__init__(self, library=library, error=error)
1812
class ParamikoNotPresent(DependencyNotPresent):
1814
_fmt = "Unable to import paramiko (required for sftp support): %(error)s"
1816
def __init__(self, error):
1817
DependencyNotPresent.__init__(self, 'paramiko', error)
1820
class PointlessMerge(BzrError):
1822
_fmt = "Nothing to merge."
1825
class UninitializableFormat(BzrError):
1827
_fmt = "Format %(format)s cannot be initialised by this version of bzr."
1829
def __init__(self, format):
1830
BzrError.__init__(self)
1831
self.format = format
1834
class BadConversionTarget(BzrError):
1836
_fmt = "Cannot convert to format %(format)s. %(problem)s"
1838
def __init__(self, problem, format):
1839
BzrError.__init__(self)
1840
self.problem = problem
1841
self.format = format
1844
class NoDiff(BzrError):
1846
_fmt = "Diff is not installed on this machine: %(msg)s"
1848
def __init__(self, msg):
1849
BzrError.__init__(self, msg=msg)
1852
class NoDiff3(BzrError):
1854
_fmt = "Diff3 is not installed on this machine."
1857
class ExistingLimbo(BzrError):
1859
_fmt = """This tree contains left-over files from a failed operation.
1860
Please examine %(limbo_dir)s to see if it contains any files you wish to
1861
keep, and delete it when you are done."""
1863
def __init__(self, limbo_dir):
1864
BzrError.__init__(self)
1865
self.limbo_dir = limbo_dir
1868
class ExistingPendingDeletion(BzrError):
1870
_fmt = """This tree contains left-over files from a failed operation.
1871
Please examine %(pending_deletion)s to see if it contains any files you
1872
wish to keep, and delete it when you are done."""
1874
def __init__(self, pending_deletion):
1875
BzrError.__init__(self, pending_deletion=pending_deletion)
1878
class ImmortalLimbo(BzrError):
1880
_fmt = """Unable to delete transform temporary directory $(limbo_dir)s.
1881
Please examine %(limbo_dir)s to see if it contains any files you wish to
1882
keep, and delete it when you are done."""
1884
def __init__(self, limbo_dir):
1885
BzrError.__init__(self)
1886
self.limbo_dir = limbo_dir
1889
class ImmortalPendingDeletion(BzrError):
1891
_fmt = """Unable to delete transform temporary directory
1892
%(pending_deletion)s. Please examine %(pending_deletions)s to see if it
1893
contains any files you wish to keep, and delete it when you are done."""
1895
def __init__(self, pending_deletion):
1896
BzrError.__init__(self, pending_deletion=pending_deletion)
1899
class OutOfDateTree(BzrError):
1901
_fmt = "Working tree is out of date, please run 'bzr update'."
1903
def __init__(self, tree):
1904
BzrError.__init__(self)
1908
class PublicBranchOutOfDate(BzrError):
1910
_fmt = 'Public branch "%(public_location)s" lacks revision '\
1913
def __init__(self, public_location, revstring):
1914
import bzrlib.urlutils as urlutils
1915
public_location = urlutils.unescape_for_display(public_location,
1917
BzrError.__init__(self, public_location=public_location,
1918
revstring=revstring)
1921
class MergeModifiedFormatError(BzrError):
1923
_fmt = "Error in merge modified format"
1926
class ConflictFormatError(BzrError):
1928
_fmt = "Format error in conflict listings"
1931
class CorruptRepository(BzrError):
1933
_fmt = ("An error has been detected in the repository %(repo_path)s.\n"
1934
"Please run bzr reconcile on this repository.")
1936
def __init__(self, repo):
1937
BzrError.__init__(self)
1938
self.repo_path = repo.bzrdir.root_transport.base
1941
class UpgradeRequired(BzrError):
1943
_fmt = "To use this feature you must upgrade your branch at %(path)s."
1945
def __init__(self, path):
1946
BzrError.__init__(self)
1950
class LocalRequiresBoundBranch(BzrError):
1952
_fmt = "Cannot perform local-only commits on unbound branches."
1955
class MissingProgressBarFinish(BzrError):
1957
_fmt = "A nested progress bar was not 'finished' correctly."
1960
class InvalidProgressBarType(BzrError):
1962
_fmt = ("Environment variable BZR_PROGRESS_BAR='%(bar_type)s"
1963
" is not a supported type Select one of: %(valid_types)s")
1965
def __init__(self, bar_type, valid_types):
1966
BzrError.__init__(self, bar_type=bar_type, valid_types=valid_types)
1969
class UnsupportedOperation(BzrError):
1971
_fmt = ("The method %(mname)s is not supported on"
1972
" objects of type %(tname)s.")
1974
def __init__(self, method, method_self):
1975
self.method = method
1976
self.mname = method.__name__
1977
self.tname = type(method_self).__name__
1980
class CannotSetRevisionId(UnsupportedOperation):
1981
"""Raised when a commit is attempting to set a revision id but cant."""
1984
class NonAsciiRevisionId(UnsupportedOperation):
1985
"""Raised when a commit is attempting to set a non-ascii revision id
1990
class BinaryFile(BzrError):
1992
_fmt = "File is binary but should be text."
1995
class IllegalPath(BzrError):
1997
_fmt = "The path %(path)s is not permitted on this platform"
1999
def __init__(self, path):
2000
BzrError.__init__(self)
2004
class TestamentMismatch(BzrError):
2006
_fmt = """Testament did not match expected value.
2007
For revision_id {%(revision_id)s}, expected {%(expected)s}, measured
2010
def __init__(self, revision_id, expected, measured):
2011
self.revision_id = revision_id
2012
self.expected = expected
2013
self.measured = measured
2016
class NotABundle(BzrError):
2018
_fmt = "Not a bzr revision-bundle: %(text)r"
2020
def __init__(self, text):
2021
BzrError.__init__(self)
2025
class BadBundle(BzrError):
2027
_fmt = "Bad bzr revision-bundle: %(text)r"
2029
def __init__(self, text):
2030
BzrError.__init__(self)
2034
class MalformedHeader(BadBundle):
2036
_fmt = "Malformed bzr revision-bundle header: %(text)r"
2039
class MalformedPatches(BadBundle):
2041
_fmt = "Malformed patches in bzr revision-bundle: %(text)r"
2044
class MalformedFooter(BadBundle):
2046
_fmt = "Malformed footer in bzr revision-bundle: %(text)r"
2049
class UnsupportedEOLMarker(BadBundle):
2051
_fmt = "End of line marker was not \\n in bzr revision-bundle"
2054
# XXX: BadBundle's constructor assumes there's explanatory text,
2055
# but for this there is not
2056
BzrError.__init__(self)
2059
class IncompatibleBundleFormat(BzrError):
2061
_fmt = "Bundle format %(bundle_format)s is incompatible with %(other)s"
2063
def __init__(self, bundle_format, other):
2064
BzrError.__init__(self)
2065
self.bundle_format = bundle_format
2069
class BadInventoryFormat(BzrError):
2071
_fmt = "Root class for inventory serialization errors"
2074
class UnexpectedInventoryFormat(BadInventoryFormat):
2076
_fmt = "The inventory was not in the expected format:\n %(msg)s"
2078
def __init__(self, msg):
2079
BadInventoryFormat.__init__(self, msg=msg)
2082
class RootNotRich(BzrError):
2084
_fmt = """This operation requires rich root data storage"""
2087
class NoSmartMedium(BzrError):
2089
_fmt = "The transport '%(transport)s' cannot tunnel the smart protocol."
2091
internal_error = True
2093
def __init__(self, transport):
2094
self.transport = transport
2097
class NoSmartServer(NotBranchError):
2099
_fmt = "No smart server available at %(url)s"
2101
def __init__(self, url):
2105
class UnknownSSH(BzrError):
2107
_fmt = "Unrecognised value for BZR_SSH environment variable: %(vendor)s"
2109
def __init__(self, vendor):
2110
BzrError.__init__(self)
2111
self.vendor = vendor
2114
class SSHVendorNotFound(BzrError):
2116
_fmt = ("Don't know how to handle SSH connections."
2117
" Please set BZR_SSH environment variable.")
2120
class GhostRevisionUnusableHere(BzrError):
2122
_fmt = "Ghost revision {%(revision_id)s} cannot be used here."
2124
def __init__(self, revision_id):
2125
BzrError.__init__(self)
2126
self.revision_id = revision_id
2129
class IllegalUseOfScopeReplacer(BzrError):
2131
_fmt = ("ScopeReplacer object %(name)r was used incorrectly:"
2132
" %(msg)s%(extra)s")
2134
internal_error = True
2136
def __init__(self, name, msg, extra=None):
2137
BzrError.__init__(self)
2141
self.extra = ': ' + str(extra)
2146
class InvalidImportLine(BzrError):
2148
_fmt = "Not a valid import statement: %(msg)\n%(text)s"
2150
internal_error = True
2152
def __init__(self, text, msg):
2153
BzrError.__init__(self)
2158
class ImportNameCollision(BzrError):
2160
_fmt = ("Tried to import an object to the same name as"
2161
" an existing object. %(name)s")
2163
internal_error = True
2165
def __init__(self, name):
2166
BzrError.__init__(self)
2170
class NotAMergeDirective(BzrError):
2171
"""File starting with %(firstline)r is not a merge directive"""
2172
def __init__(self, firstline):
2173
BzrError.__init__(self, firstline=firstline)
2176
class NoMergeSource(BzrError):
2177
"""Raise if no merge source was specified for a merge directive"""
2179
_fmt = "A merge directive must provide either a bundle or a public"\
2183
class IllegalMergeDirectivePayload(BzrError):
2184
"""A merge directive contained something other than a patch or bundle"""
2186
_fmt = "Bad merge directive payload %(start)r"
2188
def __init__(self, start):
2193
class PatchVerificationFailed(BzrError):
2194
"""A patch from a merge directive could not be verified"""
2196
_fmt = "Preview patch does not match requested changes."
2199
class PatchMissing(BzrError):
2200
"""Raise a patch type was specified but no patch supplied"""
2202
_fmt = "patch_type was %(patch_type)s, but no patch was supplied."
2204
def __init__(self, patch_type):
2205
BzrError.__init__(self)
2206
self.patch_type = patch_type
2209
class UnsupportedInventoryKind(BzrError):
2211
_fmt = """Unsupported entry kind %(kind)s"""
2213
def __init__(self, kind):
2217
class BadSubsumeSource(BzrError):
2219
_fmt = "Can't subsume %(other_tree)s into %(tree)s. %(reason)s"
2221
def __init__(self, tree, other_tree, reason):
2223
self.other_tree = other_tree
2224
self.reason = reason
2227
class SubsumeTargetNeedsUpgrade(BzrError):
2229
_fmt = """Subsume target %(other_tree)s needs to be upgraded."""
2231
def __init__(self, other_tree):
2232
self.other_tree = other_tree
2235
class BadReferenceTarget(BzrError):
2237
_fmt = "Can't add reference to %(other_tree)s into %(tree)s." \
2240
internal_error = True
2242
def __init__(self, tree, other_tree, reason):
2244
self.other_tree = other_tree
2245
self.reason = reason
2248
class NoSuchTag(BzrError):
2250
_fmt = "No such tag: %(tag_name)s"
2252
def __init__(self, tag_name):
2253
self.tag_name = tag_name
2256
class TagsNotSupported(BzrError):
2258
_fmt = ("Tags not supported by %(branch)s;"
2259
" you may be able to use bzr upgrade --dirstate-tags.")
2261
def __init__(self, branch):
2262
self.branch = branch
2265
class TagAlreadyExists(BzrError):
2267
_fmt = "Tag %(tag_name)s already exists."
2269
def __init__(self, tag_name):
2270
self.tag_name = tag_name
2273
class MalformedBugIdentifier(BzrError):
2275
_fmt = "Did not understand bug identifier %(bug_id)s: %(reason)s"
2277
def __init__(self, bug_id, reason):
2278
self.bug_id = bug_id
2279
self.reason = reason
2282
class UnknownBugTrackerAbbreviation(BzrError):
2284
_fmt = ("Cannot find registered bug tracker called %(abbreviation)s "
2287
def __init__(self, abbreviation, branch):
2288
self.abbreviation = abbreviation
2289
self.branch = branch
2292
class UnexpectedSmartServerResponse(BzrError):
2294
_fmt = "Could not understand response from smart server: %(response_tuple)r"
2296
def __init__(self, response_tuple):
2297
self.response_tuple = response_tuple
2300
class ContainerError(BzrError):
2301
"""Base class of container errors."""
2304
class UnknownContainerFormatError(ContainerError):
2306
_fmt = "Unrecognised container format: %(container_format)r"
2308
def __init__(self, container_format):
2309
self.container_format = container_format
2312
class UnexpectedEndOfContainerError(ContainerError):
2314
_fmt = "Unexpected end of container stream"
2316
internal_error = False
2319
class UnknownRecordTypeError(ContainerError):
2321
_fmt = "Unknown record type: %(record_type)r"
2323
def __init__(self, record_type):
2324
self.record_type = record_type
2327
class InvalidRecordError(ContainerError):
2329
_fmt = "Invalid record: %(reason)s"
2331
def __init__(self, reason):
2332
self.reason = reason
2335
class ContainerHasExcessDataError(ContainerError):
2337
_fmt = "Container has data after end marker: %(excess)r"
2339
def __init__(self, excess):
2340
self.excess = excess
2343
class DuplicateRecordNameError(ContainerError):
2345
_fmt = "Container has multiple records with the same name: %(name)s"
2347
def __init__(self, name):
2351
class NoDestinationAddress(BzrError):
2353
_fmt = "Message does not have a destination address."
2355
internal_error = True
2358
class SMTPError(BzrError):
2360
_fmt = "SMTP error: %(error)s"
2362
def __init__(self, error):
2366
class NoMessageSupplied(BzrError):
2368
_fmt = "No message supplied."
2371
class UnknownMailClient(BzrError):
2373
_fmt = "Unknown mail client: %(mail_client)s"
2375
def __init__(self, mail_client):
2376
BzrError.__init__(self, mail_client=mail_client)
2379
class MailClientNotFound(BzrError):
2381
_fmt = "Unable to find mail client with the following names:"\
2382
" %(mail_command_list_string)s"
2384
def __init__(self, mail_command_list):
2385
mail_command_list_string = ', '.join(mail_command_list)
2386
BzrError.__init__(self, mail_command_list=mail_command_list,
2387
mail_command_list_string=mail_command_list_string)
2389
class SMTPConnectionRefused(SMTPError):
2391
_fmt = "SMTP connection to %(host)s refused"
2393
def __init__(self, error, host):
2398
class DefaultSMTPConnectionRefused(SMTPConnectionRefused):
2400
_fmt = "Please specify smtp_server. No server at default %(host)s."
added
removed
bzrlib/errors.py
