2
# -*- coding: UTF-8 -*-
1
# Copyright (C) 2005, 2006 Canonical Ltd
4
3
# This program is free software; you can redistribute it and/or modify
5
4
# it under the terms of the GNU General Public License as published by
6
5
# the Free Software Foundation; either version 2 of the License, or
7
6
# (at your option) any later version.
9
8
# This program is distributed in the hope that it will be useful,
10
9
# but WITHOUT ANY WARRANTY; without even the implied warranty of
11
10
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12
11
# GNU General Public License for more details.
14
13
# You should have received a copy of the GNU General Public License
15
14
# along with this program; if not, write to the Free Software
16
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
19
__copyright__ = "Copyright (C) 2005 Canonical Ltd."
20
__author__ = "Martin Pool <mbp@canonical.com>"
23
######################################################################
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.
25
96
class BzrError(StandardError):
28
class BzrCheckError(BzrError):
32
class BzrCommandError(BzrError):
33
# Error from malformed user command
37
def bailout(msg, explanation=[]):
38
ex = BzrError(msg, explanation)
40
trace._tracefile.write('* raising %s\n' % ex)
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 ConnectionReset(TransportError):
878
"""Connection closed: %(msg)s %(orig_error)s"""
881
class InvalidRange(TransportError):
882
"""Invalid range access in %(path)s at %(offset)s."""
884
def __init__(self, path, offset):
885
TransportError.__init__(self, ("Invalid range access in %s at %d"
891
class InvalidHttpResponse(TransportError):
892
"""Invalid http response for %(path)s: %(msg)s"""
894
def __init__(self, path, msg, orig_error=None):
896
TransportError.__init__(self, msg, orig_error=orig_error)
899
class InvalidHttpRange(InvalidHttpResponse):
900
"""Invalid http range "%(range)s" for %(path)s: %(msg)s"""
902
def __init__(self, path, range, msg):
904
InvalidHttpResponse.__init__(self, path, msg)
907
class InvalidHttpContentType(InvalidHttpResponse):
908
"""Invalid http Content-type "%(ctype)s" for %(path)s: %(msg)s"""
910
def __init__(self, path, ctype, msg):
912
InvalidHttpResponse.__init__(self, path, msg)
915
class ConflictsInTree(BzrError):
917
BzrError.__init__(self, "Working tree has conflicts.")
920
class ParseConfigError(BzrError):
921
def __init__(self, errors, filename):
924
message = "Error(s) parsing config file %s:\n%s" % \
925
(filename, ('\n'.join(e.message for e in errors)))
926
BzrError.__init__(self, message)
929
class NoEmailInUsername(BzrNewError):
930
"""%(username)r does not seem to contain a reasonable email address"""
932
def __init__(self, username):
933
BzrNewError.__init__(self)
934
self.username = username
937
class SigningFailed(BzrError):
938
def __init__(self, command_line):
939
BzrError.__init__(self, "Failed to gpg sign data with command '%s'"
943
class WorkingTreeNotRevision(BzrError):
944
def __init__(self, tree):
945
BzrError.__init__(self, "The working tree for %s has changed since"
946
" last commit, but weave merge requires that it be"
947
" unchanged." % tree.basedir)
950
class WritingCompleted(BzrNewError):
951
"""The MediumRequest '%(request)s' has already had finish_writing called upon it - accept bytes may not be called anymore."""
953
is_user_error = False
955
def __init__(self, request):
956
BzrNewError.__init__(self)
957
self.request = request
960
class WritingNotComplete(BzrNewError):
961
"""The MediumRequest '%(request)s' has not has finish_writing called upon it - until the write phase is complete no data may be read."""
963
is_user_error = False
965
def __init__(self, request):
966
BzrNewError.__init__(self)
967
self.request = request
970
class CantReprocessAndShowBase(BzrNewError):
971
"""Can't reprocess and show base.
972
Reprocessing obscures relationship of conflicting lines to base."""
975
class GraphCycleError(BzrNewError):
976
"""Cycle in graph %(graph)r"""
977
def __init__(self, graph):
978
BzrNewError.__init__(self)
982
class NotConflicted(BzrNewError):
983
"""File %(filename)s is not conflicted."""
985
def __init__(self, filename):
986
BzrNewError.__init__(self)
987
self.filename = filename
990
class MediumNotConnected(BzrNewError):
991
"""The medium '%(medium)s' is not connected."""
993
def __init__(self, medium):
994
BzrNewError.__init__(self)
998
class MustUseDecorated(Exception):
999
"""A decorating function has requested its original command be used.
1001
This should never escape bzr, so does not need to be printable.
1005
class NoBundleFound(BzrNewError):
1006
"""No bundle was found in %(filename)s"""
1007
def __init__(self, filename):
1008
BzrNewError.__init__(self)
1009
self.filename = filename
1012
class BundleNotSupported(BzrNewError):
1013
"""Unable to handle bundle version %(version)s: %(msg)s"""
1014
def __init__(self, version, msg):
1015
BzrNewError.__init__(self)
1016
self.version = version
1020
class MissingText(BzrNewError):
1021
"""Branch %(base)s is missing revision %(text_revision)s of %(file_id)s"""
1023
def __init__(self, branch, text_revision, file_id):
1024
BzrNewError.__init__(self)
1025
self.branch = branch
1026
self.base = branch.base
1027
self.text_revision = text_revision
1028
self.file_id = file_id
1031
class DuplicateKey(BzrNewError):
1032
"""Key %(key)s is already present in map"""
1035
class MalformedTransform(BzrNewError):
1036
"""Tree transform is malformed %(conflicts)r"""
1039
class NoFinalPath(BzrNewError):
1040
"""No final name for trans_id %(trans_id)r
1041
file-id: %(file_id)r"
1042
root trans-id: %(root_trans_id)r
1045
def __init__(self, trans_id, transform):
1046
self.trans_id = trans_id
1047
self.file_id = transform.final_file_id(trans_id)
1048
self.root_trans_id = transform.root
1051
class BzrBadParameter(BzrNewError):
1052
"""A bad parameter : %(param)s is not usable.
1054
This exception should never be thrown, but it is a base class for all
1055
parameter-to-function errors.
1057
def __init__(self, param):
1058
BzrNewError.__init__(self)
1062
class BzrBadParameterNotUnicode(BzrBadParameter):
1063
"""Parameter %(param)s is neither unicode nor utf8."""
1066
class ReusingTransform(BzrNewError):
1067
"""Attempt to reuse a transform that has already been applied."""
1070
class CantMoveRoot(BzrNewError):
1071
"""Moving the root directory is not supported at this time"""
1074
class BzrBadParameterNotString(BzrBadParameter):
1075
"""Parameter %(param)s is not a string or unicode string."""
1078
class BzrBadParameterMissing(BzrBadParameter):
1079
"""Parameter $(param)s is required but not present."""
1082
class BzrBadParameterUnicode(BzrBadParameter):
1083
"""Parameter %(param)s is unicode but only byte-strings are permitted."""
1086
class BzrBadParameterContainsNewline(BzrBadParameter):
1087
"""Parameter %(param)s contains a newline."""
1090
class DependencyNotPresent(BzrNewError):
1091
"""Unable to import library "%(library)s": %(error)s"""
1093
def __init__(self, library, error):
1094
BzrNewError.__init__(self, library=library, error=error)
1097
class ParamikoNotPresent(DependencyNotPresent):
1098
"""Unable to import paramiko (required for sftp support): %(error)s"""
1100
def __init__(self, error):
1101
DependencyNotPresent.__init__(self, 'paramiko', error)
1104
class PointlessMerge(BzrNewError):
1105
"""Nothing to merge."""
1108
class UninitializableFormat(BzrNewError):
1109
"""Format %(format)s cannot be initialised by this version of bzr."""
1111
def __init__(self, format):
1112
BzrNewError.__init__(self)
1113
self.format = format
1116
class BadConversionTarget(BzrNewError):
1117
"""Cannot convert to format %(format)s. %(problem)s"""
1119
def __init__(self, problem, format):
1120
BzrNewError.__init__(self)
1121
self.problem = problem
1122
self.format = format
1125
class NoDiff(BzrNewError):
1126
"""Diff is not installed on this machine: %(msg)s"""
1128
def __init__(self, msg):
1129
BzrNewError.__init__(self, msg=msg)
1132
class NoDiff3(BzrNewError):
1133
"""Diff3 is not installed on this machine."""
1136
class ExistingLimbo(BzrNewError):
1137
"""This tree contains left-over files from a failed operation.
1138
Please examine %(limbo_dir)s to see if it contains any files you wish to
1139
keep, and delete it when you are done.
1141
def __init__(self, limbo_dir):
1142
BzrNewError.__init__(self)
1143
self.limbo_dir = limbo_dir
1146
class ImmortalLimbo(BzrNewError):
1147
"""Unable to delete transform temporary directory $(limbo_dir)s.
1148
Please examine %(limbo_dir)s to see if it contains any files you wish to
1149
keep, and delete it when you are done.
1151
def __init__(self, limbo_dir):
1152
BzrNewError.__init__(self)
1153
self.limbo_dir = limbo_dir
1156
class OutOfDateTree(BzrNewError):
1157
"""Working tree is out of date, please run 'bzr update'."""
1159
def __init__(self, tree):
1160
BzrNewError.__init__(self)
1164
class MergeModifiedFormatError(BzrNewError):
1165
"""Error in merge modified format"""
1168
class ConflictFormatError(BzrNewError):
1169
"""Format error in conflict listings"""
1172
class CorruptRepository(BzrNewError):
1173
"""An error has been detected in the repository %(repo_path)s.
1174
Please run bzr reconcile on this repository."""
1176
def __init__(self, repo):
1177
BzrNewError.__init__(self)
1178
self.repo_path = repo.bzrdir.root_transport.base
1181
class UpgradeRequired(BzrNewError):
1182
"""To use this feature you must upgrade your branch at %(path)s."""
1184
def __init__(self, path):
1185
BzrNewError.__init__(self)
1189
class LocalRequiresBoundBranch(BzrNewError):
1190
"""Cannot perform local-only commits on unbound branches."""
1193
class MissingProgressBarFinish(BzrNewError):
1194
"""A nested progress bar was not 'finished' correctly."""
1197
class InvalidProgressBarType(BzrNewError):
1198
"""Environment variable BZR_PROGRESS_BAR='%(bar_type)s is not a supported type
1199
Select one of: %(valid_types)s"""
1201
def __init__(self, bar_type, valid_types):
1202
BzrNewError.__init__(self, bar_type=bar_type, valid_types=valid_types)
1205
class UnsupportedOperation(BzrNewError):
1206
"""The method %(mname)s is not supported on objects of type %(tname)s."""
1207
def __init__(self, method, method_self):
1208
self.method = method
1209
self.mname = method.__name__
1210
self.tname = type(method_self).__name__
1213
class BinaryFile(BzrNewError):
1214
"""File is binary but should be text."""
1217
class IllegalPath(BzrNewError):
1218
"""The path %(path)s is not permitted on this platform"""
1220
def __init__(self, path):
1221
BzrNewError.__init__(self)
1225
class TestamentMismatch(BzrNewError):
1226
"""Testament did not match expected value.
1227
For revision_id {%(revision_id)s}, expected {%(expected)s}, measured
1230
def __init__(self, revision_id, expected, measured):
1231
self.revision_id = revision_id
1232
self.expected = expected
1233
self.measured = measured
1236
class NotABundle(BzrNewError):
1237
"""Not a bzr revision-bundle: %(text)r"""
1239
def __init__(self, text):
1240
BzrNewError.__init__(self)
1244
class BadBundle(BzrNewError):
1245
"""Bad bzr revision-bundle: %(text)r"""
1247
def __init__(self, text):
1248
BzrNewError.__init__(self)
1252
class MalformedHeader(BadBundle):
1253
"""Malformed bzr revision-bundle header: %(text)r"""
1255
def __init__(self, text):
1256
BzrNewError.__init__(self)
1260
class MalformedPatches(BadBundle):
1261
"""Malformed patches in bzr revision-bundle: %(text)r"""
1263
def __init__(self, text):
1264
BzrNewError.__init__(self)
1268
class MalformedFooter(BadBundle):
1269
"""Malformed footer in bzr revision-bundle: %(text)r"""
1271
def __init__(self, text):
1272
BzrNewError.__init__(self)
1276
class UnsupportedEOLMarker(BadBundle):
1277
"""End of line marker was not \\n in bzr revision-bundle"""
1280
BzrNewError.__init__(self)
1283
class IncompatibleFormat(BzrNewError):
1284
"""Bundle format %(bundle_format)s is incompatible with %(other)s"""
1286
def __init__(self, bundle_format, other):
1287
BzrNewError.__init__(self)
1288
self.bundle_format = bundle_format
1292
class BadInventoryFormat(BzrNewError):
1293
"""Root class for inventory serialization errors"""
1296
class UnexpectedInventoryFormat(BadInventoryFormat):
1297
"""The inventory was not in the expected format:\n %(msg)s"""
1299
def __init__(self, msg):
1300
BadInventoryFormat.__init__(self, msg=msg)
1303
class NoSmartMedium(BzrNewError):
1304
"""The transport '%(transport)s' cannot tunnel the smart protocol."""
1306
def __init__(self, transport):
1307
BzrNewError.__init__(self)
1308
self.transport = transport
1311
class NoSmartServer(NotBranchError):
1312
"""No smart server available at %(url)s"""
1314
def __init__(self, url):
1318
class UnknownSSH(BzrNewError):
1319
"""Unrecognised value for BZR_SSH environment variable: %(vendor)s"""
1321
def __init__(self, vendor):
1322
BzrNewError.__init__(self)
1323
self.vendor = vendor
1326
class GhostRevisionUnusableHere(BzrNewError):
1327
"""Ghost revision {%(revision_id)s} cannot be used here."""
1329
def __init__(self, revision_id):
1330
BzrNewError.__init__(self)
1331
self.revision_id = revision_id
1334
class IllegalUseOfScopeReplacer(BzrNewError):
1335
"""ScopeReplacer object %(name)r was used incorrectly: %(msg)s%(extra)s"""
1337
is_user_error = False
1339
def __init__(self, name, msg, extra=None):
1340
BzrNewError.__init__(self)
1344
self.extra = ': ' + str(extra)
1349
class InvalidImportLine(BzrNewError):
1350
"""Not a valid import statement: %(msg)\n%(text)s"""
1352
is_user_error = False
1354
def __init__(self, text, msg):
1355
BzrNewError.__init__(self)
1360
class ImportNameCollision(BzrNewError):
1361
"""Tried to import an object to the same name as an existing object. %(name)s"""
1363
is_user_error = False
1365
def __init__(self, name):
1366
BzrNewError.__init__(self)
added
removed
bzrlib/errors.py
