~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.

 

    :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:

                d = dict(self.__dict__)

                s = fmt % d

                # __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 InternalBzrError(BzrError):

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

 

 

class AlreadyBuilding(BzrError):

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

 

 

 

 

class BzrCheckError(InternalBzrError):

 

 

class DisabledMethod(InternalBzrError):

 

 

class InvalidEntryName(InternalBzrError):

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

 

    def __init__(self, name):

 

 

class InvalidRevisionNumber(BzrError):

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

 

    def __init__(self, revno):

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

class NoWorkingTree(BzrError):

 

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

    def __init__(self, base):

        BzrError.__init__(self)

        self.base = base

    # 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):

 

 

class ReadingCompleted(InternalBzrError):

    _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.")

        self.url = url

 

 

class UnstackableRepositoryFormat(BzrError):

 

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

 

 

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):

 

 

       import bzrlib.urlutils as urlutils

 

 

class NoSubmitBranch(PathError):

 

 

class UnknownFormatError(BzrError):

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

 

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

 

 

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):

 

class LockContention(LockError):

 

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

    # bits?

 

    internal_error = False

 

        self.lock = lock

 

 

class LockBroken(LockError):

 

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 InvalidRevisionSpec(BzrError):

 

            " %(branch)s%(extra)s")

 

    def __init__(self, spec, branch, extra=None):

class DivergedBranches(BzrError):

 

    _fmt = ("These branches have diverged."

 

    def __init__(self, branch1, branch2):

        self.branch1 = branch1

 

 

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):

        msg = ("The correct base is unclear, because %s are all equally close"

                % ", ".join(bases))

        BzrError.__init__(self, msg)

class BoundBranchOutOfDate(BzrError):

 

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

 

    def __init__(self, branch, master):

        BzrError.__init__(self)

        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):

 

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

 

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):

 

 

class KnitError(InternalBzrError):

    _fmt = "Knit error"

 

 

        self.how = how

 

 

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.

    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.

 

    def __init__(self, stream_format):

        self.stream_format = stream_format

 

class KnitHeaderError(KnitError):

 

 

    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):

    _fmt = "Export format %(format)r not supported"

 

    def __init__(self, format):

 

 

class TransportError(BzrError):

    _fmt = "Transport error: %(msg)s %(orig_error)s"

 

    def __init__(self, msg=None, orig_error=None):

 

class SmartMessageHandlerError(InternalBzrError):

 

 

    def __init__(self, exc_info):

 

# A set of semi-meaningful errors which can be thrown

class TransportNotPossible(TransportError):

            self.port = ':%s' % port

 

 

class ConnectionReset(TransportError):

 

    _fmt = "Connection closed: %(msg)s %(orig_error)s"

 

    _fmt = '%(source)s is%(permanently)s redirected to %(target)s'

 

        self.source = source

        self.target = target

        if is_permanent:

            self.permanently = ' permanently'

        else:

            self.permanently = ''

        TransportError.__init__(self)

 

 

class TooManyRedirections(TransportError):

 

        if filename is None:

            filename = ""

        message = "Error(s) parsing config file %s:\n%s" % \

        BzrError.__init__(self, message)

 

 

 

class WorkingTreeNotRevision(BzrError):

 

            " the last commit, but weave merge requires that it be"

            " unchanged")

 

    _fmt = "Could not move %(from_path)s%(operator)s %(to_path)s%(extra)s"

 

    def __init__(self, from_path='', to_path='', extra=None):

        BzrError.__init__(self)

        if extra:

            self.extra = ': ' + str(extra)

        has_from = len(from_path) > 0

        has_to = len(to_path) > 0

        if has_from:

        else:

            self.from_path = ''

 

        if has_to:

        else:

            self.to_path = ''

 

 

class BadConversionTarget(BzrError):

 

 

        BzrError.__init__(self)

        self.problem = problem

        self.format = format

 

 

class NoDiffFound(BzrError):

    _fmt = """This tree contains left-over files from a failed operation.

    Please examine %(limbo_dir)s to see if it contains any files you wish to

    keep, and delete it when you are done."""

    def __init__(self, limbo_dir):

       BzrError.__init__(self)

       self.limbo_dir = limbo_dir

 

class OutOfDateTree(BzrError):

 

 

        BzrError.__init__(self)

        self.tree = tree

 

 

class PublicBranchOutOfDate(BzrError):

 

    def __init__(self, repo):

        BzrError.__init__(self)

 

 

class InconsistentDelta(BzrError):

        self.reason = reason

 

 

class UpgradeRequired(BzrError):

 

    _fmt = "To use this feature you must upgrade your branch at %(path)s."

    _fmt = "To use this feature you must upgrade your repository at %(path)s."

 

 

class LocalRequiresBoundBranch(BzrError):

 

    _fmt = "Cannot perform local-only commits on unbound branches."