1
# Copyright (C) 2005, 2006, 2007 Canonical Ltd
2
# -*- coding: UTF-8 -*-
3
4
# This program is free software; you can redistribute it and/or modify
4
5
# it under the terms of the GNU General Public License as published by
5
6
# the Free Software Foundation; either version 2 of the License, or
6
7
# (at your option) any later version.
8
9
# This program is distributed in the hope that it will be useful,
9
10
# but WITHOUT ANY WARRANTY; without even the implied warranty of
10
11
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
11
12
# GNU General Public License for more details.
13
14
# You should have received a copy of the GNU General Public License
14
15
# along with this program; if not, write to the Free Software
15
16
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
17
"""Exceptions for bzr, and reporting of them.
25
from bzrlib.patches import (
34
# TODO: is there any value in providing the .args field used by standard
35
# python exceptions? A list of values with no names seems less useful
38
# TODO: Perhaps convert the exception to a string at the moment it's
39
# constructed to make sure it will succeed. But that says nothing about
40
# exceptions that are never raised.
42
# TODO: selftest assertRaises should probably also check that every error
43
# raised can be formatted as a string successfully, and without giving
19
__copyright__ = "Copyright (C) 2005 Canonical Ltd."
20
__author__ = "Martin Pool <mbp@canonical.com>"
23
######################################################################
47
25
class BzrError(StandardError):
49
Base class for errors raised by bzrlib.
51
:cvar internal_error: if true (or absent) this was probably caused by a
52
bzr bug and should be displayed with a traceback; if False this was
53
probably a user or environment error and they don't need the gory details.
54
(That can be overridden by -Derror on the command line.)
56
:cvar _fmt: Format string to display the error; this is expanded
57
by the instance's dict.
60
internal_error = False
62
def __init__(self, msg=None, **kwds):
63
"""Construct a new BzrError.
65
There are two alternative forms for constructing these objects.
66
Either a preformatted string may be passed, or a set of named
67
arguments can be given. The first is for generic "user" errors which
68
are not intended to be caught and so do not need a specific subclass.
69
The second case is for use with subclasses that provide a _fmt format
70
string to print the arguments.
72
Keyword arguments are taken as parameters to the error, which can
73
be inserted into the format string template. It's recommended
74
that subclasses override the __init__ method to require specific
77
:param msg: If given, this is the literal complete text for the error,
78
not subject to expansion.
80
StandardError.__init__(self)
82
# I was going to deprecate this, but it actually turns out to be
83
# quite handy - mbp 20061103.
84
self._preformatted_string = msg
86
self._preformatted_string = None
87
for key, value in kwds.items():
88
setattr(self, key, value)
91
s = getattr(self, '_preformatted_string', None)
93
# contains a preformatted message; must be cast to plain str
96
fmt = self._get_format_string()
98
s = fmt % self.__dict__
99
# __str__() should always return a 'str' object
100
# never a 'unicode' object.
101
if isinstance(s, unicode):
102
return s.encode('utf8')
104
except (AttributeError, TypeError, NameError, ValueError, KeyError), e:
105
return 'Unprintable exception %s: dict=%r, fmt=%r, error=%s' \
106
% (self.__class__.__name__,
108
getattr(self, '_fmt', None),
111
def _get_format_string(self):
112
"""Return format string for this exception or None"""
113
fmt = getattr(self, '_fmt', None)
116
fmt = getattr(self, '__doc__', None)
118
symbol_versioning.warn("%s uses its docstring as a format, "
119
"it should use _fmt instead" % self.__class__.__name__,
122
return 'Unprintable exception %s: dict=%r, fmt=%r' \
123
% (self.__class__.__name__,
125
getattr(self, '_fmt', None),
129
class BzrNewError(BzrError):
130
"""Deprecated error base class."""
131
# base classes should override the docstring with their human-
132
# readable explanation
134
def __init__(self, *args, **kwds):
135
# XXX: Use the underlying BzrError to always generate the args
136
# attribute if it doesn't exist. We can't use super here, because
137
# exceptions are old-style classes in python2.4 (but new in 2.5).
139
symbol_versioning.warn('BzrNewError was deprecated in bzr 0.13; '
140
'please convert %s to use BzrError instead'
141
% self.__class__.__name__,
144
BzrError.__init__(self, *args)
145
for key, value in kwds.items():
146
setattr(self, key, value)
150
# __str__() should always return a 'str' object
151
# never a 'unicode' object.
152
s = self.__doc__ % self.__dict__
153
if isinstance(s, unicode):
154
return s.encode('utf8')
156
except (TypeError, NameError, ValueError, KeyError), e:
157
return 'Unprintable exception %s(%r): %s' \
158
% (self.__class__.__name__,
159
self.__dict__, str(e))
162
class AlreadyBuilding(BzrError):
164
_fmt = "The tree builder is already building a tree."
167
28
class BzrCheckError(BzrError):
169
_fmt = "Internal check failed: %(message)s"
171
internal_error = True
173
def __init__(self, message):
174
BzrError.__init__(self)
175
self.message = message
178
class DisabledMethod(BzrError):
180
_fmt = "The smart server method '%(class_name)s' is disabled."
182
internal_error = True
184
def __init__(self, class_name):
185
BzrError.__init__(self)
186
self.class_name = class_name
189
class InvalidEntryName(BzrError):
191
_fmt = "Invalid entry name: %(name)s"
193
internal_error = True
195
def __init__(self, name):
196
BzrError.__init__(self)
200
class InvalidRevisionNumber(BzrError):
202
_fmt = "Invalid revision number %(revno)s"
204
def __init__(self, revno):
205
BzrError.__init__(self)
209
class InvalidRevisionId(BzrError):
211
_fmt = "Invalid revision-id {%(revision_id)s} in %(branch)s"
213
def __init__(self, revision_id, branch):
214
# branch can be any string or object with __str__ defined
215
BzrError.__init__(self)
216
self.revision_id = revision_id
219
class ReservedId(BzrError):
221
_fmt = "Reserved revision-id {%(revision_id)s}"
223
def __init__(self, revision_id):
224
self.revision_id = revision_id
226
class NoSuchId(BzrError):
228
_fmt = "The file id %(file_id)s is not present in the tree %(tree)s."
230
def __init__(self, tree, file_id):
231
BzrError.__init__(self)
232
self.file_id = file_id
236
class InventoryModified(BzrError):
238
_fmt = ("The current inventory for the tree %(tree)r has been modified,"
239
" so a clean inventory cannot be read without data loss.")
241
internal_error = True
243
def __init__(self, tree):
247
class NoWorkingTree(BzrError):
249
_fmt = "No WorkingTree exists for %(base)s."
251
def __init__(self, base):
252
BzrError.__init__(self)
256
class NotBuilding(BzrError):
258
_fmt = "Not currently building a tree."
261
class NotLocalUrl(BzrError):
263
_fmt = "%(url)s is not a local path."
265
def __init__(self, url):
269
class WorkingTreeAlreadyPopulated(BzrError):
271
_fmt = """Working tree already populated in %(base)s"""
273
internal_error = True
275
def __init__(self, base):
278
32
class BzrCommandError(BzrError):
279
"""Error from user command"""
281
internal_error = False
283
# Error from malformed user command; please avoid raising this as a
284
# generic exception not caused by user input.
286
# I think it's a waste of effort to differentiate between errors that
287
# are not intended to be caught anyway. UI code need not subclass
288
# BzrCommandError, and non-UI code should not throw a subclass of
289
# BzrCommandError. ADHB 20051211
290
def __init__(self, msg):
291
# Object.__str__() must return a real string
292
# returning a Unicode string is a python error.
293
if isinstance(msg, unicode):
294
self.msg = msg.encode('utf8')
302
class NotWriteLocked(BzrError):
304
_fmt = """%(not_locked)r is not write locked but needs to be."""
306
def __init__(self, not_locked):
307
self.not_locked = not_locked
310
class BzrOptionError(BzrCommandError):
312
_fmt = "Error in command line options"
315
class BadOptionValue(BzrError):
317
_fmt = """Bad value "%(value)s" for option "%(name)s"."""
319
def __init__(self, name, value):
320
BzrError.__init__(self, name=name, value=value)
323
class StrictCommitFailed(BzrError):
325
_fmt = "Commit refused because there are unknown files in the tree"
328
# XXX: Should be unified with TransportError; they seem to represent the
330
class PathError(BzrError):
332
_fmt = "Generic path error: %(path)r%(extra)s)"
334
def __init__(self, path, extra=None):
335
BzrError.__init__(self)
338
self.extra = ': ' + str(extra)
343
class NoSuchFile(PathError):
345
_fmt = "No such file: %(path)r%(extra)s"
348
class FileExists(PathError):
350
_fmt = "File exists: %(path)r%(extra)s"
353
class RenameFailedFilesExist(BzrError):
354
"""Used when renaming and both source and dest exist."""
356
_fmt = ("Could not rename %(source)s => %(dest)s because both files exist."
359
def __init__(self, source, dest, extra=None):
360
BzrError.__init__(self)
361
self.source = str(source)
362
self.dest = str(dest)
364
self.extra = ' ' + str(extra)
369
class NotADirectory(PathError):
371
_fmt = "%(path)r is not a directory %(extra)s"
374
class NotInWorkingDirectory(PathError):
376
_fmt = "%(path)r is not in the working directory %(extra)s"
379
class DirectoryNotEmpty(PathError):
381
_fmt = "Directory not empty: %(path)r%(extra)s"
384
class ReadingCompleted(BzrError):
386
_fmt = ("The MediumRequest '%(request)s' has already had finish_reading "
387
"called upon it - the request has been completed and no more "
390
internal_error = True
392
def __init__(self, request):
393
self.request = request
396
class ResourceBusy(PathError):
398
_fmt = "Device or resource busy: %(path)r%(extra)s"
401
class PermissionDenied(PathError):
403
_fmt = "Permission denied: %(path)r%(extra)s"
406
class InvalidURL(PathError):
408
_fmt = "Invalid url supplied to transport: %(path)r%(extra)s"
411
class InvalidURLJoin(PathError):
413
_fmt = "Invalid URL join request: %(args)s%(extra)s"
415
def __init__(self, msg, base, args):
416
PathError.__init__(self, base, msg)
417
self.args = [base] + list(args)
420
class UnknownHook(BzrError):
422
_fmt = "The %(type)s hook '%(hook)s' is unknown in this version of bzrlib."
424
def __init__(self, hook_type, hook_name):
425
BzrError.__init__(self)
426
self.type = hook_type
427
self.hook = hook_name
430
class UnsupportedProtocol(PathError):
432
_fmt = 'Unsupported protocol for url "%(path)s"%(extra)s'
434
def __init__(self, url, extra):
435
PathError.__init__(self, url, extra=extra)
438
class ShortReadvError(PathError):
440
_fmt = ("readv() read %(actual)s bytes rather than %(length)s bytes"
441
" at %(offset)s for %(path)s%(extra)s")
443
internal_error = True
445
def __init__(self, path, offset, length, actual, extra=None):
446
PathError.__init__(self, path, extra=extra)
452
class PathNotChild(BzrError):
454
_fmt = "Path %(path)r is not a child of path %(base)r%(extra)s"
456
internal_error = True
458
def __init__(self, path, base, extra=None):
459
BzrError.__init__(self)
463
self.extra = ': ' + str(extra)
468
class InvalidNormalization(PathError):
470
_fmt = "Path %(path)r is not unicode normalized"
473
# TODO: This is given a URL; we try to unescape it but doing that from inside
474
# the exception object is a bit undesirable.
475
# TODO: Probably this behavior of should be a common superclass
476
class NotBranchError(PathError):
478
_fmt = "Not a branch: %(path)s"
480
def __init__(self, path):
481
import bzrlib.urlutils as urlutils
482
self.path = urlutils.unescape_for_display(path, 'ascii')
485
class NoSubmitBranch(PathError):
487
_fmt = 'No submit branch available for branch "%(path)s"'
489
def __init__(self, branch):
490
import bzrlib.urlutils as urlutils
491
self.path = urlutils.unescape_for_display(branch.base, 'ascii')
494
class AlreadyBranchError(PathError):
496
_fmt = "Already a branch: %(path)s."
499
class BranchExistsWithoutWorkingTree(PathError):
501
_fmt = "Directory contains a branch, but no working tree \
502
(use bzr checkout if you wish to build a working tree): %(path)s"
505
class AtomicFileAlreadyClosed(PathError):
507
_fmt = ("'%(function)s' called on an AtomicFile after it was closed:"
510
def __init__(self, path, function):
511
PathError.__init__(self, path=path, extra=None)
512
self.function = function
515
class InaccessibleParent(PathError):
517
_fmt = ("Parent not accessible given base %(base)s and"
518
" relative path %(path)s")
520
def __init__(self, path, base):
521
PathError.__init__(self, path)
525
class NoRepositoryPresent(BzrError):
527
_fmt = "No repository present: %(path)r"
528
def __init__(self, bzrdir):
529
BzrError.__init__(self)
530
self.path = bzrdir.transport.clone('..').base
533
class FileInWrongBranch(BzrError):
535
_fmt = "File %(path)s in not in branch %(branch_base)s."
537
def __init__(self, branch, path):
538
BzrError.__init__(self)
540
self.branch_base = branch.base
544
class UnsupportedFormatError(BzrError):
546
_fmt = "Unsupported branch format: %(format)s\nPlease run 'bzr upgrade'"
549
class UnknownFormatError(BzrError):
551
_fmt = "Unknown branch format: %(format)r"
554
class IncompatibleFormat(BzrError):
556
_fmt = "Format %(format)s is not compatible with .bzr version %(bzrdir)s."
558
def __init__(self, format, bzrdir_format):
559
BzrError.__init__(self)
561
self.bzrdir = bzrdir_format
564
class IncompatibleRepositories(BzrError):
566
_fmt = "Repository %(target)s is not compatible with repository"\
569
def __init__(self, source, target):
570
BzrError.__init__(self, target=target, source=source)
573
class IncompatibleRevision(BzrError):
575
_fmt = "Revision is not compatible with %(repo_format)s"
577
def __init__(self, repo_format):
578
BzrError.__init__(self)
579
self.repo_format = repo_format
582
class AlreadyVersionedError(BzrError):
583
"""Used when a path is expected not to be versioned, but it is."""
585
_fmt = "%(context_info)s%(path)s is already versioned"
587
def __init__(self, path, context_info=None):
588
"""Construct a new AlreadyVersionedError.
590
:param path: This is the path which is versioned,
591
which should be in a user friendly form.
592
:param context_info: If given, this is information about the context,
593
which could explain why this is expected to not be versioned.
595
BzrError.__init__(self)
597
if context_info is None:
598
self.context_info = ''
600
self.context_info = context_info + ". "
603
class NotVersionedError(BzrError):
604
"""Used when a path is expected to be versioned, but it is not."""
606
_fmt = "%(context_info)s%(path)s is not versioned"
608
def __init__(self, path, context_info=None):
609
"""Construct a new NotVersionedError.
611
:param path: This is the path which is not versioned,
612
which should be in a user friendly form.
613
:param context_info: If given, this is information about the context,
614
which could explain why this is expected to be versioned.
616
BzrError.__init__(self)
618
if context_info is None:
619
self.context_info = ''
621
self.context_info = context_info + ". "
624
class PathsNotVersionedError(BzrError):
625
"""Used when reporting several paths which are not versioned"""
627
_fmt = "Path(s) are not versioned: %(paths_as_string)s"
629
def __init__(self, paths):
630
from bzrlib.osutils import quotefn
631
BzrError.__init__(self)
633
self.paths_as_string = ' '.join([quotefn(p) for p in paths])
636
class PathsDoNotExist(BzrError):
638
_fmt = "Path(s) do not exist: %(paths_as_string)s%(extra)s"
640
# used when reporting that paths are neither versioned nor in the working
643
def __init__(self, paths, extra=None):
645
from bzrlib.osutils import quotefn
646
BzrError.__init__(self)
648
self.paths_as_string = ' '.join([quotefn(p) for p in paths])
650
self.extra = ': ' + str(extra)
655
class BadFileKindError(BzrError):
657
_fmt = 'Cannot operate on "%(filename)s" of unsupported kind "%(kind)s"'
659
def __init__(self, filename, kind):
660
BzrError.__init__(self, filename=filename, kind=kind)
663
class ForbiddenControlFileError(BzrError):
665
_fmt = "Cannot operate on %(filename)s because it is a control file"
668
class LockError(BzrError):
670
_fmt = "Lock error: %(msg)s"
672
internal_error = True
674
# All exceptions from the lock/unlock functions should be from
675
# this exception class. They will be translated as necessary. The
676
# original exception is available as e.original_error
678
# New code should prefer to raise specific subclasses
679
def __init__(self, message):
680
# Python 2.5 uses a slot for StandardError.message,
681
# so use a different variable name
682
# so it is exposed in self.__dict__
686
class LockActive(LockError):
688
_fmt = "The lock for '%(lock_description)s' is in use and cannot be broken."
690
internal_error = False
692
def __init__(self, lock_description):
693
self.lock_description = lock_description
696
class CommitNotPossible(LockError):
698
_fmt = "A commit was attempted but we do not have a write lock open."
704
class AlreadyCommitted(LockError):
706
_fmt = "A rollback was requested, but is not able to be accomplished."
712
class ReadOnlyError(LockError):
714
_fmt = "A write attempt was made in a read only transaction on %(obj)s"
716
# TODO: There should also be an error indicating that you need a write
717
# lock and don't have any lock at all... mbp 20070226
719
def __init__(self, obj):
723
class ReadOnlyLockError(LockError):
725
_fmt = "Cannot acquire write lock on %(fname)s. %(msg)s"
727
def __init__(self, fname, msg):
728
LockError.__init__(self, '')
733
class OutSideTransaction(BzrError):
735
_fmt = ("A transaction related operation was attempted after"
736
" the transaction finished.")
739
class ObjectNotLocked(LockError):
741
_fmt = "%(obj)r is not locked"
743
# this can indicate that any particular object is not locked; see also
744
# LockNotHeld which means that a particular *lock* object is not held by
745
# the caller -- perhaps they should be unified.
746
def __init__(self, obj):
750
class ReadOnlyObjectDirtiedError(ReadOnlyError):
752
_fmt = "Cannot change object %(obj)r in read only transaction"
754
def __init__(self, obj):
758
class UnlockableTransport(LockError):
760
_fmt = "Cannot lock: transport is read only: %(transport)s"
762
def __init__(self, transport):
763
self.transport = transport
766
class LockContention(LockError):
768
_fmt = "Could not acquire lock %(lock)s"
769
# TODO: show full url for lock, combining the transport and relative
772
internal_error = False
774
def __init__(self, lock):
778
class LockBroken(LockError):
780
_fmt = ("Lock was broken while still open: %(lock)s"
781
" - check storage consistency!")
783
internal_error = False
785
def __init__(self, lock):
789
class LockBreakMismatch(LockError):
791
_fmt = ("Lock was released and re-acquired before being broken:"
792
" %(lock)s: held by %(holder)r, wanted to break %(target)r")
794
internal_error = False
796
def __init__(self, lock, holder, target):
802
class LockNotHeld(LockError):
804
_fmt = "Lock not held: %(lock)s"
806
internal_error = False
808
def __init__(self, lock):
812
class PointlessCommit(BzrError):
814
_fmt = "No changes to commit"
817
class UpgradeReadonly(BzrError):
819
_fmt = "Upgrade URL cannot work with readonly URLs."
822
class UpToDateFormat(BzrError):
824
_fmt = "The branch format %(format)s is already at the most recent format."
826
def __init__(self, format):
827
BzrError.__init__(self)
831
class StrictCommitFailed(Exception):
833
_fmt = "Commit refused because there are unknowns in the tree."
836
class NoSuchRevision(BzrError):
838
_fmt = "Branch %(branch)s has no revision %(revision)s"
840
internal_error = True
842
def __init__(self, branch, revision):
843
BzrError.__init__(self, branch=branch, revision=revision)
846
class NotLeftParentDescendant(BzrError):
848
_fmt = ("Revision %(old_revision)s is not the left parent of"
849
" %(new_revision)s, but branch %(branch_location)s expects this")
851
internal_error = True
853
def __init__(self, branch, old_revision, new_revision):
854
BzrError.__init__(self, branch_location=branch.base,
855
old_revision=old_revision,
856
new_revision=new_revision)
859
class NoSuchRevisionSpec(BzrError):
861
_fmt = "No namespace registered for string: %(spec)r"
863
def __init__(self, spec):
864
BzrError.__init__(self, spec=spec)
867
class NoSuchRevisionInTree(NoSuchRevision):
868
"""When using Tree.revision_tree, and the revision is not accessible."""
870
_fmt = "The revision id %(revision_id)s is not present in the tree %(tree)s."
872
def __init__(self, tree, revision_id):
873
BzrError.__init__(self)
875
self.revision_id = revision_id
878
class InvalidRevisionSpec(BzrError):
880
_fmt = ("Requested revision: %(spec)r does not exist in branch:"
881
" %(branch)s%(extra)s")
883
def __init__(self, spec, branch, extra=None):
884
BzrError.__init__(self, branch=branch, spec=spec)
886
self.extra = '\n' + str(extra)
891
class HistoryMissing(BzrError):
893
_fmt = "%(branch)s is missing %(object_type)s {%(object_id)s}"
896
class AppendRevisionsOnlyViolation(BzrError):
898
_fmt = ('Operation denied because it would change the main history,'
899
' which is not permitted by the append_revisions_only setting on'
900
' branch "%(location)s".')
902
def __init__(self, location):
903
import bzrlib.urlutils as urlutils
904
location = urlutils.unescape_for_display(location, 'ascii')
905
BzrError.__init__(self, location=location)
908
class DivergedBranches(BzrError):
910
_fmt = ("These branches have diverged."
911
" Use the merge command to reconcile them.")
913
internal_error = False
915
def __init__(self, branch1, branch2):
916
self.branch1 = branch1
917
self.branch2 = branch2
920
class NotLefthandHistory(BzrError):
922
_fmt = "Supplied history does not follow left-hand parents"
924
internal_error = True
926
def __init__(self, history):
927
BzrError.__init__(self, history=history)
930
class UnrelatedBranches(BzrError):
932
_fmt = ("Branches have no common ancestor, and"
933
" no merge base revision was specified.")
935
internal_error = False
938
class NoCommonAncestor(BzrError):
940
_fmt = "Revisions have no common ancestor: %(revision_a)s %(revision_b)s"
942
def __init__(self, revision_a, revision_b):
943
self.revision_a = revision_a
944
self.revision_b = revision_b
947
class NoCommonRoot(BzrError):
949
_fmt = ("Revisions are not derived from the same root: "
950
"%(revision_a)s %(revision_b)s.")
952
def __init__(self, revision_a, revision_b):
953
BzrError.__init__(self, revision_a=revision_a, revision_b=revision_b)
956
class NotAncestor(BzrError):
958
_fmt = "Revision %(rev_id)s is not an ancestor of %(not_ancestor_id)s"
960
def __init__(self, rev_id, not_ancestor_id):
961
BzrError.__init__(self, rev_id=rev_id,
962
not_ancestor_id=not_ancestor_id)
965
class InstallFailed(BzrError):
967
def __init__(self, revisions):
968
revision_str = ", ".join(str(r) for r in revisions)
969
msg = "Could not install revisions:\n%s" % revision_str
970
BzrError.__init__(self, msg)
971
self.revisions = revisions
974
class AmbiguousBase(BzrError):
976
def __init__(self, bases):
977
warn("BzrError AmbiguousBase has been deprecated as of bzrlib 0.8.",
979
msg = ("The correct base is unclear, because %s are all equally close"
981
BzrError.__init__(self, msg)
985
class NoCommits(BzrError):
987
_fmt = "Branch %(branch)s has no commits."
989
def __init__(self, branch):
990
BzrError.__init__(self, branch=branch)
993
class UnlistableStore(BzrError):
995
def __init__(self, store):
996
BzrError.__init__(self, "Store %s is not listable" % store)
1000
class UnlistableBranch(BzrError):
1002
def __init__(self, br):
1003
BzrError.__init__(self, "Stores for branch %s are not listable" % br)
1006
class BoundBranchOutOfDate(BzrError):
1008
_fmt = ("Bound branch %(branch)s is out of date"
1009
" with master branch %(master)s.")
1011
def __init__(self, branch, master):
1012
BzrError.__init__(self)
1013
self.branch = branch
1014
self.master = master
1017
class CommitToDoubleBoundBranch(BzrError):
1019
_fmt = ("Cannot commit to branch %(branch)s."
1020
" It is bound to %(master)s, which is bound to %(remote)s.")
1022
def __init__(self, branch, master, remote):
1023
BzrError.__init__(self)
1024
self.branch = branch
1025
self.master = master
1026
self.remote = remote
1029
class OverwriteBoundBranch(BzrError):
1031
_fmt = "Cannot pull --overwrite to a branch which is bound %(branch)s"
1033
def __init__(self, branch):
1034
BzrError.__init__(self)
1035
self.branch = branch
1038
class BoundBranchConnectionFailure(BzrError):
1040
_fmt = ("Unable to connect to target of bound branch %(branch)s"
1041
" => %(target)s: %(error)s")
1043
def __init__(self, branch, target, error):
1044
BzrError.__init__(self)
1045
self.branch = branch
1046
self.target = target
1050
class WeaveError(BzrError):
1052
_fmt = "Error in processing weave: %(message)s"
1054
def __init__(self, message=None):
1055
BzrError.__init__(self)
1056
self.message = message
1059
class WeaveRevisionAlreadyPresent(WeaveError):
1061
_fmt = "Revision {%(revision_id)s} already present in %(weave)s"
1063
def __init__(self, revision_id, weave):
1065
WeaveError.__init__(self)
1066
self.revision_id = revision_id
1070
class WeaveRevisionNotPresent(WeaveError):
1072
_fmt = "Revision {%(revision_id)s} not present in %(weave)s"
1074
def __init__(self, revision_id, weave):
1075
WeaveError.__init__(self)
1076
self.revision_id = revision_id
1080
class WeaveFormatError(WeaveError):
1082
_fmt = "Weave invariant violated: %(what)s"
1084
def __init__(self, what):
1085
WeaveError.__init__(self)
1089
class WeaveParentMismatch(WeaveError):
1091
_fmt = "Parents are mismatched between two revisions."
1094
class WeaveInvalidChecksum(WeaveError):
1096
_fmt = "Text did not match it's checksum: %(message)s"
1099
class WeaveTextDiffers(WeaveError):
1101
_fmt = ("Weaves differ on text content. Revision:"
1102
" {%(revision_id)s}, %(weave_a)s, %(weave_b)s")
1104
def __init__(self, revision_id, weave_a, weave_b):
1105
WeaveError.__init__(self)
1106
self.revision_id = revision_id
1107
self.weave_a = weave_a
1108
self.weave_b = weave_b
1111
class WeaveTextDiffers(WeaveError):
1113
_fmt = ("Weaves differ on text content. Revision:"
1114
" {%(revision_id)s}, %(weave_a)s, %(weave_b)s")
1116
def __init__(self, revision_id, weave_a, weave_b):
1117
WeaveError.__init__(self)
1118
self.revision_id = revision_id
1119
self.weave_a = weave_a
1120
self.weave_b = weave_b
1123
class VersionedFileError(BzrError):
1125
_fmt = "Versioned file error"
1128
class RevisionNotPresent(VersionedFileError):
1130
_fmt = "Revision {%(revision_id)s} not present in %(file_id)s."
1132
def __init__(self, revision_id, file_id):
1133
VersionedFileError.__init__(self)
1134
self.revision_id = revision_id
1135
self.file_id = file_id
1138
class RevisionAlreadyPresent(VersionedFileError):
1140
_fmt = "Revision {%(revision_id)s} already present in %(file_id)s."
1142
def __init__(self, revision_id, file_id):
1143
VersionedFileError.__init__(self)
1144
self.revision_id = revision_id
1145
self.file_id = file_id
1148
class KnitError(BzrError):
1152
internal_error = True
1155
class KnitHeaderError(KnitError):
1157
_fmt = "Knit header error: %(badline)r unexpected for file %(filename)s"
1159
def __init__(self, badline, filename):
1160
KnitError.__init__(self)
1161
self.badline = badline
1162
self.filename = filename
1165
class KnitCorrupt(KnitError):
1167
_fmt = "Knit %(filename)s corrupt: %(how)s"
1169
def __init__(self, filename, how):
1170
KnitError.__init__(self)
1171
self.filename = filename
1175
class KnitIndexUnknownMethod(KnitError):
1176
"""Raised when we don't understand the storage method.
1178
Currently only 'fulltext' and 'line-delta' are supported.
1181
_fmt = ("Knit index %(filename)s does not have a known method"
1182
" in options: %(options)r")
1184
def __init__(self, filename, options):
1185
KnitError.__init__(self)
1186
self.filename = filename
1187
self.options = options
1190
class NoSuchExportFormat(BzrError):
1192
_fmt = "Export format %(format)r not supported"
1194
def __init__(self, format):
1195
BzrError.__init__(self)
1196
self.format = format
1199
class TransportError(BzrError):
1201
_fmt = "Transport error: %(msg)s %(orig_error)s"
1203
def __init__(self, msg=None, orig_error=None):
1204
if msg is None and orig_error is not None:
1205
msg = str(orig_error)
1206
if orig_error is None:
1211
self.orig_error = orig_error
1212
BzrError.__init__(self)
1215
class TooManyConcurrentRequests(BzrError):
1217
_fmt = ("The medium '%(medium)s' has reached its concurrent request limit."
1218
" Be sure to finish_writing and finish_reading on the"
1219
" current request that is open.")
1221
internal_error = True
1223
def __init__(self, medium):
1224
self.medium = medium
1227
class SmartProtocolError(TransportError):
1229
_fmt = "Generic bzr smart protocol error: %(details)s"
1231
def __init__(self, details):
1232
self.details = details
1235
# A set of semi-meaningful errors which can be thrown
1236
class TransportNotPossible(TransportError):
1238
_fmt = "Transport operation not possible: %(msg)s %(orig_error)s"
1241
class ConnectionError(TransportError):
1243
_fmt = "Connection error: %(msg)s %(orig_error)s"
1246
class SocketConnectionError(ConnectionError):
1248
_fmt = "%(msg)s %(host)s%(port)s%(orig_error)s"
1250
def __init__(self, host, port=None, msg=None, orig_error=None):
1252
msg = 'Failed to connect to'
1253
if orig_error is None:
1256
orig_error = '; ' + str(orig_error)
1257
ConnectionError.__init__(self, msg=msg, orig_error=orig_error)
1262
self.port = ':%s' % port
1265
class ConnectionReset(TransportError):
1267
_fmt = "Connection closed: %(msg)s %(orig_error)s"
1270
class InvalidRange(TransportError):
1272
_fmt = "Invalid range access in %(path)s at %(offset)s."
1274
def __init__(self, path, offset):
1275
TransportError.__init__(self, ("Invalid range access in %s at %d"
1278
self.offset = offset
1281
class InvalidHttpResponse(TransportError):
1283
_fmt = "Invalid http response for %(path)s: %(msg)s"
1285
def __init__(self, path, msg, orig_error=None):
1287
TransportError.__init__(self, msg, orig_error=orig_error)
1290
class InvalidHttpRange(InvalidHttpResponse):
1292
_fmt = "Invalid http range %(range)r for %(path)s: %(msg)s"
1294
def __init__(self, path, range, msg):
1296
InvalidHttpResponse.__init__(self, path, msg)
1299
class InvalidHttpContentType(InvalidHttpResponse):
1301
_fmt = 'Invalid http Content-type "%(ctype)s" for %(path)s: %(msg)s'
1303
def __init__(self, path, ctype, msg):
1305
InvalidHttpResponse.__init__(self, path, msg)
1308
class RedirectRequested(TransportError):
1310
_fmt = '%(source)s is%(permanently)s redirected to %(target)s'
1312
def __init__(self, source, target, is_permament=False, qual_proto=None):
1313
self.source = source
1314
self.target = target
1316
self.permanently = ' permanently'
1318
self.permanently = ''
1319
self.is_permament = is_permament
1320
self._qualified_proto = qual_proto
1321
TransportError.__init__(self)
1323
def _requalify_url(self, url):
1324
"""Restore the qualified proto in front of the url"""
1325
# When this exception is raised, source and target are in
1326
# user readable format. But some transports may use a
1327
# different proto (http+urllib:// will present http:// to
1328
# the user. If a qualified proto is specified, the code
1329
# trapping the exception can get the qualified urls to
1330
# properly handle the redirection themself (creating a
1331
# new transport object from the target url for example).
1332
# But checking that the scheme of the original and
1333
# redirected urls are the same can be tricky. (see the
1334
# FIXME in BzrDir.open_from_transport for the unique use
1336
if self._qualified_proto is None:
1339
# The TODO related to NotBranchError mention that doing
1340
# that kind of manipulation on the urls may not be the
1341
# exception object job. On the other hand, this object is
1342
# the interface between the code and the user so
1343
# presenting the urls in different ways is indeed its
1346
proto, netloc, path, query, fragment = urlparse.urlsplit(url)
1347
return urlparse.urlunsplit((self._qualified_proto, netloc, path,
1350
def get_source_url(self):
1351
return self._requalify_url(self.source)
1353
def get_target_url(self):
1354
return self._requalify_url(self.target)
1357
class TooManyRedirections(TransportError):
1359
_fmt = "Too many redirections"
1361
class ConflictsInTree(BzrError):
1363
_fmt = "Working tree has conflicts."
1366
class ParseConfigError(BzrError):
1368
def __init__(self, errors, filename):
1369
if filename is None:
1371
message = "Error(s) parsing config file %s:\n%s" % \
1372
(filename, ('\n'.join(e.message for e in errors)))
1373
BzrError.__init__(self, message)
1376
class NoEmailInUsername(BzrError):
1378
_fmt = "%(username)r does not seem to contain a reasonable email address"
1380
def __init__(self, username):
1381
BzrError.__init__(self)
1382
self.username = username
1385
class SigningFailed(BzrError):
1387
_fmt = "Failed to gpg sign data with command %(command_line)r"
1389
def __init__(self, command_line):
1390
BzrError.__init__(self, command_line=command_line)
1393
class WorkingTreeNotRevision(BzrError):
1395
_fmt = ("The working tree for %(basedir)s has changed since"
1396
" the last commit, but weave merge requires that it be"
1399
def __init__(self, tree):
1400
BzrError.__init__(self, basedir=tree.basedir)
1403
class CantReprocessAndShowBase(BzrError):
1405
_fmt = ("Can't reprocess and show base, because reprocessing obscures "
1406
"the relationship of conflicting lines to the base")
1409
class GraphCycleError(BzrError):
1411
_fmt = "Cycle in graph %(graph)r"
1413
def __init__(self, graph):
1414
BzrError.__init__(self)
1418
class WritingCompleted(BzrError):
1420
_fmt = ("The MediumRequest '%(request)s' has already had finish_writing "
1421
"called upon it - accept bytes may not be called anymore.")
1423
internal_error = True
1425
def __init__(self, request):
1426
self.request = request
1429
class WritingNotComplete(BzrError):
1431
_fmt = ("The MediumRequest '%(request)s' has not has finish_writing "
1432
"called upon it - until the write phase is complete no "
1433
"data may be read.")
1435
internal_error = True
1437
def __init__(self, request):
1438
self.request = request
1441
class NotConflicted(BzrError):
1443
_fmt = "File %(filename)s is not conflicted."
1445
def __init__(self, filename):
1446
BzrError.__init__(self)
1447
self.filename = filename
1450
class MediumNotConnected(BzrError):
1452
_fmt = """The medium '%(medium)s' is not connected."""
1454
internal_error = True
1456
def __init__(self, medium):
1457
self.medium = medium
1460
class MustUseDecorated(Exception):
1462
_fmt = "A decorating function has requested its original command be used."
1465
class NoBundleFound(BzrError):
1467
_fmt = "No bundle was found in %(filename)s"
1469
def __init__(self, filename):
1470
BzrError.__init__(self)
1471
self.filename = filename
1474
class BundleNotSupported(BzrError):
1476
_fmt = "Unable to handle bundle version %(version)s: %(msg)s"
1478
def __init__(self, version, msg):
1479
BzrError.__init__(self)
1480
self.version = version
1484
class MissingText(BzrError):
1486
_fmt = ("Branch %(base)s is missing revision"
1487
" %(text_revision)s of %(file_id)s")
1489
def __init__(self, branch, text_revision, file_id):
1490
BzrError.__init__(self)
1491
self.branch = branch
1492
self.base = branch.base
1493
self.text_revision = text_revision
1494
self.file_id = file_id
1497
class DuplicateFileId(BzrError):
1499
_fmt = "File id {%(file_id)s} already exists in inventory as %(entry)s"
1501
def __init__(self, file_id, entry):
1502
BzrError.__init__(self)
1503
self.file_id = file_id
1507
class DuplicateKey(BzrError):
1509
_fmt = "Key %(key)s is already present in map"
1512
class MalformedTransform(BzrError):
1514
_fmt = "Tree transform is malformed %(conflicts)r"
1517
class NoFinalPath(BzrError):
1519
_fmt = ("No final name for trans_id %(trans_id)r\n"
1520
"file-id: %(file_id)r\n"
1521
"root trans-id: %(root_trans_id)r\n")
1523
def __init__(self, trans_id, transform):
1524
self.trans_id = trans_id
1525
self.file_id = transform.final_file_id(trans_id)
1526
self.root_trans_id = transform.root
1529
class BzrBadParameter(BzrError):
1531
_fmt = "Bad parameter: %(param)r"
1533
# This exception should never be thrown, but it is a base class for all
1534
# parameter-to-function errors.
1536
def __init__(self, param):
1537
BzrError.__init__(self)
1541
class BzrBadParameterNotUnicode(BzrBadParameter):
1543
_fmt = "Parameter %(param)s is neither unicode nor utf8."
1546
class ReusingTransform(BzrError):
1548
_fmt = "Attempt to reuse a transform that has already been applied."
1551
class CantMoveRoot(BzrError):
1553
_fmt = "Moving the root directory is not supported at this time"
1556
class BzrMoveFailedError(BzrError):
1558
_fmt = "Could not move %(from_path)s%(operator)s %(to_path)s%(extra)s"
1560
def __init__(self, from_path='', to_path='', extra=None):
1561
BzrError.__init__(self)
1563
self.extra = ': ' + str(extra)
1567
has_from = len(from_path) > 0
1568
has_to = len(to_path) > 0
1570
self.from_path = osutils.splitpath(from_path)[-1]
1575
self.to_path = osutils.splitpath(to_path)[-1]
1580
if has_from and has_to:
1581
self.operator = " =>"
1583
self.from_path = "from " + from_path
1585
self.operator = "to"
1587
self.operator = "file"
1590
class BzrRenameFailedError(BzrMoveFailedError):
1592
_fmt = "Could not rename %(from_path)s%(operator)s %(to_path)s%(extra)s"
1594
def __init__(self, from_path, to_path, extra=None):
1595
BzrMoveFailedError.__init__(self, from_path, to_path, extra)
1598
class BzrBadParameterNotString(BzrBadParameter):
1600
_fmt = "Parameter %(param)s is not a string or unicode string."
1603
class BzrBadParameterMissing(BzrBadParameter):
1605
_fmt = "Parameter $(param)s is required but not present."
1608
class BzrBadParameterUnicode(BzrBadParameter):
1610
_fmt = ("Parameter %(param)s is unicode but"
1611
" only byte-strings are permitted.")
1614
class BzrBadParameterContainsNewline(BzrBadParameter):
1616
_fmt = "Parameter %(param)s contains a newline."
1619
class DependencyNotPresent(BzrError):
1621
_fmt = 'Unable to import library "%(library)s": %(error)s'
1623
def __init__(self, library, error):
1624
BzrError.__init__(self, library=library, error=error)
1627
class ParamikoNotPresent(DependencyNotPresent):
1629
_fmt = "Unable to import paramiko (required for sftp support): %(error)s"
1631
def __init__(self, error):
1632
DependencyNotPresent.__init__(self, 'paramiko', error)
1635
class PointlessMerge(BzrError):
1637
_fmt = "Nothing to merge."
1640
class UninitializableFormat(BzrError):
1642
_fmt = "Format %(format)s cannot be initialised by this version of bzr."
1644
def __init__(self, format):
1645
BzrError.__init__(self)
1646
self.format = format
1649
class BadConversionTarget(BzrError):
1651
_fmt = "Cannot convert to format %(format)s. %(problem)s"
1653
def __init__(self, problem, format):
1654
BzrError.__init__(self)
1655
self.problem = problem
1656
self.format = format
1659
class NoDiff(BzrError):
1661
_fmt = "Diff is not installed on this machine: %(msg)s"
1663
def __init__(self, msg):
1664
BzrError.__init__(self, msg=msg)
1667
class NoDiff3(BzrError):
1669
_fmt = "Diff3 is not installed on this machine."
1672
class ExistingLimbo(BzrError):
1674
_fmt = """This tree contains left-over files from a failed operation.
1675
Please examine %(limbo_dir)s to see if it contains any files you wish to
1676
keep, and delete it when you are done."""
1678
def __init__(self, limbo_dir):
1679
BzrError.__init__(self)
1680
self.limbo_dir = limbo_dir
1683
class ImmortalLimbo(BzrError):
1685
_fmt = """Unable to delete transform temporary directory $(limbo_dir)s.
1686
Please examine %(limbo_dir)s to see if it contains any files you wish to
1687
keep, and delete it when you are done."""
1689
def __init__(self, limbo_dir):
1690
BzrError.__init__(self)
1691
self.limbo_dir = limbo_dir
1694
class OutOfDateTree(BzrError):
1696
_fmt = "Working tree is out of date, please run 'bzr update'."
1698
def __init__(self, tree):
1699
BzrError.__init__(self)
1703
class PublicBranchOutOfDate(BzrError):
1705
_fmt = 'Public branch "%(public_location)s" lacks revision '\
1708
def __init__(self, public_location, revstring):
1709
import bzrlib.urlutils as urlutils
1710
public_location = urlutils.unescape_for_display(public_location,
1712
BzrError.__init__(self, public_location=public_location,
1713
revstring=revstring)
1716
class MergeModifiedFormatError(BzrError):
1718
_fmt = "Error in merge modified format"
1721
class ConflictFormatError(BzrError):
1723
_fmt = "Format error in conflict listings"
1726
class CorruptRepository(BzrError):
1728
_fmt = ("An error has been detected in the repository %(repo_path)s.\n"
1729
"Please run bzr reconcile on this repository.")
1731
def __init__(self, repo):
1732
BzrError.__init__(self)
1733
self.repo_path = repo.bzrdir.root_transport.base
1736
class UpgradeRequired(BzrError):
1738
_fmt = "To use this feature you must upgrade your branch at %(path)s."
1740
def __init__(self, path):
1741
BzrError.__init__(self)
1745
class LocalRequiresBoundBranch(BzrError):
1747
_fmt = "Cannot perform local-only commits on unbound branches."
1750
class MissingProgressBarFinish(BzrError):
1752
_fmt = "A nested progress bar was not 'finished' correctly."
1755
class InvalidProgressBarType(BzrError):
1757
_fmt = ("Environment variable BZR_PROGRESS_BAR='%(bar_type)s"
1758
" is not a supported type Select one of: %(valid_types)s")
1760
def __init__(self, bar_type, valid_types):
1761
BzrError.__init__(self, bar_type=bar_type, valid_types=valid_types)
1764
class UnsupportedOperation(BzrError):
1766
_fmt = ("The method %(mname)s is not supported on"
1767
" objects of type %(tname)s.")
1769
def __init__(self, method, method_self):
1770
self.method = method
1771
self.mname = method.__name__
1772
self.tname = type(method_self).__name__
1775
class CannotSetRevisionId(UnsupportedOperation):
1776
"""Raised when a commit is attempting to set a revision id but cant."""
1779
class NonAsciiRevisionId(UnsupportedOperation):
1780
"""Raised when a commit is attempting to set a non-ascii revision id
1785
class BinaryFile(BzrError):
1787
_fmt = "File is binary but should be text."
1790
class IllegalPath(BzrError):
1792
_fmt = "The path %(path)s is not permitted on this platform"
1794
def __init__(self, path):
1795
BzrError.__init__(self)
1799
class TestamentMismatch(BzrError):
1801
_fmt = """Testament did not match expected value.
1802
For revision_id {%(revision_id)s}, expected {%(expected)s}, measured
1805
def __init__(self, revision_id, expected, measured):
1806
self.revision_id = revision_id
1807
self.expected = expected
1808
self.measured = measured
1811
class NotABundle(BzrError):
1813
_fmt = "Not a bzr revision-bundle: %(text)r"
1815
def __init__(self, text):
1816
BzrError.__init__(self)
1820
class BadBundle(BzrError):
1822
_fmt = "Bad bzr revision-bundle: %(text)r"
1824
def __init__(self, text):
1825
BzrError.__init__(self)
1829
class MalformedHeader(BadBundle):
1831
_fmt = "Malformed bzr revision-bundle header: %(text)r"
1834
class MalformedPatches(BadBundle):
1836
_fmt = "Malformed patches in bzr revision-bundle: %(text)r"
1839
class MalformedFooter(BadBundle):
1841
_fmt = "Malformed footer in bzr revision-bundle: %(text)r"
1844
class UnsupportedEOLMarker(BadBundle):
1846
_fmt = "End of line marker was not \\n in bzr revision-bundle"
1849
# XXX: BadBundle's constructor assumes there's explanatory text,
1850
# but for this there is not
1851
BzrError.__init__(self)
1854
class IncompatibleBundleFormat(BzrError):
1856
_fmt = "Bundle format %(bundle_format)s is incompatible with %(other)s"
1858
def __init__(self, bundle_format, other):
1859
BzrError.__init__(self)
1860
self.bundle_format = bundle_format
1864
class BadInventoryFormat(BzrError):
1866
_fmt = "Root class for inventory serialization errors"
1869
class UnexpectedInventoryFormat(BadInventoryFormat):
1871
_fmt = "The inventory was not in the expected format:\n %(msg)s"
1873
def __init__(self, msg):
1874
BadInventoryFormat.__init__(self, msg=msg)
1877
class RootNotRich(BzrError):
1879
_fmt = """This operation requires rich root data storage"""
1882
class NoSmartMedium(BzrError):
1884
_fmt = "The transport '%(transport)s' cannot tunnel the smart protocol."
1886
internal_error = True
1888
def __init__(self, transport):
1889
self.transport = transport
1892
class NoSmartServer(NotBranchError):
1894
_fmt = "No smart server available at %(url)s"
1896
def __init__(self, url):
1900
class UnknownSSH(BzrError):
1902
_fmt = "Unrecognised value for BZR_SSH environment variable: %(vendor)s"
1904
def __init__(self, vendor):
1905
BzrError.__init__(self)
1906
self.vendor = vendor
1909
class SSHVendorNotFound(BzrError):
1911
_fmt = ("Don't know how to handle SSH connections."
1912
" Please set BZR_SSH environment variable.")
1915
class GhostRevisionUnusableHere(BzrError):
1917
_fmt = "Ghost revision {%(revision_id)s} cannot be used here."
1919
def __init__(self, revision_id):
1920
BzrError.__init__(self)
1921
self.revision_id = revision_id
1924
class IllegalUseOfScopeReplacer(BzrError):
1926
_fmt = ("ScopeReplacer object %(name)r was used incorrectly:"
1927
" %(msg)s%(extra)s")
1929
internal_error = True
1931
def __init__(self, name, msg, extra=None):
1932
BzrError.__init__(self)
1936
self.extra = ': ' + str(extra)
1941
class InvalidImportLine(BzrError):
1943
_fmt = "Not a valid import statement: %(msg)\n%(text)s"
1945
internal_error = True
1947
def __init__(self, text, msg):
1948
BzrError.__init__(self)
1953
class ImportNameCollision(BzrError):
1955
_fmt = ("Tried to import an object to the same name as"
1956
" an existing object. %(name)s")
1958
internal_error = True
1960
def __init__(self, name):
1961
BzrError.__init__(self)
1965
class NotAMergeDirective(BzrError):
1966
"""File starting with %(firstline)r is not a merge directive"""
1967
def __init__(self, firstline):
1968
BzrError.__init__(self, firstline=firstline)
1971
class NoMergeSource(BzrError):
1972
"""Raise if no merge source was specified for a merge directive"""
1974
_fmt = "A merge directive must provide either a bundle or a public"\
1978
class PatchMissing(BzrError):
1979
"""Raise a patch type was specified but no patch supplied"""
1981
_fmt = "patch_type was %(patch_type)s, but no patch was supplied."
1983
def __init__(self, patch_type):
1984
BzrError.__init__(self)
1985
self.patch_type = patch_type
1988
class UnsupportedInventoryKind(BzrError):
1990
_fmt = """Unsupported entry kind %(kind)s"""
1992
def __init__(self, kind):
1996
class BadSubsumeSource(BzrError):
1998
_fmt = """Can't subsume %(other_tree)s into %(tree)s. %(reason)s"""
2000
def __init__(self, tree, other_tree, reason):
2002
self.other_tree = other_tree
2003
self.reason = reason
2006
class SubsumeTargetNeedsUpgrade(BzrError):
2008
_fmt = """Subsume target %(other_tree)s needs to be upgraded."""
2010
def __init__(self, other_tree):
2011
self.other_tree = other_tree
2014
class BadReferenceTarget(BzrError):
2016
_fmt = "Can't add reference to %(other_tree)s into %(tree)s. %(reason)s"
2018
internal_error = True
2020
def __init__(self, tree, other_tree, reason):
2022
self.other_tree = other_tree
2023
self.reason = reason
2026
class NoSuchTag(BzrError):
2028
_fmt = "No such tag: %(tag_name)s"
2030
def __init__(self, tag_name):
2031
self.tag_name = tag_name
2034
class TagsNotSupported(BzrError):
2036
_fmt = ("Tags not supported by %(branch)s;"
2037
" you may be able to use bzr upgrade.")
2039
def __init__(self, branch):
2040
self.branch = branch
2043
class TagAlreadyExists(BzrError):
2045
_fmt = "Tag %(tag_name)s already exists."
2047
def __init__(self, tag_name):
2048
self.tag_name = tag_name
33
# Error from malformed user command
37
def bailout(msg, explanation=[]):
38
ex = BzrError(msg, explanation)
40
trace._tracefile.write('* raising %s\n' % ex)
added
removed
bzrlib/errors.py
