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
# TODO: This is given a URL; we try to unescape it but doing that from inside
277
# the exception object is a bit undesirable.
278
# TODO: Probably this behavior of should be a common superclass
279
class NotBranchError(PathError):
280
"""Not a branch: %(path)s"""
282
def __init__(self, path):
283
import bzrlib.urlutils as urlutils
284
self.path = urlutils.unescape_for_display(path, 'ascii')
287
class AlreadyBranchError(PathError):
288
"""Already a branch: %(path)s."""
291
class BranchExistsWithoutWorkingTree(PathError):
292
"""Directory contains a branch, but no working tree \
293
(use bzr checkout if you wish to build a working tree): %(path)s"""
296
class NoRepositoryPresent(BzrNewError):
297
"""No repository present: %(path)r"""
298
def __init__(self, bzrdir):
299
BzrNewError.__init__(self)
300
self.path = bzrdir.transport.clone('..').base
303
class FileInWrongBranch(BzrNewError):
304
"""File %(path)s in not in branch %(branch_base)s."""
306
def __init__(self, branch, path):
307
BzrNewError.__init__(self)
309
self.branch_base = branch.base
313
class UnsupportedFormatError(BzrNewError):
314
"""Unsupported branch format: %(format)s"""
317
class UnknownFormatError(BzrNewError):
318
"""Unknown branch format: %(format)r"""
321
class IncompatibleFormat(BzrNewError):
322
"""Format %(format)s is not compatible with .bzr version %(bzrdir)s."""
324
def __init__(self, format, bzrdir_format):
325
BzrNewError.__init__(self)
327
self.bzrdir = bzrdir_format
330
class NotVersionedError(BzrNewError):
331
"""%(path)s is not versioned"""
332
def __init__(self, path):
333
BzrNewError.__init__(self)
337
class PathsNotVersionedError(BzrNewError):
338
# used when reporting several paths are not versioned
339
"""Path(s) are not versioned: %(paths_as_string)s"""
341
def __init__(self, paths):
342
from bzrlib.osutils import quotefn
343
BzrNewError.__init__(self)
345
self.paths_as_string = ' '.join([quotefn(p) for p in paths])
348
class PathsDoNotExist(BzrNewError):
349
"""Path(s) do not exist: %(paths_as_string)s"""
351
# used when reporting that paths are neither versioned nor in the working
354
def __init__(self, paths):
356
from bzrlib.osutils import quotefn
357
BzrNewError.__init__(self)
359
self.paths_as_string = ' '.join([quotefn(p) for p in paths])
362
class BadFileKindError(BzrError):
363
"""Specified file is of a kind that cannot be added.
365
(For example a symlink or device file.)"""
368
class ForbiddenFileError(BzrError):
369
"""Cannot operate on a file because it is a control file."""
372
class LockError(BzrNewError):
373
"""Lock error: %(message)s"""
374
# All exceptions from the lock/unlock functions should be from
375
# this exception class. They will be translated as necessary. The
376
# original exception is available as e.original_error
378
# New code should prefer to raise specific subclasses
379
def __init__(self, message):
380
self.message = message
383
class CommitNotPossible(LockError):
384
"""A commit was attempted but we do not have a write lock open."""
389
class AlreadyCommitted(LockError):
390
"""A rollback was requested, but is not able to be accomplished."""
395
class ReadOnlyError(LockError):
396
"""A write attempt was made in a read only transaction on %(obj)s"""
397
def __init__(self, obj):
401
class OutSideTransaction(BzrNewError):
402
"""A transaction related operation was attempted after the transaction finished."""
405
class ObjectNotLocked(LockError):
406
"""%(obj)r is not locked"""
408
is_user_error = False
410
# this can indicate that any particular object is not locked; see also
411
# LockNotHeld which means that a particular *lock* object is not held by
412
# the caller -- perhaps they should be unified.
413
def __init__(self, obj):
417
class ReadOnlyObjectDirtiedError(ReadOnlyError):
418
"""Cannot change object %(obj)r in read only transaction"""
419
def __init__(self, obj):
423
class UnlockableTransport(LockError):
424
"""Cannot lock: transport is read only: %(transport)s"""
425
def __init__(self, transport):
426
self.transport = transport
429
class LockContention(LockError):
430
"""Could not acquire lock %(lock)s"""
431
# TODO: show full url for lock, combining the transport and relative bits?
432
def __init__(self, lock):
436
class LockBroken(LockError):
437
"""Lock was broken while still open: %(lock)s - check storage consistency!"""
438
def __init__(self, lock):
442
class LockBreakMismatch(LockError):
443
"""Lock was released and re-acquired before being broken: %(lock)s: held by %(holder)r, wanted to break %(target)r"""
444
def __init__(self, lock, holder, target):
450
class LockNotHeld(LockError):
451
"""Lock not held: %(lock)s"""
452
def __init__(self, lock):
456
class PointlessCommit(BzrNewError):
457
"""No changes to commit"""
460
class UpgradeReadonly(BzrNewError):
461
"""Upgrade URL cannot work with readonly URL's."""
464
class UpToDateFormat(BzrNewError):
465
"""The branch format %(format)s is already at the most recent format."""
467
def __init__(self, format):
468
BzrNewError.__init__(self)
473
class StrictCommitFailed(Exception):
474
"""Commit refused because there are unknowns in the tree."""
477
class NoSuchRevision(BzrNewError):
478
"""Branch %(branch)s has no revision %(revision)s"""
480
is_user_error = False
482
def __init__(self, branch, revision):
484
self.revision = revision
487
class HistoryMissing(BzrError):
488
def __init__(self, branch, object_type, object_id):
490
BzrError.__init__(self,
491
'%s is missing %s {%s}'
492
% (branch, object_type, object_id))
495
class DivergedBranches(BzrNewError):
496
"These branches have diverged. Use the merge command to reconcile them."""
500
def __init__(self, branch1, branch2):
501
self.branch1 = branch1
502
self.branch2 = branch2
505
class UnrelatedBranches(BzrNewError):
506
"Branches have no common ancestor, and no merge base revision was specified."
511
class NoCommonAncestor(BzrNewError):
512
"Revisions have no common ancestor: %(revision_a)s %(revision_b)s"
514
def __init__(self, revision_a, revision_b):
515
self.revision_a = revision_a
516
self.revision_b = revision_b
519
class NoCommonRoot(BzrError):
520
def __init__(self, revision_a, revision_b):
521
msg = "Revisions are not derived from the same root: %s %s." \
522
% (revision_a, revision_b)
523
BzrError.__init__(self, msg)
527
class NotAncestor(BzrError):
528
def __init__(self, rev_id, not_ancestor_id):
529
msg = "Revision %s is not an ancestor of %s" % (not_ancestor_id,
531
BzrError.__init__(self, msg)
533
self.not_ancestor_id = not_ancestor_id
536
class InstallFailed(BzrError):
537
def __init__(self, revisions):
538
msg = "Could not install revisions:\n%s" % " ,".join(revisions)
539
BzrError.__init__(self, msg)
540
self.revisions = revisions
543
class AmbiguousBase(BzrError):
544
def __init__(self, bases):
545
warn("BzrError AmbiguousBase has been deprecated as of bzrlib 0.8.",
547
msg = "The correct base is unclear, because %s are all equally close" %\
549
BzrError.__init__(self, msg)
553
class NoCommits(BzrError):
554
def __init__(self, branch):
555
msg = "Branch %s has no commits." % branch
556
BzrError.__init__(self, msg)
559
class UnlistableStore(BzrError):
560
def __init__(self, store):
561
BzrError.__init__(self, "Store %s is not listable" % store)
565
class UnlistableBranch(BzrError):
566
def __init__(self, br):
567
BzrError.__init__(self, "Stores for branch %s are not listable" % br)
570
class BoundBranchOutOfDate(BzrNewError):
571
"""Bound branch %(branch)s is out of date with master branch %(master)s."""
572
def __init__(self, branch, master):
573
BzrNewError.__init__(self)
578
class CommitToDoubleBoundBranch(BzrNewError):
579
"""Cannot commit to branch %(branch)s. It is bound to %(master)s, which is bound to %(remote)s."""
580
def __init__(self, branch, master, remote):
581
BzrNewError.__init__(self)
587
class OverwriteBoundBranch(BzrNewError):
588
"""Cannot pull --overwrite to a branch which is bound %(branch)s"""
589
def __init__(self, branch):
590
BzrNewError.__init__(self)
594
class BoundBranchConnectionFailure(BzrNewError):
595
"""Unable to connect to target of bound branch %(branch)s => %(target)s: %(error)s"""
596
def __init__(self, branch, target, error):
597
BzrNewError.__init__(self)
603
class WeaveError(BzrNewError):
604
"""Error in processing weave: %(message)s"""
606
def __init__(self, message=None):
607
BzrNewError.__init__(self)
608
self.message = message
611
class WeaveRevisionAlreadyPresent(WeaveError):
612
"""Revision {%(revision_id)s} already present in %(weave)s"""
613
def __init__(self, revision_id, weave):
615
WeaveError.__init__(self)
616
self.revision_id = revision_id
620
class WeaveRevisionNotPresent(WeaveError):
621
"""Revision {%(revision_id)s} not present in %(weave)s"""
623
def __init__(self, revision_id, weave):
624
WeaveError.__init__(self)
625
self.revision_id = revision_id
629
class WeaveFormatError(WeaveError):
630
"""Weave invariant violated: %(what)s"""
632
def __init__(self, what):
633
WeaveError.__init__(self)
637
class WeaveParentMismatch(WeaveError):
638
"""Parents are mismatched between two revisions."""
641
class WeaveInvalidChecksum(WeaveError):
642
"""Text did not match it's checksum: %(message)s"""
645
class WeaveTextDiffers(WeaveError):
646
"""Weaves differ on text content. Revision: {%(revision_id)s}, %(weave_a)s, %(weave_b)s"""
648
def __init__(self, revision_id, weave_a, weave_b):
649
WeaveError.__init__(self)
650
self.revision_id = revision_id
651
self.weave_a = weave_a
652
self.weave_b = weave_b
655
class WeaveTextDiffers(WeaveError):
656
"""Weaves differ on text content. Revision: {%(revision_id)s}, %(weave_a)s, %(weave_b)s"""
658
def __init__(self, revision_id, weave_a, weave_b):
659
WeaveError.__init__(self)
660
self.revision_id = revision_id
661
self.weave_a = weave_a
662
self.weave_b = weave_b
665
class VersionedFileError(BzrNewError):
666
"""Versioned file error."""
669
class RevisionNotPresent(VersionedFileError):
670
"""Revision {%(revision_id)s} not present in %(file_id)s."""
672
def __init__(self, revision_id, file_id):
673
VersionedFileError.__init__(self)
674
self.revision_id = revision_id
675
self.file_id = file_id
678
class RevisionAlreadyPresent(VersionedFileError):
679
"""Revision {%(revision_id)s} already present in %(file_id)s."""
681
def __init__(self, revision_id, file_id):
682
VersionedFileError.__init__(self)
683
self.revision_id = revision_id
684
self.file_id = file_id
687
class KnitError(BzrNewError):
691
class KnitHeaderError(KnitError):
692
"""Knit header error: %(badline)r unexpected"""
694
def __init__(self, badline):
695
KnitError.__init__(self)
696
self.badline = badline
699
class KnitCorrupt(KnitError):
700
"""Knit %(filename)s corrupt: %(how)s"""
702
def __init__(self, filename, how):
703
KnitError.__init__(self)
704
self.filename = filename
708
class NoSuchExportFormat(BzrNewError):
709
"""Export format %(format)r not supported"""
710
def __init__(self, format):
711
BzrNewError.__init__(self)
715
class TransportError(BzrError):
716
"""All errors thrown by Transport implementations should derive
719
def __init__(self, msg=None, orig_error=None):
720
if msg is None and orig_error is not None:
721
msg = str(orig_error)
722
BzrError.__init__(self, msg)
724
self.orig_error = orig_error
727
# A set of semi-meaningful errors which can be thrown
728
class TransportNotPossible(TransportError):
729
"""This is for transports where a specific function is explicitly not
730
possible. Such as pushing files to an HTTP server.
735
class ConnectionError(TransportError):
736
"""A connection problem prevents file retrieval.
737
This does not indicate whether the file exists or not; it indicates that a
738
precondition for requesting the file was not met.
740
def __init__(self, msg=None, orig_error=None):
741
TransportError.__init__(self, msg=msg, orig_error=orig_error)
744
class ConnectionReset(TransportError):
745
"""The connection has been closed."""
749
class ConflictsInTree(BzrError):
751
BzrError.__init__(self, "Working tree has conflicts.")
754
class ParseConfigError(BzrError):
755
def __init__(self, errors, filename):
758
message = "Error(s) parsing config file %s:\n%s" % \
759
(filename, ('\n'.join(e.message for e in errors)))
760
BzrError.__init__(self, message)
763
class SigningFailed(BzrError):
764
def __init__(self, command_line):
765
BzrError.__init__(self, "Failed to gpg sign data with command '%s'"
769
class WorkingTreeNotRevision(BzrError):
770
def __init__(self, tree):
771
BzrError.__init__(self, "The working tree for %s has changed since"
772
" last commit, but weave merge requires that it be"
773
" unchanged." % tree.basedir)
776
class CantReprocessAndShowBase(BzrNewError):
777
"""Can't reprocess and show base.
778
Reprocessing obscures relationship of conflicting lines to base."""
781
class GraphCycleError(BzrNewError):
782
"""Cycle in graph %(graph)r"""
783
def __init__(self, graph):
784
BzrNewError.__init__(self)
788
class NotConflicted(BzrNewError):
789
"""File %(filename)s is not conflicted."""
791
def __init__(self, filename):
792
BzrNewError.__init__(self)
793
self.filename = filename
796
class MustUseDecorated(Exception):
797
"""A decorating function has requested its original command be used.
799
This should never escape bzr, so does not need to be printable.
803
class NoBundleFound(BzrNewError):
804
"""No bundle was found in %(filename)s"""
805
def __init__(self, filename):
806
BzrNewError.__init__(self)
807
self.filename = filename
810
class BundleNotSupported(BzrNewError):
811
"""Unable to handle bundle version %(version)s: %(msg)s"""
812
def __init__(self, version, msg):
813
BzrNewError.__init__(self)
814
self.version = version
818
class MissingText(BzrNewError):
819
"""Branch %(base)s is missing revision %(text_revision)s of %(file_id)s"""
821
def __init__(self, branch, text_revision, file_id):
822
BzrNewError.__init__(self)
824
self.base = branch.base
825
self.text_revision = text_revision
826
self.file_id = file_id
829
class DuplicateKey(BzrNewError):
830
"""Key %(key)s is already present in map"""
833
class MalformedTransform(BzrNewError):
834
"""Tree transform is malformed %(conflicts)r"""
837
class BzrBadParameter(BzrNewError):
838
"""A bad parameter : %(param)s is not usable.
840
This exception should never be thrown, but it is a base class for all
841
parameter-to-function errors.
843
def __init__(self, param):
844
BzrNewError.__init__(self)
848
class BzrBadParameterNotUnicode(BzrBadParameter):
849
"""Parameter %(param)s is neither unicode nor utf8."""
852
class ReusingTransform(BzrNewError):
853
"""Attempt to reuse a transform that has already been applied."""
856
class CantMoveRoot(BzrNewError):
857
"""Moving the root directory is not supported at this time"""
860
class BzrBadParameterNotString(BzrBadParameter):
861
"""Parameter %(param)s is not a string or unicode string."""
864
class BzrBadParameterMissing(BzrBadParameter):
865
"""Parameter $(param)s is required but not present."""
868
class BzrBadParameterUnicode(BzrBadParameter):
869
"""Parameter %(param)s is unicode but only byte-strings are permitted."""
872
class BzrBadParameterContainsNewline(BzrBadParameter):
873
"""Parameter %(param)s contains a newline."""
876
class DependencyNotPresent(BzrNewError):
877
"""Unable to import library "%(library)s": %(error)s"""
879
def __init__(self, library, error):
880
BzrNewError.__init__(self, library=library, error=error)
883
class ParamikoNotPresent(DependencyNotPresent):
884
"""Unable to import paramiko (required for sftp support): %(error)s"""
886
def __init__(self, error):
887
DependencyNotPresent.__init__(self, 'paramiko', error)
890
class UninitializableFormat(BzrNewError):
891
"""Format %(format)s cannot be initialised by this version of bzr."""
893
def __init__(self, format):
894
BzrNewError.__init__(self)
898
class NoDiff(BzrNewError):
899
"""Diff is not installed on this machine: %(msg)s"""
901
def __init__(self, msg):
902
super(NoDiff, self).__init__(msg=msg)
905
class NoDiff3(BzrNewError):
906
"""Diff3 is not installed on this machine."""
909
class ExistingLimbo(BzrNewError):
910
"""This tree contains left-over files from a failed operation.
911
Please examine %(limbo_dir)s to see if it contains any files you wish to
912
keep, and delete it when you are done.
914
def __init__(self, limbo_dir):
915
BzrNewError.__init__(self)
916
self.limbo_dir = limbo_dir
919
class ImmortalLimbo(BzrNewError):
920
"""Unable to delete transform temporary directory $(limbo_dir)s.
921
Please examine %(limbo_dir)s to see if it contains any files you wish to
922
keep, and delete it when you are done.
924
def __init__(self, limbo_dir):
925
BzrNewError.__init__(self)
926
self.limbo_dir = limbo_dir
929
class OutOfDateTree(BzrNewError):
930
"""Working tree is out of date, please run 'bzr update'."""
932
def __init__(self, tree):
933
BzrNewError.__init__(self)
937
class MergeModifiedFormatError(BzrNewError):
938
"""Error in merge modified format"""
941
class ConflictFormatError(BzrNewError):
942
"""Format error in conflict listings"""
945
class CorruptRepository(BzrNewError):
946
"""An error has been detected in the repository %(repo_path)s.
947
Please run bzr reconcile on this repository."""
949
def __init__(self, repo):
950
BzrNewError.__init__(self)
951
self.repo_path = repo.bzrdir.root_transport.base
954
class UpgradeRequired(BzrNewError):
955
"""To use this feature you must upgrade your branch at %(path)s."""
957
def __init__(self, path):
958
BzrNewError.__init__(self)
962
class LocalRequiresBoundBranch(BzrNewError):
963
"""Cannot perform local-only commits on unbound branches."""
966
class MissingProgressBarFinish(BzrNewError):
967
"""A nested progress bar was not 'finished' correctly."""
970
class UnsupportedOperation(BzrNewError):
971
"""The method %(mname)s is not supported on objects of type %(tname)s."""
972
def __init__(self, method, method_self):
974
self.mname = method.__name__
975
self.tname = type(method_self).__name__
978
class BinaryFile(BzrNewError):
979
"""File is binary but should be text."""
982
class IllegalPath(BzrNewError):
983
"""The path %(path)s is not permitted on this platform"""
985
def __init__(self, path):
986
BzrNewError.__init__(self)
990
class TestamentMismatch(BzrNewError):
991
"""Testament did not match expected value.
992
For revision_id {%(revision_id)s}, expected {%(expected)s}, measured
995
def __init__(self, revision_id, expected, measured):
996
self.revision_id = revision_id
997
self.expected = expected
998
self.measured = measured
1001
class NotABundle(BzrNewError):
1002
"""Not a bzr revision-bundle: %(text)r"""
1004
def __init__(self, text):
1008
class BadBundle(Exception): pass
1011
class MalformedHeader(BadBundle): pass
1014
class MalformedPatches(BadBundle): pass
1017
class MalformedFooter(BadBundle): pass
added
removed
bzrlib/errors.py
