1
# Copyright (C) 2005, 2006 Canonical
3
# This program is free software; you can redistribute it and/or modify
4
# it under the terms of the GNU General Public License as published by
5
# the Free Software Foundation; either version 2 of the License, or
6
# (at your option) any later version.
8
# This program is distributed in the hope that it will be useful,
9
# but WITHOUT ANY WARRANTY; without even the implied warranty of
10
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
11
# GNU General Public License for more details.
13
# You should have received a copy of the GNU General Public License
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
17
"""Exceptions for bzr, and reporting of them.
19
There are 3 different classes of error:
21
* KeyboardInterrupt, and OSError with EPIPE - the program terminates
22
with an appropriate short message
24
* User errors, indicating a problem caused by the user such as a bad URL.
25
These are printed in a short form.
27
* Internal unexpected errors, including most Python builtin errors
28
and some raised from inside bzr. These are printed with a full
29
traceback and an invitation to report the bug.
31
Exceptions are caught at a high level to report errors to the user, and
32
might also be caught inside the program. Therefore it needs to be
33
possible to convert them to a meaningful string, and also for them to be
34
interrogated by the program.
36
Exceptions are defined such that the arguments given to the constructor
37
are stored in the object as properties of the same name. When the
38
object is printed as a string, the doc string of the class is used as
39
a format string with the property dictionary available to it.
41
This means that exceptions can used like this:
45
... raise NotBranchError(path='/foo/bar')
47
... print sys.exc_type
48
... print sys.exc_value
49
... path = getattr(sys.exc_value, 'path', None)
50
... if path is not None:
52
bzrlib.errors.NotBranchError
53
Not a branch: /foo/bar
58
* create a new exception class for any class of error that can be
59
usefully distinguished. If no callers are likely to want to catch
60
one but not another, don't worry about them.
62
* the __str__ method should generate something useful; BzrError provides
63
a good default implementation
65
Exception strings should start with a capital letter and should not have a
69
from warnings import warn
71
from bzrlib.patches import (PatchSyntax,
78
# based on Scott James Remnant's hct error classes
80
# TODO: is there any value in providing the .args field used by standard
81
# python exceptions? A list of values with no names seems less useful
84
# TODO: Perhaps convert the exception to a string at the moment it's
85
# constructed to make sure it will succeed. But that says nothing about
86
# exceptions that are never raised.
88
# TODO: Convert all the other error classes here to BzrNewError, and eliminate
91
# TODO: The pattern (from hct) of using classes docstrings as message
92
# templates is cute but maybe not such a great idea - perhaps should have a
93
# separate static message_template.
96
class BzrError(StandardError):
101
# XXX: Should we show the exception class in
102
# exceptions that don't provide their own message?
103
# maybe it should be done at a higher level
104
## n = self.__class__.__name__ + ': '
106
if len(self.args) == 1:
107
return str(self.args[0])
108
elif len(self.args) == 2:
109
# further explanation or suggestions
111
return n + '\n '.join([self.args[0]] + self.args[1])
113
return n + "%r" % self
115
return n + `self.args`
118
class BzrNewError(BzrError):
120
# base classes should override the docstring with their human-
121
# readable explanation
123
def __init__(self, **kwds):
124
for key, value in kwds.items():
125
setattr(self, key, value)
129
return self.__doc__ % self.__dict__
130
except (NameError, ValueError, KeyError), e:
131
return 'Unprintable exception %s: %s' \
132
% (self.__class__.__name__, str(e))
135
class BzrCheckError(BzrNewError):
136
"""Internal check failed: %(message)s"""
138
is_user_error = False
140
def __init__(self, message):
141
BzrNewError.__init__(self)
142
self.message = message
145
class InvalidEntryName(BzrNewError):
146
"""Invalid entry name: %(name)s"""
148
is_user_error = False
150
def __init__(self, name):
151
BzrNewError.__init__(self)
155
class InvalidRevisionNumber(BzrNewError):
156
"""Invalid revision number %(revno)d"""
157
def __init__(self, revno):
158
BzrNewError.__init__(self)
162
class InvalidRevisionId(BzrNewError):
163
"""Invalid revision-id {%(revision_id)s} in %(branch)s"""
164
def __init__(self, revision_id, branch):
165
# branch can be any string or object with __str__ defined
166
BzrNewError.__init__(self)
167
self.revision_id = revision_id
171
class NoWorkingTree(BzrNewError):
172
"""No WorkingTree exists for %(base)s."""
174
def __init__(self, base):
175
BzrNewError.__init__(self)
179
class NotLocalUrl(BzrNewError):
180
"""%(url)s is not a local path."""
182
def __init__(self, url):
183
BzrNewError.__init__(self)
187
class BzrCommandError(BzrNewError):
188
"""Error from user command"""
192
# Error from malformed user command; please avoid raising this as a
193
# generic exception not caused by user input.
195
# I think it's a waste of effort to differentiate between errors that
196
# are not intended to be caught anyway. UI code need not subclass
197
# BzrCommandError, and non-UI code should not throw a subclass of
198
# BzrCommandError. ADHB 20051211
199
def __init__(self, msg):
206
class BzrOptionError(BzrCommandError):
207
"""Error in command line options"""
210
class StrictCommitFailed(BzrNewError):
211
"""Commit refused because there are unknown files in the tree"""
214
# XXX: Should be unified with TransportError; they seem to represent the
216
class PathError(BzrNewError):
217
"""Generic path error: %(path)r%(extra)s)"""
219
def __init__(self, path, extra=None):
220
BzrNewError.__init__(self)
223
self.extra = ': ' + str(extra)
228
class NoSuchFile(PathError):
229
"""No such file: %(path)r%(extra)s"""
232
class FileExists(PathError):
233
"""File exists: %(path)r%(extra)s"""
236
class DirectoryNotEmpty(PathError):
237
"""Directory not empty: %(path)r%(extra)s"""
240
class ResourceBusy(PathError):
241
"""Device or resource busy: %(path)r%(extra)s"""
244
class PermissionDenied(PathError):
245
"""Permission denied: %(path)r%(extra)s"""
248
class InvalidURL(PathError):
249
"""Invalid url supplied to transport: %(path)r%(extra)s"""
252
class InvalidURLJoin(PathError):
253
"""Invalid URL join request: %(args)s%(extra)s"""
255
def __init__(self, msg, base, args):
256
PathError.__init__(self, base, msg)
258
self.args.extend(args)
261
class PathNotChild(BzrNewError):
262
"""Path %(path)r is not a child of path %(base)r%(extra)s"""
264
is_user_error = False
266
def __init__(self, path, base, extra=None):
267
BzrNewError.__init__(self)
271
self.extra = ': ' + str(extra)
276
class InvalidNormalization(PathError):
277
"""Path %(path)r is not unicode normalized"""
280
# TODO: This is given a URL; we try to unescape it but doing that from inside
281
# the exception object is a bit undesirable.
282
# TODO: Probably this behavior of should be a common superclass
283
class NotBranchError(PathError):
284
"""Not a branch: %(path)s"""
286
def __init__(self, path):
287
import bzrlib.urlutils as urlutils
288
self.path = urlutils.unescape_for_display(path, 'ascii')
291
class AlreadyBranchError(PathError):
292
"""Already a branch: %(path)s."""
295
class BranchExistsWithoutWorkingTree(PathError):
296
"""Directory contains a branch, but no working tree \
297
(use bzr checkout if you wish to build a working tree): %(path)s"""
300
class NoRepositoryPresent(BzrNewError):
301
"""No repository present: %(path)r"""
302
def __init__(self, bzrdir):
303
BzrNewError.__init__(self)
304
self.path = bzrdir.transport.clone('..').base
307
class FileInWrongBranch(BzrNewError):
308
"""File %(path)s in not in branch %(branch_base)s."""
310
def __init__(self, branch, path):
311
BzrNewError.__init__(self)
313
self.branch_base = branch.base
317
class UnsupportedFormatError(BzrNewError):
318
"""Unsupported branch format: %(format)s"""
321
class UnknownFormatError(BzrNewError):
322
"""Unknown branch format: %(format)r"""
325
class IncompatibleFormat(BzrNewError):
326
"""Format %(format)s is not compatible with .bzr version %(bzrdir)s."""
328
def __init__(self, format, bzrdir_format):
329
BzrNewError.__init__(self)
331
self.bzrdir = bzrdir_format
334
class NotVersionedError(BzrNewError):
335
"""%(path)s is not versioned"""
336
def __init__(self, path):
337
BzrNewError.__init__(self)
341
class PathsNotVersionedError(BzrNewError):
342
# used when reporting several paths are not versioned
343
"""Path(s) are not versioned: %(paths_as_string)s"""
345
def __init__(self, paths):
346
from bzrlib.osutils import quotefn
347
BzrNewError.__init__(self)
349
self.paths_as_string = ' '.join([quotefn(p) for p in paths])
352
class PathsDoNotExist(BzrNewError):
353
"""Path(s) do not exist: %(paths_as_string)s"""
355
# used when reporting that paths are neither versioned nor in the working
358
def __init__(self, paths):
360
from bzrlib.osutils import quotefn
361
BzrNewError.__init__(self)
363
self.paths_as_string = ' '.join([quotefn(p) for p in paths])
366
class BadFileKindError(BzrNewError):
367
"""Cannot operate on %(filename)s of unsupported kind %(kind)s"""
370
class ForbiddenControlFileError(BzrNewError):
371
"""Cannot operate on %(filename)s because it is a control file"""
374
class LockError(BzrNewError):
375
"""Lock error: %(message)s"""
376
# All exceptions from the lock/unlock functions should be from
377
# this exception class. They will be translated as necessary. The
378
# original exception is available as e.original_error
380
# New code should prefer to raise specific subclasses
381
def __init__(self, message):
382
self.message = message
385
class CommitNotPossible(LockError):
386
"""A commit was attempted but we do not have a write lock open."""
391
class AlreadyCommitted(LockError):
392
"""A rollback was requested, but is not able to be accomplished."""
397
class ReadOnlyError(LockError):
398
"""A write attempt was made in a read only transaction on %(obj)s"""
399
def __init__(self, obj):
403
class OutSideTransaction(BzrNewError):
404
"""A transaction related operation was attempted after the transaction finished."""
407
class ObjectNotLocked(LockError):
408
"""%(obj)r is not locked"""
410
is_user_error = False
412
# this can indicate that any particular object is not locked; see also
413
# LockNotHeld which means that a particular *lock* object is not held by
414
# the caller -- perhaps they should be unified.
415
def __init__(self, obj):
419
class ReadOnlyObjectDirtiedError(ReadOnlyError):
420
"""Cannot change object %(obj)r in read only transaction"""
421
def __init__(self, obj):
425
class UnlockableTransport(LockError):
426
"""Cannot lock: transport is read only: %(transport)s"""
427
def __init__(self, transport):
428
self.transport = transport
431
class LockContention(LockError):
432
"""Could not acquire lock %(lock)s"""
433
# TODO: show full url for lock, combining the transport and relative bits?
434
def __init__(self, lock):
438
class LockBroken(LockError):
439
"""Lock was broken while still open: %(lock)s - check storage consistency!"""
440
def __init__(self, lock):
444
class LockBreakMismatch(LockError):
445
"""Lock was released and re-acquired before being broken: %(lock)s: held by %(holder)r, wanted to break %(target)r"""
446
def __init__(self, lock, holder, target):
452
class LockNotHeld(LockError):
453
"""Lock not held: %(lock)s"""
454
def __init__(self, lock):
458
class PointlessCommit(BzrNewError):
459
"""No changes to commit"""
462
class UpgradeReadonly(BzrNewError):
463
"""Upgrade URL cannot work with readonly URL's."""
466
class UpToDateFormat(BzrNewError):
467
"""The branch format %(format)s is already at the most recent format."""
469
def __init__(self, format):
470
BzrNewError.__init__(self)
475
class StrictCommitFailed(Exception):
476
"""Commit refused because there are unknowns in the tree."""
479
class NoSuchRevision(BzrNewError):
480
"""Branch %(branch)s has no revision %(revision)s"""
482
is_user_error = False
484
def __init__(self, branch, revision):
486
self.revision = revision
489
class HistoryMissing(BzrError):
490
def __init__(self, branch, object_type, object_id):
492
BzrError.__init__(self,
493
'%s is missing %s {%s}'
494
% (branch, object_type, object_id))
497
class DivergedBranches(BzrNewError):
498
"These branches have diverged. Use the merge command to reconcile them."""
502
def __init__(self, branch1, branch2):
503
self.branch1 = branch1
504
self.branch2 = branch2
507
class UnrelatedBranches(BzrNewError):
508
"Branches have no common ancestor, and no merge base revision was specified."
513
class NoCommonAncestor(BzrNewError):
514
"Revisions have no common ancestor: %(revision_a)s %(revision_b)s"
516
def __init__(self, revision_a, revision_b):
517
self.revision_a = revision_a
518
self.revision_b = revision_b
521
class NoCommonRoot(BzrError):
522
def __init__(self, revision_a, revision_b):
523
msg = "Revisions are not derived from the same root: %s %s." \
524
% (revision_a, revision_b)
525
BzrError.__init__(self, msg)
529
class NotAncestor(BzrError):
530
def __init__(self, rev_id, not_ancestor_id):
531
msg = "Revision %s is not an ancestor of %s" % (not_ancestor_id,
533
BzrError.__init__(self, msg)
535
self.not_ancestor_id = not_ancestor_id
538
class InstallFailed(BzrError):
539
def __init__(self, revisions):
540
msg = "Could not install revisions:\n%s" % " ,".join(revisions)
541
BzrError.__init__(self, msg)
542
self.revisions = revisions
545
class AmbiguousBase(BzrError):
546
def __init__(self, bases):
547
warn("BzrError AmbiguousBase has been deprecated as of bzrlib 0.8.",
549
msg = "The correct base is unclear, because %s are all equally close" %\
551
BzrError.__init__(self, msg)
555
class NoCommits(BzrError):
556
def __init__(self, branch):
557
msg = "Branch %s has no commits." % branch
558
BzrError.__init__(self, msg)
561
class UnlistableStore(BzrError):
562
def __init__(self, store):
563
BzrError.__init__(self, "Store %s is not listable" % store)
567
class UnlistableBranch(BzrError):
568
def __init__(self, br):
569
BzrError.__init__(self, "Stores for branch %s are not listable" % br)
572
class BoundBranchOutOfDate(BzrNewError):
573
"""Bound branch %(branch)s is out of date with master branch %(master)s."""
574
def __init__(self, branch, master):
575
BzrNewError.__init__(self)
580
class CommitToDoubleBoundBranch(BzrNewError):
581
"""Cannot commit to branch %(branch)s. It is bound to %(master)s, which is bound to %(remote)s."""
582
def __init__(self, branch, master, remote):
583
BzrNewError.__init__(self)
589
class OverwriteBoundBranch(BzrNewError):
590
"""Cannot pull --overwrite to a branch which is bound %(branch)s"""
591
def __init__(self, branch):
592
BzrNewError.__init__(self)
596
class BoundBranchConnectionFailure(BzrNewError):
597
"""Unable to connect to target of bound branch %(branch)s => %(target)s: %(error)s"""
598
def __init__(self, branch, target, error):
599
BzrNewError.__init__(self)
605
class WeaveError(BzrNewError):
606
"""Error in processing weave: %(message)s"""
608
def __init__(self, message=None):
609
BzrNewError.__init__(self)
610
self.message = message
613
class WeaveRevisionAlreadyPresent(WeaveError):
614
"""Revision {%(revision_id)s} already present in %(weave)s"""
615
def __init__(self, revision_id, weave):
617
WeaveError.__init__(self)
618
self.revision_id = revision_id
622
class WeaveRevisionNotPresent(WeaveError):
623
"""Revision {%(revision_id)s} not present in %(weave)s"""
625
def __init__(self, revision_id, weave):
626
WeaveError.__init__(self)
627
self.revision_id = revision_id
631
class WeaveFormatError(WeaveError):
632
"""Weave invariant violated: %(what)s"""
634
def __init__(self, what):
635
WeaveError.__init__(self)
639
class WeaveParentMismatch(WeaveError):
640
"""Parents are mismatched between two revisions."""
643
class WeaveInvalidChecksum(WeaveError):
644
"""Text did not match it's checksum: %(message)s"""
647
class WeaveTextDiffers(WeaveError):
648
"""Weaves differ on text content. Revision: {%(revision_id)s}, %(weave_a)s, %(weave_b)s"""
650
def __init__(self, revision_id, weave_a, weave_b):
651
WeaveError.__init__(self)
652
self.revision_id = revision_id
653
self.weave_a = weave_a
654
self.weave_b = weave_b
657
class WeaveTextDiffers(WeaveError):
658
"""Weaves differ on text content. Revision: {%(revision_id)s}, %(weave_a)s, %(weave_b)s"""
660
def __init__(self, revision_id, weave_a, weave_b):
661
WeaveError.__init__(self)
662
self.revision_id = revision_id
663
self.weave_a = weave_a
664
self.weave_b = weave_b
667
class VersionedFileError(BzrNewError):
668
"""Versioned file error."""
671
class RevisionNotPresent(VersionedFileError):
672
"""Revision {%(revision_id)s} not present in %(file_id)s."""
674
def __init__(self, revision_id, file_id):
675
VersionedFileError.__init__(self)
676
self.revision_id = revision_id
677
self.file_id = file_id
680
class RevisionAlreadyPresent(VersionedFileError):
681
"""Revision {%(revision_id)s} already present in %(file_id)s."""
683
def __init__(self, revision_id, file_id):
684
VersionedFileError.__init__(self)
685
self.revision_id = revision_id
686
self.file_id = file_id
689
class KnitError(BzrNewError):
693
class KnitHeaderError(KnitError):
694
"""Knit header error: %(badline)r unexpected"""
696
def __init__(self, badline):
697
KnitError.__init__(self)
698
self.badline = badline
701
class KnitCorrupt(KnitError):
702
"""Knit %(filename)s corrupt: %(how)s"""
704
def __init__(self, filename, how):
705
KnitError.__init__(self)
706
self.filename = filename
710
class NoSuchExportFormat(BzrNewError):
711
"""Export format %(format)r not supported"""
712
def __init__(self, format):
713
BzrNewError.__init__(self)
717
class TransportError(BzrError):
718
"""All errors thrown by Transport implementations should derive
721
def __init__(self, msg=None, orig_error=None):
722
if msg is None and orig_error is not None:
723
msg = str(orig_error)
724
BzrError.__init__(self, msg)
726
self.orig_error = orig_error
729
# A set of semi-meaningful errors which can be thrown
730
class TransportNotPossible(TransportError):
731
"""This is for transports where a specific function is explicitly not
732
possible. Such as pushing files to an HTTP server.
737
class ConnectionError(TransportError):
738
"""A connection problem prevents file retrieval.
739
This does not indicate whether the file exists or not; it indicates that a
740
precondition for requesting the file was not met.
742
def __init__(self, msg=None, orig_error=None):
743
TransportError.__init__(self, msg=msg, orig_error=orig_error)
746
class ConnectionReset(TransportError):
747
"""The connection has been closed."""
751
class ConflictsInTree(BzrError):
753
BzrError.__init__(self, "Working tree has conflicts.")
756
class ParseConfigError(BzrError):
757
def __init__(self, errors, filename):
760
message = "Error(s) parsing config file %s:\n%s" % \
761
(filename, ('\n'.join(e.message for e in errors)))
762
BzrError.__init__(self, message)
765
class SigningFailed(BzrError):
766
def __init__(self, command_line):
767
BzrError.__init__(self, "Failed to gpg sign data with command '%s'"
771
class WorkingTreeNotRevision(BzrError):
772
def __init__(self, tree):
773
BzrError.__init__(self, "The working tree for %s has changed since"
774
" last commit, but weave merge requires that it be"
775
" unchanged." % tree.basedir)
778
class CantReprocessAndShowBase(BzrNewError):
779
"""Can't reprocess and show base.
780
Reprocessing obscures relationship of conflicting lines to base."""
783
class GraphCycleError(BzrNewError):
784
"""Cycle in graph %(graph)r"""
785
def __init__(self, graph):
786
BzrNewError.__init__(self)
790
class NotConflicted(BzrNewError):
791
"""File %(filename)s is not conflicted."""
793
def __init__(self, filename):
794
BzrNewError.__init__(self)
795
self.filename = filename
798
class MustUseDecorated(Exception):
799
"""A decorating function has requested its original command be used.
801
This should never escape bzr, so does not need to be printable.
805
class NoBundleFound(BzrNewError):
806
"""No bundle was found in %(filename)s"""
807
def __init__(self, filename):
808
BzrNewError.__init__(self)
809
self.filename = filename
812
class BundleNotSupported(BzrNewError):
813
"""Unable to handle bundle version %(version)s: %(msg)s"""
814
def __init__(self, version, msg):
815
BzrNewError.__init__(self)
816
self.version = version
820
class MissingText(BzrNewError):
821
"""Branch %(base)s is missing revision %(text_revision)s of %(file_id)s"""
823
def __init__(self, branch, text_revision, file_id):
824
BzrNewError.__init__(self)
826
self.base = branch.base
827
self.text_revision = text_revision
828
self.file_id = file_id
831
class DuplicateKey(BzrNewError):
832
"""Key %(key)s is already present in map"""
835
class MalformedTransform(BzrNewError):
836
"""Tree transform is malformed %(conflicts)r"""
839
class BzrBadParameter(BzrNewError):
840
"""A bad parameter : %(param)s is not usable.
842
This exception should never be thrown, but it is a base class for all
843
parameter-to-function errors.
845
def __init__(self, param):
846
BzrNewError.__init__(self)
850
class BzrBadParameterNotUnicode(BzrBadParameter):
851
"""Parameter %(param)s is neither unicode nor utf8."""
854
class ReusingTransform(BzrNewError):
855
"""Attempt to reuse a transform that has already been applied."""
858
class CantMoveRoot(BzrNewError):
859
"""Moving the root directory is not supported at this time"""
862
class BzrBadParameterNotString(BzrBadParameter):
863
"""Parameter %(param)s is not a string or unicode string."""
866
class BzrBadParameterMissing(BzrBadParameter):
867
"""Parameter $(param)s is required but not present."""
870
class BzrBadParameterUnicode(BzrBadParameter):
871
"""Parameter %(param)s is unicode but only byte-strings are permitted."""
874
class BzrBadParameterContainsNewline(BzrBadParameter):
875
"""Parameter %(param)s contains a newline."""
878
class DependencyNotPresent(BzrNewError):
879
"""Unable to import library "%(library)s": %(error)s"""
881
def __init__(self, library, error):
882
BzrNewError.__init__(self, library=library, error=error)
885
class ParamikoNotPresent(DependencyNotPresent):
886
"""Unable to import paramiko (required for sftp support): %(error)s"""
888
def __init__(self, error):
889
DependencyNotPresent.__init__(self, 'paramiko', error)
892
class UninitializableFormat(BzrNewError):
893
"""Format %(format)s cannot be initialised by this version of bzr."""
895
def __init__(self, format):
896
BzrNewError.__init__(self)
900
class NoDiff(BzrNewError):
901
"""Diff is not installed on this machine: %(msg)s"""
903
def __init__(self, msg):
904
super(NoDiff, self).__init__(msg=msg)
907
class NoDiff3(BzrNewError):
908
"""Diff3 is not installed on this machine."""
911
class ExistingLimbo(BzrNewError):
912
"""This tree contains left-over files from a failed operation.
913
Please examine %(limbo_dir)s to see if it contains any files you wish to
914
keep, and delete it when you are done.
916
def __init__(self, limbo_dir):
917
BzrNewError.__init__(self)
918
self.limbo_dir = limbo_dir
921
class ImmortalLimbo(BzrNewError):
922
"""Unable to delete transform temporary directory $(limbo_dir)s.
923
Please examine %(limbo_dir)s to see if it contains any files you wish to
924
keep, and delete it when you are done.
926
def __init__(self, limbo_dir):
927
BzrNewError.__init__(self)
928
self.limbo_dir = limbo_dir
931
class OutOfDateTree(BzrNewError):
932
"""Working tree is out of date, please run 'bzr update'."""
934
def __init__(self, tree):
935
BzrNewError.__init__(self)
939
class MergeModifiedFormatError(BzrNewError):
940
"""Error in merge modified format"""
943
class ConflictFormatError(BzrNewError):
944
"""Format error in conflict listings"""
947
class CorruptRepository(BzrNewError):
948
"""An error has been detected in the repository %(repo_path)s.
949
Please run bzr reconcile on this repository."""
951
def __init__(self, repo):
952
BzrNewError.__init__(self)
953
self.repo_path = repo.bzrdir.root_transport.base
956
class UpgradeRequired(BzrNewError):
957
"""To use this feature you must upgrade your branch at %(path)s."""
959
def __init__(self, path):
960
BzrNewError.__init__(self)
964
class LocalRequiresBoundBranch(BzrNewError):
965
"""Cannot perform local-only commits on unbound branches."""
968
class MissingProgressBarFinish(BzrNewError):
969
"""A nested progress bar was not 'finished' correctly."""
972
class UnsupportedOperation(BzrNewError):
973
"""The method %(mname)s is not supported on objects of type %(tname)s."""
974
def __init__(self, method, method_self):
976
self.mname = method.__name__
977
self.tname = type(method_self).__name__
980
class BinaryFile(BzrNewError):
981
"""File is binary but should be text."""
984
class IllegalPath(BzrNewError):
985
"""The path %(path)s is not permitted on this platform"""
987
def __init__(self, path):
988
BzrNewError.__init__(self)
992
class TestamentMismatch(BzrNewError):
993
"""Testament did not match expected value.
994
For revision_id {%(revision_id)s}, expected {%(expected)s}, measured
997
def __init__(self, revision_id, expected, measured):
998
self.revision_id = revision_id
999
self.expected = expected
1000
self.measured = measured
1003
class NotABundle(BzrNewError):
1004
"""Not a bzr revision-bundle: %(text)r"""
1006
def __init__(self, text):
1010
class BadBundle(Exception): pass
1013
class MalformedHeader(BadBundle): pass
1016
class MalformedPatches(BadBundle): pass
1019
class MalformedFooter(BadBundle): pass
added
removed
bzrlib/errors.py
