1
# -*- coding: UTF-8 -*-
1
# Copyright (C) 2005-2013, 2016 Canonical Ltd
3
3
# This program is free software; you can redistribute it and/or modify
4
4
# it under the terms of the GNU General Public License as published by
5
5
# the Free Software Foundation; either version 2 of the License, or
6
6
# (at your option) any later version.
8
8
# This program is distributed in the hope that it will be useful,
9
9
# but WITHOUT ANY WARRANTY; without even the implied warranty of
10
10
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
11
11
# GNU General Public License for more details.
13
13
# You should have received a copy of the GNU General Public License
14
14
# along with this program; if not, write to the Free Software
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
18
__copyright__ = "Copyright (C) 2005 Canonical Ltd."
19
__author__ = "Martin Pool <mbp@canonical.com>"
22
######################################################################
24
class BzrError(StandardError):
28
class BzrCheckError(BzrError):
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
17
"""Exceptions for bzr, and reporting of them.
21
# TODO: is there any value in providing the .args field used by standard
22
# python exceptions? A list of values with no names seems less useful
25
# TODO: Perhaps convert the exception to a string at the moment it's
26
# constructed to make sure it will succeed. But that says nothing about
27
# exceptions that are never raised.
29
# TODO: selftest assertRaises should probably also check that every error
30
# raised can be formatted as a string successfully, and without giving
34
# return codes from the brz program
37
EXIT_INTERNAL_ERROR = 4
40
class BzrError(Exception):
42
Base class for errors raised by breezy.
44
:cvar internal_error: if True this was probably caused by a brz bug and
45
should be displayed with a traceback; if False (or absent) this was
46
probably a user or environment error and they don't need the gory
47
details. (That can be overridden by -Derror on the command line.)
49
:cvar _fmt: Format string to display the error; this is expanded
50
by the instance's dict.
53
internal_error = False
55
def __init__(self, msg=None, **kwds):
56
"""Construct a new BzrError.
58
There are two alternative forms for constructing these objects.
59
Either a preformatted string may be passed, or a set of named
60
arguments can be given. The first is for generic "user" errors which
61
are not intended to be caught and so do not need a specific subclass.
62
The second case is for use with subclasses that provide a _fmt format
63
string to print the arguments.
65
Keyword arguments are taken as parameters to the error, which can
66
be inserted into the format string template. It's recommended
67
that subclasses override the __init__ method to require specific
70
:param msg: If given, this is the literal complete text for the error,
71
not subject to expansion. 'msg' is used instead of 'message' because
72
python evolved and, in 2.6, forbids the use of 'message'.
74
Exception.__init__(self)
76
# I was going to deprecate this, but it actually turns out to be
77
# quite handy - mbp 20061103.
78
self._preformatted_string = msg
80
self._preformatted_string = None
81
for key, value in kwds.items():
82
setattr(self, key, value)
85
s = getattr(self, '_preformatted_string', None)
87
# 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.
98
except Exception as e:
100
return 'Unprintable exception %s: dict=%r, fmt=%r, error=%r' \
101
% (self.__class__.__name__,
103
getattr(self, '_fmt', None),
109
return '%s(%s)' % (self.__class__.__name__, str(self))
111
def _get_format_string(self):
112
"""Return format string for this exception or None"""
113
fmt = getattr(self, '_fmt', None)
115
from breezy.i18n import gettext
116
return gettext(fmt) # _fmt strings should be ascii
118
def __eq__(self, other):
119
if self.__class__ is not other.__class__:
120
return NotImplemented
121
return self.__dict__ == other.__dict__
127
class InternalBzrError(BzrError):
128
"""Base class for errors that are internal in nature.
130
This is a convenience class for errors that are internal. The
131
internal_error attribute can still be altered in subclasses, if needed.
132
Using this class is simply an easy way to get internal errors.
135
internal_error = True
138
class BranchError(BzrError):
139
"""Base class for concrete 'errors about a branch'."""
141
def __init__(self, branch):
142
BzrError.__init__(self, branch=branch)
145
class BzrCheckError(InternalBzrError):
147
_fmt = "Internal check failed: %(msg)s"
149
def __init__(self, msg):
150
BzrError.__init__(self)
154
class IncompatibleVersion(BzrError):
156
_fmt = 'API %(api)s is not compatible; one of versions %(wanted)r '\
157
'is required, but current version is %(current)r.'
159
def __init__(self, api, wanted, current):
162
self.current = current
165
class InProcessTransport(BzrError):
167
_fmt = "The transport '%(transport)s' is only accessible within this " \
170
def __init__(self, transport):
171
self.transport = transport
32
174
class InvalidRevisionNumber(BzrError):
176
_fmt = "Invalid revision number %(revno)s"
33
178
def __init__(self, revno):
37
return 'invalid revision number: %r' % self.args[0]
179
BzrError.__init__(self)
40
183
class InvalidRevisionId(BzrError):
44
class BzrCommandError(BzrError):
45
# Error from malformed user command
49
class NotBranchError(BzrError):
50
"""Specified path is not in a branch"""
185
_fmt = "Invalid revision-id {%(revision_id)s} in %(branch)s"
187
def __init__(self, revision_id, branch):
188
# branch can be any string or object with __str__ defined
189
BzrError.__init__(self)
190
self.revision_id = revision_id
194
class ReservedId(BzrError):
196
_fmt = "Reserved revision-id {%(revision_id)s}"
198
def __init__(self, revision_id):
199
self.revision_id = revision_id
202
class RootMissing(InternalBzrError):
204
_fmt = ("The root entry of a tree must be the first entry supplied to "
205
"the commit builder.")
208
class NoPublicBranch(BzrError):
210
_fmt = 'There is no public branch set for "%(branch_url)s".'
212
def __init__(self, branch):
213
from . import urlutils
214
public_location = urlutils.unescape_for_display(branch.base, 'ascii')
215
BzrError.__init__(self, branch_url=public_location)
218
class NoSuchId(BzrError):
220
_fmt = 'The file id "%(file_id)s" is not present in the tree %(tree)s.'
222
def __init__(self, tree, file_id):
223
BzrError.__init__(self)
224
self.file_id = file_id
228
class NotStacked(BranchError):
230
_fmt = "The branch '%(branch)s' is not stacked."
233
class NoWorkingTree(BzrError):
235
_fmt = 'No WorkingTree exists for "%(base)s".'
237
def __init__(self, base):
238
BzrError.__init__(self)
242
class NotLocalUrl(BzrError):
244
_fmt = "%(url)s is not a local path."
246
def __init__(self, url):
250
class WorkingTreeAlreadyPopulated(InternalBzrError):
252
_fmt = 'Working tree already populated in "%(base)s"'
254
def __init__(self, base):
258
class NoWhoami(BzrError):
260
_fmt = ('Unable to determine your name.\n'
261
"Please, set your name with the 'whoami' command.\n"
262
'E.g. brz whoami "Your Name <name@example.com>"')
265
class CommandError(BzrError):
266
"""Error from user command"""
268
# Error from malformed user command; please avoid raising this as a
269
# generic exception not caused by user input.
271
# I think it's a waste of effort to differentiate between errors that
272
# are not intended to be caught anyway. UI code need not subclass
273
# CommandError, and non-UI code should not throw a subclass of
274
# CommandError. ADHB 20051211
277
# Provide the old name as backup, for the moment.
278
BzrCommandError = CommandError
281
class NotWriteLocked(BzrError):
283
_fmt = """%(not_locked)r is not write locked but needs to be."""
285
def __init__(self, not_locked):
286
self.not_locked = not_locked
289
class StrictCommitFailed(BzrError):
291
_fmt = "Commit refused because there are unknown files in the tree"
294
# XXX: Should be unified with TransportError; they seem to represent the
296
# RBC 20060929: I think that unifiying with TransportError would be a mistake
297
# - this is finer than a TransportError - and more useful as such. It
298
# differentiates between 'transport has failed' and 'operation on a transport
300
class PathError(BzrError):
302
_fmt = "Generic path error: %(path)r%(extra)s)"
304
def __init__(self, path, extra=None):
305
BzrError.__init__(self)
308
self.extra = ': ' + str(extra)
313
class NoSuchFile(PathError):
315
_fmt = "No such file: %(path)r%(extra)s"
318
class FileExists(PathError):
320
_fmt = "File exists: %(path)r%(extra)s"
323
class RenameFailedFilesExist(BzrError):
324
"""Used when renaming and both source and dest exist."""
326
_fmt = ("Could not rename %(source)s => %(dest)s because both files exist."
327
" (Use --after to tell brz about a rename that has already"
328
" happened)%(extra)s")
330
def __init__(self, source, dest, extra=None):
331
BzrError.__init__(self)
332
self.source = str(source)
333
self.dest = str(dest)
335
self.extra = ' ' + str(extra)
340
class NotADirectory(PathError):
342
_fmt = '"%(path)s" is not a directory %(extra)s'
345
class NotInWorkingDirectory(PathError):
347
_fmt = '"%(path)s" is not in the working directory %(extra)s'
350
class DirectoryNotEmpty(PathError):
352
_fmt = 'Directory not empty: "%(path)s"%(extra)s'
355
class HardLinkNotSupported(PathError):
357
_fmt = 'Hard-linking "%(path)s" is not supported'
360
class ReadingCompleted(InternalBzrError):
362
_fmt = ("The MediumRequest '%(request)s' has already had finish_reading "
363
"called upon it - the request has been completed and no more "
366
def __init__(self, request):
367
self.request = request
370
class ResourceBusy(PathError):
372
_fmt = 'Device or resource busy: "%(path)s"%(extra)s'
375
class PermissionDenied(PathError):
377
_fmt = 'Permission denied: "%(path)s"%(extra)s'
380
class UnsupportedProtocol(PathError):
382
_fmt = 'Unsupported protocol for url "%(path)s"%(extra)s'
384
def __init__(self, url, extra=""):
385
PathError.__init__(self, url, extra=extra)
388
class UnstackableLocationError(BzrError):
390
_fmt = "The branch '%(branch_url)s' cannot be stacked on '%(target_url)s'."
392
def __init__(self, branch_url, target_url):
393
BzrError.__init__(self)
394
self.branch_url = branch_url
395
self.target_url = target_url
398
class UnstackableRepositoryFormat(BzrError):
400
_fmt = ("The repository '%(url)s'(%(format)s) is not a stackable format. "
401
"You will need to upgrade the repository to permit branch stacking.")
403
def __init__(self, format, url):
404
BzrError.__init__(self)
409
class ReadError(PathError):
411
_fmt = """Error reading from %(path)r."""
414
class ShortReadvError(PathError):
416
_fmt = ('readv() read %(actual)s bytes rather than %(length)s bytes'
417
' at %(offset)s for "%(path)s"%(extra)s')
419
internal_error = True
421
def __init__(self, path, offset, length, actual, extra=None):
422
PathError.__init__(self, path, extra=extra)
428
class PathNotChild(PathError):
430
_fmt = 'Path "%(path)s" is not a child of path "%(base)s"%(extra)s'
432
internal_error = False
434
def __init__(self, path, base, extra=None):
435
BzrError.__init__(self)
439
self.extra = ': ' + str(extra)
444
class InvalidNormalization(PathError):
446
_fmt = 'Path "%(path)s" is not unicode normalized'
449
# TODO: This is given a URL; we try to unescape it but doing that from inside
450
# the exception object is a bit undesirable.
451
# TODO: Probably this behavior of should be a common superclass
452
class NotBranchError(PathError):
454
_fmt = 'Not a branch: "%(path)s"%(detail)s.'
456
def __init__(self, path, detail=None, controldir=None):
457
from . import urlutils
458
path = urlutils.unescape_for_display(path, 'ascii')
459
if detail is not None:
460
detail = ': ' + detail
462
self.controldir = controldir
463
PathError.__init__(self, path=path)
466
return '<%s %r>' % (self.__class__.__name__, self.__dict__)
468
def _get_format_string(self):
469
# GZ 2017-06-08: Not the best place to lazy fill detail in.
470
if self.detail is None:
471
self.detail = self._get_detail()
472
return super(NotBranchError, self)._get_format_string()
474
def _get_detail(self):
475
if self.controldir is not None:
477
self.controldir.open_repository()
478
except NoRepositoryPresent:
480
except Exception as e:
481
# Just ignore unexpected errors. Raising arbitrary errors
482
# during str(err) can provoke strange bugs. Concretely
483
# Launchpad's codehosting managed to raise NotBranchError
484
# here, and then get stuck in an infinite loop/recursion
485
# trying to str() that error. All this error really cares
486
# about that there's no working repository there, and if
487
# open_repository() fails, there probably isn't.
488
return ': ' + e.__class__.__name__
490
return ': location is a repository'
494
class NoSubmitBranch(PathError):
496
_fmt = 'No submit branch available for branch "%(path)s"'
498
def __init__(self, branch):
499
from . import urlutils
500
self.path = urlutils.unescape_for_display(branch.base, 'ascii')
503
class AlreadyControlDirError(PathError):
505
_fmt = 'A control directory already exists: "%(path)s".'
508
class AlreadyBranchError(PathError):
510
_fmt = 'Already a branch: "%(path)s".'
513
class InvalidBranchName(PathError):
515
_fmt = "Invalid branch name: %(name)s"
517
def __init__(self, name):
518
BzrError.__init__(self)
522
class ParentBranchExists(AlreadyBranchError):
524
_fmt = 'Parent branch already exists: "%(path)s".'
527
class BranchExistsWithoutWorkingTree(PathError):
529
_fmt = 'Directory contains a branch, but no working tree \
530
(use brz checkout if you wish to build a working tree): "%(path)s"'
533
class InaccessibleParent(PathError):
535
_fmt = ('Parent not accessible given base "%(base)s" and'
536
' relative path "%(path)s"')
538
def __init__(self, path, base):
539
PathError.__init__(self, path)
543
class NoRepositoryPresent(BzrError):
545
_fmt = 'No repository present: "%(path)s"'
547
def __init__(self, controldir):
548
BzrError.__init__(self)
549
self.path = controldir.transport.clone('..').base
552
class UnsupportedFormatError(BzrError):
554
_fmt = "Unsupported branch format: %(format)s\nPlease run 'brz upgrade'"
557
class UnknownFormatError(BzrError):
559
_fmt = "Unknown %(kind)s format: %(format)r"
561
def __init__(self, format, kind='branch'):
566
class IncompatibleFormat(BzrError):
568
_fmt = "Format %(format)s is not compatible with .bzr version %(controldir)s."
570
def __init__(self, format, controldir_format):
571
BzrError.__init__(self)
573
self.controldir = controldir_format
576
class ParseFormatError(BzrError):
578
_fmt = "Parse error on line %(lineno)d of %(format)s format: %(line)s"
580
def __init__(self, format, lineno, line, text):
581
BzrError.__init__(self)
588
class IncompatibleRepositories(BzrError):
589
"""Report an error that two repositories are not compatible.
591
Note that the source and target repositories are permitted to be strings:
592
this exception is thrown from the smart server and may refer to a
593
repository the client hasn't opened.
596
_fmt = "%(target)s\n" \
597
"is not compatible with\n" \
601
def __init__(self, source, target, details=None):
603
details = "(no details)"
604
BzrError.__init__(self, target=target, source=source, details=details)
607
class IncompatibleRevision(BzrError):
609
_fmt = "Revision is not compatible with %(repo_format)s"
611
def __init__(self, repo_format):
612
BzrError.__init__(self)
613
self.repo_format = repo_format
616
class AlreadyVersionedError(BzrError):
617
"""Used when a path is expected not to be versioned, but it is."""
619
_fmt = "%(context_info)s%(path)s is already versioned."
621
def __init__(self, path, context_info=None):
622
"""Construct a new AlreadyVersionedError.
624
:param path: This is the path which is versioned,
625
which should be in a user friendly form.
626
:param context_info: If given, this is information about the context,
627
which could explain why this is expected to not be versioned.
629
BzrError.__init__(self)
631
if context_info is None:
632
self.context_info = ''
634
self.context_info = context_info + ". "
54
637
class NotVersionedError(BzrError):
55
"""Specified object is not versioned."""
638
"""Used when a path is expected to be versioned, but it is not."""
640
_fmt = "%(context_info)s%(path)s is not versioned."
642
def __init__(self, path, context_info=None):
643
"""Construct a new NotVersionedError.
645
:param path: This is the path which is not versioned,
646
which should be in a user friendly form.
647
:param context_info: If given, this is information about the context,
648
which could explain why this is expected to be versioned.
650
BzrError.__init__(self)
652
if context_info is None:
653
self.context_info = ''
655
self.context_info = context_info + ". "
658
class PathsNotVersionedError(BzrError):
659
"""Used when reporting several paths which are not versioned"""
661
_fmt = "Path(s) are not versioned: %(paths_as_string)s"
663
def __init__(self, paths):
664
from breezy.osutils import quotefn
665
BzrError.__init__(self)
667
self.paths_as_string = ' '.join([quotefn(p) for p in paths])
670
class PathsDoNotExist(BzrError):
672
_fmt = "Path(s) do not exist: %(paths_as_string)s%(extra)s"
674
# used when reporting that paths are neither versioned nor in the working
677
def __init__(self, paths, extra=None):
679
from breezy.osutils import quotefn
680
BzrError.__init__(self)
682
self.paths_as_string = ' '.join([quotefn(p) for p in paths])
684
self.extra = ': ' + str(extra)
58
689
class BadFileKindError(BzrError):
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."""
87
class NoSuchRevision(BzrError):
691
_fmt = 'Cannot operate on "%(filename)s" of unsupported kind "%(kind)s"'
693
def __init__(self, filename, kind):
694
BzrError.__init__(self, filename=filename, kind=kind)
697
class BadFilenameEncoding(BzrError):
699
_fmt = ('Filename %(filename)r is not valid in your current filesystem'
700
' encoding %(fs_encoding)s')
702
def __init__(self, filename, fs_encoding):
703
BzrError.__init__(self)
704
self.filename = filename
705
self.fs_encoding = fs_encoding
708
class ForbiddenControlFileError(BzrError):
710
_fmt = 'Cannot operate on "%(filename)s" because it is a control file'
713
class LockError(InternalBzrError):
715
_fmt = "Lock error: %(msg)s"
717
# All exceptions from the lock/unlock functions should be from
718
# this exception class. They will be translated as necessary. The
719
# original exception is available as e.original_error
721
# New code should prefer to raise specific subclasses
722
def __init__(self, msg):
726
class LockActive(LockError):
728
_fmt = "The lock for '%(lock_description)s' is in use and cannot be broken."
730
internal_error = False
732
def __init__(self, lock_description):
733
self.lock_description = lock_description
736
class CommitNotPossible(LockError):
738
_fmt = "A commit was attempted but we do not have a write lock open."
744
class AlreadyCommitted(LockError):
746
_fmt = "A rollback was requested, but is not able to be accomplished."
752
class ReadOnlyError(LockError):
754
_fmt = "A write attempt was made in a read only transaction on %(obj)s"
756
# TODO: There should also be an error indicating that you need a write
757
# lock and don't have any lock at all... mbp 20070226
759
def __init__(self, obj):
763
class LockFailed(LockError):
765
internal_error = False
767
_fmt = "Cannot lock %(lock)s: %(why)s"
769
def __init__(self, lock, why):
770
LockError.__init__(self, '')
775
class OutSideTransaction(BzrError):
777
_fmt = ("A transaction related operation was attempted after"
778
" the transaction finished.")
781
class ObjectNotLocked(LockError):
783
_fmt = "%(obj)r is not locked"
785
# this can indicate that any particular object is not locked; see also
786
# LockNotHeld which means that a particular *lock* object is not held by
787
# the caller -- perhaps they should be unified.
788
def __init__(self, obj):
792
class ReadOnlyObjectDirtiedError(ReadOnlyError):
794
_fmt = "Cannot change object %(obj)r in read only transaction"
796
def __init__(self, obj):
800
class UnlockableTransport(LockError):
802
internal_error = False
804
_fmt = "Cannot lock: transport is read only: %(transport)s"
806
def __init__(self, transport):
807
self.transport = transport
810
class LockContention(LockError):
812
_fmt = 'Could not acquire lock "%(lock)s": %(msg)s'
814
internal_error = False
816
def __init__(self, lock, msg=''):
821
class LockBroken(LockError):
823
_fmt = ("Lock was broken while still open: %(lock)s"
824
" - check storage consistency!")
826
internal_error = False
828
def __init__(self, lock):
832
class LockBreakMismatch(LockError):
834
_fmt = ("Lock was released and re-acquired before being broken:"
835
" %(lock)s: held by %(holder)r, wanted to break %(target)r")
837
internal_error = False
839
def __init__(self, lock, holder, target):
845
class LockCorrupt(LockError):
847
_fmt = ("Lock is apparently held, but corrupted: %(corruption_info)s\n"
848
"Use 'brz break-lock' to clear it")
850
internal_error = False
852
def __init__(self, corruption_info, file_data=None):
853
self.corruption_info = corruption_info
854
self.file_data = file_data
857
class LockNotHeld(LockError):
859
_fmt = "Lock not held: %(lock)s"
861
internal_error = False
863
def __init__(self, lock):
867
class TokenLockingNotSupported(LockError):
869
_fmt = "The object %(obj)s does not support token specifying a token when locking."
871
def __init__(self, obj):
875
class TokenMismatch(LockBroken):
877
_fmt = "The lock token %(given_token)r does not match lock token %(lock_token)r."
879
internal_error = True
881
def __init__(self, given_token, lock_token):
882
self.given_token = given_token
883
self.lock_token = lock_token
886
class UpgradeReadonly(BzrError):
888
_fmt = "Upgrade URL cannot work with readonly URLs."
891
class UpToDateFormat(BzrError):
893
_fmt = "The branch format %(format)s is already at the most recent format."
895
def __init__(self, format):
896
BzrError.__init__(self)
900
class NoSuchRevision(InternalBzrError):
902
_fmt = "%(branch)s has no revision %(revision)s"
88
904
def __init__(self, branch, revision):
90
self.revision = revision
91
msg = "Branch %s has no revision %s" % (branch, revision)
92
BzrError.__init__(self, msg)
905
# 'branch' may sometimes be an internal object like a KnitRevisionStore
906
BzrError.__init__(self, branch=branch, revision=revision)
909
class RangeInChangeOption(BzrError):
911
_fmt = "Option --change does not accept revision ranges"
914
class NoSuchRevisionSpec(BzrError):
916
_fmt = "No namespace registered for string: %(spec)r"
918
def __init__(self, spec):
919
BzrError.__init__(self, spec=spec)
922
class NoSuchRevisionInTree(NoSuchRevision):
923
"""When using Tree.revision_tree, and the revision is not accessible."""
925
_fmt = "The revision id {%(revision_id)s} is not present in the tree %(tree)s."
927
def __init__(self, tree, revision_id):
928
BzrError.__init__(self)
930
self.revision_id = revision_id
933
class AppendRevisionsOnlyViolation(BzrError):
935
_fmt = ('Operation denied because it would change the main history,'
936
' which is not permitted by the append_revisions_only setting on'
937
' branch "%(location)s".')
939
def __init__(self, location):
940
import breezy.urlutils as urlutils
941
location = urlutils.unescape_for_display(location, 'ascii')
942
BzrError.__init__(self, location=location)
95
945
class DivergedBranches(BzrError):
947
_fmt = ("These branches have diverged."
948
" Use the missing command to see how.\n"
949
"Use the merge command to reconcile them.")
96
951
def __init__(self, branch1, branch2):
97
BzrError.__init__(self, "These branches have diverged.")
98
952
self.branch1 = branch1
99
953
self.branch2 = branch2
101
class UnrelatedBranches(BzrCommandError):
103
msg = "Branches have no common ancestor, and no base revision"\
105
BzrCommandError.__init__(self, msg)
956
class NotLefthandHistory(InternalBzrError):
958
_fmt = "Supplied history does not follow left-hand parents"
960
def __init__(self, history):
961
BzrError.__init__(self, history=history)
964
class UnrelatedBranches(BzrError):
966
_fmt = ("Branches have no common ancestor, and"
967
" no merge base revision was specified.")
970
class CannotReverseCherrypick(BzrError):
972
_fmt = ('Selected merge cannot perform reverse cherrypicks. Try merge3'
107
976
class NoCommonAncestor(BzrError):
978
_fmt = "Revisions have no common ancestor: %(revision_a)s %(revision_b)s"
108
980
def __init__(self, revision_a, revision_b):
109
msg = "Revisions have no common ancestor: %s %s." \
110
% (revision_a, revision_b)
111
BzrError.__init__(self, msg)
981
self.revision_a = revision_a
982
self.revision_b = revision_b
113
985
class NoCommonRoot(BzrError):
987
_fmt = ("Revisions are not derived from the same root: "
988
"%(revision_a)s %(revision_b)s.")
114
990
def __init__(self, revision_a, revision_b):
115
msg = "Revisions are not derived from the same root: %s %s." \
116
% (revision_a, revision_b)
117
BzrError.__init__(self, msg)
991
BzrError.__init__(self, revision_a=revision_a, revision_b=revision_b)
119
994
class NotAncestor(BzrError):
996
_fmt = "Revision %(rev_id)s is not an ancestor of %(not_ancestor_id)s"
120
998
def __init__(self, rev_id, not_ancestor_id):
121
msg = "Revision %s is not an ancestor of %s" % (not_ancestor_id,
123
BzrError.__init__(self, msg)
125
self.not_ancestor_id = not_ancestor_id
128
class InstallFailed(BzrError):
129
def __init__(self, revisions):
130
msg = "Could not install revisions:\n%s" % " ,".join(revisions)
131
BzrError.__init__(self, msg)
132
self.revisions = revisions
135
class AmbiguousBase(BzrError):
136
def __init__(self, bases):
137
msg = "The correct base is unclear, becase %s are all equally close" %\
139
BzrError.__init__(self, msg)
142
class NoCommits(BzrError):
143
def __init__(self, branch):
144
msg = "Branch %s has no commits." % branch
145
BzrError.__init__(self, msg)
999
BzrError.__init__(self, rev_id=rev_id,
1000
not_ancestor_id=not_ancestor_id)
1003
class NoCommits(BranchError):
1005
_fmt = "Branch %(branch)s has no commits."
1008
class UnlistableStore(BzrError):
1010
def __init__(self, store):
1011
BzrError.__init__(self, "Store %s is not listable" % store)
1014
class UnlistableBranch(BzrError):
1016
def __init__(self, br):
1017
BzrError.__init__(self, "Stores for branch %s are not listable" % br)
1020
class BoundBranchOutOfDate(BzrError):
1022
_fmt = ("Bound branch %(branch)s is out of date with master branch"
1023
" %(master)s.%(extra_help)s")
1025
def __init__(self, branch, master):
1026
BzrError.__init__(self)
1027
self.branch = branch
1028
self.master = master
1029
self.extra_help = ''
1032
class CommitToDoubleBoundBranch(BzrError):
1034
_fmt = ("Cannot commit to branch %(branch)s."
1035
" It is bound to %(master)s, which is bound to %(remote)s.")
1037
def __init__(self, branch, master, remote):
1038
BzrError.__init__(self)
1039
self.branch = branch
1040
self.master = master
1041
self.remote = remote
1044
class OverwriteBoundBranch(BzrError):
1046
_fmt = "Cannot pull --overwrite to a branch which is bound %(branch)s"
1048
def __init__(self, branch):
1049
BzrError.__init__(self)
1050
self.branch = branch
1053
class BoundBranchConnectionFailure(BzrError):
1055
_fmt = ("Unable to connect to target of bound branch %(branch)s"
1056
" => %(target)s: %(error)s")
1058
def __init__(self, branch, target, error):
1059
BzrError.__init__(self)
1060
self.branch = branch
1061
self.target = target
1065
class VersionedFileError(BzrError):
1067
_fmt = "Versioned file error"
1070
class RevisionNotPresent(VersionedFileError):
1072
_fmt = 'Revision {%(revision_id)s} not present in "%(file_id)s".'
1074
def __init__(self, revision_id, file_id):
1075
VersionedFileError.__init__(self)
1076
self.revision_id = revision_id
1077
self.file_id = file_id
1080
class RevisionAlreadyPresent(VersionedFileError):
1082
_fmt = 'Revision {%(revision_id)s} already present in "%(file_id)s".'
1084
def __init__(self, revision_id, file_id):
1085
VersionedFileError.__init__(self)
1086
self.revision_id = revision_id
1087
self.file_id = file_id
1090
class VersionedFileInvalidChecksum(VersionedFileError):
1092
_fmt = "Text did not match its checksum: %(msg)s"
1095
class RetryWithNewPacks(BzrError):
1096
"""Raised when we realize that the packs on disk have changed.
1098
This is meant as more of a signaling exception, to trap between where a
1099
local error occurred and the code that can actually handle the error and
1100
code that can retry appropriately.
1103
internal_error = True
1105
_fmt = ("Pack files have changed, reload and retry. context: %(context)s"
1108
def __init__(self, context, reload_occurred, exc_info):
1109
"""create a new RetryWithNewPacks error.
1111
:param reload_occurred: Set to True if we know that the packs have
1112
already been reloaded, and we are failing because of an in-memory
1113
cache miss. If set to True then we will ignore if a reload says
1114
nothing has changed, because we assume it has already reloaded. If
1115
False, then a reload with nothing changed will force an error.
1116
:param exc_info: The original exception traceback, so if there is a
1117
problem we can raise the original error (value from sys.exc_info())
1119
BzrError.__init__(self)
1120
self.context = context
1121
self.reload_occurred = reload_occurred
1122
self.exc_info = exc_info
1123
self.orig_error = exc_info[1]
1124
# TODO: The global error handler should probably treat this by
1125
# raising/printing the original exception with a bit about
1126
# RetryWithNewPacks also not being caught
1129
class RetryAutopack(RetryWithNewPacks):
1130
"""Raised when we are autopacking and we find a missing file.
1132
Meant as a signaling exception, to tell the autopack code it should try
1136
internal_error = True
1138
_fmt = ("Pack files have changed, reload and try autopack again."
1139
" context: %(context)s %(orig_error)s")
1142
class NoSuchExportFormat(BzrError):
1144
_fmt = "Export format %(format)r not supported"
1146
def __init__(self, format):
1147
BzrError.__init__(self)
1148
self.format = format
1151
class TransportError(BzrError):
1153
_fmt = "Transport error: %(msg)s %(orig_error)s"
1155
def __init__(self, msg=None, orig_error=None):
1156
if msg is None and orig_error is not None:
1157
msg = str(orig_error)
1158
if orig_error is None:
1163
self.orig_error = orig_error
1164
BzrError.__init__(self)
1167
class TooManyConcurrentRequests(InternalBzrError):
1169
_fmt = ("The medium '%(medium)s' has reached its concurrent request limit."
1170
" Be sure to finish_writing and finish_reading on the"
1171
" currently open request.")
1173
def __init__(self, medium):
1174
self.medium = medium
1177
class SmartProtocolError(TransportError):
1179
_fmt = "Generic bzr smart protocol error: %(details)s"
1181
def __init__(self, details):
1182
self.details = details
1185
class UnexpectedProtocolVersionMarker(TransportError):
1187
_fmt = "Received bad protocol version marker: %(marker)r"
1189
def __init__(self, marker):
1190
self.marker = marker
1193
class UnknownSmartMethod(InternalBzrError):
1195
_fmt = "The server does not recognise the '%(verb)s' request."
1197
def __init__(self, verb):
1201
class SmartMessageHandlerError(InternalBzrError):
1203
_fmt = ("The message handler raised an exception:\n"
1204
"%(traceback_text)s")
1206
def __init__(self, exc_info):
1208
# GZ 2010-08-10: Cycle with exc_tb/exc_info affects at least one test
1209
self.exc_type, self.exc_value, self.exc_tb = exc_info
1210
self.exc_info = exc_info
1211
traceback_strings = traceback.format_exception(
1212
self.exc_type, self.exc_value, self.exc_tb)
1213
self.traceback_text = ''.join(traceback_strings)
1216
# A set of semi-meaningful errors which can be thrown
1217
class TransportNotPossible(TransportError):
1219
_fmt = "Transport operation not possible: %(msg)s %(orig_error)s"
1222
class ConnectionError(TransportError):
1224
_fmt = "Connection error: %(msg)s %(orig_error)s"
1227
class SocketConnectionError(ConnectionError):
1229
_fmt = "%(msg)s %(host)s%(port)s%(orig_error)s"
1231
def __init__(self, host, port=None, msg=None, orig_error=None):
1233
msg = 'Failed to connect to'
1234
if orig_error is None:
1237
orig_error = '; ' + str(orig_error)
1238
ConnectionError.__init__(self, msg=msg, orig_error=orig_error)
1243
self.port = ':%s' % port
1246
# XXX: This is also used for unexpected end of file, which is different at the
1247
# TCP level from "connection reset".
1248
class ConnectionReset(TransportError):
1250
_fmt = "Connection closed: %(msg)s %(orig_error)s"
1253
class ConnectionTimeout(ConnectionError):
1255
_fmt = "Connection Timeout: %(msg)s%(orig_error)s"
1258
class InvalidRange(TransportError):
1260
_fmt = "Invalid range access in %(path)s at %(offset)s: %(msg)s"
1262
def __init__(self, path, offset, msg=None):
1263
TransportError.__init__(self, msg)
1265
self.offset = offset
1268
class InvalidHttpResponse(TransportError):
1270
_fmt = "Invalid http response for %(path)s: %(msg)s%(orig_error)s"
1272
def __init__(self, path, msg, orig_error=None):
1274
if orig_error is None:
1277
# This is reached for obscure and unusual errors so we want to
1278
# preserve as much info as possible to ease debug.
1279
orig_error = ': %r' % (orig_error,)
1280
TransportError.__init__(self, msg, orig_error=orig_error)
1283
class UnexpectedHttpStatus(InvalidHttpResponse):
1285
_fmt = "Unexpected HTTP status %(code)d for %(path)s: %(extra)s"
1287
def __init__(self, path, code, extra=None):
1290
self.extra = extra or ''
1291
full_msg = 'status code %d unexpected' % code
1292
if extra is not None:
1293
full_msg += ': ' + extra
1294
InvalidHttpResponse.__init__(
1295
self, path, full_msg)
1298
class BadHttpRequest(UnexpectedHttpStatus):
1300
_fmt = "Bad http request for %(path)s: %(reason)s"
1302
def __init__(self, path, reason):
1304
self.reason = reason
1305
TransportError.__init__(self, reason)
1308
class InvalidHttpRange(InvalidHttpResponse):
1310
_fmt = "Invalid http range %(range)r for %(path)s: %(msg)s"
1312
def __init__(self, path, range, msg):
1314
InvalidHttpResponse.__init__(self, path, msg)
1317
class HttpBoundaryMissing(InvalidHttpResponse):
1318
"""A multipart response ends with no boundary marker.
1320
This is a special case caused by buggy proxies, described in
1321
<https://bugs.launchpad.net/bzr/+bug/198646>.
1324
_fmt = "HTTP MIME Boundary missing for %(path)s: %(msg)s"
1326
def __init__(self, path, msg):
1327
InvalidHttpResponse.__init__(self, path, msg)
1330
class InvalidHttpContentType(InvalidHttpResponse):
1332
_fmt = 'Invalid http Content-type "%(ctype)s" for %(path)s: %(msg)s'
1334
def __init__(self, path, ctype, msg):
1336
InvalidHttpResponse.__init__(self, path, msg)
1339
class RedirectRequested(TransportError):
1341
_fmt = '%(source)s is%(permanently)s redirected to %(target)s'
1343
def __init__(self, source, target, is_permanent=False):
1344
self.source = source
1345
self.target = target
1347
self.permanently = ' permanently'
1349
self.permanently = ''
1350
TransportError.__init__(self)
1353
class TooManyRedirections(TransportError):
1355
_fmt = "Too many redirections"
1358
class ConflictsInTree(BzrError):
1360
_fmt = "Working tree has conflicts."
1363
class DependencyNotPresent(BzrError):
1365
_fmt = 'Unable to import library "%(library)s": %(error)s'
1367
def __init__(self, library, error):
1368
BzrError.__init__(self, library=library, error=error)
1371
class WorkingTreeNotRevision(BzrError):
1373
_fmt = ("The working tree for %(basedir)s has changed since"
1374
" the last commit, but weave merge requires that it be"
1377
def __init__(self, tree):
1378
BzrError.__init__(self, basedir=tree.basedir)
1381
class GraphCycleError(BzrError):
1383
_fmt = "Cycle in graph %(graph)r"
1385
def __init__(self, graph):
1386
BzrError.__init__(self)
1390
class WritingCompleted(InternalBzrError):
1392
_fmt = ("The MediumRequest '%(request)s' has already had finish_writing "
1393
"called upon it - accept bytes may not be called anymore.")
1395
def __init__(self, request):
1396
self.request = request
1399
class WritingNotComplete(InternalBzrError):
1401
_fmt = ("The MediumRequest '%(request)s' has not has finish_writing "
1402
"called upon it - until the write phase is complete no "
1403
"data may be read.")
1405
def __init__(self, request):
1406
self.request = request
1409
class NotConflicted(BzrError):
1411
_fmt = "File %(filename)s is not conflicted."
1413
def __init__(self, filename):
1414
BzrError.__init__(self)
1415
self.filename = filename
1418
class MediumNotConnected(InternalBzrError):
1420
_fmt = """The medium '%(medium)s' is not connected."""
1422
def __init__(self, medium):
1423
self.medium = medium
1426
class MustUseDecorated(Exception):
1428
_fmt = "A decorating function has requested its original command be used."
1431
class NoBundleFound(BzrError):
1433
_fmt = 'No bundle was found in "%(filename)s".'
1435
def __init__(self, filename):
1436
BzrError.__init__(self)
1437
self.filename = filename
1440
class BundleNotSupported(BzrError):
1442
_fmt = "Unable to handle bundle version %(version)s: %(msg)s"
1444
def __init__(self, version, msg):
1445
BzrError.__init__(self)
1446
self.version = version
1450
class MissingText(BzrError):
1452
_fmt = ("Branch %(base)s is missing revision"
1453
" %(text_revision)s of %(file_id)s")
1455
def __init__(self, branch, text_revision, file_id):
1456
BzrError.__init__(self)
1457
self.branch = branch
1458
self.base = branch.base
1459
self.text_revision = text_revision
1460
self.file_id = file_id
1463
class DuplicateKey(BzrError):
1465
_fmt = "Key %(key)s is already present in map"
1468
class DuplicateHelpPrefix(BzrError):
1470
_fmt = "The prefix %(prefix)s is in the help search path twice."
1472
def __init__(self, prefix):
1473
self.prefix = prefix
1476
class BzrBadParameter(InternalBzrError):
1478
_fmt = "Bad parameter: %(param)r"
1480
# This exception should never be thrown, but it is a base class for all
1481
# parameter-to-function errors.
1483
def __init__(self, param):
1484
BzrError.__init__(self)
1488
class BzrBadParameterNotUnicode(BzrBadParameter):
1490
_fmt = "Parameter %(param)s is neither unicode nor utf8."
1493
class BzrMoveFailedError(BzrError):
1495
_fmt = ("Could not move %(from_path)s%(operator)s %(to_path)s"
1496
"%(_has_extra)s%(extra)s")
1498
def __init__(self, from_path='', to_path='', extra=None):
1499
from breezy.osutils import splitpath
1500
BzrError.__init__(self)
1502
self.extra, self._has_extra = extra, ': '
1504
self.extra = self._has_extra = ''
1506
has_from = len(from_path) > 0
1507
has_to = len(to_path) > 0
1509
self.from_path = splitpath(from_path)[-1]
1514
self.to_path = splitpath(to_path)[-1]
1519
if has_from and has_to:
1520
self.operator = " =>"
1522
self.from_path = "from " + from_path
1524
self.operator = "to"
1526
self.operator = "file"
1529
class BzrRenameFailedError(BzrMoveFailedError):
1531
_fmt = ("Could not rename %(from_path)s%(operator)s %(to_path)s"
1532
"%(_has_extra)s%(extra)s")
1534
def __init__(self, from_path, to_path, extra=None):
1535
BzrMoveFailedError.__init__(self, from_path, to_path, extra)
1538
class BzrBadParameterNotString(BzrBadParameter):
1540
_fmt = "Parameter %(param)s is not a string or unicode string."
1543
class BzrBadParameterMissing(BzrBadParameter):
1545
_fmt = "Parameter %(param)s is required but not present."
1548
class BzrBadParameterUnicode(BzrBadParameter):
1550
_fmt = ("Parameter %(param)s is unicode but"
1551
" only byte-strings are permitted.")
1554
class BzrBadParameterContainsNewline(BzrBadParameter):
1556
_fmt = "Parameter %(param)s contains a newline."
1559
class ParamikoNotPresent(DependencyNotPresent):
1561
_fmt = "Unable to import paramiko (required for sftp support): %(error)s"
1563
def __init__(self, error):
1564
DependencyNotPresent.__init__(self, 'paramiko', error)
1567
class PointlessMerge(BzrError):
1569
_fmt = "Nothing to merge."
1572
class UninitializableFormat(BzrError):
1574
_fmt = "Format %(format)s cannot be initialised by this version of brz."
1576
def __init__(self, format):
1577
BzrError.__init__(self)
1578
self.format = format
1581
class BadConversionTarget(BzrError):
1583
_fmt = "Cannot convert from format %(from_format)s to format %(format)s." \
1586
def __init__(self, problem, format, from_format=None):
1587
BzrError.__init__(self)
1588
self.problem = problem
1589
self.format = format
1590
self.from_format = from_format or '(unspecified)'
1593
class NoDiffFound(BzrError):
1595
_fmt = 'Could not find an appropriate Differ for file "%(path)s"'
1597
def __init__(self, path):
1598
BzrError.__init__(self, path)
1601
class ExecutableMissing(BzrError):
1603
_fmt = "%(exe_name)s could not be found on this machine"
1605
def __init__(self, exe_name):
1606
BzrError.__init__(self, exe_name=exe_name)
1609
class NoDiff(BzrError):
1611
_fmt = "Diff is not installed on this machine: %(msg)s"
1613
def __init__(self, msg):
1614
BzrError.__init__(self, msg=msg)
1617
class NoDiff3(BzrError):
1619
_fmt = "Diff3 is not installed on this machine."
1622
class ExistingLimbo(BzrError):
1624
_fmt = """This tree contains left-over files from a failed operation.
1625
Please examine %(limbo_dir)s to see if it contains any files you wish to
1626
keep, and delete it when you are done."""
1628
def __init__(self, limbo_dir):
1629
BzrError.__init__(self)
1630
self.limbo_dir = limbo_dir
1633
class ExistingPendingDeletion(BzrError):
1635
_fmt = """This tree contains left-over files from a failed operation.
1636
Please examine %(pending_deletion)s to see if it contains any files you
1637
wish to keep, and delete it when you are done."""
1639
def __init__(self, pending_deletion):
1640
BzrError.__init__(self, pending_deletion=pending_deletion)
1643
class ImmortalPendingDeletion(BzrError):
1645
_fmt = ("Unable to delete transform temporary directory "
1646
"%(pending_deletion)s. Please examine %(pending_deletion)s to see if it "
1647
"contains any files you wish to keep, and delete it when you are done.")
1649
def __init__(self, pending_deletion):
1650
BzrError.__init__(self, pending_deletion=pending_deletion)
1653
class OutOfDateTree(BzrError):
1655
_fmt = "Working tree is out of date, please run 'brz update'.%(more)s"
1657
def __init__(self, tree, more=None):
1662
BzrError.__init__(self)
1667
class PublicBranchOutOfDate(BzrError):
1669
_fmt = 'Public branch "%(public_location)s" lacks revision '\
1672
def __init__(self, public_location, revstring):
1673
import breezy.urlutils as urlutils
1674
public_location = urlutils.unescape_for_display(public_location,
1676
BzrError.__init__(self, public_location=public_location,
1677
revstring=revstring)
1680
class MergeModifiedFormatError(BzrError):
1682
_fmt = "Error in merge modified format"
1685
class ConflictFormatError(BzrError):
1687
_fmt = "Format error in conflict listings"
1690
class CorruptRepository(BzrError):
1692
_fmt = ("An error has been detected in the repository %(repo_path)s.\n"
1693
"Please run brz reconcile on this repository.")
1695
def __init__(self, repo):
1696
BzrError.__init__(self)
1697
self.repo_path = repo.user_url
1700
class InconsistentDelta(BzrError):
1701
"""Used when we get a delta that is not valid."""
1703
_fmt = ("An inconsistent delta was supplied involving %(path)r,"
1704
" %(file_id)r\nreason: %(reason)s")
1706
def __init__(self, path, file_id, reason):
1707
BzrError.__init__(self)
1709
self.file_id = file_id
1710
self.reason = reason
1713
class InconsistentDeltaDelta(InconsistentDelta):
1714
"""Used when we get a delta that is not valid."""
1716
_fmt = ("An inconsistent delta was supplied: %(delta)r"
1717
"\nreason: %(reason)s")
1719
def __init__(self, delta, reason):
1720
BzrError.__init__(self)
1722
self.reason = reason
1725
class UpgradeRequired(BzrError):
1727
_fmt = "To use this feature you must upgrade your branch at %(path)s."
1729
def __init__(self, path):
1730
BzrError.__init__(self)
1734
class RepositoryUpgradeRequired(UpgradeRequired):
1736
_fmt = "To use this feature you must upgrade your repository at %(path)s."
1739
class RichRootUpgradeRequired(UpgradeRequired):
1741
_fmt = ("To use this feature you must upgrade your branch at %(path)s to"
1742
" a format which supports rich roots.")
1745
class LocalRequiresBoundBranch(BzrError):
1747
_fmt = "Cannot perform local-only commits on unbound branches."
1750
class UnsupportedOperation(BzrError):
1752
_fmt = ("The method %(mname)s is not supported on"
1753
" objects of type %(tname)s.")
1755
def __init__(self, method, method_self):
1756
self.method = method
1757
self.mname = method.__name__
1758
self.tname = type(method_self).__name__
1761
class FetchLimitUnsupported(UnsupportedOperation):
1763
fmt = ("InterBranch %(interbranch)r does not support fetching limits.")
1765
def __init__(self, interbranch):
1766
BzrError.__init__(self, interbranch=interbranch)
1769
class NonAsciiRevisionId(UnsupportedOperation):
1770
"""Raised when a commit is attempting to set a non-ascii revision id
1775
class SharedRepositoriesUnsupported(UnsupportedOperation):
1776
_fmt = "Shared repositories are not supported by %(format)r."
1778
def __init__(self, format):
1779
BzrError.__init__(self, format=format)
1782
class GhostTagsNotSupported(BzrError):
1784
_fmt = "Ghost tags not supported by format %(format)r."
1786
def __init__(self, format):
1787
self.format = format
1790
class BinaryFile(BzrError):
1792
_fmt = "File is binary but should be text."
1795
class IllegalPath(BzrError):
1797
_fmt = "The path %(path)s is not permitted on this platform"
1799
def __init__(self, path):
1800
BzrError.__init__(self)
1804
class TestamentMismatch(BzrError):
1806
_fmt = """Testament did not match expected value.
1807
For revision_id {%(revision_id)s}, expected {%(expected)s}, measured
1810
def __init__(self, revision_id, expected, measured):
1811
self.revision_id = revision_id
1812
self.expected = expected
1813
self.measured = measured
1816
class NotABundle(BzrError):
1818
_fmt = "Not a bzr revision-bundle: %(text)r"
1820
def __init__(self, text):
1821
BzrError.__init__(self)
1825
class BadBundle(BzrError):
1827
_fmt = "Bad bzr revision-bundle: %(text)r"
1829
def __init__(self, text):
1830
BzrError.__init__(self)
1834
class MalformedHeader(BadBundle):
1836
_fmt = "Malformed bzr revision-bundle header: %(text)r"
1839
class MalformedPatches(BadBundle):
1841
_fmt = "Malformed patches in bzr revision-bundle: %(text)r"
1844
class MalformedFooter(BadBundle):
1846
_fmt = "Malformed footer in bzr revision-bundle: %(text)r"
1849
class UnsupportedEOLMarker(BadBundle):
1851
_fmt = "End of line marker was not \\n in bzr revision-bundle"
1854
# XXX: BadBundle's constructor assumes there's explanatory text,
1855
# but for this there is not
1856
BzrError.__init__(self)
1859
class IncompatibleBundleFormat(BzrError):
1861
_fmt = "Bundle format %(bundle_format)s is incompatible with %(other)s"
1863
def __init__(self, bundle_format, other):
1864
BzrError.__init__(self)
1865
self.bundle_format = bundle_format
1869
class RootNotRich(BzrError):
1871
_fmt = """This operation requires rich root data storage"""
1874
class NoSmartMedium(InternalBzrError):
1876
_fmt = "The transport '%(transport)s' cannot tunnel the smart protocol."
1878
def __init__(self, transport):
1879
self.transport = transport
1882
class UnknownSSH(BzrError):
1884
_fmt = "Unrecognised value for BRZ_SSH environment variable: %(vendor)s"
1886
def __init__(self, vendor):
1887
BzrError.__init__(self)
1888
self.vendor = vendor
1891
class SSHVendorNotFound(BzrError):
1893
_fmt = ("Don't know how to handle SSH connections."
1894
" Please set BRZ_SSH environment variable.")
1897
class GhostRevisionsHaveNoRevno(BzrError):
1898
"""When searching for revnos, if we encounter a ghost, we are stuck"""
1900
_fmt = ("Could not determine revno for {%(revision_id)s} because"
1901
" its ancestry shows a ghost at {%(ghost_revision_id)s}")
1903
def __init__(self, revision_id, ghost_revision_id):
1904
self.revision_id = revision_id
1905
self.ghost_revision_id = ghost_revision_id
1908
class GhostRevisionUnusableHere(BzrError):
1910
_fmt = "Ghost revision {%(revision_id)s} cannot be used here."
1912
def __init__(self, revision_id):
1913
BzrError.__init__(self)
1914
self.revision_id = revision_id
1917
class NotAMergeDirective(BzrError):
1918
"""File starting with %(firstline)r is not a merge directive"""
1920
def __init__(self, firstline):
1921
BzrError.__init__(self, firstline=firstline)
1924
class NoMergeSource(BzrError):
1925
"""Raise if no merge source was specified for a merge directive"""
1927
_fmt = "A merge directive must provide either a bundle or a public"\
1931
class PatchVerificationFailed(BzrError):
1932
"""A patch from a merge directive could not be verified"""
1934
_fmt = "Preview patch does not match requested changes."
1937
class PatchMissing(BzrError):
1938
"""Raise a patch type was specified but no patch supplied"""
1940
_fmt = "Patch_type was %(patch_type)s, but no patch was supplied."
1942
def __init__(self, patch_type):
1943
BzrError.__init__(self)
1944
self.patch_type = patch_type
1947
class TargetNotBranch(BzrError):
1948
"""A merge directive's target branch is required, but isn't a branch"""
1950
_fmt = ("Your branch does not have all of the revisions required in "
1951
"order to merge this merge directive and the target "
1952
"location specified in the merge directive is not a branch: "
1955
def __init__(self, location):
1956
BzrError.__init__(self)
1957
self.location = location
1960
class BadSubsumeSource(BzrError):
1962
_fmt = "Can't subsume %(other_tree)s into %(tree)s. %(reason)s"
1964
def __init__(self, tree, other_tree, reason):
1966
self.other_tree = other_tree
1967
self.reason = reason
1970
class SubsumeTargetNeedsUpgrade(BzrError):
1972
_fmt = """Subsume target %(other_tree)s needs to be upgraded."""
1974
def __init__(self, other_tree):
1975
self.other_tree = other_tree
1978
class NoSuchTag(BzrError):
1980
_fmt = "No such tag: %(tag_name)s"
1982
def __init__(self, tag_name):
1983
self.tag_name = tag_name
1986
class TagsNotSupported(BzrError):
1988
_fmt = ("Tags not supported by %(branch)s;"
1989
" you may be able to use 'brz upgrade %(branch_url)s'.")
1991
def __init__(self, branch):
1992
self.branch = branch
1993
self.branch_url = branch.user_url
1996
class TagAlreadyExists(BzrError):
1998
_fmt = "Tag %(tag_name)s already exists."
2000
def __init__(self, tag_name):
2001
self.tag_name = tag_name
2004
class UnexpectedSmartServerResponse(BzrError):
2006
_fmt = "Could not understand response from smart server: %(response_tuple)r"
2008
def __init__(self, response_tuple):
2009
self.response_tuple = response_tuple
2012
class ErrorFromSmartServer(BzrError):
2013
"""An error was received from a smart server.
2015
:seealso: UnknownErrorFromSmartServer
2018
_fmt = "Error received from smart server: %(error_tuple)r"
2020
internal_error = True
2022
def __init__(self, error_tuple):
2023
self.error_tuple = error_tuple
2025
self.error_verb = error_tuple[0]
2027
self.error_verb = None
2028
self.error_args = error_tuple[1:]
2031
class UnknownErrorFromSmartServer(BzrError):
2032
"""An ErrorFromSmartServer could not be translated into a typical breezy
2035
This is distinct from ErrorFromSmartServer so that it is possible to
2036
distinguish between the following two cases:
2038
- ErrorFromSmartServer was uncaught. This is logic error in the client
2039
and so should provoke a traceback to the user.
2040
- ErrorFromSmartServer was caught but its error_tuple could not be
2041
translated. This is probably because the server sent us garbage, and
2042
should not provoke a traceback.
2045
_fmt = "Server sent an unexpected error: %(error_tuple)r"
2047
internal_error = False
2049
def __init__(self, error_from_smart_server):
2052
:param error_from_smart_server: An ErrorFromSmartServer instance.
2054
self.error_from_smart_server = error_from_smart_server
2055
self.error_tuple = error_from_smart_server.error_tuple
2058
class ContainerError(BzrError):
2059
"""Base class of container errors."""
2062
class UnknownContainerFormatError(ContainerError):
2064
_fmt = "Unrecognised container format: %(container_format)r"
2066
def __init__(self, container_format):
2067
self.container_format = container_format
2070
class UnexpectedEndOfContainerError(ContainerError):
2072
_fmt = "Unexpected end of container stream"
2075
class UnknownRecordTypeError(ContainerError):
2077
_fmt = "Unknown record type: %(record_type)r"
2079
def __init__(self, record_type):
2080
self.record_type = record_type
2083
class InvalidRecordError(ContainerError):
2085
_fmt = "Invalid record: %(reason)s"
2087
def __init__(self, reason):
2088
self.reason = reason
2091
class ContainerHasExcessDataError(ContainerError):
2093
_fmt = "Container has data after end marker: %(excess)r"
2095
def __init__(self, excess):
2096
self.excess = excess
2099
class DuplicateRecordNameError(ContainerError):
2101
_fmt = "Container has multiple records with the same name: %(name)s"
2103
def __init__(self, name):
2104
self.name = name.decode("utf-8")
2107
class RepositoryDataStreamError(BzrError):
2109
_fmt = "Corrupt or incompatible data stream: %(reason)s"
2111
def __init__(self, reason):
2112
self.reason = reason
2115
class UncommittedChanges(BzrError):
2117
_fmt = ('Working tree "%(display_url)s" has uncommitted changes'
2118
' (See brz status).%(more)s')
2120
def __init__(self, tree, more=None):
2125
import breezy.urlutils as urlutils
2126
user_url = getattr(tree, "user_url", None)
2127
if user_url is None:
2128
display_url = str(tree)
2130
display_url = urlutils.unescape_for_display(user_url, 'ascii')
2131
BzrError.__init__(self, tree=tree, display_url=display_url, more=more)
2134
class StoringUncommittedNotSupported(BzrError):
2136
_fmt = ('Branch "%(display_url)s" does not support storing uncommitted'
2139
def __init__(self, branch):
2140
import breezy.urlutils as urlutils
2141
user_url = getattr(branch, "user_url", None)
2142
if user_url is None:
2143
display_url = str(branch)
2145
display_url = urlutils.unescape_for_display(user_url, 'ascii')
2146
BzrError.__init__(self, branch=branch, display_url=display_url)
2149
class ShelvedChanges(UncommittedChanges):
2151
_fmt = ('Working tree "%(display_url)s" has shelved changes'
2152
' (See brz shelve --list).%(more)s')
2155
class UnableEncodePath(BzrError):
2157
_fmt = ('Unable to encode %(kind)s path %(path)r in '
2158
'user encoding %(user_encoding)s')
2160
def __init__(self, path, kind):
2161
from breezy.osutils import get_user_encoding
2164
self.user_encoding = get_user_encoding()
2167
class NoSuchAlias(BzrError):
2169
_fmt = ('The alias "%(alias_name)s" does not exist.')
2171
def __init__(self, alias_name):
2172
BzrError.__init__(self, alias_name=alias_name)
2175
class CannotBindAddress(BzrError):
2177
_fmt = 'Cannot bind address "%(host)s:%(port)i": %(orig_error)s.'
2179
def __init__(self, host, port, orig_error):
2180
# nb: in python2.4 socket.error doesn't have a useful repr
2181
BzrError.__init__(self, host=host, port=port,
2182
orig_error=repr(orig_error.args))
2185
class TipChangeRejected(BzrError):
2186
"""A pre_change_branch_tip hook function may raise this to cleanly and
2187
explicitly abort a change to a branch tip.
2190
_fmt = u"Tip change rejected: %(msg)s"
2192
def __init__(self, msg):
2196
class JailBreak(BzrError):
2198
_fmt = "An attempt to access a url outside the server jail was made: '%(url)s'."
2200
def __init__(self, url):
2201
BzrError.__init__(self, url=url)
2204
class UserAbort(BzrError):
2206
_fmt = 'The user aborted the operation.'
2209
class UnresumableWriteGroup(BzrError):
2211
_fmt = ("Repository %(repository)s cannot resume write group "
2212
"%(write_groups)r: %(reason)s")
2214
internal_error = True
2216
def __init__(self, repository, write_groups, reason):
2217
self.repository = repository
2218
self.write_groups = write_groups
2219
self.reason = reason
2222
class UnsuspendableWriteGroup(BzrError):
2224
_fmt = ("Repository %(repository)s cannot suspend a write group.")
2226
internal_error = True
2228
def __init__(self, repository):
2229
self.repository = repository
2232
class LossyPushToSameVCS(BzrError):
2234
_fmt = ("Lossy push not possible between %(source_branch)r and "
2235
"%(target_branch)r that are in the same VCS.")
2237
internal_error = True
2239
def __init__(self, source_branch, target_branch):
2240
self.source_branch = source_branch
2241
self.target_branch = target_branch
2244
class NoRoundtrippingSupport(BzrError):
2246
_fmt = ("Roundtripping is not supported between %(source_branch)r and "
2247
"%(target_branch)r.")
2249
internal_error = True
2251
def __init__(self, source_branch, target_branch):
2252
self.source_branch = source_branch
2253
self.target_branch = target_branch
2256
class NoColocatedBranchSupport(BzrError):
2258
_fmt = ("%(controldir)r does not support co-located branches.")
2260
def __init__(self, controldir):
2261
self.controldir = controldir
2264
class RecursiveBind(BzrError):
2266
_fmt = ('Branch "%(branch_url)s" appears to be bound to itself. '
2267
'Please use `brz unbind` to fix.')
2269
def __init__(self, branch_url):
2270
self.branch_url = branch_url
2273
class UnsupportedKindChange(BzrError):
2275
_fmt = ("Kind change from %(from_kind)s to %(to_kind)s for "
2276
"%(path)s not supported by format %(format)r")
2278
def __init__(self, path, from_kind, to_kind, format):
2280
self.from_kind = from_kind
2281
self.to_kind = to_kind
2282
self.format = format
2285
class ChangesAlreadyStored(CommandError):
2287
_fmt = ('Cannot store uncommitted changes because this branch already'
2288
' stores uncommitted changes.')
2291
class RevnoOutOfBounds(InternalBzrError):
2293
_fmt = ("The requested revision number %(revno)d is outside of the "
2294
"expected boundaries (%(minimum)d <= %(maximum)d).")
2296
def __init__(self, revno, bounds):
2297
InternalBzrError.__init__(
2298
self, revno=revno, minimum=bounds[0], maximum=bounds[1])
added
removed
breezy/errors.py
