~bzr-pqm/bzr/bzr.dev

#

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

            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 a unicode object.

            u = unicode(u)

        return u

    def __str__(self):

        s = self._format()

        if isinstance(s, unicode):

            s = str(s)

        return s

 

    def _get_format_string(self):

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

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

               )

 

    def __eq__(self, other):

            return NotImplemented

        return self.__dict__ == other.__dict__

 

 

 

class AlreadyBuilding(BzrError):

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

 

 

 

 

class BzrCheckError(InternalBzrError):

        BzrError.__init__(self)

 

 

class DirstateCorrupt(BzrError):

 

 

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

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

 

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

 

 

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

 

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

            "is not compatible with\n" \

 

 

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

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

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

 

 

class UnsupportedOperation(BzrError):

 

    _fmt = ("The method %(mname)s is not supported on"

 

 

class BinaryFile(BzrError):

    _fmt = "File is binary but should be text."

 

 

 

 

class NotABundle(BzrError):

    _fmt = "Not a bzr revision-bundle: %(text)r"

 

    def __init__(self, text):

        self.text = text

 

 

    _fmt = "Bad bzr revision-bundle: %(text)r"

 

    def __init__(self, text):

        self.text = text

 

 

    _fmt = "Malformed bzr revision-bundle header: %(text)r"

 

 

    _fmt = "Malformed patches in bzr revision-bundle: %(text)r"

 

 

    _fmt = "Malformed footer in bzr revision-bundle: %(text)r"

 

 

class UnsupportedEOLMarker(BadBundle):

 

    def __init__(self):

        # but for this there is not

        BzrError.__init__(self)

 

 

class IncompatibleBundleFormat(BzrError):

    _fmt = "Bundle format %(bundle_format)s is incompatible with %(other)s"

 

    def __init__(self, bundle_format, other):

 

 

class BadInventoryFormat(BzrError):

    _fmt = "Root class for inventory serialization errors"

 

 

        self.transport = transport

 

 

class UnknownSSH(BzrError):

 

    _fmt = "Unrecognised value for BZR_SSH environment variable: %(vendor)s"

        self.revision_id = revision_id

        self.ghost_revision_id = ghost_revision_id

 

class GhostRevisionUnusableHere(BzrError):

 

    _fmt = "Ghost revision {%(revision_id)s} cannot be used here."

 

 

class UnsupportedInventoryKind(BzrError):

    _fmt = """Unsupported entry kind %(kind)s"""

 

    def __init__(self, kind):

 

 

class SubsumeTargetNeedsUpgrade(BzrError):

    _fmt = """Subsume target %(other_tree)s needs to be upgraded."""

 

    def __init__(self, other_tree):

    def __init__(self, branch):

        self.branch = branch

 

class TagAlreadyExists(BzrError):

 

    _fmt = "Tag %(tag_name)s already exists."

 

class MalformedBugIdentifier(BzrError):

 

 

    def __init__(self, bug_id, reason):

        self.bug_id = bug_id

        self.branch = branch

 

 

class UnexpectedSmartServerResponse(BzrError):

 

    _fmt = "Could not understand response from smart server: %(response_tuple)r"

 

 

class ErrorFromSmartServer(BzrError):

 

    _fmt = "Error received from smart server: %(error_tuple)r"

 

        self.error_args = error_tuple[1:]

 

 

class ContainerError(BzrError):

    """Base class of container errors."""

 

class UnknownContainerFormatError(ContainerError):

 

    _fmt = "Unrecognised container format: %(container_format)r"

    def __init__(self, container_format):

        self.container_format = container_format

 

 

class NoMailAddressSpecified(BzrError):

 

 

 

class UnknownMailClient(BzrError):

    _fmt = "'%(display_url)s' is already standalone."

 

 

class ReconfigurationNotSupported(BzrDirError):

 

    _fmt = "Requested reconfiguration of '%(display_url)s' is not supported."

 

class UncommittedChanges(BzrError):

 

 

        import bzrlib.urlutils as urlutils

        display_url = urlutils.unescape_for_display(

            tree.bzrdir.root_transport.base, 'ascii')

 

 

class MissingTemplateVariable(BzrError):

 

 

class CommandAvailableInPlugin(StandardError):