~bzr-pqm/bzr/bzr.dev

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

# return codes from the bzr program

EXIT_OK = 0

EXIT_ERROR = 3

EXIT_INTERNAL_ERROR = 4

 

 

    def _format(self):

            # contains a preformatted message

            return s

                d = dict(self.__dict__)

                # special case: python2.5 puts the 'message' attribute in a

                # slot, so it isn't seen in __dict__

                d['message'] = getattr(self, 'message', 'no message')

                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 __eq__(self, other):

        if self.__class__ != 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):

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

 

    _fmt = "The transport '%(transport)s' is only accessible within this " \

        "process."

 

    def __init__(self, transport):

        self.transport = transport

 

 

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

 

class BadIndexFormatSignature(BzrError):

 

    _fmt = "%(value)s is not an index of type %(_type)s."

 

    def __init__(self, value, _type):

        BzrError.__init__(self)

        self.value = value

        self._type = _type

 

 

class BadIndexData(BzrError):

 

    _fmt = "Error in data for index %(value)s."

 

    def __init__(self, value):

        BzrError.__init__(self)

        self.value = value

 

 

class BadIndexDuplicateKey(BzrError):

 

    _fmt = "The key '%(key)s' is already in index '%(index)s'."

 

    def __init__(self, key, index):

        BzrError.__init__(self)

        self.key = key

        self.index = index

 

 

class BadIndexKey(BzrError):

 

    _fmt = "The key '%(key)s' is not a valid key."

 

    def __init__(self, key):

        BzrError.__init__(self)

        self.key = key

 

 

class BadIndexOptions(BzrError):

 

    _fmt = "Could not parse options for index %(value)s."

 

    def __init__(self, value):

        BzrError.__init__(self)

        self.value = value

 

 

class BadIndexValue(BzrError):

 

    _fmt = "The value '%(value)s' is not a valid value."

 

    def __init__(self, value):

        BzrError.__init__(self)

        self.value = value

 

 

            " (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'

    _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"'

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 = "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 VersionedFileInvalidChecksum(VersionedFileError):

 

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

 

 

class KnitError(InternalBzrError):

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

        

 

class KnitHeaderError(KnitError):

 

    _fmt = 'Knit header error: %(badline)r unexpected for file "%(filename)s".'

 

    def __init__(self, badline, filename):

        KnitError.__init__(self)

        self.badline = badline

        self.filename = filename

 

class TooManyConcurrentRequests(InternalBzrError):

class UnexpectedProtocolVersionMarker(TransportError):

 

    _fmt = "Received bad protocol version marker: %(marker)r"

 

    def __init__(self, marker):

        self.marker = marker

 

 

class UnknownSmartMethod(InternalBzrError):

 

    _fmt = "The server does not recognise the '%(verb)s' request."

 

    def __init__(self, verb):

        self.verb = verb

 

 

class SmartMessageHandlerError(InternalBzrError):

 

    _fmt = "The message handler raised an exception: %(exc_value)s."

 

    def __init__(self, exc_info):

        self.exc_type, self.exc_value, self.tb = exc_info

        

 

    _fmt = "Invalid range access in %(path)s at %(offset)s: %(msg)s"

 

    def __init__(self, path, offset, msg=None):

        TransportError.__init__(self, msg)

 

 

    def __init__(self, source, target, is_permanent=False, qual_proto=None):

        if is_permanent:

 

    _fmt = 'Failed to gpg sign data with command "%(command_line)s"'

class WritingCompleted(InternalBzrError):

class WritingNotComplete(InternalBzrError):

class MediumNotConnected(InternalBzrError):

    _fmt = 'No bundle was found in "%(filename)s".'

class BzrBadParameter(InternalBzrError):

    _fmt = ("Can't safely remove modified or unknown files:\n"

        "%(changes_as_text)s"

class NoDiffFound(BzrError):

 

    _fmt = 'Could not find an appropriate Differ for file "%(path)s"'

 

    def __init__(self, path):

        BzrError.__init__(self, path)

 

 

class ExecutableMissing(BzrError):

 

    _fmt = "%(exe_name)s could not be found on this machine"

 

    def __init__(self, exe_name):

        BzrError.__init__(self, exe_name=exe_name)

 

 

class ExistingContent(BzrError):

    # Added in bzrlib 0.92, used by VersionedFile.add_lines.

 

    _fmt = "The content being inserted is already present."

 

 

class ExistingPendingDeletion(BzrError):

 

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

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

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

 

    def __init__(self, pending_deletion):

       BzrError.__init__(self, pending_deletion=pending_deletion)