~bzr-pqm/bzr/bzr.dev

#

# This program is free software; you can redistribute it and/or modify

# it under the terms of the GNU General Public License as published by

#

# You should have received a copy of the GNU General Public License

# along with this program; if not, write to the Free Software

 

"""Exceptions for bzr, and reporting of them.

"""

 

from bzrlib import (

    osutils,

    symbol_versioning,

 

 

# TODO: is there any value in providing the .args field used by standard

# to me.

 

# constructed to make sure it will succeed.  But that says nothing about

# exceptions that are never raised.

 

# 'unprintable'.

 

 

class BzrError(StandardError):

    """

    Base class for errors raised by bzrlib.

    :cvar _fmt: Format string to display the error; this is expanded

    by the instance's dict.

    """

    internal_error = False

 

    def __init__(self, msg=None, **kwds):

        arguments can be given.  The first is for generic "user" errors which

        are not intended to be caught and so do not need a specific subclass.

        The second case is for use with subclasses that provide a _fmt format

 

        parameters.

 

        :param msg: If given, this is the literal complete text for the error,

        """

        StandardError.__init__(self)

        if msg is not None:

            for key, value in kwds.items():

                setattr(self, key, value)

 

        s = getattr(self, '_preformatted_string', None)

        if s is not None:

        try:

            fmt = self._get_format_string()

            if fmt:

                # __str__() should always return a 'str' object

                # never a 'unicode' object.

                return s

        except (AttributeError, TypeError, NameError, ValueError, KeyError), e:

            return 'Unprintable exception %s: dict=%r, fmt=%r, error=%r' \

                   getattr(self, '_fmt', None),

                   e)

 

    def _get_format_string(self):

        """Return format string for this exception or None"""

        fmt = getattr(self, '_fmt', None)

               getattr(self, '_fmt', None),

               )

 

 

class BzrNewError(BzrError):

    """Deprecated error base class."""

 

 

class AlreadyBuilding(BzrError):

    _fmt = "The tree builder is already building a tree."

 

 

 

    _fmt = "The smart server method '%(class_name)s' is disabled."

 

    def __init__(self, class_name):

        BzrError.__init__(self)

        self.class_name = class_name

        self.transport = transport

 

 

    _fmt = "Invalid entry name: %(name)s"

 

    def __init__(self, name):

        BzrError.__init__(self)

        self.name = name

 

 

class InvalidRevisionNumber(BzrError):

    _fmt = "Invalid revision number %(revno)s"

 

    def __init__(self, revno):

        self.revision_id = revision_id

        self.branch = branch

 

class ReservedId(BzrError):

 

    _fmt = "Reserved revision-id {%(revision_id)s}"

        self.revision_id = revision_id

 

 

class NoHelpTopic(BzrError):

 

    _fmt = ("No help could be found for '%(topic)s'. "

class NoSuchId(BzrError):

 

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

    def __init__(self, tree, file_id):

        BzrError.__init__(self)

        self.file_id = file_id

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

 

 

 

    _fmt = ("The current inventory for the tree %(tree)r has been modified,"

            " so a clean inventory cannot be read without data loss.")

 

    def __init__(self, tree):

        self.tree = tree

 

class NoWorkingTree(BzrError):

 

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

    def __init__(self, base):

        BzrError.__init__(self)

        self.base = base

        self.url = url

 

 

 

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

 

    def __init__(self, base):

        self.base = base

 

class BzrCommandError(BzrError):

    """Error from user command"""

 

    # Error from malformed user command; please avoid raising this as a

    # generic exception not caused by user input.

    #

    # are not intended to be caught anyway.  UI code need not subclass

    # BzrCommandError, and non-UI code should not throw a subclass of

    # BzrCommandError.  ADHB 20051211

 

 

class NotWriteLocked(BzrError):

    def __init__(self, name, value):

        BzrError.__init__(self, name=name, value=value)

 

class StrictCommitFailed(BzrError):

 

    _fmt = "Commit refused because there are unknown files in the tree"

# XXX: Should be unified with TransportError; they seem to represent the

# same thing

# RBC 20060929: I think that unifiying with TransportError would be a mistake

# differentiates between 'transport has failed' and 'operation on a transport

# has failed.'

class PathError(BzrError):

    _fmt = "Generic path error: %(path)r%(extra)s)"

 

    def __init__(self, path, extra=None):

    """Used when renaming and both source and dest exist."""

 

    _fmt = ("Could not rename %(source)s => %(dest)s because both files exist."

 

    def __init__(self, source, dest, extra=None):

        BzrError.__init__(self)

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

 

 

    _fmt = ("The MediumRequest '%(request)s' has already had finish_reading "

            "called upon it - the request has been completed and no more "

            "data may be read.")

 

    def __init__(self, request):

        self.request = request

 

 

class InvalidURLJoin(PathError):

 

 

 

class UnknownHook(BzrError):

        PathError.__init__(self, url, extra=extra)

 

 

class ReadError(PathError):

    _fmt = """Error reading from %(path)r."""

 

 

 

# TODO: This is given a URL; we try to unescape it but doing that from inside

# the exception object is a bit undesirable.

class NotBranchError(PathError):

 

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

 

class FileInWrongBranch(BzrError):

 

 

    def __init__(self, branch, path):

        BzrError.__init__(self)

 

 

class UnknownFormatError(BzrError):

 

 

class IncompatibleFormat(BzrError):

    _fmt = "Format %(format)s is not compatible with .bzr version %(bzrdir)s."

 

    def __init__(self, format, bzrdir_format):

 

 

class IncompatibleRepositories(BzrError):

 

 

class IncompatibleRevision(BzrError):

    _fmt = "Revision is not compatible with %(repo_format)s"

 

    def __init__(self, repo_format):

        BzrError.__init__(self, filename=filename, kind=kind)

 

 

class ForbiddenControlFileError(BzrError):

 

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

 

 

 

    _fmt = "Lock error: %(msg)s"

 

    # All exceptions from the lock/unlock functions should be from

    # this exception class.  They will be translated as necessary. The

    # original exception is available as e.original_error

    # New code should prefer to raise specific subclasses

    def __init__(self, message):

        # Python 2.5 uses a slot for StandardError.message,

        self.msg = message

 

 

        self.obj = obj

 

 

        LockError.__init__(self, '')

 

 

class OutSideTransaction(BzrError):

 

class UnlockableTransport(LockError):

 

    _fmt = "Cannot lock: transport is read only: %(transport)s"

 

    def __init__(self, transport):

 

class LockContention(LockError):

 

    # TODO: show full url for lock, combining the transport and relative

    # bits?

 

    internal_error = False

 

        self.lock = lock

 

 

class LockBroken(LockError):

 

    _fmt = "The object %(obj)s does not support token specifying a token when locking."

 

    def __init__(self, obj):

        self.obj = obj

 

    _fmt = "Commit refused because there are unknowns in the tree."

 

 

 

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

 

    def __init__(self, branch, revision):

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

        BzrError.__init__(self, branch=branch, revision=revision)

 

 

class RangeInChangeOption(BzrError):

 

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

 

class NoSuchRevisionInTree(NoSuchRevision):

    """When using Tree.revision_tree, and the revision is not accessible."""

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

 

    def __init__(self, tree, revision_id):

class DivergedBranches(BzrError):

 

    _fmt = ("These branches have diverged."

 

    def __init__(self, branch1, branch2):

        self.branch1 = branch1

        self.branch2 = branch2

 

 

 

    _fmt = "Supplied history does not follow left-hand parents"

 

    def __init__(self, history):

        BzrError.__init__(self, history=history)

 

    _fmt = ("Branches have no common ancestor, and"

            " no merge base revision was specified.")

 

 

 

class NoCommonAncestor(BzrError):

    _fmt = "Revisions have no common ancestor: %(revision_a)s %(revision_b)s"

 

    def __init__(self, revision_a, revision_b):

            not_ancestor_id=not_ancestor_id)

 

 

class AmbiguousBase(BzrError):

 

    def __init__(self, bases):

        self.bases = bases

 

 

 

    _fmt = "Branch %(branch)s has no commits."

 

 

class UnlistableStore(BzrError):

 

        self.branch = branch

        self.master = master

 

class CommitToDoubleBoundBranch(BzrError):

 

    _fmt = ("Cannot commit to branch %(branch)s."

 

class WeaveError(BzrError):

 

 

        BzrError.__init__(self)

 

 

class WeaveRevisionAlreadyPresent(WeaveError):

 

class WeaveParentMismatch(WeaveError):

 

 

class WeaveInvalidChecksum(WeaveError):

 

 

 

class VersionedFileError(BzrError):

    _fmt = "Versioned file error"

 

 

class RevisionNotPresent(VersionedFileError):

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

 

    def __init__(self, revision_id, file_id):

 

 

class RevisionAlreadyPresent(VersionedFileError):

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

 

    def __init__(self, revision_id, file_id):

    _fmt = "Text did not match its checksum: %(message)s"

 

 

    _fmt = "Knit error"

 

 

class KnitCorrupt(KnitError):

 

        self.how = how

 

 

class KnitDataStreamIncompatible(KnitError):

 

    _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 KnitHeaderError(KnitError):

 

        self.badline = badline

        self.filename = filename

 

class KnitIndexUnknownMethod(KnitError):

    """Raised when we don't understand the storage method.

 

    Currently only 'fulltext' and 'line-delta' are supported.

    """

    _fmt = ("Knit index %(filename)s does not have a known method"

            " in options: %(options)r")

 

        self.options = options

 

 

class NoSuchExportFormat(BzrError):