1
# Copyright (C) 2005-2011 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
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
17
"""Exceptions for bzr, and reporting of them.
20
from __future__ import absolute_import
22
# 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
26
# TODO: Perhaps convert the exception to a string at the moment it's
27
# constructed to make sure it will succeed. But that says nothing about
28
# 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
16
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
19
__copyright__ = "Copyright (C) 2005 Canonical Ltd."
20
__author__ = "Martin Pool <mbp@canonical.com>"
23
######################################################################
41
25
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
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
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"
220
def __init__(self, name):
221
BzrError.__init__(self)
225
class InvalidRevisionNumber(BzrError):
227
_fmt = "Invalid revision number %(revno)s"
229
def __init__(self, revno):
230
BzrError.__init__(self)
234
class InvalidRevisionId(BzrError):
236
_fmt = "Invalid revision-id {%(revision_id)s} in %(branch)s"
238
def __init__(self, revision_id, branch):
239
# branch can be any string or object with __str__ defined
240
BzrError.__init__(self)
241
self.revision_id = revision_id
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".'
315
def __init__(self, base):
316
BzrError.__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."
329
def __init__(self, url):
333
class WorkingTreeAlreadyPopulated(InternalBzrError):
335
_fmt = 'Working tree already populated in "%(base)s"'
337
def __init__(self, base):
28
class BzrCheckError(BzrError):
341
32
class BzrCommandError(BzrError):
342
"""Error from user command"""
344
# Error from malformed user command; please avoid raising this as a
345
# generic exception not caused by user input.
347
# I think it's a waste of effort to differentiate between errors that
348
# are not intended to be caught anyway. UI code need not subclass
349
# BzrCommandError, and non-UI code should not throw a subclass of
350
# BzrCommandError. ADHB 20051211
353
class NotWriteLocked(BzrError):
355
_fmt = """%(not_locked)r is not write locked but needs to be."""
357
def __init__(self, not_locked):
358
self.not_locked = not_locked
361
class BzrOptionError(BzrCommandError):
363
_fmt = "Error in command line options"
366
class BadIndexFormatSignature(BzrError):
368
_fmt = "%(value)s is not an index of type %(_type)s."
370
def __init__(self, value, _type):
371
BzrError.__init__(self)
376
class BadIndexData(BzrError):
378
_fmt = "Error in data for index %(value)s."
380
def __init__(self, value):
381
BzrError.__init__(self)
385
class BadIndexDuplicateKey(BzrError):
387
_fmt = "The key '%(key)s' is already in index '%(index)s'."
389
def __init__(self, key, index):
390
BzrError.__init__(self)
395
class BadIndexKey(BzrError):
397
_fmt = "The key '%(key)s' is not a valid key."
399
def __init__(self, key):
400
BzrError.__init__(self)
404
class BadIndexOptions(BzrError):
406
_fmt = "Could not parse options for index %(value)s."
408
def __init__(self, value):
409
BzrError.__init__(self)
413
class BadIndexValue(BzrError):
415
_fmt = "The value '%(value)s' is not a valid value."
417
def __init__(self, value):
418
BzrError.__init__(self)
422
class BadOptionValue(BzrError):
424
_fmt = """Bad value "%(value)s" for option "%(name)s"."""
426
def __init__(self, name, value):
427
BzrError.__init__(self, name=name, value=value)
430
class StrictCommitFailed(BzrError):
432
_fmt = "Commit refused because there are unknown files in the tree"
435
# XXX: Should be unified with TransportError; they seem to represent the
437
# RBC 20060929: I think that unifiying with TransportError would be a mistake
438
# - this is finer than a TransportError - and more useful as such. It
439
# differentiates between 'transport has failed' and 'operation on a transport
441
class PathError(BzrError):
443
_fmt = "Generic path error: %(path)r%(extra)s)"
445
def __init__(self, path, extra=None):
446
BzrError.__init__(self)
449
self.extra = ': ' + str(extra)
454
class NoSuchFile(PathError):
456
_fmt = "No such file: %(path)r%(extra)s"
459
class FileExists(PathError):
461
_fmt = "File exists: %(path)r%(extra)s"
464
class RenameFailedFilesExist(BzrError):
465
"""Used when renaming and both source and dest exist."""
467
_fmt = ("Could not rename %(source)s => %(dest)s because both files exist."
468
" (Use --after to tell bzr about a rename that has already"
469
" happened)%(extra)s")
471
def __init__(self, source, dest, extra=None):
472
BzrError.__init__(self)
473
self.source = str(source)
474
self.dest = str(dest)
476
self.extra = ' ' + str(extra)
481
class NotADirectory(PathError):
483
_fmt = '"%(path)s" is not a directory %(extra)s'
486
class NotInWorkingDirectory(PathError):
488
_fmt = '"%(path)s" is not in the working directory %(extra)s'
491
class DirectoryNotEmpty(PathError):
493
_fmt = 'Directory not empty: "%(path)s"%(extra)s'
496
class HardLinkNotSupported(PathError):
498
_fmt = 'Hard-linking "%(path)s" is not supported'
501
class ReadingCompleted(InternalBzrError):
503
_fmt = ("The MediumRequest '%(request)s' has already had finish_reading "
504
"called upon it - the request has been completed and no more "
507
def __init__(self, request):
508
self.request = request
511
class ResourceBusy(PathError):
513
_fmt = 'Device or resource busy: "%(path)s"%(extra)s'
516
class PermissionDenied(PathError):
518
_fmt = 'Permission denied: "%(path)s"%(extra)s'
521
class InvalidURL(PathError):
523
_fmt = 'Invalid url supplied to transport: "%(path)s"%(extra)s'
526
class InvalidURLJoin(PathError):
528
_fmt = "Invalid URL join request: %(reason)s: %(base)r + %(join_args)r"
530
def __init__(self, reason, base, join_args):
533
self.join_args = join_args
534
PathError.__init__(self, base, reason)
537
class InvalidRebaseURLs(PathError):
539
_fmt = "URLs differ by more than path: %(from_)r and %(to)r"
541
def __init__(self, from_, to):
544
PathError.__init__(self, from_, 'URLs differ by more than path.')
547
class UnavailableRepresentation(InternalBzrError):
549
_fmt = ("The encoding '%(wanted)s' is not available for key %(key)s which "
550
"is encoded as '%(native)s'.")
552
def __init__(self, key, wanted, native):
553
InternalBzrError.__init__(self)
559
class UnknownHook(BzrError):
561
_fmt = "The %(type)s hook '%(hook)s' is unknown in this version of bzrlib."
563
def __init__(self, hook_type, hook_name):
564
BzrError.__init__(self)
565
self.type = hook_type
566
self.hook = hook_name
569
class UnsupportedProtocol(PathError):
571
_fmt = 'Unsupported protocol for url "%(path)s"%(extra)s'
573
def __init__(self, url, extra=""):
574
PathError.__init__(self, url, extra=extra)
577
class UnstackableBranchFormat(BzrError):
579
_fmt = ("The branch '%(url)s'(%(format)s) is not a stackable format. "
580
"You will need to upgrade the branch to permit branch stacking.")
582
def __init__(self, format, url):
583
BzrError.__init__(self)
588
class UnstackableLocationError(BzrError):
590
_fmt = "The branch '%(branch_url)s' cannot be stacked on '%(target_url)s'."
592
def __init__(self, branch_url, target_url):
593
BzrError.__init__(self)
594
self.branch_url = branch_url
595
self.target_url = target_url
598
class UnstackableRepositoryFormat(BzrError):
600
_fmt = ("The repository '%(url)s'(%(format)s) is not a stackable format. "
601
"You will need to upgrade the repository to permit branch stacking.")
603
def __init__(self, format, url):
604
BzrError.__init__(self)
609
class ReadError(PathError):
611
_fmt = """Error reading from %(path)r."""
614
class ShortReadvError(PathError):
616
_fmt = ('readv() read %(actual)s bytes rather than %(length)s bytes'
617
' at %(offset)s for "%(path)s"%(extra)s')
619
internal_error = True
621
def __init__(self, path, offset, length, actual, extra=None):
622
PathError.__init__(self, path, extra=extra)
628
class PathNotChild(PathError):
630
_fmt = 'Path "%(path)s" is not a child of path "%(base)s"%(extra)s'
632
internal_error = False
634
def __init__(self, path, base, extra=None):
635
BzrError.__init__(self)
639
self.extra = ': ' + str(extra)
644
class InvalidNormalization(PathError):
646
_fmt = 'Path "%(path)s" is not unicode normalized'
649
# TODO: This is given a URL; we try to unescape it but doing that from inside
650
# the exception object is a bit undesirable.
651
# TODO: Probably this behavior of should be a common superclass
652
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 AlreadyBranchError(PathError):
705
_fmt = 'Already a branch: "%(path)s".'
708
class BranchExistsWithoutWorkingTree(PathError):
710
_fmt = 'Directory contains a branch, but no working tree \
711
(use bzr checkout if you wish to build a working tree): "%(path)s"'
714
class AtomicFileAlreadyClosed(PathError):
716
_fmt = ('"%(function)s" called on an AtomicFile after it was closed:'
719
def __init__(self, path, function):
720
PathError.__init__(self, path=path, extra=None)
721
self.function = function
724
class InaccessibleParent(PathError):
726
_fmt = ('Parent not accessible given base "%(base)s" and'
727
' relative path "%(path)s"')
729
def __init__(self, path, base):
730
PathError.__init__(self, path)
734
class NoRepositoryPresent(BzrError):
736
_fmt = 'No repository present: "%(path)s"'
737
def __init__(self, bzrdir):
738
BzrError.__init__(self)
739
self.path = bzrdir.transport.clone('..').base
742
class UnsupportedFormatError(BzrError):
744
_fmt = "Unsupported branch format: %(format)s\nPlease run 'bzr upgrade'"
747
class UnknownFormatError(BzrError):
749
_fmt = "Unknown %(kind)s format: %(format)r"
751
def __init__(self, format, kind='branch'):
756
class IncompatibleFormat(BzrError):
758
_fmt = "Format %(format)s is not compatible with .bzr version %(bzrdir)s."
760
def __init__(self, format, bzrdir_format):
761
BzrError.__init__(self)
763
self.bzrdir = bzrdir_format
766
class ParseFormatError(BzrError):
768
_fmt = "Parse error on line %(lineno)d of %(format)s format: %(line)s"
770
def __init__(self, format, lineno, line, text):
771
BzrError.__init__(self)
778
class IncompatibleRepositories(BzrError):
779
"""Report an error that two repositories are not compatible.
781
Note that the source and target repositories are permitted to be strings:
782
this exception is thrown from the smart server and may refer to a
783
repository the client hasn't opened.
786
_fmt = "%(target)s\n" \
787
"is not compatible with\n" \
791
def __init__(self, source, target, details=None):
793
details = "(no details)"
794
BzrError.__init__(self, target=target, source=source, details=details)
797
class IncompatibleRevision(BzrError):
799
_fmt = "Revision is not compatible with %(repo_format)s"
801
def __init__(self, repo_format):
802
BzrError.__init__(self)
803
self.repo_format = repo_format
806
class AlreadyVersionedError(BzrError):
807
"""Used when a path is expected not to be versioned, but it is."""
809
_fmt = "%(context_info)s%(path)s is already versioned."
811
def __init__(self, path, context_info=None):
812
"""Construct a new AlreadyVersionedError.
814
:param path: This is the path which is versioned,
815
which should be in a user friendly form.
816
:param context_info: If given, this is information about the context,
817
which could explain why this is expected to not be versioned.
819
BzrError.__init__(self)
821
if context_info is None:
822
self.context_info = ''
824
self.context_info = context_info + ". "
33
# Error from malformed user command
37
class NotBranchError(BzrError):
38
"""Specified path is not in a branch"""
827
42
class NotVersionedError(BzrError):
828
"""Used when a path is expected to be versioned, but it is not."""
830
_fmt = "%(context_info)s%(path)s is not versioned."
832
def __init__(self, path, context_info=None):
833
"""Construct a new NotVersionedError.
835
:param path: This is the path which is not versioned,
836
which should be in a user friendly form.
837
:param context_info: If given, this is information about the context,
838
which could explain why this is expected to be versioned.
840
BzrError.__init__(self)
842
if context_info is None:
843
self.context_info = ''
845
self.context_info = context_info + ". "
848
class PathsNotVersionedError(BzrError):
849
"""Used when reporting several paths which are not versioned"""
851
_fmt = "Path(s) are not versioned: %(paths_as_string)s"
853
def __init__(self, paths):
854
from bzrlib.osutils import quotefn
855
BzrError.__init__(self)
857
self.paths_as_string = ' '.join([quotefn(p) for p in paths])
860
class PathsDoNotExist(BzrError):
862
_fmt = "Path(s) do not exist: %(paths_as_string)s%(extra)s"
864
# used when reporting that paths are neither versioned nor in the working
867
def __init__(self, paths, extra=None):
869
from bzrlib.osutils import quotefn
870
BzrError.__init__(self)
872
self.paths_as_string = ' '.join([quotefn(p) for p in paths])
874
self.extra = ': ' + str(extra)
43
"""Specified object is not versioned."""
879
46
class BadFileKindError(BzrError):
881
_fmt = 'Cannot operate on "%(filename)s" of unsupported kind "%(kind)s"'
883
def __init__(self, filename, kind):
884
BzrError.__init__(self, filename=filename, kind=kind)
887
class BadFilenameEncoding(BzrError):
889
_fmt = ('Filename %(filename)r is not valid in your current filesystem'
890
' encoding %(fs_encoding)s')
892
def __init__(self, filename, fs_encoding):
893
BzrError.__init__(self)
894
self.filename = filename
895
self.fs_encoding = fs_encoding
898
class ForbiddenControlFileError(BzrError):
900
_fmt = 'Cannot operate on "%(filename)s" because it is a control file'
903
class LockError(InternalBzrError):
905
_fmt = "Lock error: %(msg)s"
907
# All exceptions from the lock/unlock functions should be from
908
# this exception class. They will be translated as necessary. The
909
# original exception is available as e.original_error
911
# New code should prefer to raise specific subclasses
912
def __init__(self, msg):
916
class LockActive(LockError):
918
_fmt = "The lock for '%(lock_description)s' is in use and cannot be broken."
920
internal_error = False
922
def __init__(self, lock_description):
923
self.lock_description = lock_description
926
class CommitNotPossible(LockError):
928
_fmt = "A commit was attempted but we do not have a write lock open."
934
class AlreadyCommitted(LockError):
936
_fmt = "A rollback was requested, but is not able to be accomplished."
942
class ReadOnlyError(LockError):
944
_fmt = "A write attempt was made in a read only transaction on %(obj)s"
946
# TODO: There should also be an error indicating that you need a write
947
# lock and don't have any lock at all... mbp 20070226
949
def __init__(self, obj):
953
class LockFailed(LockError):
955
internal_error = False
957
_fmt = "Cannot lock %(lock)s: %(why)s"
959
def __init__(self, lock, why):
960
LockError.__init__(self, '')
965
class OutSideTransaction(BzrError):
967
_fmt = ("A transaction related operation was attempted after"
968
" the transaction finished.")
971
class ObjectNotLocked(LockError):
973
_fmt = "%(obj)r is not locked"
975
# this can indicate that any particular object is not locked; see also
976
# LockNotHeld which means that a particular *lock* object is not held by
977
# the caller -- perhaps they should be unified.
978
def __init__(self, obj):
982
class ReadOnlyObjectDirtiedError(ReadOnlyError):
984
_fmt = "Cannot change object %(obj)r in read only transaction"
986
def __init__(self, obj):
990
class UnlockableTransport(LockError):
992
internal_error = False
994
_fmt = "Cannot lock: transport is read only: %(transport)s"
996
def __init__(self, transport):
997
self.transport = transport
1000
class LockContention(LockError):
1002
_fmt = 'Could not acquire lock "%(lock)s": %(msg)s'
1004
internal_error = False
1006
def __init__(self, lock, msg=''):
1011
class LockBroken(LockError):
1013
_fmt = ("Lock was broken while still open: %(lock)s"
1014
" - check storage consistency!")
1016
internal_error = False
1018
def __init__(self, lock):
1022
class LockBreakMismatch(LockError):
1024
_fmt = ("Lock was released and re-acquired before being broken:"
1025
" %(lock)s: held by %(holder)r, wanted to break %(target)r")
1027
internal_error = False
1029
def __init__(self, lock, holder, target):
1031
self.holder = holder
1032
self.target = target
1035
class LockCorrupt(LockError):
1037
_fmt = ("Lock is apparently held, but corrupted: %(corruption_info)s\n"
1038
"Use 'bzr break-lock' to clear it")
1040
internal_error = False
1042
def __init__(self, corruption_info, file_data=None):
1043
self.corruption_info = corruption_info
1044
self.file_data = file_data
1047
class LockNotHeld(LockError):
1049
_fmt = "Lock not held: %(lock)s"
1051
internal_error = False
1053
def __init__(self, lock):
1057
class TokenLockingNotSupported(LockError):
1059
_fmt = "The object %(obj)s does not support token specifying a token when locking."
1061
def __init__(self, obj):
1065
class TokenMismatch(LockBroken):
1067
_fmt = "The lock token %(given_token)r does not match lock token %(lock_token)r."
1069
internal_error = True
1071
def __init__(self, given_token, lock_token):
1072
self.given_token = given_token
1073
self.lock_token = lock_token
1076
class PointlessCommit(BzrError):
1078
_fmt = "No changes to commit"
1081
class CannotCommitSelectedFileMerge(BzrError):
1083
_fmt = 'Selected-file commit of merges is not supported yet:'\
1084
' files %(files_str)s'
1086
def __init__(self, files):
1087
files_str = ', '.join(files)
1088
BzrError.__init__(self, files=files, files_str=files_str)
1091
class ExcludesUnsupported(BzrError):
1093
_fmt = ('Excluding paths during commit is not supported by '
1094
'repository at %(repository)r.')
1096
def __init__(self, repository):
1097
BzrError.__init__(self, repository=repository)
1100
class BadCommitMessageEncoding(BzrError):
1102
_fmt = 'The specified commit message contains characters unsupported by '\
1103
'the current encoding.'
1106
class UpgradeReadonly(BzrError):
1108
_fmt = "Upgrade URL cannot work with readonly URLs."
1111
class UpToDateFormat(BzrError):
1113
_fmt = "The branch format %(format)s is already at the most recent format."
1115
def __init__(self, format):
1116
BzrError.__init__(self)
1117
self.format = format
1120
class StrictCommitFailed(Exception):
1122
_fmt = "Commit refused because there are unknowns in the tree."
1125
class NoSuchRevision(InternalBzrError):
1127
_fmt = "%(branch)s has no revision %(revision)s"
1129
def __init__(self, branch, revision):
1130
# 'branch' may sometimes be an internal object like a KnitRevisionStore
1131
BzrError.__init__(self, branch=branch, revision=revision)
1134
class RangeInChangeOption(BzrError):
1136
_fmt = "Option --change does not accept revision ranges"
1139
class NoSuchRevisionSpec(BzrError):
1141
_fmt = "No namespace registered for string: %(spec)r"
1143
def __init__(self, spec):
1144
BzrError.__init__(self, spec=spec)
1147
class NoSuchRevisionInTree(NoSuchRevision):
1148
"""When using Tree.revision_tree, and the revision is not accessible."""
1150
_fmt = "The revision id {%(revision_id)s} is not present in the tree %(tree)s."
1152
def __init__(self, tree, revision_id):
1153
BzrError.__init__(self)
1155
self.revision_id = revision_id
1158
class InvalidRevisionSpec(BzrError):
1160
_fmt = ("Requested revision: '%(spec)s' does not exist in branch:"
1161
" %(branch_url)s%(extra)s")
1163
def __init__(self, spec, branch, extra=None):
1164
BzrError.__init__(self, branch=branch, spec=spec)
1165
self.branch_url = getattr(branch, 'user_url', str(branch))
1167
self.extra = '\n' + str(extra)
1172
class AppendRevisionsOnlyViolation(BzrError):
1174
_fmt = ('Operation denied because it would change the main history,'
1175
' which is not permitted by the append_revisions_only setting on'
1176
' branch "%(location)s".')
1178
def __init__(self, location):
1179
import bzrlib.urlutils as urlutils
1180
location = urlutils.unescape_for_display(location, 'ascii')
1181
BzrError.__init__(self, location=location)
1184
class DivergedBranches(BzrError):
1186
_fmt = ("These branches have diverged."
1187
" Use the missing command to see how.\n"
1188
"Use the merge command to reconcile them.")
1190
def __init__(self, branch1, branch2):
1191
self.branch1 = branch1
1192
self.branch2 = branch2
1195
class NotLefthandHistory(InternalBzrError):
1197
_fmt = "Supplied history does not follow left-hand parents"
1199
def __init__(self, history):
1200
BzrError.__init__(self, history=history)
1203
class UnrelatedBranches(BzrError):
1205
_fmt = ("Branches have no common ancestor, and"
1206
" no merge base revision was specified.")
1209
class CannotReverseCherrypick(BzrError):
1211
_fmt = ('Selected merge cannot perform reverse cherrypicks. Try merge3'
1215
class NoCommonAncestor(BzrError):
1217
_fmt = "Revisions have no common ancestor: %(revision_a)s %(revision_b)s"
1219
def __init__(self, revision_a, revision_b):
1220
self.revision_a = revision_a
1221
self.revision_b = revision_b
1224
class NoCommonRoot(BzrError):
1226
_fmt = ("Revisions are not derived from the same root: "
1227
"%(revision_a)s %(revision_b)s.")
1229
def __init__(self, revision_a, revision_b):
1230
BzrError.__init__(self, revision_a=revision_a, revision_b=revision_b)
1233
class NotAncestor(BzrError):
1235
_fmt = "Revision %(rev_id)s is not an ancestor of %(not_ancestor_id)s"
1237
def __init__(self, rev_id, not_ancestor_id):
1238
BzrError.__init__(self, rev_id=rev_id,
1239
not_ancestor_id=not_ancestor_id)
1242
class NoCommits(BranchError):
1244
_fmt = "Branch %(branch)s has no commits."
1247
class UnlistableStore(BzrError):
1249
def __init__(self, store):
1250
BzrError.__init__(self, "Store %s is not listable" % store)
1254
class UnlistableBranch(BzrError):
1256
def __init__(self, br):
1257
BzrError.__init__(self, "Stores for branch %s are not listable" % br)
1260
class BoundBranchOutOfDate(BzrError):
1262
_fmt = ("Bound branch %(branch)s is out of date with master branch"
1263
" %(master)s.%(extra_help)s")
1265
def __init__(self, branch, master):
1266
BzrError.__init__(self)
1267
self.branch = branch
1268
self.master = master
1269
self.extra_help = ''
1272
class CommitToDoubleBoundBranch(BzrError):
1274
_fmt = ("Cannot commit to branch %(branch)s."
1275
" It is bound to %(master)s, which is bound to %(remote)s.")
1277
def __init__(self, branch, master, remote):
1278
BzrError.__init__(self)
1279
self.branch = branch
1280
self.master = master
1281
self.remote = remote
1284
class OverwriteBoundBranch(BzrError):
1286
_fmt = "Cannot pull --overwrite to a branch which is bound %(branch)s"
1288
def __init__(self, branch):
1289
BzrError.__init__(self)
1290
self.branch = branch
1293
class BoundBranchConnectionFailure(BzrError):
1295
_fmt = ("Unable to connect to target of bound branch %(branch)s"
1296
" => %(target)s: %(error)s")
1298
def __init__(self, branch, target, error):
1299
BzrError.__init__(self)
1300
self.branch = branch
1301
self.target = target
1305
class WeaveError(BzrError):
1307
_fmt = "Error in processing weave: %(msg)s"
1309
def __init__(self, msg=None):
1310
BzrError.__init__(self)
1314
class WeaveRevisionAlreadyPresent(WeaveError):
1316
_fmt = "Revision {%(revision_id)s} already present in %(weave)s"
1318
def __init__(self, revision_id, weave):
1320
WeaveError.__init__(self)
1321
self.revision_id = revision_id
1325
class WeaveRevisionNotPresent(WeaveError):
1327
_fmt = "Revision {%(revision_id)s} not present in %(weave)s"
1329
def __init__(self, revision_id, weave):
1330
WeaveError.__init__(self)
1331
self.revision_id = revision_id
1335
class WeaveFormatError(WeaveError):
1337
_fmt = "Weave invariant violated: %(what)s"
1339
def __init__(self, what):
1340
WeaveError.__init__(self)
1344
class WeaveParentMismatch(WeaveError):
1346
_fmt = "Parents are mismatched between two revisions. %(msg)s"
1349
class WeaveInvalidChecksum(WeaveError):
1351
_fmt = "Text did not match its checksum: %(msg)s"
1354
class WeaveTextDiffers(WeaveError):
1356
_fmt = ("Weaves differ on text content. Revision:"
1357
" {%(revision_id)s}, %(weave_a)s, %(weave_b)s")
1359
def __init__(self, revision_id, weave_a, weave_b):
1360
WeaveError.__init__(self)
1361
self.revision_id = revision_id
1362
self.weave_a = weave_a
1363
self.weave_b = weave_b
1366
class WeaveTextDiffers(WeaveError):
1368
_fmt = ("Weaves differ on text content. Revision:"
1369
" {%(revision_id)s}, %(weave_a)s, %(weave_b)s")
1371
def __init__(self, revision_id, weave_a, weave_b):
1372
WeaveError.__init__(self)
1373
self.revision_id = revision_id
1374
self.weave_a = weave_a
1375
self.weave_b = weave_b
1378
class VersionedFileError(BzrError):
1380
_fmt = "Versioned file error"
1383
class RevisionNotPresent(VersionedFileError):
1385
_fmt = 'Revision {%(revision_id)s} not present in "%(file_id)s".'
1387
def __init__(self, revision_id, file_id):
1388
VersionedFileError.__init__(self)
1389
self.revision_id = revision_id
1390
self.file_id = file_id
1393
class RevisionAlreadyPresent(VersionedFileError):
1395
_fmt = 'Revision {%(revision_id)s} already present in "%(file_id)s".'
1397
def __init__(self, revision_id, file_id):
1398
VersionedFileError.__init__(self)
1399
self.revision_id = revision_id
1400
self.file_id = file_id
1403
class VersionedFileInvalidChecksum(VersionedFileError):
1405
_fmt = "Text did not match its checksum: %(msg)s"
1408
class KnitError(InternalBzrError):
1413
class KnitCorrupt(KnitError):
1415
_fmt = "Knit %(filename)s corrupt: %(how)s"
1417
def __init__(self, filename, how):
1418
KnitError.__init__(self)
1419
self.filename = filename
1423
class SHA1KnitCorrupt(KnitCorrupt):
1425
_fmt = ("Knit %(filename)s corrupt: sha-1 of reconstructed text does not "
1426
"match expected sha-1. key %(key)s expected sha %(expected)s actual "
1429
def __init__(self, filename, actual, expected, key, content):
1430
KnitError.__init__(self)
1431
self.filename = filename
1432
self.actual = actual
1433
self.expected = expected
1435
self.content = content
1438
class KnitDataStreamIncompatible(KnitError):
1439
# Not raised anymore, as we can convert data streams. In future we may
1440
# need it again for more exotic cases, so we're keeping it around for now.
1442
_fmt = "Cannot insert knit data stream of format \"%(stream_format)s\" into knit of format \"%(target_format)s\"."
1444
def __init__(self, stream_format, target_format):
1445
self.stream_format = stream_format
1446
self.target_format = target_format
1449
class KnitDataStreamUnknown(KnitError):
1450
# Indicates a data stream we don't know how to handle.
1452
_fmt = "Cannot parse knit data stream of format \"%(stream_format)s\"."
1454
def __init__(self, stream_format):
1455
self.stream_format = stream_format
1458
class KnitHeaderError(KnitError):
1460
_fmt = 'Knit header error: %(badline)r unexpected for file "%(filename)s".'
1462
def __init__(self, badline, filename):
1463
KnitError.__init__(self)
1464
self.badline = badline
1465
self.filename = filename
1467
class KnitIndexUnknownMethod(KnitError):
1468
"""Raised when we don't understand the storage method.
1470
Currently only 'fulltext' and 'line-delta' are supported.
1473
_fmt = ("Knit index %(filename)s does not have a known method"
1474
" in options: %(options)r")
1476
def __init__(self, filename, options):
1477
KnitError.__init__(self)
1478
self.filename = filename
1479
self.options = options
1482
class RetryWithNewPacks(BzrError):
1483
"""Raised when we realize that the packs on disk have changed.
1485
This is meant as more of a signaling exception, to trap between where a
1486
local error occurred and the code that can actually handle the error and
1487
code that can retry appropriately.
1490
internal_error = True
1492
_fmt = ("Pack files have changed, reload and retry. context: %(context)s"
1495
def __init__(self, context, reload_occurred, exc_info):
1496
"""create a new RetryWithNewPacks error.
1498
:param reload_occurred: Set to True if we know that the packs have
1499
already been reloaded, and we are failing because of an in-memory
1500
cache miss. If set to True then we will ignore if a reload says
1501
nothing has changed, because we assume it has already reloaded. If
1502
False, then a reload with nothing changed will force an error.
1503
:param exc_info: The original exception traceback, so if there is a
1504
problem we can raise the original error (value from sys.exc_info())
1506
BzrError.__init__(self)
1507
self.context = context
1508
self.reload_occurred = reload_occurred
1509
self.exc_info = exc_info
1510
self.orig_error = exc_info[1]
1511
# TODO: The global error handler should probably treat this by
1512
# raising/printing the original exception with a bit about
1513
# RetryWithNewPacks also not being caught
1516
class RetryAutopack(RetryWithNewPacks):
1517
"""Raised when we are autopacking and we find a missing file.
1519
Meant as a signaling exception, to tell the autopack code it should try
1523
internal_error = True
1525
_fmt = ("Pack files have changed, reload and try autopack again."
1526
" context: %(context)s %(orig_error)s")
1529
class NoSuchExportFormat(BzrError):
1531
_fmt = "Export format %(format)r not supported"
1533
def __init__(self, format):
1534
BzrError.__init__(self)
1535
self.format = format
1538
class TransportError(BzrError):
1540
_fmt = "Transport error: %(msg)s %(orig_error)s"
1542
def __init__(self, msg=None, orig_error=None):
1543
if msg is None and orig_error is not None:
1544
msg = str(orig_error)
1545
if orig_error is None:
1550
self.orig_error = orig_error
1551
BzrError.__init__(self)
1554
class TooManyConcurrentRequests(InternalBzrError):
1556
_fmt = ("The medium '%(medium)s' has reached its concurrent request limit."
1557
" Be sure to finish_writing and finish_reading on the"
1558
" currently open request.")
1560
def __init__(self, medium):
1561
self.medium = medium
1564
class SmartProtocolError(TransportError):
1566
_fmt = "Generic bzr smart protocol error: %(details)s"
1568
def __init__(self, details):
1569
self.details = details
1572
class UnexpectedProtocolVersionMarker(TransportError):
1574
_fmt = "Received bad protocol version marker: %(marker)r"
1576
def __init__(self, marker):
1577
self.marker = marker
1580
class UnknownSmartMethod(InternalBzrError):
1582
_fmt = "The server does not recognise the '%(verb)s' request."
1584
def __init__(self, verb):
1588
class SmartMessageHandlerError(InternalBzrError):
1590
_fmt = ("The message handler raised an exception:\n"
1591
"%(traceback_text)s")
1593
def __init__(self, exc_info):
1595
# GZ 2010-08-10: Cycle with exc_tb/exc_info affects at least one test
1596
self.exc_type, self.exc_value, self.exc_tb = exc_info
1597
self.exc_info = exc_info
1598
traceback_strings = traceback.format_exception(
1599
self.exc_type, self.exc_value, self.exc_tb)
1600
self.traceback_text = ''.join(traceback_strings)
1603
# A set of semi-meaningful errors which can be thrown
1604
class TransportNotPossible(TransportError):
1606
_fmt = "Transport operation not possible: %(msg)s %(orig_error)s"
1609
class ConnectionError(TransportError):
1611
_fmt = "Connection error: %(msg)s %(orig_error)s"
1614
class SocketConnectionError(ConnectionError):
1616
_fmt = "%(msg)s %(host)s%(port)s%(orig_error)s"
1618
def __init__(self, host, port=None, msg=None, orig_error=None):
1620
msg = 'Failed to connect to'
1621
if orig_error is None:
1624
orig_error = '; ' + str(orig_error)
1625
ConnectionError.__init__(self, msg=msg, orig_error=orig_error)
1630
self.port = ':%s' % port
1633
# XXX: This is also used for unexpected end of file, which is different at the
1634
# TCP level from "connection reset".
1635
class ConnectionReset(TransportError):
1637
_fmt = "Connection closed: %(msg)s %(orig_error)s"
1640
class ConnectionTimeout(ConnectionError):
1642
_fmt = "Connection Timeout: %(msg)s%(orig_error)s"
1645
class InvalidRange(TransportError):
1647
_fmt = "Invalid range access in %(path)s at %(offset)s: %(msg)s"
1649
def __init__(self, path, offset, msg=None):
1650
TransportError.__init__(self, msg)
1652
self.offset = offset
1655
class InvalidHttpResponse(TransportError):
1657
_fmt = "Invalid http response for %(path)s: %(msg)s%(orig_error)s"
1659
def __init__(self, path, msg, orig_error=None):
1661
if orig_error is None:
1664
# This is reached for obscure and unusual errors so we want to
1665
# preserve as much info as possible to ease debug.
1666
orig_error = ': %r' % (orig_error,)
1667
TransportError.__init__(self, msg, orig_error=orig_error)
1670
class InvalidHttpRange(InvalidHttpResponse):
1672
_fmt = "Invalid http range %(range)r for %(path)s: %(msg)s"
1674
def __init__(self, path, range, msg):
1676
InvalidHttpResponse.__init__(self, path, msg)
1679
class HttpBoundaryMissing(InvalidHttpResponse):
1680
"""A multipart response ends with no boundary marker.
1682
This is a special case caused by buggy proxies, described in
1683
<https://bugs.launchpad.net/bzr/+bug/198646>.
1686
_fmt = "HTTP MIME Boundary missing for %(path)s: %(msg)s"
1688
def __init__(self, path, msg):
1689
InvalidHttpResponse.__init__(self, path, msg)
1692
class InvalidHttpContentType(InvalidHttpResponse):
1694
_fmt = 'Invalid http Content-type "%(ctype)s" for %(path)s: %(msg)s'
1696
def __init__(self, path, ctype, msg):
1698
InvalidHttpResponse.__init__(self, path, msg)
1701
class RedirectRequested(TransportError):
1703
_fmt = '%(source)s is%(permanently)s redirected to %(target)s'
1705
def __init__(self, source, target, is_permanent=False):
1706
self.source = source
1707
self.target = target
1709
self.permanently = ' permanently'
1711
self.permanently = ''
1712
TransportError.__init__(self)
1715
class TooManyRedirections(TransportError):
1717
_fmt = "Too many redirections"
1720
class ConflictsInTree(BzrError):
1722
_fmt = "Working tree has conflicts."
1725
class ConfigContentError(BzrError):
1727
_fmt = "Config file %(filename)s is not UTF-8 encoded\n"
1729
def __init__(self, filename):
1730
BzrError.__init__(self)
1731
self.filename = filename
1734
class ParseConfigError(BzrError):
1736
_fmt = "Error(s) parsing config file %(filename)s:\n%(errors)s"
1738
def __init__(self, errors, filename):
1739
BzrError.__init__(self)
1740
self.filename = filename
1741
self.errors = '\n'.join(e.msg for e in errors)
1744
class ConfigOptionValueError(BzrError):
1746
_fmt = """Bad value "%(value)s" for option "%(name)s"."""
1748
def __init__(self, name, value):
1749
BzrError.__init__(self, name=name, value=value)
1752
class NoEmailInUsername(BzrError):
1754
_fmt = "%(username)r does not seem to contain a reasonable email address"
1756
def __init__(self, username):
1757
BzrError.__init__(self)
1758
self.username = username
1761
class SigningFailed(BzrError):
1763
_fmt = 'Failed to GPG sign data with command "%(command_line)s"'
1765
def __init__(self, command_line):
1766
BzrError.__init__(self, command_line=command_line)
1769
class SignatureVerificationFailed(BzrError):
1771
_fmt = 'Failed to verify GPG signature data with error "%(error)s"'
1773
def __init__(self, error):
1774
BzrError.__init__(self, error=error)
1777
class DependencyNotPresent(BzrError):
1779
_fmt = 'Unable to import library "%(library)s": %(error)s'
1781
def __init__(self, library, error):
1782
BzrError.__init__(self, library=library, error=error)
1785
class GpgmeNotInstalled(DependencyNotPresent):
1787
_fmt = 'python-gpgme is not installed, it is needed to verify signatures'
1789
def __init__(self, error):
1790
DependencyNotPresent.__init__(self, 'gpgme', error)
1793
class WorkingTreeNotRevision(BzrError):
1795
_fmt = ("The working tree for %(basedir)s has changed since"
1796
" the last commit, but weave merge requires that it be"
1799
def __init__(self, tree):
1800
BzrError.__init__(self, basedir=tree.basedir)
1803
class CantReprocessAndShowBase(BzrError):
1805
_fmt = ("Can't reprocess and show base, because reprocessing obscures "
1806
"the relationship of conflicting lines to the base")
1809
class GraphCycleError(BzrError):
1811
_fmt = "Cycle in graph %(graph)r"
1813
def __init__(self, graph):
1814
BzrError.__init__(self)
1818
class WritingCompleted(InternalBzrError):
1820
_fmt = ("The MediumRequest '%(request)s' has already had finish_writing "
1821
"called upon it - accept bytes may not be called anymore.")
1823
def __init__(self, request):
1824
self.request = request
1827
class WritingNotComplete(InternalBzrError):
1829
_fmt = ("The MediumRequest '%(request)s' has not has finish_writing "
1830
"called upon it - until the write phase is complete no "
1831
"data may be read.")
1833
def __init__(self, request):
1834
self.request = request
1837
class NotConflicted(BzrError):
1839
_fmt = "File %(filename)s is not conflicted."
1841
def __init__(self, filename):
1842
BzrError.__init__(self)
1843
self.filename = filename
1846
class MediumNotConnected(InternalBzrError):
1848
_fmt = """The medium '%(medium)s' is not connected."""
1850
def __init__(self, medium):
1851
self.medium = medium
1854
class MustUseDecorated(Exception):
1856
_fmt = "A decorating function has requested its original command be used."
1859
class NoBundleFound(BzrError):
1861
_fmt = 'No bundle was found in "%(filename)s".'
1863
def __init__(self, filename):
1864
BzrError.__init__(self)
1865
self.filename = filename
1868
class BundleNotSupported(BzrError):
1870
_fmt = "Unable to handle bundle version %(version)s: %(msg)s"
1872
def __init__(self, version, msg):
1873
BzrError.__init__(self)
1874
self.version = version
1878
class MissingText(BzrError):
1880
_fmt = ("Branch %(base)s is missing revision"
1881
" %(text_revision)s of %(file_id)s")
1883
def __init__(self, branch, text_revision, file_id):
1884
BzrError.__init__(self)
1885
self.branch = branch
1886
self.base = branch.base
1887
self.text_revision = text_revision
1888
self.file_id = file_id
1891
class DuplicateFileId(BzrError):
1893
_fmt = "File id {%(file_id)s} already exists in inventory as %(entry)s"
1895
def __init__(self, file_id, entry):
1896
BzrError.__init__(self)
1897
self.file_id = file_id
1901
class DuplicateKey(BzrError):
1903
_fmt = "Key %(key)s is already present in map"
1906
class DuplicateHelpPrefix(BzrError):
1908
_fmt = "The prefix %(prefix)s is in the help search path twice."
1910
def __init__(self, prefix):
1911
self.prefix = prefix
1914
class MalformedTransform(InternalBzrError):
1916
_fmt = "Tree transform is malformed %(conflicts)r"
1919
class NoFinalPath(BzrError):
1921
_fmt = ("No final name for trans_id %(trans_id)r\n"
1922
"file-id: %(file_id)r\n"
1923
"root trans-id: %(root_trans_id)r\n")
1925
def __init__(self, trans_id, transform):
1926
self.trans_id = trans_id
1927
self.file_id = transform.final_file_id(trans_id)
1928
self.root_trans_id = transform.root
1931
class BzrBadParameter(InternalBzrError):
1933
_fmt = "Bad parameter: %(param)r"
1935
# This exception should never be thrown, but it is a base class for all
1936
# parameter-to-function errors.
1938
def __init__(self, param):
1939
BzrError.__init__(self)
1943
class BzrBadParameterNotUnicode(BzrBadParameter):
1945
_fmt = "Parameter %(param)s is neither unicode nor utf8."
1948
class ReusingTransform(BzrError):
1950
_fmt = "Attempt to reuse a transform that has already been applied."
1953
class CantMoveRoot(BzrError):
1955
_fmt = "Moving the root directory is not supported at this time"
1958
class TransformRenameFailed(BzrError):
1960
_fmt = "Failed to rename %(from_path)s to %(to_path)s: %(why)s"
1962
def __init__(self, from_path, to_path, why, errno):
1963
self.from_path = from_path
1964
self.to_path = to_path
1969
class BzrMoveFailedError(BzrError):
1971
_fmt = ("Could not move %(from_path)s%(operator)s %(to_path)s"
1972
"%(_has_extra)s%(extra)s")
1974
def __init__(self, from_path='', to_path='', extra=None):
1975
from bzrlib.osutils import splitpath
1976
BzrError.__init__(self)
1978
self.extra, self._has_extra = extra, ': '
1980
self.extra = self._has_extra = ''
1982
has_from = len(from_path) > 0
1983
has_to = len(to_path) > 0
1985
self.from_path = splitpath(from_path)[-1]
1990
self.to_path = splitpath(to_path)[-1]
1995
if has_from and has_to:
1996
self.operator = " =>"
1998
self.from_path = "from " + from_path
2000
self.operator = "to"
2002
self.operator = "file"
2005
class BzrRenameFailedError(BzrMoveFailedError):
2007
_fmt = ("Could not rename %(from_path)s%(operator)s %(to_path)s"
2008
"%(_has_extra)s%(extra)s")
2010
def __init__(self, from_path, to_path, extra=None):
2011
BzrMoveFailedError.__init__(self, from_path, to_path, extra)
2014
class BzrBadParameterNotString(BzrBadParameter):
2016
_fmt = "Parameter %(param)s is not a string or unicode string."
2019
class BzrBadParameterMissing(BzrBadParameter):
2021
_fmt = "Parameter %(param)s is required but not present."
2024
class BzrBadParameterUnicode(BzrBadParameter):
2026
_fmt = ("Parameter %(param)s is unicode but"
2027
" only byte-strings are permitted.")
2030
class BzrBadParameterContainsNewline(BzrBadParameter):
2032
_fmt = "Parameter %(param)s contains a newline."
2035
class ParamikoNotPresent(DependencyNotPresent):
2037
_fmt = "Unable to import paramiko (required for sftp support): %(error)s"
2039
def __init__(self, error):
2040
DependencyNotPresent.__init__(self, 'paramiko', error)
2043
class PointlessMerge(BzrError):
2045
_fmt = "Nothing to merge."
2048
class UninitializableFormat(BzrError):
2050
_fmt = "Format %(format)s cannot be initialised by this version of bzr."
2052
def __init__(self, format):
2053
BzrError.__init__(self)
2054
self.format = format
2057
class BadConversionTarget(BzrError):
2059
_fmt = "Cannot convert from format %(from_format)s to format %(format)s." \
2062
def __init__(self, problem, format, from_format=None):
2063
BzrError.__init__(self)
2064
self.problem = problem
2065
self.format = format
2066
self.from_format = from_format or '(unspecified)'
2069
class NoDiffFound(BzrError):
2071
_fmt = 'Could not find an appropriate Differ for file "%(path)s"'
2073
def __init__(self, path):
2074
BzrError.__init__(self, path)
2077
class ExecutableMissing(BzrError):
2079
_fmt = "%(exe_name)s could not be found on this machine"
2081
def __init__(self, exe_name):
2082
BzrError.__init__(self, exe_name=exe_name)
2085
class NoDiff(BzrError):
2087
_fmt = "Diff is not installed on this machine: %(msg)s"
2089
def __init__(self, msg):
2090
BzrError.__init__(self, msg=msg)
2093
class NoDiff3(BzrError):
2095
_fmt = "Diff3 is not installed on this machine."
2098
class ExistingContent(BzrError):
2099
# Added in bzrlib 0.92, used by VersionedFile.add_lines.
2101
_fmt = "The content being inserted is already present."
2104
class ExistingLimbo(BzrError):
2106
_fmt = """This tree contains left-over files from a failed operation.
2107
Please examine %(limbo_dir)s to see if it contains any files you wish to
2108
keep, and delete it when you are done."""
2110
def __init__(self, limbo_dir):
2111
BzrError.__init__(self)
2112
self.limbo_dir = limbo_dir
2115
class ExistingPendingDeletion(BzrError):
2117
_fmt = """This tree contains left-over files from a failed operation.
2118
Please examine %(pending_deletion)s to see if it contains any files you
2119
wish to keep, and delete it when you are done."""
2121
def __init__(self, pending_deletion):
2122
BzrError.__init__(self, pending_deletion=pending_deletion)
2125
class ImmortalLimbo(BzrError):
2127
_fmt = """Unable to delete transform temporary directory %(limbo_dir)s.
2128
Please examine %(limbo_dir)s to see if it contains any files you wish to
2129
keep, and delete it when you are done."""
2131
def __init__(self, limbo_dir):
2132
BzrError.__init__(self)
2133
self.limbo_dir = limbo_dir
2136
class ImmortalPendingDeletion(BzrError):
2138
_fmt = ("Unable to delete transform temporary directory "
2139
"%(pending_deletion)s. Please examine %(pending_deletion)s to see if it "
2140
"contains any files you wish to keep, and delete it when you are done.")
2142
def __init__(self, pending_deletion):
2143
BzrError.__init__(self, pending_deletion=pending_deletion)
2146
class OutOfDateTree(BzrError):
2148
_fmt = "Working tree is out of date, please run 'bzr update'.%(more)s"
2150
def __init__(self, tree, more=None):
2155
BzrError.__init__(self)
2160
class PublicBranchOutOfDate(BzrError):
2162
_fmt = 'Public branch "%(public_location)s" lacks revision '\
2165
def __init__(self, public_location, revstring):
2166
import bzrlib.urlutils as urlutils
2167
public_location = urlutils.unescape_for_display(public_location,
2169
BzrError.__init__(self, public_location=public_location,
2170
revstring=revstring)
2173
class MergeModifiedFormatError(BzrError):
2175
_fmt = "Error in merge modified format"
2178
class ConflictFormatError(BzrError):
2180
_fmt = "Format error in conflict listings"
2183
class CorruptDirstate(BzrError):
2185
_fmt = ("Inconsistency in dirstate file %(dirstate_path)s.\n"
2186
"Error: %(description)s")
2188
def __init__(self, dirstate_path, description):
2189
BzrError.__init__(self)
2190
self.dirstate_path = dirstate_path
2191
self.description = description
2194
class CorruptRepository(BzrError):
2196
_fmt = ("An error has been detected in the repository %(repo_path)s.\n"
2197
"Please run bzr reconcile on this repository.")
2199
def __init__(self, repo):
2200
BzrError.__init__(self)
2201
self.repo_path = repo.user_url
2204
class InconsistentDelta(BzrError):
2205
"""Used when we get a delta that is not valid."""
2207
_fmt = ("An inconsistent delta was supplied involving %(path)r,"
2208
" %(file_id)r\nreason: %(reason)s")
2210
def __init__(self, path, file_id, reason):
2211
BzrError.__init__(self)
2213
self.file_id = file_id
2214
self.reason = reason
2217
class InconsistentDeltaDelta(InconsistentDelta):
2218
"""Used when we get a delta that is not valid."""
2220
_fmt = ("An inconsistent delta was supplied: %(delta)r"
2221
"\nreason: %(reason)s")
2223
def __init__(self, delta, reason):
2224
BzrError.__init__(self)
2226
self.reason = reason
2229
class UpgradeRequired(BzrError):
2231
_fmt = "To use this feature you must upgrade your branch at %(path)s."
2233
def __init__(self, path):
2234
BzrError.__init__(self)
2238
class RepositoryUpgradeRequired(UpgradeRequired):
2240
_fmt = "To use this feature you must upgrade your repository at %(path)s."
2243
class RichRootUpgradeRequired(UpgradeRequired):
2245
_fmt = ("To use this feature you must upgrade your branch at %(path)s to"
2246
" a format which supports rich roots.")
2249
class LocalRequiresBoundBranch(BzrError):
2251
_fmt = "Cannot perform local-only commits on unbound branches."
2254
class UnsupportedOperation(BzrError):
2256
_fmt = ("The method %(mname)s is not supported on"
2257
" objects of type %(tname)s.")
2259
def __init__(self, method, method_self):
2260
self.method = method
2261
self.mname = method.__name__
2262
self.tname = type(method_self).__name__
2265
class CannotSetRevisionId(UnsupportedOperation):
2266
"""Raised when a commit is attempting to set a revision id but cant."""
2269
class NonAsciiRevisionId(UnsupportedOperation):
2270
"""Raised when a commit is attempting to set a non-ascii revision id
2275
class GhostTagsNotSupported(BzrError):
2277
_fmt = "Ghost tags not supported by format %(format)r."
2279
def __init__(self, format):
2280
self.format = format
2283
class BinaryFile(BzrError):
2285
_fmt = "File is binary but should be text."
2288
class IllegalPath(BzrError):
2290
_fmt = "The path %(path)s is not permitted on this platform"
2292
def __init__(self, path):
2293
BzrError.__init__(self)
2297
class TestamentMismatch(BzrError):
2299
_fmt = """Testament did not match expected value.
2300
For revision_id {%(revision_id)s}, expected {%(expected)s}, measured
2303
def __init__(self, revision_id, expected, measured):
2304
self.revision_id = revision_id
2305
self.expected = expected
2306
self.measured = measured
2309
class NotABundle(BzrError):
2311
_fmt = "Not a bzr revision-bundle: %(text)r"
2313
def __init__(self, text):
2314
BzrError.__init__(self)
2318
class BadBundle(BzrError):
2320
_fmt = "Bad bzr revision-bundle: %(text)r"
2322
def __init__(self, text):
2323
BzrError.__init__(self)
2327
class MalformedHeader(BadBundle):
2329
_fmt = "Malformed bzr revision-bundle header: %(text)r"
2332
class MalformedPatches(BadBundle):
2334
_fmt = "Malformed patches in bzr revision-bundle: %(text)r"
2337
class MalformedFooter(BadBundle):
2339
_fmt = "Malformed footer in bzr revision-bundle: %(text)r"
2342
class UnsupportedEOLMarker(BadBundle):
2344
_fmt = "End of line marker was not \\n in bzr revision-bundle"
2347
# XXX: BadBundle's constructor assumes there's explanatory text,
2348
# but for this there is not
2349
BzrError.__init__(self)
2352
class IncompatibleBundleFormat(BzrError):
2354
_fmt = "Bundle format %(bundle_format)s is incompatible with %(other)s"
2356
def __init__(self, bundle_format, other):
2357
BzrError.__init__(self)
2358
self.bundle_format = bundle_format
2362
class BadInventoryFormat(BzrError):
2364
_fmt = "Root class for inventory serialization errors"
2367
class UnexpectedInventoryFormat(BadInventoryFormat):
2369
_fmt = "The inventory was not in the expected format:\n %(msg)s"
2371
def __init__(self, msg):
2372
BadInventoryFormat.__init__(self, msg=msg)
2375
class RootNotRich(BzrError):
2377
_fmt = """This operation requires rich root data storage"""
2380
class NoSmartMedium(InternalBzrError):
2382
_fmt = "The transport '%(transport)s' cannot tunnel the smart protocol."
2384
def __init__(self, transport):
2385
self.transport = transport
2388
class UnknownSSH(BzrError):
2390
_fmt = "Unrecognised value for BZR_SSH environment variable: %(vendor)s"
2392
def __init__(self, vendor):
2393
BzrError.__init__(self)
2394
self.vendor = vendor
2397
class SSHVendorNotFound(BzrError):
2399
_fmt = ("Don't know how to handle SSH connections."
2400
" Please set BZR_SSH environment variable.")
2403
class GhostRevisionsHaveNoRevno(BzrError):
2404
"""When searching for revnos, if we encounter a ghost, we are stuck"""
2406
_fmt = ("Could not determine revno for {%(revision_id)s} because"
2407
" its ancestry shows a ghost at {%(ghost_revision_id)s}")
2409
def __init__(self, revision_id, ghost_revision_id):
2410
self.revision_id = revision_id
2411
self.ghost_revision_id = ghost_revision_id
2414
class GhostRevisionUnusableHere(BzrError):
2416
_fmt = "Ghost revision {%(revision_id)s} cannot be used here."
2418
def __init__(self, revision_id):
2419
BzrError.__init__(self)
2420
self.revision_id = revision_id
2423
class IllegalUseOfScopeReplacer(InternalBzrError):
2425
_fmt = ("ScopeReplacer object %(name)r was used incorrectly:"
2426
" %(msg)s%(extra)s")
2428
def __init__(self, name, msg, extra=None):
2429
BzrError.__init__(self)
2433
self.extra = ': ' + str(extra)
2438
class InvalidImportLine(InternalBzrError):
2440
_fmt = "Not a valid import statement: %(msg)\n%(text)s"
2442
def __init__(self, text, msg):
2443
BzrError.__init__(self)
2448
class ImportNameCollision(InternalBzrError):
2450
_fmt = ("Tried to import an object to the same name as"
2451
" an existing object. %(name)s")
2453
def __init__(self, name):
2454
BzrError.__init__(self)
2458
class NotAMergeDirective(BzrError):
2459
"""File starting with %(firstline)r is not a merge directive"""
2460
def __init__(self, firstline):
2461
BzrError.__init__(self, firstline=firstline)
2464
class NoMergeSource(BzrError):
2465
"""Raise if no merge source was specified for a merge directive"""
2467
_fmt = "A merge directive must provide either a bundle or a public"\
2471
class IllegalMergeDirectivePayload(BzrError):
2472
"""A merge directive contained something other than a patch or bundle"""
2474
_fmt = "Bad merge directive payload %(start)r"
2476
def __init__(self, start):
2481
class PatchVerificationFailed(BzrError):
2482
"""A patch from a merge directive could not be verified"""
2484
_fmt = "Preview patch does not match requested changes."
2487
class PatchMissing(BzrError):
2488
"""Raise a patch type was specified but no patch supplied"""
2490
_fmt = "Patch_type was %(patch_type)s, but no patch was supplied."
2492
def __init__(self, patch_type):
2493
BzrError.__init__(self)
2494
self.patch_type = patch_type
2497
class TargetNotBranch(BzrError):
2498
"""A merge directive's target branch is required, but isn't a branch"""
2500
_fmt = ("Your branch does not have all of the revisions required in "
2501
"order to merge this merge directive and the target "
2502
"location specified in the merge directive is not a branch: "
2505
def __init__(self, location):
2506
BzrError.__init__(self)
2507
self.location = location
2510
class UnsupportedInventoryKind(BzrError):
2512
_fmt = """Unsupported entry kind %(kind)s"""
2514
def __init__(self, kind):
2518
class BadSubsumeSource(BzrError):
2520
_fmt = "Can't subsume %(other_tree)s into %(tree)s. %(reason)s"
2522
def __init__(self, tree, other_tree, reason):
2524
self.other_tree = other_tree
2525
self.reason = reason
2528
class SubsumeTargetNeedsUpgrade(BzrError):
2530
_fmt = """Subsume target %(other_tree)s needs to be upgraded."""
2532
def __init__(self, other_tree):
2533
self.other_tree = other_tree
2536
class BadReferenceTarget(InternalBzrError):
2538
_fmt = "Can't add reference to %(other_tree)s into %(tree)s." \
2541
def __init__(self, tree, other_tree, reason):
2543
self.other_tree = other_tree
2544
self.reason = reason
2547
class NoSuchTag(BzrError):
2549
_fmt = "No such tag: %(tag_name)s"
2551
def __init__(self, tag_name):
2552
self.tag_name = tag_name
2555
class TagsNotSupported(BzrError):
2557
_fmt = ("Tags not supported by %(branch)s;"
2558
" you may be able to use bzr upgrade.")
2560
def __init__(self, branch):
2561
self.branch = branch
2564
class TagAlreadyExists(BzrError):
2566
_fmt = "Tag %(tag_name)s already exists."
2568
def __init__(self, tag_name):
2569
self.tag_name = tag_name
2572
class MalformedBugIdentifier(BzrError):
2574
_fmt = ('Did not understand bug identifier %(bug_id)s: %(reason)s. '
2575
'See "bzr help bugs" for more information on this feature.')
2577
def __init__(self, bug_id, reason):
2578
self.bug_id = bug_id
2579
self.reason = reason
2582
class InvalidBugTrackerURL(BzrError):
2584
_fmt = ("The URL for bug tracker \"%(abbreviation)s\" doesn't "
2585
"contain {id}: %(url)s")
2587
def __init__(self, abbreviation, url):
2588
self.abbreviation = abbreviation
2592
class UnknownBugTrackerAbbreviation(BzrError):
2594
_fmt = ("Cannot find registered bug tracker called %(abbreviation)s "
2597
def __init__(self, abbreviation, branch):
2598
self.abbreviation = abbreviation
2599
self.branch = branch
2602
class InvalidLineInBugsProperty(BzrError):
2604
_fmt = ("Invalid line in bugs property: '%(line)s'")
2606
def __init__(self, line):
2610
class InvalidBugStatus(BzrError):
2612
_fmt = ("Invalid bug status: '%(status)s'")
2614
def __init__(self, status):
2615
self.status = status
2618
class UnexpectedSmartServerResponse(BzrError):
2620
_fmt = "Could not understand response from smart server: %(response_tuple)r"
2622
def __init__(self, response_tuple):
2623
self.response_tuple = response_tuple
2626
class ErrorFromSmartServer(BzrError):
2627
"""An error was received from a smart server.
2629
:seealso: UnknownErrorFromSmartServer
2632
_fmt = "Error received from smart server: %(error_tuple)r"
2634
internal_error = True
2636
def __init__(self, error_tuple):
2637
self.error_tuple = error_tuple
2639
self.error_verb = error_tuple[0]
2641
self.error_verb = None
2642
self.error_args = error_tuple[1:]
2645
class UnknownErrorFromSmartServer(BzrError):
2646
"""An ErrorFromSmartServer could not be translated into a typical bzrlib
2649
This is distinct from ErrorFromSmartServer so that it is possible to
2650
distinguish between the following two cases:
2652
- ErrorFromSmartServer was uncaught. This is logic error in the client
2653
and so should provoke a traceback to the user.
2654
- ErrorFromSmartServer was caught but its error_tuple could not be
2655
translated. This is probably because the server sent us garbage, and
2656
should not provoke a traceback.
2659
_fmt = "Server sent an unexpected error: %(error_tuple)r"
2661
internal_error = False
2663
def __init__(self, error_from_smart_server):
2666
:param error_from_smart_server: An ErrorFromSmartServer instance.
2668
self.error_from_smart_server = error_from_smart_server
2669
self.error_tuple = error_from_smart_server.error_tuple
2672
class ContainerError(BzrError):
2673
"""Base class of container errors."""
2676
class UnknownContainerFormatError(ContainerError):
2678
_fmt = "Unrecognised container format: %(container_format)r"
2680
def __init__(self, container_format):
2681
self.container_format = container_format
2684
class UnexpectedEndOfContainerError(ContainerError):
2686
_fmt = "Unexpected end of container stream"
2689
class UnknownRecordTypeError(ContainerError):
2691
_fmt = "Unknown record type: %(record_type)r"
2693
def __init__(self, record_type):
2694
self.record_type = record_type
2697
class InvalidRecordError(ContainerError):
2699
_fmt = "Invalid record: %(reason)s"
2701
def __init__(self, reason):
2702
self.reason = reason
2705
class ContainerHasExcessDataError(ContainerError):
2707
_fmt = "Container has data after end marker: %(excess)r"
2709
def __init__(self, excess):
2710
self.excess = excess
2713
class DuplicateRecordNameError(ContainerError):
2715
_fmt = "Container has multiple records with the same name: %(name)s"
2717
def __init__(self, name):
2718
self.name = name.decode("utf-8")
2721
class NoDestinationAddress(InternalBzrError):
2723
_fmt = "Message does not have a destination address."
2726
class RepositoryDataStreamError(BzrError):
2728
_fmt = "Corrupt or incompatible data stream: %(reason)s"
2730
def __init__(self, reason):
2731
self.reason = reason
2734
class SMTPError(BzrError):
2736
_fmt = "SMTP error: %(error)s"
2738
def __init__(self, error):
2742
class NoMessageSupplied(BzrError):
2744
_fmt = "No message supplied."
2747
class NoMailAddressSpecified(BzrError):
2749
_fmt = "No mail-to address (--mail-to) or output (-o) specified."
2752
class UnknownMailClient(BzrError):
2754
_fmt = "Unknown mail client: %(mail_client)s"
2756
def __init__(self, mail_client):
2757
BzrError.__init__(self, mail_client=mail_client)
2760
class MailClientNotFound(BzrError):
2762
_fmt = "Unable to find mail client with the following names:"\
2763
" %(mail_command_list_string)s"
2765
def __init__(self, mail_command_list):
2766
mail_command_list_string = ', '.join(mail_command_list)
2767
BzrError.__init__(self, mail_command_list=mail_command_list,
2768
mail_command_list_string=mail_command_list_string)
2770
class SMTPConnectionRefused(SMTPError):
2772
_fmt = "SMTP connection to %(host)s refused"
2774
def __init__(self, error, host):
2779
class DefaultSMTPConnectionRefused(SMTPConnectionRefused):
2781
_fmt = "Please specify smtp_server. No server at default %(host)s."
2784
class BzrDirError(BzrError):
2786
def __init__(self, bzrdir):
2787
import bzrlib.urlutils as urlutils
2788
display_url = urlutils.unescape_for_display(bzrdir.user_url,
2790
BzrError.__init__(self, bzrdir=bzrdir, display_url=display_url)
2793
class UnsyncedBranches(BzrDirError):
2795
_fmt = ("'%(display_url)s' is not in sync with %(target_url)s. See"
2796
" bzr help sync-for-reconfigure.")
2798
def __init__(self, bzrdir, target_branch):
2799
BzrDirError.__init__(self, bzrdir)
2800
import bzrlib.urlutils as urlutils
2801
self.target_url = urlutils.unescape_for_display(target_branch.base,
2805
class AlreadyBranch(BzrDirError):
2807
_fmt = "'%(display_url)s' is already a branch."
2810
class AlreadyTree(BzrDirError):
2812
_fmt = "'%(display_url)s' is already a tree."
2815
class AlreadyCheckout(BzrDirError):
2817
_fmt = "'%(display_url)s' is already a checkout."
2820
class AlreadyLightweightCheckout(BzrDirError):
2822
_fmt = "'%(display_url)s' is already a lightweight checkout."
2825
class AlreadyUsingShared(BzrDirError):
2827
_fmt = "'%(display_url)s' is already using a shared repository."
2830
class AlreadyStandalone(BzrDirError):
2832
_fmt = "'%(display_url)s' is already standalone."
2835
class AlreadyWithTrees(BzrDirError):
2837
_fmt = ("Shared repository '%(display_url)s' already creates "
2841
class AlreadyWithNoTrees(BzrDirError):
2843
_fmt = ("Shared repository '%(display_url)s' already doesn't create "
2847
class ReconfigurationNotSupported(BzrDirError):
2849
_fmt = "Requested reconfiguration of '%(display_url)s' is not supported."
2852
class NoBindLocation(BzrDirError):
2854
_fmt = "No location could be found to bind to at %(display_url)s."
2857
class UncommittedChanges(BzrError):
2859
_fmt = ('Working tree "%(display_url)s" has uncommitted changes'
2860
' (See bzr status).%(more)s')
2862
def __init__(self, tree, more=None):
2867
import bzrlib.urlutils as urlutils
2868
user_url = getattr(tree, "user_url", None)
2869
if user_url is None:
2870
display_url = str(tree)
2872
display_url = urlutils.unescape_for_display(user_url, 'ascii')
2873
BzrError.__init__(self, tree=tree, display_url=display_url, more=more)
2876
class ShelvedChanges(UncommittedChanges):
2878
_fmt = ('Working tree "%(display_url)s" has shelved changes'
2879
' (See bzr shelve --list).%(more)s')
2882
class MissingTemplateVariable(BzrError):
2884
_fmt = 'Variable {%(name)s} is not available.'
2886
def __init__(self, name):
2890
class NoTemplate(BzrError):
2892
_fmt = 'No template specified.'
2895
class UnableCreateSymlink(BzrError):
2897
_fmt = 'Unable to create symlink %(path_str)son this platform'
2899
def __init__(self, path=None):
2903
path_str = repr(str(path))
2904
except UnicodeEncodeError:
2905
path_str = repr(path)
2907
self.path_str = path_str
2910
class UnsupportedTimezoneFormat(BzrError):
2912
_fmt = ('Unsupported timezone format "%(timezone)s", '
2913
'options are "utc", "original", "local".')
2915
def __init__(self, timezone):
2916
self.timezone = timezone
2919
class CommandAvailableInPlugin(StandardError):
2921
internal_error = False
2923
def __init__(self, cmd_name, plugin_metadata, provider):
2925
self.plugin_metadata = plugin_metadata
2926
self.cmd_name = cmd_name
2927
self.provider = provider
2931
_fmt = ('"%s" is not a standard bzr command. \n'
2932
'However, the following official plugin provides this command: %s\n'
2933
'You can install it by going to: %s'
2934
% (self.cmd_name, self.plugin_metadata['name'],
2935
self.plugin_metadata['url']))
2940
class NoPluginAvailable(BzrError):
2944
class UnableEncodePath(BzrError):
2946
_fmt = ('Unable to encode %(kind)s path %(path)r in '
2947
'user encoding %(user_encoding)s')
2949
def __init__(self, path, kind):
2950
from bzrlib.osutils import get_user_encoding
2953
self.user_encoding = get_user_encoding()
2956
class NoSuchConfig(BzrError):
2958
_fmt = ('The "%(config_id)s" configuration does not exist.')
2960
def __init__(self, config_id):
2961
BzrError.__init__(self, config_id=config_id)
2964
class NoSuchConfigOption(BzrError):
2966
_fmt = ('The "%(option_name)s" configuration option does not exist.')
2968
def __init__(self, option_name):
2969
BzrError.__init__(self, option_name=option_name)
2972
class NoSuchAlias(BzrError):
2974
_fmt = ('The alias "%(alias_name)s" does not exist.')
2976
def __init__(self, alias_name):
2977
BzrError.__init__(self, alias_name=alias_name)
2980
class DirectoryLookupFailure(BzrError):
2981
"""Base type for lookup errors."""
2986
class InvalidLocationAlias(DirectoryLookupFailure):
2988
_fmt = '"%(alias_name)s" is not a valid location alias.'
2990
def __init__(self, alias_name):
2991
DirectoryLookupFailure.__init__(self, alias_name=alias_name)
2994
class UnsetLocationAlias(DirectoryLookupFailure):
2996
_fmt = 'No %(alias_name)s location assigned.'
2998
def __init__(self, alias_name):
2999
DirectoryLookupFailure.__init__(self, alias_name=alias_name[1:])
3002
class CannotBindAddress(BzrError):
3004
_fmt = 'Cannot bind address "%(host)s:%(port)i": %(orig_error)s.'
3006
def __init__(self, host, port, orig_error):
3007
# nb: in python2.4 socket.error doesn't have a useful repr
3008
BzrError.__init__(self, host=host, port=port,
3009
orig_error=repr(orig_error.args))
3012
class UnknownRules(BzrError):
3014
_fmt = ('Unknown rules detected: %(unknowns_str)s.')
3016
def __init__(self, unknowns):
3017
BzrError.__init__(self, unknowns_str=", ".join(unknowns))
3020
class TipChangeRejected(BzrError):
3021
"""A pre_change_branch_tip hook function may raise this to cleanly and
3022
explicitly abort a change to a branch tip.
3025
_fmt = u"Tip change rejected: %(msg)s"
3027
def __init__(self, msg):
3031
class ShelfCorrupt(BzrError):
3033
_fmt = "Shelf corrupt."
3036
class DecompressCorruption(BzrError):
3038
_fmt = "Corruption while decompressing repository file%(orig_error)s"
3040
def __init__(self, orig_error=None):
3041
if orig_error is not None:
3042
self.orig_error = ", %s" % (orig_error,)
3044
self.orig_error = ""
3045
BzrError.__init__(self)
3048
class NoSuchShelfId(BzrError):
3050
_fmt = 'No changes are shelved with id "%(shelf_id)d".'
3052
def __init__(self, shelf_id):
3053
BzrError.__init__(self, shelf_id=shelf_id)
3056
class InvalidShelfId(BzrError):
3058
_fmt = '"%(invalid_id)s" is not a valid shelf id, try a number instead.'
3060
def __init__(self, invalid_id):
3061
BzrError.__init__(self, invalid_id=invalid_id)
3064
class JailBreak(BzrError):
3066
_fmt = "An attempt to access a url outside the server jail was made: '%(url)s'."
3068
def __init__(self, url):
3069
BzrError.__init__(self, url=url)
3072
class UserAbort(BzrError):
3074
_fmt = 'The user aborted the operation.'
3077
class MustHaveWorkingTree(BzrError):
3079
_fmt = ("Branching '%(url)s'(%(format)s) must create a working tree.")
3081
def __init__(self, format, url):
3082
BzrError.__init__(self, format=format, url=url)
3085
class NoSuchView(BzrError):
3086
"""A view does not exist.
3089
_fmt = u"No such view: %(view_name)s."
3091
def __init__(self, view_name):
3092
self.view_name = view_name
3095
class ViewsNotSupported(BzrError):
3096
"""Views are not supported by a tree format.
3099
_fmt = ("Views are not supported by %(tree)s;"
3100
" use 'bzr upgrade' to change your tree to a later format.")
3102
def __init__(self, tree):
3106
class FileOutsideView(BzrError):
3108
_fmt = ('Specified file "%(file_name)s" is outside the current view: '
3111
def __init__(self, file_name, view_files):
3112
self.file_name = file_name
3113
self.view_str = ", ".join(view_files)
3116
class UnresumableWriteGroup(BzrError):
3118
_fmt = ("Repository %(repository)s cannot resume write group "
3119
"%(write_groups)r: %(reason)s")
3121
internal_error = True
3123
def __init__(self, repository, write_groups, reason):
3124
self.repository = repository
3125
self.write_groups = write_groups
3126
self.reason = reason
3129
class UnsuspendableWriteGroup(BzrError):
3131
_fmt = ("Repository %(repository)s cannot suspend a write group.")
3133
internal_error = True
3135
def __init__(self, repository):
3136
self.repository = repository
3139
class LossyPushToSameVCS(BzrError):
3141
_fmt = ("Lossy push not possible between %(source_branch)r and "
3142
"%(target_branch)r that are in the same VCS.")
3144
internal_error = True
3146
def __init__(self, source_branch, target_branch):
3147
self.source_branch = source_branch
3148
self.target_branch = target_branch
3151
class NoRoundtrippingSupport(BzrError):
3153
_fmt = ("Roundtripping is not supported between %(source_branch)r and "
3154
"%(target_branch)r.")
3156
internal_error = True
3158
def __init__(self, source_branch, target_branch):
3159
self.source_branch = source_branch
3160
self.target_branch = target_branch
3163
class FileTimestampUnavailable(BzrError):
3165
_fmt = "The filestamp for %(path)s is not available."
3167
internal_error = True
3169
def __init__(self, path):
3173
class NoColocatedBranchSupport(BzrError):
3175
_fmt = ("%(bzrdir)r does not support co-located branches.")
3177
def __init__(self, bzrdir):
3178
self.bzrdir = bzrdir
3181
class NoWhoami(BzrError):
3183
_fmt = ('Unable to determine your name.\n'
3184
"Please, set your name with the 'whoami' command.\n"
3185
'E.g. bzr whoami "Your Name <name@example.com>"')
3188
class InvalidPattern(BzrError):
3190
_fmt = ('Invalid pattern(s) found. %(msg)s')
3192
def __init__(self, msg):
3196
class RecursiveBind(BzrError):
3198
_fmt = ('Branch "%(branch_url)s" appears to be bound to itself. '
3199
'Please use `bzr unbind` to fix.')
3201
def __init__(self, branch_url):
3202
self.branch_url = branch_url
3205
# FIXME: I would prefer to define the config related exception classes in
3206
# config.py but the lazy import mechanism proscribes this -- vila 20101222
3207
class OptionExpansionLoop(BzrError):
3209
_fmt = 'Loop involving %(refs)r while expanding "%(string)s".'
3211
def __init__(self, string, refs):
3212
self.string = string
3213
self.refs = '->'.join(refs)
3216
class ExpandingUnknownOption(BzrError):
3218
_fmt = 'Option %(name)s is not defined while expanding "%(string)s".'
3220
def __init__(self, name, string):
3222
self.string = string
3225
class NoCompatibleInter(BzrError):
3227
_fmt = ('No compatible object available for operations from %(source)r '
3230
def __init__(self, source, target):
3231
self.source = source
3232
self.target = target
3235
class HpssVfsRequestNotAllowed(BzrError):
3237
_fmt = ("VFS requests over the smart server are not allowed. Encountered: "
3238
"%(method)s, %(arguments)s.")
3240
def __init__(self, method, arguments):
3241
self.method = method
3242
self.arguments = arguments
3245
class UnsupportedKindChange(BzrError):
3247
_fmt = ("Kind change from %(from_kind)s to %(to_kind)s for "
3248
"%(path)s not supported by format %(format)r")
3250
def __init__(self, path, from_kind, to_kind, format):
3252
self.from_kind = from_kind
3253
self.to_kind = to_kind
3254
self.format = format
3257
class MissingFeature(BzrError):
3259
_fmt = ("Missing feature %(feature)s not provided by this "
3260
"version of Bazaar or any plugin.")
3262
def __init__(self, feature):
3263
self.feature = feature
3266
class PatchSyntax(BzrError):
3267
"""Base class for patch syntax errors."""
3270
class BinaryFiles(BzrError):
3272
_fmt = 'Binary files section encountered.'
3274
def __init__(self, orig_name, mod_name):
3275
self.orig_name = orig_name
3276
self.mod_name = mod_name
3279
class MalformedPatchHeader(PatchSyntax):
3281
_fmt = "Malformed patch header. %(desc)s\n%(line)r"
3283
def __init__(self, desc, line):
3288
class MalformedHunkHeader(PatchSyntax):
3290
_fmt = "Malformed hunk header. %(desc)s\n%(line)r"
3292
def __init__(self, desc, line):
3297
class MalformedLine(PatchSyntax):
3299
_fmt = "Malformed line. %(desc)s\n%(line)r"
3301
def __init__(self, desc, line):
3306
class PatchConflict(BzrError):
3308
_fmt = ('Text contents mismatch at line %(line_no)d. Original has '
3309
'"%(orig_line)s", but patch says it should be "%(patch_line)s"')
3311
def __init__(self, line_no, orig_line, patch_line):
3312
self.line_no = line_no
3313
self.orig_line = orig_line.rstrip('\n')
3314
self.patch_line = patch_line.rstrip('\n')
3317
class FeatureAlreadyRegistered(BzrError):
3319
_fmt = 'The feature %(feature)s has already been registered.'
3321
def __init__(self, feature):
3322
self.feature = feature
47
"""Specified file is of a kind that cannot be added.
49
(For example a symlink or device file.)"""
53
class ForbiddenFileError(BzrError):
54
"""Cannot operate on a file because it is a control file."""
58
class LockError(Exception):
59
"""All exceptions from the lock/unlock functions should be from
60
this exception class. They will be translated as necessary. The
61
original exception is available as e.original_error
63
def __init__(self, e=None):
64
self.original_error = e
66
Exception.__init__(self, e)
68
Exception.__init__(self)
71
class PointlessCommit(Exception):
72
"""Commit failed because nothing was changed."""
added
removed
bzrlib/errors.py
