~bzr-pqm/bzr/bzr.dev

# Copyright (C) 2005, 2006, 2007, 2008 Canonical Ltd

# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA

# python exceptions?   A list of values with no names seems less useful

# TODO: Perhaps convert the exception to a string at the moment it's

# return codes from the bzr program

EXIT_OK = 0

EXIT_ERROR = 3

EXIT_INTERNAL_ERROR = 4

 

 

 

        string to print the arguments.

        Keyword arguments are taken as parameters to the error, which can

        be inserted into the format string template.  It's recommended

        that subclasses override the __init__ method to require specific

           not subject to expansion. 'msg' is used instead of 'message' because

           python evolved and, in 2.6, forbids the use of 'message'.

    def _format(self):

            # contains a preformatted message

            return s

                d = dict(self.__dict__)

                s = fmt % d

    def __unicode__(self):

        u = self._format()

        if isinstance(u, str):

            # Try decoding the str using the default encoding.

            u = unicode(u)

        elif not isinstance(u, unicode):

            # Try to make a unicode object from it, because __unicode__ must

            # return a unicode object.

            u = unicode(u)

        return u

 

    def __str__(self):

        s = self._format()

        if isinstance(s, unicode):

            s = s.encode('utf8')

        else:

            # __str__ must return a str.

            s = str(s)

        return s

 

    def __repr__(self):

        return '%s(%s)' % (self.__class__.__name__, str(self))

 

    def __eq__(self, other):

        if self.__class__ is not other.__class__:

            return NotImplemented

        return self.__dict__ == other.__dict__

 

 

class InternalBzrError(BzrError):

    """Base class for errors that are internal in nature.

 

    This is a convenience class for errors that are internal. The

    internal_error attribute can still be altered in subclasses, if needed.

    Using this class is simply an easy way to get internal errors.

    """

 

    internal_error = True

 

 

class BranchError(BzrError):

    """Base class for concrete 'errors about a branch'."""

 

    def __init__(self, branch):

        BzrError.__init__(self, branch=branch)

 

 

class BzrCheckError(InternalBzrError):

 

    _fmt = "Internal check failed: %(msg)s"

 

    def __init__(self, msg):

        BzrError.__init__(self)

        self.msg = msg

 

 

class DirstateCorrupt(BzrError):

 

    _fmt = "The dirstate file (%(state)s) appears to be corrupt: %(msg)s"

 

    def __init__(self, state, msg):

        BzrError.__init__(self)

        self.state = state

        self.msg = msg

 

 

class DisabledMethod(InternalBzrError):

class InvalidEntryName(InternalBzrError):

 

 

 

class RootMissing(InternalBzrError):

 

    _fmt = ("The root entry of a tree must be the first entry supplied to "

        "record_entry_contents.")

 

 

class NoPublicBranch(BzrError):

 

    _fmt = 'There is no public branch set for "%(branch_url)s".'

 

    def __init__(self, branch):

        import bzrlib.urlutils as urlutils

        public_location = urlutils.unescape_for_display(branch.base, 'ascii')

        BzrError.__init__(self, branch_url=public_location)

 

 

    _fmt = 'The file id "%(file_id)s" is not present in the tree %(tree)s.'

 

class NoSuchIdInRepository(NoSuchId):

 

    _fmt = ('The file id "%(file_id)s" is not present in the repository'

            ' %(repository)r')

 

    def __init__(self, repository, file_id):

        BzrError.__init__(self, repository=repository, file_id=file_id)

 

 

class NotStacked(BranchError):

 

    _fmt = "The branch '%(branch)s' is not stacked."

 

 

class InventoryModified(InternalBzrError):

    _fmt = 'No WorkingTree exists for "%(base)s".'

 

class WorkingTreeAlreadyPopulated(InternalBzrError):

 

    _fmt = 'Working tree already populated in "%(base)s"'

 

 

# - this is finer than a TransportError - and more useful as such. It

 

            " (Use --after to tell bzr about a rename that has already"

            " happened)%(extra)s")

    _fmt = '"%(path)s" is not a directory %(extra)s'

    _fmt = '"%(path)s" is not in the working directory %(extra)s'

    _fmt = 'Directory not empty: "%(path)s"%(extra)s'

 

 

class HardLinkNotSupported(PathError):

 

    _fmt = 'Hard-linking "%(path)s" is not supported'

 

 

class ReadingCompleted(InternalBzrError):

 

    _fmt = 'Device or resource busy: "%(path)s"%(extra)s'

    _fmt = 'Permission denied: "%(path)s"%(extra)s'

    _fmt = 'Invalid url supplied to transport: "%(path)s"%(extra)s'

    _fmt = "Invalid URL join request: %(reason)s: %(base)r + %(join_args)r"

 

    def __init__(self, reason, base, join_args):

        self.reason = reason

        self.base = base

        self.join_args = join_args

        PathError.__init__(self, base, reason)

 

 

class InvalidRebaseURLs(PathError):

 

    _fmt = "URLs differ by more than path: %(from_)r and %(to)r"

 

    def __init__(self, from_, to):

        self.from_ = from_

        self.to = to

        PathError.__init__(self, from_, 'URLs differ by more than path.')

 

 

class UnavailableRepresentation(InternalBzrError):

 

    _fmt = ("The encoding '%(wanted)s' is not available for key %(key)s which "

        "is encoded as '%(native)s'.")

 

    def __init__(self, key, wanted, native):

        InternalBzrError.__init__(self)

        self.wanted = wanted

        self.native = native

        self.key = key

class UnstackableBranchFormat(BzrError):

 

    _fmt = ("The branch '%(url)s'(%(format)s) is not a stackable format. "

        "You will need to upgrade the branch to permit branch stacking.")

 

    def __init__(self, format, url):

        BzrError.__init__(self)

        self.format = format

        self.url = url

 

 

class UnstackableRepositoryFormat(BzrError):

 

    _fmt = ("The repository '%(url)s'(%(format)s) is not a stackable format. "

        "You will need to upgrade the repository to permit branch stacking.")

 

    def __init__(self, format, url):

        BzrError.__init__(self)

        self.format = format

        self.url = url

 

 

 

    _fmt = ('readv() read %(actual)s bytes rather than %(length)s bytes'

            ' at %(offset)s for "%(path)s"%(extra)s')

class PathNotChild(PathError):

    _fmt = 'Path "%(path)s" is not a child of path "%(base)s"%(extra)s'

    _fmt = 'Path "%(path)s" is not unicode normalized'

# TODO: Probably this behavior of should be a common superclass

    _fmt = 'Not a branch: "%(path)s".'

    _fmt = 'Already a branch: "%(path)s".'

    _fmt = 'Directory contains a branch, but no working tree \

(use bzr checkout if you wish to build a working tree): "%(path)s"'

    _fmt = ('"%(function)s" called on an AtomicFile after it was closed:'

            ' "%(path)s"')

    _fmt = ('Parent not accessible given base "%(base)s" and'

            ' relative path "%(path)s"')

    _fmt = 'No repository present: "%(path)s"'

    _fmt = 'File "%(path)s" is not in branch %(branch_base)s.'

 

    _fmt = "Unknown %(kind)s format: %(format)r"

 

    def __init__(self, format, kind='branch'):

        self.kind = kind

        self.format = format

 

    _fmt = "%(target)s\n" \

            "is not compatible with\n" \

            "%(source)s\n" \

            "%(details)s"

    def __init__(self, source, target, details=None):

        if details is None:

            details = "(no details)"

        BzrError.__init__(self, target=target, source=source, details=details)

 

    _fmt = "%(context_info)s%(path)s is already versioned."

    _fmt = "%(context_info)s%(path)s is not versioned."

class BadFilenameEncoding(BzrError):

 

    _fmt = ('Filename %(filename)r is not valid in your current filesystem'

            ' encoding %(fs_encoding)s')

 

    def __init__(self, filename, fs_encoding):

        BzrError.__init__(self)

        self.filename = filename

        self.fs_encoding = fs_encoding

 

 

    _fmt = 'Cannot operate on "%(filename)s" because it is a control file'

 

 

class LockError(InternalBzrError):

        # so use a different variable name.  We now work around this in

        # BzrError.__str__, but this member name is kept for compatability.

class LockFailed(LockError):

 

    internal_error = False

 

    _fmt = "Cannot lock %(lock)s: %(why)s"

 

    def __init__(self, lock, why):

        self.lock = lock

        self.why = why

    internal_error = False

 

    _fmt = 'Could not acquire lock "%(lock)s": %(msg)s'

    def __init__(self, lock, msg=''):

        self.msg = msg

class BadCommitMessageEncoding(BzrError):

 

    _fmt = 'The specified commit message contains characters unsupported by '\

        'the current encoding.'

 

 

class NoSuchRevision(InternalBzrError):

 

    _fmt = "%(branch)s has no revision %(revision)s"

        # 'branch' may sometimes be an internal object like a KnitRevisionStore

class RangeInChangeOption(BzrError):

 

    _fmt = "Option --change does not accept revision ranges"

 

    _fmt = "The revision id {%(revision_id)s} is not present in the tree %(tree)s."

class NotLefthandHistory(InternalBzrError):

 

class CannotReverseCherrypick(BzrError):

 

    _fmt = ('Selected merge cannot perform reverse cherrypicks.  Try merge3'

            ' or diff3.')

 

class NoCommits(BranchError):

    _fmt = ("Bound branch %(branch)s is out of date with master branch"

            " %(master)s.")

 

    _fmt = "Error in processing weave: %(msg)s"

    def __init__(self, msg=None):

        self.msg = msg

    _fmt = "Parents are mismatched between two revisions. %(message)s"

 

 

 

    _fmt = 'Revision {%(revision_id)s} not present in "%(file_id)s".'

 

    _fmt = 'Revision {%(revision_id)s} already present in "%(file_id)s".'

class KnitError(InternalBzrError):

 

class SHA1KnitCorrupt(KnitCorrupt):

 

    _fmt = ("Knit %(filename)s corrupt: sha-1 of reconstructed text does not "

        "match expected sha-1. key %(key)s expected sha %(expected)s actual "

        "sha %(actual)s")

 

    def __init__(self, filename, actual, expected, key, content):

        KnitError.__init__(self)

        self.filename = filename

        self.actual = actual

        self.expected = expected

        self.key = key

        self.content = content

 

 

class KnitDataStreamIncompatible(KnitError):

    # Not raised anymore, as we can convert data streams.  In future we may

    # need it again for more exotic cases, so we're keeping it around for now.

 

    _fmt = "Cannot insert knit data stream of format \"%(stream_format)s\" into knit of format \"%(target_format)s\"."

 

    def __init__(self, stream_format, target_format):

        self.stream_format = stream_format

        self.target_format = target_format

 

 

class KnitDataStreamUnknown(KnitError):

    # Indicates a data stream we don't know how to handle.

 

    _fmt = "Cannot parse knit data stream of format \"%(stream_format)s\"."

 

    def __init__(self, stream_format):

        self.stream_format = stream_format