1
# Copyright (C) 2005, 2006 Canonical Ltd
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 '%s.%s' % (sys.exc_type.__module__, sys.exc_type.__name__)
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, *args, **kwds):
124
# XXX: Use the underlying BzrError to always generate the args attribute
125
# if it doesn't exist. We can't use super here, because exceptions are
126
# old-style classes in python2.4 (but new in 2.5). --bmc, 20060426
127
BzrError.__init__(self, *args)
128
for key, value in kwds.items():
129
setattr(self, key, value)
133
# __str__() should always return a 'str' object
134
# never a 'unicode' object.
135
s = self.__doc__ % self.__dict__
136
if isinstance(s, unicode):
137
return s.encode('utf8')
139
except (TypeError, NameError, ValueError, KeyError), e:
140
return 'Unprintable exception %s(%r): %s' \
141
% (self.__class__.__name__,
142
self.__dict__, str(e))
145
class AlreadyBuilding(BzrNewError):
146
"""The tree builder is already building a tree."""
149
class BzrCheckError(BzrNewError):
150
"""Internal check failed: %(message)s"""
152
is_user_error = False
154
def __init__(self, message):
155
BzrNewError.__init__(self)
156
self.message = message
159
class InvalidEntryName(BzrNewError):
160
"""Invalid entry name: %(name)s"""
162
is_user_error = False
164
def __init__(self, name):
165
BzrNewError.__init__(self)
169
class InvalidRevisionNumber(BzrNewError):
170
"""Invalid revision number %(revno)d"""
171
def __init__(self, revno):
172
BzrNewError.__init__(self)
176
class InvalidRevisionId(BzrNewError):
177
"""Invalid revision-id {%(revision_id)s} in %(branch)s"""
179
def __init__(self, revision_id, branch):
180
# branch can be any string or object with __str__ defined
181
BzrNewError.__init__(self)
182
self.revision_id = revision_id
186
class InventoryModified(BzrNewError):
187
"""The current inventory for the tree %(tree)r has been modified, so a clean inventory cannot be read without data loss."""
189
def __init__(self, tree):
190
BzrNewError.__init__(self)
194
class NoSuchId(BzrNewError):
195
"""The file id %(file_id)s is not present in the tree %(tree)s."""
197
def __init__(self, tree, file_id):
198
BzrNewError.__init__(self)
199
self.file_id = file_id
203
class NoWorkingTree(BzrNewError):
204
"""No WorkingTree exists for %(base)s."""
206
def __init__(self, base):
207
BzrNewError.__init__(self)
211
class NotBuilding(BzrNewError):
212
"""Not currently building a tree."""
215
class NotLocalUrl(BzrNewError):
216
"""%(url)s is not a local path."""
218
def __init__(self, url):
219
BzrNewError.__init__(self)
223
class NotWriteLocked(BzrNewError):
224
"""%(not_locked)r is not write locked but needs to be."""
226
def __init__(self, not_locked):
227
BzrNewError.__init__(self)
228
self.not_locked = not_locked
231
class BzrCommandError(BzrNewError):
232
"""Error from user command"""
236
# Error from malformed user command; please avoid raising this as a
237
# generic exception not caused by user input.
239
# I think it's a waste of effort to differentiate between errors that
240
# are not intended to be caught anyway. UI code need not subclass
241
# BzrCommandError, and non-UI code should not throw a subclass of
242
# BzrCommandError. ADHB 20051211
243
def __init__(self, msg):
244
# Object.__str__() must return a real string
245
# returning a Unicode string is a python error.
246
if isinstance(msg, unicode):
247
self.msg = msg.encode('utf8')
255
class BzrOptionError(BzrCommandError):
256
"""Error in command line options"""
259
class StrictCommitFailed(BzrNewError):
260
"""Commit refused because there are unknown files in the tree"""
263
# XXX: Should be unified with TransportError; they seem to represent the
265
class PathError(BzrNewError):
266
"""Generic path error: %(path)r%(extra)s)"""
268
def __init__(self, path, extra=None):
269
BzrNewError.__init__(self)
272
self.extra = ': ' + str(extra)
277
class NoSuchFile(PathError):
278
"""No such file: %(path)r%(extra)s"""
281
class FileExists(PathError):
282
"""File exists: %(path)r%(extra)s"""
285
class DirectoryNotEmpty(PathError):
286
"""Directory not empty: %(path)r%(extra)s"""
289
class ReadingCompleted(BzrNewError):
290
"""The MediumRequest '%(request)s' has already had finish_reading called upon it - the request has been completed and no more data may be read."""
292
is_user_error = False
294
def __init__(self, request):
295
BzrNewError.__init__(self)
296
self.request = request
299
class ResourceBusy(PathError):
300
"""Device or resource busy: %(path)r%(extra)s"""
303
class PermissionDenied(PathError):
304
"""Permission denied: %(path)r%(extra)s"""
307
class InvalidURL(PathError):
308
"""Invalid url supplied to transport: %(path)r%(extra)s"""
311
class InvalidURLJoin(PathError):
312
"""Invalid URL join request: %(args)s%(extra)s"""
314
def __init__(self, msg, base, args):
315
PathError.__init__(self, base, msg)
316
self.args = [base] + list(args)
319
class UnsupportedProtocol(PathError):
320
"""Unsupported protocol for url "%(path)s"%(extra)s"""
322
def __init__(self, url, extra):
323
PathError.__init__(self, url, extra=extra)
326
class ShortReadvError(PathError):
327
"""readv() read %(actual)s bytes rather than %(length)s bytes at %(offset)s for %(path)s%(extra)s"""
329
is_user_error = False
331
def __init__(self, path, offset, length, actual, extra=None):
332
PathError.__init__(self, path, extra=extra)
338
class PathNotChild(BzrNewError):
339
"""Path %(path)r is not a child of path %(base)r%(extra)s"""
341
is_user_error = False
343
def __init__(self, path, base, extra=None):
344
BzrNewError.__init__(self)
348
self.extra = ': ' + str(extra)
353
class InvalidNormalization(PathError):
354
"""Path %(path)r is not unicode normalized"""
357
# TODO: This is given a URL; we try to unescape it but doing that from inside
358
# the exception object is a bit undesirable.
359
# TODO: Probably this behavior of should be a common superclass
360
class NotBranchError(PathError):
361
"""Not a branch: %(path)s"""
363
def __init__(self, path):
364
import bzrlib.urlutils as urlutils
365
self.path = urlutils.unescape_for_display(path, 'ascii')
368
class AlreadyBranchError(PathError):
369
"""Already a branch: %(path)s."""
372
class BranchExistsWithoutWorkingTree(PathError):
373
"""Directory contains a branch, but no working tree \
374
(use bzr checkout if you wish to build a working tree): %(path)s"""
377
class AtomicFileAlreadyClosed(PathError):
378
"""'%(function)s' called on an AtomicFile after it was closed: %(path)s"""
380
def __init__(self, path, function):
381
PathError.__init__(self, path=path, extra=None)
382
self.function = function
385
class InaccessibleParent(PathError):
386
"""Parent not accessible given base %(base)s and relative path %(path)s"""
388
def __init__(self, path, base):
389
PathError.__init__(self, path)
393
class NoRepositoryPresent(BzrNewError):
394
"""No repository present: %(path)r"""
395
def __init__(self, bzrdir):
396
BzrNewError.__init__(self)
397
self.path = bzrdir.transport.clone('..').base
400
class FileInWrongBranch(BzrNewError):
401
"""File %(path)s in not in branch %(branch_base)s."""
403
def __init__(self, branch, path):
404
BzrNewError.__init__(self)
406
self.branch_base = branch.base
410
class UnsupportedFormatError(BzrNewError):
411
"""Unsupported branch format: %(format)s"""
414
class UnknownFormatError(BzrNewError):
415
"""Unknown branch format: %(format)r"""
418
class IncompatibleFormat(BzrNewError):
419
"""Format %(format)s is not compatible with .bzr version %(bzrdir)s."""
421
def __init__(self, format, bzrdir_format):
422
BzrNewError.__init__(self)
424
self.bzrdir = bzrdir_format
427
class IncompatibleRevision(BzrNewError):
428
"""Revision is not compatible with %(repo_format)s"""
430
def __init__(self, repo_format):
431
BzrNewError.__init__(self)
432
self.repo_format = repo_format
435
class NotVersionedError(BzrNewError):
436
"""%(path)s is not versioned"""
437
def __init__(self, path):
438
BzrNewError.__init__(self)
442
class PathsNotVersionedError(BzrNewError):
443
# used when reporting several paths are not versioned
444
"""Path(s) are not versioned: %(paths_as_string)s"""
446
def __init__(self, paths):
447
from bzrlib.osutils import quotefn
448
BzrNewError.__init__(self)
450
self.paths_as_string = ' '.join([quotefn(p) for p in paths])
453
class PathsDoNotExist(BzrNewError):
454
"""Path(s) do not exist: %(paths_as_string)s"""
456
# used when reporting that paths are neither versioned nor in the working
459
def __init__(self, paths):
461
from bzrlib.osutils import quotefn
462
BzrNewError.__init__(self)
464
self.paths_as_string = ' '.join([quotefn(p) for p in paths])
467
class BadFileKindError(BzrNewError):
468
"""Cannot operate on %(filename)s of unsupported kind %(kind)s"""
471
class ForbiddenControlFileError(BzrNewError):
472
"""Cannot operate on %(filename)s because it is a control file"""
475
class LockError(BzrNewError):
476
"""Lock error: %(message)s"""
477
# All exceptions from the lock/unlock functions should be from
478
# this exception class. They will be translated as necessary. The
479
# original exception is available as e.original_error
481
# New code should prefer to raise specific subclasses
482
def __init__(self, message):
483
self.message = message
486
class CommitNotPossible(LockError):
487
"""A commit was attempted but we do not have a write lock open."""
492
class AlreadyCommitted(LockError):
493
"""A rollback was requested, but is not able to be accomplished."""
498
class ReadOnlyError(LockError):
499
"""A write attempt was made in a read only transaction on %(obj)s"""
500
def __init__(self, obj):
504
class OutSideTransaction(BzrNewError):
505
"""A transaction related operation was attempted after the transaction finished."""
508
class ObjectNotLocked(LockError):
509
"""%(obj)r is not locked"""
511
is_user_error = False
513
# this can indicate that any particular object is not locked; see also
514
# LockNotHeld which means that a particular *lock* object is not held by
515
# the caller -- perhaps they should be unified.
516
def __init__(self, obj):
520
class ReadOnlyObjectDirtiedError(ReadOnlyError):
521
"""Cannot change object %(obj)r in read only transaction"""
522
def __init__(self, obj):
526
class UnlockableTransport(LockError):
527
"""Cannot lock: transport is read only: %(transport)s"""
528
def __init__(self, transport):
529
self.transport = transport
532
class LockContention(LockError):
533
"""Could not acquire lock %(lock)s"""
534
# TODO: show full url for lock, combining the transport and relative bits?
535
def __init__(self, lock):
539
class LockBroken(LockError):
540
"""Lock was broken while still open: %(lock)s - check storage consistency!"""
541
def __init__(self, lock):
545
class LockBreakMismatch(LockError):
546
"""Lock was released and re-acquired before being broken: %(lock)s: held by %(holder)r, wanted to break %(target)r"""
547
def __init__(self, lock, holder, target):
553
class LockNotHeld(LockError):
554
"""Lock not held: %(lock)s"""
555
def __init__(self, lock):
559
class PointlessCommit(BzrNewError):
560
"""No changes to commit"""
563
class UpgradeReadonly(BzrNewError):
564
"""Upgrade URL cannot work with readonly URL's."""
567
class UpToDateFormat(BzrNewError):
568
"""The branch format %(format)s is already at the most recent format."""
570
def __init__(self, format):
571
BzrNewError.__init__(self)
575
class StrictCommitFailed(Exception):
576
"""Commit refused because there are unknowns in the tree."""
579
class NoSuchRevision(BzrNewError):
580
"""Branch %(branch)s has no revision %(revision)s"""
582
is_user_error = False
584
def __init__(self, branch, revision):
585
BzrNewError.__init__(self, branch=branch, revision=revision)
588
class NoSuchRevisionSpec(BzrNewError):
589
"""No namespace registered for string: %(spec)r"""
591
def __init__(self, spec):
592
BzrNewError.__init__(self, spec=spec)
595
class InvalidRevisionSpec(BzrNewError):
596
"""Requested revision: '%(spec)s' does not exist in branch:
597
%(branch)s%(extra)s"""
599
def __init__(self, spec, branch, extra=None):
600
BzrNewError.__init__(self, branch=branch, spec=spec)
602
self.extra = '\n' + str(extra)
607
class HistoryMissing(BzrError):
608
def __init__(self, branch, object_type, object_id):
610
BzrError.__init__(self,
611
'%s is missing %s {%s}'
612
% (branch, object_type, object_id))
615
class DivergedBranches(BzrNewError):
616
"These branches have diverged. Use the merge command to reconcile them."""
620
def __init__(self, branch1, branch2):
621
self.branch1 = branch1
622
self.branch2 = branch2
625
class UnrelatedBranches(BzrNewError):
626
"Branches have no common ancestor, and no merge base revision was specified."
631
class NoCommonAncestor(BzrNewError):
632
"Revisions have no common ancestor: %(revision_a)s %(revision_b)s"
634
def __init__(self, revision_a, revision_b):
635
self.revision_a = revision_a
636
self.revision_b = revision_b
639
class NoCommonRoot(BzrError):
640
def __init__(self, revision_a, revision_b):
641
msg = "Revisions are not derived from the same root: %s %s." \
642
% (revision_a, revision_b)
643
BzrError.__init__(self, msg)
647
class NotAncestor(BzrError):
648
def __init__(self, rev_id, not_ancestor_id):
649
msg = "Revision %s is not an ancestor of %s" % (not_ancestor_id,
651
BzrError.__init__(self, msg)
653
self.not_ancestor_id = not_ancestor_id
656
class InstallFailed(BzrError):
657
def __init__(self, revisions):
658
msg = "Could not install revisions:\n%s" % " ,".join(revisions)
659
BzrError.__init__(self, msg)
660
self.revisions = revisions
663
class AmbiguousBase(BzrError):
664
def __init__(self, bases):
665
warn("BzrError AmbiguousBase has been deprecated as of bzrlib 0.8.",
667
msg = "The correct base is unclear, because %s are all equally close" %\
669
BzrError.__init__(self, msg)
673
class NoCommits(BzrNewError):
674
"""Branch %(branch)s has no commits."""
676
def __init__(self, branch):
677
BzrNewError.__init__(self, branch=branch)
680
class UnlistableStore(BzrError):
681
def __init__(self, store):
682
BzrError.__init__(self, "Store %s is not listable" % store)
686
class UnlistableBranch(BzrError):
687
def __init__(self, br):
688
BzrError.__init__(self, "Stores for branch %s are not listable" % br)
691
class BoundBranchOutOfDate(BzrNewError):
692
"""Bound branch %(branch)s is out of date with master branch %(master)s."""
693
def __init__(self, branch, master):
694
BzrNewError.__init__(self)
699
class CommitToDoubleBoundBranch(BzrNewError):
700
"""Cannot commit to branch %(branch)s. It is bound to %(master)s, which is bound to %(remote)s."""
701
def __init__(self, branch, master, remote):
702
BzrNewError.__init__(self)
708
class OverwriteBoundBranch(BzrNewError):
709
"""Cannot pull --overwrite to a branch which is bound %(branch)s"""
710
def __init__(self, branch):
711
BzrNewError.__init__(self)
715
class BoundBranchConnectionFailure(BzrNewError):
716
"""Unable to connect to target of bound branch %(branch)s => %(target)s: %(error)s"""
717
def __init__(self, branch, target, error):
718
BzrNewError.__init__(self)
724
class WeaveError(BzrNewError):
725
"""Error in processing weave: %(message)s"""
727
def __init__(self, message=None):
728
BzrNewError.__init__(self)
729
self.message = message
732
class WeaveRevisionAlreadyPresent(WeaveError):
733
"""Revision {%(revision_id)s} already present in %(weave)s"""
734
def __init__(self, revision_id, weave):
736
WeaveError.__init__(self)
737
self.revision_id = revision_id
741
class WeaveRevisionNotPresent(WeaveError):
742
"""Revision {%(revision_id)s} not present in %(weave)s"""
744
def __init__(self, revision_id, weave):
745
WeaveError.__init__(self)
746
self.revision_id = revision_id
750
class WeaveFormatError(WeaveError):
751
"""Weave invariant violated: %(what)s"""
753
def __init__(self, what):
754
WeaveError.__init__(self)
758
class WeaveParentMismatch(WeaveError):
759
"""Parents are mismatched between two revisions."""
762
class WeaveInvalidChecksum(WeaveError):
763
"""Text did not match it's checksum: %(message)s"""
766
class WeaveTextDiffers(WeaveError):
767
"""Weaves differ on text content. Revision: {%(revision_id)s}, %(weave_a)s, %(weave_b)s"""
769
def __init__(self, revision_id, weave_a, weave_b):
770
WeaveError.__init__(self)
771
self.revision_id = revision_id
772
self.weave_a = weave_a
773
self.weave_b = weave_b
776
class WeaveTextDiffers(WeaveError):
777
"""Weaves differ on text content. Revision: {%(revision_id)s}, %(weave_a)s, %(weave_b)s"""
779
def __init__(self, revision_id, weave_a, weave_b):
780
WeaveError.__init__(self)
781
self.revision_id = revision_id
782
self.weave_a = weave_a
783
self.weave_b = weave_b
786
class VersionedFileError(BzrNewError):
787
"""Versioned file error."""
790
class RevisionNotPresent(VersionedFileError):
791
"""Revision {%(revision_id)s} not present in %(file_id)s."""
793
def __init__(self, revision_id, file_id):
794
VersionedFileError.__init__(self)
795
self.revision_id = revision_id
796
self.file_id = file_id
799
class RevisionAlreadyPresent(VersionedFileError):
800
"""Revision {%(revision_id)s} already present in %(file_id)s."""
802
def __init__(self, revision_id, file_id):
803
VersionedFileError.__init__(self)
804
self.revision_id = revision_id
805
self.file_id = file_id
808
class KnitError(BzrNewError):
812
class KnitHeaderError(KnitError):
813
"""Knit header error: %(badline)r unexpected"""
815
def __init__(self, badline):
816
KnitError.__init__(self)
817
self.badline = badline
820
class KnitCorrupt(KnitError):
821
"""Knit %(filename)s corrupt: %(how)s"""
823
def __init__(self, filename, how):
824
KnitError.__init__(self)
825
self.filename = filename
829
class NoSuchExportFormat(BzrNewError):
830
"""Export format %(format)r not supported"""
832
def __init__(self, format):
833
BzrNewError.__init__(self)
838
class TooManyConcurrentRequests(BzrNewError):
839
"""The medium '%(medium)s' has reached its concurrent request limit. Be sure to finish_writing and finish_reading on the current request that is open."""
841
def __init__(self, medium):
842
BzrNewError.__init__(self)
846
class TransportError(BzrNewError):
847
"""Transport error: %(msg)s %(orig_error)s"""
849
def __init__(self, msg=None, orig_error=None):
850
if msg is None and orig_error is not None:
851
msg = str(orig_error)
852
if orig_error is None:
857
self.orig_error = orig_error
858
BzrNewError.__init__(self)
861
class SmartProtocolError(TransportError):
862
"""Generic bzr smart protocol error: %(details)s"""
864
def __init__(self, details):
865
self.details = details
868
# A set of semi-meaningful errors which can be thrown
869
class TransportNotPossible(TransportError):
870
"""Transport operation not possible: %(msg)s %(orig_error)s"""
873
class ConnectionError(TransportError):
874
"""Connection error: %(msg)s %(orig_error)s"""
877
class SocketConnectionError(ConnectionError):
878
"""%(msg)s %(host)s%(port)s%(orig_error)s"""
880
def __init__(self, host, port=None, msg=None, orig_error=None):
882
msg = 'Failed to connect to'
883
if orig_error is None:
886
orig_error = '; ' + str(orig_error)
887
ConnectionError.__init__(self, msg=msg, orig_error=orig_error)
892
self.port = ':%s' % port
895
class ConnectionReset(TransportError):
896
"""Connection closed: %(msg)s %(orig_error)s"""
899
class InvalidRange(TransportError):
900
"""Invalid range access in %(path)s at %(offset)s."""
902
def __init__(self, path, offset):
903
TransportError.__init__(self, ("Invalid range access in %s at %d"
909
class InvalidHttpResponse(TransportError):
910
"""Invalid http response for %(path)s: %(msg)s"""
912
def __init__(self, path, msg, orig_error=None):
914
TransportError.__init__(self, msg, orig_error=orig_error)
917
class InvalidHttpRange(InvalidHttpResponse):
918
"""Invalid http range "%(range)s" for %(path)s: %(msg)s"""
920
def __init__(self, path, range, msg):
922
InvalidHttpResponse.__init__(self, path, msg)
925
class InvalidHttpContentType(InvalidHttpResponse):
926
"""Invalid http Content-type "%(ctype)s" for %(path)s: %(msg)s"""
928
def __init__(self, path, ctype, msg):
930
InvalidHttpResponse.__init__(self, path, msg)
933
class ConflictsInTree(BzrError):
935
BzrError.__init__(self, "Working tree has conflicts.")
938
class ParseConfigError(BzrError):
939
def __init__(self, errors, filename):
942
message = "Error(s) parsing config file %s:\n%s" % \
943
(filename, ('\n'.join(e.message for e in errors)))
944
BzrError.__init__(self, message)
947
class NoEmailInUsername(BzrNewError):
948
"""%(username)r does not seem to contain a reasonable email address"""
950
def __init__(self, username):
951
BzrNewError.__init__(self)
952
self.username = username
955
class SigningFailed(BzrError):
956
def __init__(self, command_line):
957
BzrError.__init__(self, "Failed to gpg sign data with command '%s'"
961
class WorkingTreeNotRevision(BzrError):
962
def __init__(self, tree):
963
BzrError.__init__(self, "The working tree for %s has changed since"
964
" last commit, but weave merge requires that it be"
965
" unchanged." % tree.basedir)
968
class WritingCompleted(BzrNewError):
969
"""The MediumRequest '%(request)s' has already had finish_writing called upon it - accept bytes may not be called anymore."""
971
is_user_error = False
973
def __init__(self, request):
974
BzrNewError.__init__(self)
975
self.request = request
978
class WritingNotComplete(BzrNewError):
979
"""The MediumRequest '%(request)s' has not has finish_writing called upon it - until the write phase is complete no data may be read."""
981
is_user_error = False
983
def __init__(self, request):
984
BzrNewError.__init__(self)
985
self.request = request
988
class CantReprocessAndShowBase(BzrNewError):
989
"""Can't reprocess and show base.
990
Reprocessing obscures relationship of conflicting lines to base."""
993
class GraphCycleError(BzrNewError):
994
"""Cycle in graph %(graph)r"""
995
def __init__(self, graph):
996
BzrNewError.__init__(self)
1000
class NotConflicted(BzrNewError):
1001
"""File %(filename)s is not conflicted."""
1003
def __init__(self, filename):
1004
BzrNewError.__init__(self)
1005
self.filename = filename
1008
class MediumNotConnected(BzrNewError):
1009
"""The medium '%(medium)s' is not connected."""
1011
def __init__(self, medium):
1012
BzrNewError.__init__(self)
1013
self.medium = medium
1016
class MustUseDecorated(Exception):
1017
"""A decorating function has requested its original command be used.
1019
This should never escape bzr, so does not need to be printable.
1023
class NoBundleFound(BzrNewError):
1024
"""No bundle was found in %(filename)s"""
1025
def __init__(self, filename):
1026
BzrNewError.__init__(self)
1027
self.filename = filename
1030
class BundleNotSupported(BzrNewError):
1031
"""Unable to handle bundle version %(version)s: %(msg)s"""
1032
def __init__(self, version, msg):
1033
BzrNewError.__init__(self)
1034
self.version = version
1038
class MissingText(BzrNewError):
1039
"""Branch %(base)s is missing revision %(text_revision)s of %(file_id)s"""
1041
def __init__(self, branch, text_revision, file_id):
1042
BzrNewError.__init__(self)
1043
self.branch = branch
1044
self.base = branch.base
1045
self.text_revision = text_revision
1046
self.file_id = file_id
1049
class DuplicateKey(BzrNewError):
1050
"""Key %(key)s is already present in map"""
1053
class MalformedTransform(BzrNewError):
1054
"""Tree transform is malformed %(conflicts)r"""
1057
class NoFinalPath(BzrNewError):
1058
"""No final name for trans_id %(trans_id)r
1059
file-id: %(file_id)r"
1060
root trans-id: %(root_trans_id)r
1063
def __init__(self, trans_id, transform):
1064
self.trans_id = trans_id
1065
self.file_id = transform.final_file_id(trans_id)
1066
self.root_trans_id = transform.root
1069
class BzrBadParameter(BzrNewError):
1070
"""A bad parameter : %(param)s is not usable.
1072
This exception should never be thrown, but it is a base class for all
1073
parameter-to-function errors.
1075
def __init__(self, param):
1076
BzrNewError.__init__(self)
1080
class BzrBadParameterNotUnicode(BzrBadParameter):
1081
"""Parameter %(param)s is neither unicode nor utf8."""
1084
class ReusingTransform(BzrNewError):
1085
"""Attempt to reuse a transform that has already been applied."""
1088
class CantMoveRoot(BzrNewError):
1089
"""Moving the root directory is not supported at this time"""
1092
class BzrBadParameterNotString(BzrBadParameter):
1093
"""Parameter %(param)s is not a string or unicode string."""
1096
class BzrBadParameterMissing(BzrBadParameter):
1097
"""Parameter $(param)s is required but not present."""
1100
class BzrBadParameterUnicode(BzrBadParameter):
1101
"""Parameter %(param)s is unicode but only byte-strings are permitted."""
1104
class BzrBadParameterContainsNewline(BzrBadParameter):
1105
"""Parameter %(param)s contains a newline."""
1108
class DependencyNotPresent(BzrNewError):
1109
"""Unable to import library "%(library)s": %(error)s"""
1111
def __init__(self, library, error):
1112
BzrNewError.__init__(self, library=library, error=error)
1115
class ParamikoNotPresent(DependencyNotPresent):
1116
"""Unable to import paramiko (required for sftp support): %(error)s"""
1118
def __init__(self, error):
1119
DependencyNotPresent.__init__(self, 'paramiko', error)
1122
class PointlessMerge(BzrNewError):
1123
"""Nothing to merge."""
1126
class UninitializableFormat(BzrNewError):
1127
"""Format %(format)s cannot be initialised by this version of bzr."""
1129
def __init__(self, format):
1130
BzrNewError.__init__(self)
1131
self.format = format
1134
class BadConversionTarget(BzrNewError):
1135
"""Cannot convert to format %(format)s. %(problem)s"""
1137
def __init__(self, problem, format):
1138
BzrNewError.__init__(self)
1139
self.problem = problem
1140
self.format = format
1143
class NoDiff(BzrNewError):
1144
"""Diff is not installed on this machine: %(msg)s"""
1146
def __init__(self, msg):
1147
BzrNewError.__init__(self, msg=msg)
1150
class NoDiff3(BzrNewError):
1151
"""Diff3 is not installed on this machine."""
1154
class ExistingLimbo(BzrNewError):
1155
"""This tree contains left-over files from a failed operation.
1156
Please examine %(limbo_dir)s to see if it contains any files you wish to
1157
keep, and delete it when you are done.
1159
def __init__(self, limbo_dir):
1160
BzrNewError.__init__(self)
1161
self.limbo_dir = limbo_dir
1164
class ImmortalLimbo(BzrNewError):
1165
"""Unable to delete transform temporary directory $(limbo_dir)s.
1166
Please examine %(limbo_dir)s to see if it contains any files you wish to
1167
keep, and delete it when you are done.
1169
def __init__(self, limbo_dir):
1170
BzrNewError.__init__(self)
1171
self.limbo_dir = limbo_dir
1174
class OutOfDateTree(BzrNewError):
1175
"""Working tree is out of date, please run 'bzr update'."""
1177
def __init__(self, tree):
1178
BzrNewError.__init__(self)
1182
class MergeModifiedFormatError(BzrNewError):
1183
"""Error in merge modified format"""
1186
class ConflictFormatError(BzrNewError):
1187
"""Format error in conflict listings"""
1190
class CorruptRepository(BzrNewError):
1191
"""An error has been detected in the repository %(repo_path)s.
1192
Please run bzr reconcile on this repository."""
1194
def __init__(self, repo):
1195
BzrNewError.__init__(self)
1196
self.repo_path = repo.bzrdir.root_transport.base
1199
class UpgradeRequired(BzrNewError):
1200
"""To use this feature you must upgrade your branch at %(path)s."""
1202
def __init__(self, path):
1203
BzrNewError.__init__(self)
1207
class LocalRequiresBoundBranch(BzrNewError):
1208
"""Cannot perform local-only commits on unbound branches."""
1211
class MissingProgressBarFinish(BzrNewError):
1212
"""A nested progress bar was not 'finished' correctly."""
1215
class InvalidProgressBarType(BzrNewError):
1216
"""Environment variable BZR_PROGRESS_BAR='%(bar_type)s is not a supported type
1217
Select one of: %(valid_types)s"""
1219
def __init__(self, bar_type, valid_types):
1220
BzrNewError.__init__(self, bar_type=bar_type, valid_types=valid_types)
1223
class UnsupportedOperation(BzrNewError):
1224
"""The method %(mname)s is not supported on objects of type %(tname)s."""
1225
def __init__(self, method, method_self):
1226
self.method = method
1227
self.mname = method.__name__
1228
self.tname = type(method_self).__name__
1231
class BinaryFile(BzrNewError):
1232
"""File is binary but should be text."""
1235
class IllegalPath(BzrNewError):
1236
"""The path %(path)s is not permitted on this platform"""
1238
def __init__(self, path):
1239
BzrNewError.__init__(self)
1243
class TestamentMismatch(BzrNewError):
1244
"""Testament did not match expected value.
1245
For revision_id {%(revision_id)s}, expected {%(expected)s}, measured
1248
def __init__(self, revision_id, expected, measured):
1249
self.revision_id = revision_id
1250
self.expected = expected
1251
self.measured = measured
1254
class NotABundle(BzrNewError):
1255
"""Not a bzr revision-bundle: %(text)r"""
1257
def __init__(self, text):
1258
BzrNewError.__init__(self)
1262
class BadBundle(BzrNewError):
1263
"""Bad bzr revision-bundle: %(text)r"""
1265
def __init__(self, text):
1266
BzrNewError.__init__(self)
1270
class MalformedHeader(BadBundle):
1271
"""Malformed bzr revision-bundle header: %(text)r"""
1273
def __init__(self, text):
1274
BzrNewError.__init__(self)
1278
class MalformedPatches(BadBundle):
1279
"""Malformed patches in bzr revision-bundle: %(text)r"""
1281
def __init__(self, text):
1282
BzrNewError.__init__(self)
1286
class MalformedFooter(BadBundle):
1287
"""Malformed footer in bzr revision-bundle: %(text)r"""
1289
def __init__(self, text):
1290
BzrNewError.__init__(self)
1294
class UnsupportedEOLMarker(BadBundle):
1295
"""End of line marker was not \\n in bzr revision-bundle"""
1298
BzrNewError.__init__(self)
1301
class IncompatibleFormat(BzrNewError):
1302
"""Bundle format %(bundle_format)s is incompatible with %(other)s"""
1304
def __init__(self, bundle_format, other):
1305
BzrNewError.__init__(self)
1306
self.bundle_format = bundle_format
1310
class BadInventoryFormat(BzrNewError):
1311
"""Root class for inventory serialization errors"""
1314
class UnexpectedInventoryFormat(BadInventoryFormat):
1315
"""The inventory was not in the expected format:\n %(msg)s"""
1317
def __init__(self, msg):
1318
BadInventoryFormat.__init__(self, msg=msg)
1321
class NoSmartMedium(BzrNewError):
1322
"""The transport '%(transport)s' cannot tunnel the smart protocol."""
1324
def __init__(self, transport):
1325
BzrNewError.__init__(self)
1326
self.transport = transport
1329
class NoSmartServer(NotBranchError):
1330
"""No smart server available at %(url)s"""
1332
def __init__(self, url):
1336
class UnknownSSH(BzrNewError):
1337
"""Unrecognised value for BZR_SSH environment variable: %(vendor)s"""
1339
def __init__(self, vendor):
1340
BzrNewError.__init__(self)
1341
self.vendor = vendor
1344
class GhostRevisionUnusableHere(BzrNewError):
1345
"""Ghost revision {%(revision_id)s} cannot be used here."""
1347
def __init__(self, revision_id):
1348
BzrNewError.__init__(self)
1349
self.revision_id = revision_id
1352
class IllegalUseOfScopeReplacer(BzrNewError):
1353
"""ScopeReplacer object %(name)r was used incorrectly: %(msg)s%(extra)s"""
1355
is_user_error = False
1357
def __init__(self, name, msg, extra=None):
1358
BzrNewError.__init__(self)
1362
self.extra = ': ' + str(extra)
1367
class InvalidImportLine(BzrNewError):
1368
"""Not a valid import statement: %(msg)\n%(text)s"""
1370
is_user_error = False
1372
def __init__(self, text, msg):
1373
BzrNewError.__init__(self)
1378
class ImportNameCollision(BzrNewError):
1379
"""Tried to import an object to the same name as an existing object. %(name)s"""
1381
is_user_error = False
1383
def __init__(self, name):
1384
BzrNewError.__init__(self)
added
removed
bzrlib/errors.py
