#!/usr/bin/python2.4

#

# CDDL HEADER START

#

# The contents of this file are subject to the terms of the

# Common Development and Distribution License (the "License").

# You may not use this file except in compliance with the License.

#

# You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE

# or http://www.opensolaris.org/os/licensing.

# See the License for the specific language governing permissions

# and limitations under the License.

#

# When distributing Covered Code, include this CDDL HEADER in each

# file and include the License file at usr/src/OPENSOLARIS.LICENSE.

# If applicable, add the following below this CDDL HEADER, with the

# fields enclosed by brackets "[]" replaced with your own identifying

# information: Portions Copyright [yyyy] [name of copyright owner]

#

# CDDL HEADER END

#

#

# Copyright 2009 Sun Microsystems, Inc.  All rights reserved.

# Use is subject to license terms.

#

import os

import urlparse

# EmptyI for argument defaults; can't import from misc due to circular

# dependency.

EmptyI = tuple()

class ApiException(Exception):

        pass

class ImageNotFoundException(ApiException):

        """Used when an image was not found"""

        def __init__(self, user_specified, user_dir, root_dir):

                ApiException.__init__(self)

                self.user_specified = user_specified

                self.user_dir = user_dir

                self.root_dir = root_dir

class VersionException(ApiException):

        def __init__(self, expected_version, received_version):

                ApiException.__init__(self)

                self.expected_version = expected_version

                self.received_version = received_version

class PlanExistsException(ApiException):

        def __init__(self, plan_type):

                ApiException.__init__(self)

                self.plan_type = plan_type

class ActuatorException(ApiException):

        def __init__(self, e):

                ApiException.__init__(self)

                self.exception = e

        def __str__(self):

                return str(self.exception)

class PrematureExecutionException(ApiException):

        pass

class AlreadyPreparedException(ApiException):

        pass

class AlreadyExecutedException(ApiException):

        pass

class ImageplanStateException(ApiException):

        def __init__(self, state):

                ApiException.__init__(self)

                self.state = state

class ImagePkgStateError(ApiException):

        def __init__(self, fmri, states):

                ApiException.__init__(self)

                self.fmri = fmri

                self.states = states

        def __str__(self):

                return _("Invalid package state change attempted '%(states)s' "

                    "for package '%(fmri)s'.") % { "states": self.states,

                    "fmri": self.fmri }

class IpkgOutOfDateException(ApiException):

        pass

class ImageUpdateOnLiveImageException(ApiException):

        pass

class RebootNeededOnLiveImageException(ApiException):

        pass

class CanceledException(ApiException):

        pass

class PlanMissingException(ApiException):

        pass

class NoPackagesInstalledException(ApiException):

        pass

class PermissionsException(ApiException):

        def __init__(self, path):

                ApiException.__init__(self)

                self.path = path

        def __str__(self):

                if self.path:

                        return _("Could not operate on %s\nbecause of "

                            "insufficient permissions. Please try the command "

                            "again using pfexec\nor otherwise increase your "

                            "privileges.") % self.path

                else:

                        return _("""

Could not complete the operation because of insufficient permissions. Please

try the command again using pfexec or otherwise increase your privileges.

""")

class FileInUseException(PermissionsException):

        def __init__(self, path):

                PermissionsException.__init__(self, path)

                assert path

        def __str__(self):

                return _("Could not operate on %s\nbecause the file is "

                    "in use. Please stop using the file and try the\n"

                    "operation again.") % self.path

class ReadOnlyFileSystemException(PermissionsException):

        """Used to indicate that the operation was attempted on a 

        read-only filesystem"""

        def __init__(self, path):

                ApiException.__init__(self)

                self.path = path

        def __str__(self):

                if self.path:

                        return _("Could not complete the operation on %s: "

                            "read-only filesystem\n") % self.path

                return _("Could not complete the operation: read-only "

                        "filesystem.")

class PlanCreationException(ApiException):

        def __init__(self, unmatched_fmris=EmptyI, multiple_matches=EmptyI,

            missing_matches=EmptyI, illegal=EmptyI,

                ApiException.__init__(self)

                self.obsolete = obsolete

        def __str__(self):

                res = []

                if self.unmatched_fmris:

                        s = _("""\

The following pattern(s) did not match any packages in the current catalog.

Try relaxing the pattern, refreshing and/or examining the catalogs:""")

                        res += [s]

                        res += ["\t%s" % p for p in self.unmatched_fmris]

                if self.multiple_matches:

                        s = _("'%s' matches multiple packages")

                        for p, lst in self.multiple_matches:

                                res.append(s % p)

                                for pfmri in lst:

                                        res.append("\t%s" % pfmri)

                if self.badarch:

                        s = _("'%s' supports the following architectures: %s")

                        a = _("Image architecture is defined as: %s")

                        res += [ s % (self.badarch[0],

                            ", ".join(self.badarch[1]))]

                        res += [ a % (self.badarch[2])]

                s = _("'%(p)s' depends on obsolete package '%(op)s'")

                res += [ s % {"p": p, "op": op} for p, op in self.obsolete ]

                if self.installed:

                        s = _("The proposed operation can not be performed for "

                            "the following package(s) as they are already "

                            "installed: ")

                        res += [s]

                        res += ["\t%s" % p for p in self.installed]

                return "\n".join(res)

class ActionExecutionError(ApiException):

        """An error was encountered executing an action.

        In particular, this exception indicates that something went wrong in the

        application (or unapplication) of the action to the system, not an error

        in the pkg(5) code.

        The 'msg' argument can provide a more specific message than what would

        be returned from, and 'ignoreerrno' can be set to True to indicate that

        the sterror() text is misleading, and shouldn't be displayed.

        """

        def __init__(self, action, exception, msg=None, ignoreerrno=False):

                self.action = action

                self.exception = exception

                self.msg = msg

                self.ignoreerrno = ignoreerrno

        def __str__(self):

                errno = ""

                if not self.ignoreerrno and hasattr(self.exception, "errno"):

                        errno = "[errno %d: %s]" % (self.exception.errno,

                            os.strerror(self.exception.errno))

                msg = self.msg or ""

                # Fall back on the wrapped exception if we don't have anything

                # useful.

                if not errno and not msg:

                        return str(self.exception)

                if errno and msg:

                        return "%s: %s" % (errno, msg)

                # If we only have one of the two, no need for the colon.

                return "%s%s" % (errno, msg)

class CatalogRefreshException(ApiException):

        def __init__(self, failed, total, succeeded, message=None):

                ApiException.__init__(self)

                self.failed = failed

                self.total = total

                self.succeeded = succeeded

                self.message = message

class CatalogError(ApiException):

        """Base exception class for all catalog exceptions."""

        def __init__(self, *args, **kwargs):

                ApiException.__init__(self)

                if args:

                        self.data = args[0]

                else:

                        self.data = None

                self.args = kwargs

        def __str__(self):

                return str(self.data)

class AnarchicalCatalogFMRI(CatalogError):

        """Used to indicate that the specified FMRI is not valid for catalog

        operations because it is missing publisher information."""

        def __str__(self):

                return _("The FMRI '%s' does not contain publisher information "

                    "and cannot be used for catalog operations.") % self.data

class BadCatalogMetaRoot(CatalogError):

        """Used to indicate an operation on the catalog's meta_root failed

        because the meta_root is invalid."""

        def __str__(self):

                return _("Catalog meta_root '%(root)s' is invalid; unable "

                    "to complete operation: '%(op)s'.") % { "root": self.data,

                    "op": self.args.get("operation", None) }

class BadCatalogPermissions(CatalogError):

        """Used to indicate the server catalog files do not have the expected

        permissions."""

        def __init__(self, files):

                """files should contain a list object with each entry consisting

                of a tuple of filename, expected_mode, received_mode."""

                if not files:

                        files = []

                CatalogError.__init__(self, files)

        def __str__(self):

                msg = _("The following catalog files have incorrect "

                    "permissions:\n")

                for f in self.args:

                        fname, emode, fmode = f

                        msg += _("\t%(fname)s: expected mode: %(emode)s, found "

                            "mode: %(fmode)s\n") % { "fname": fname,

                            "emode": emode, "fmode": fmode }

                return msg

class BadCatalogSignatures(CatalogError):

        """Used to indicate that the Catalog signatures are not valid."""

        def __str__(self):

                return _("The signature data for the '%s' catalog file is not "

                    "valid.") % self.data

class BadCatalogUpdateIdentity(CatalogError):

        """Used to indicate that the requested catalog updates could not be

        applied as the new catalog data is significantly different such that

        the old catalog cannot be updated to match it."""

        def __str__(self):

                return _("Unable to determine the updates needed for  "

                    "the current catalog using the provided catalog "

                    "update data in '%s'.") % self.data

class DuplicateCatalogEntry(CatalogError):

        """Used to indicate that the specified catalog operation could not be

        performed since it would result in a duplicate catalog entry."""

        def __str__(self):

                return _("Unable to perform '%(op)s' operation for catalog "

                    "%(name)s; completion would result in a duplicate entry "

                    "for package '%(fmri)s'.") % { "op": self.args.get(

                    "operation", None), "name": self.args.get("catalog_name",

                    None), "fmri": self.data }

class CatalogUpdateRequirements(CatalogError):

        """Used to indicate that an update request for the catalog could not

        be performed because update requirements were not satisfied."""

        def __str__(self):

                return _("Catalog updates can only be applied to an on-disk "

                    "catalog.")

class InvalidCatalogFile(CatalogError):

        """Used to indicate a Catalog file could not be loaded."""

        def __str__(self):

                return _("Catalog file '%s' is invalid.") % self.data

class ObsoleteCatalogUpdate(CatalogError):

        """Used to indicate that the specified catalog updates are for an older

        version of the catalog and cannot be applied."""

        def __str__(self):

                return _("Unable to determine the updates needed for the "

                    "catalog using the provided catalog update data in '%s'. "

                    "The specified catalog updates are for an older version "

                    "of the catalog and cannot be used.") % self.data

class UnknownCatalogEntry(CatalogError):

        """Used to indicate that an entry for the specified package FMRI or

        pattern could not be found in the catalog."""

        def __str__(self):

                return _("'%s' could not be found in the catalog.") % self.data

class UnknownUpdateType(CatalogError):

        """Used to indicate that the specified CatalogUpdate operation is

        unknown."""

        def __str__(self):

                return _("Unknown catalog update type '%s'") % self.data

class UnrecognizedCatalogPart(CatalogError):

        """Raised when the catalog finds a CatalogPart that is unrecognized

        or invalid."""

        def __str__(self):

                return _("Unrecognized, unknown, or invalid CatalogPart '%s'") \

                    % self.data

class InventoryException(ApiException):

        """Used to indicate that some of the specified patterns to a catalog

        matching function did not match any catalog entries."""

        def __init__(self, illegal=EmptyI, matcher=EmptyI, notfound=EmptyI,

            publisher=EmptyI, version=EmptyI):

                ApiException.__init__(self)

                self.illegal = illegal

                self.matcher = matcher

                self.notfound = set(notfound)

                self.publisher = publisher

                self.version = version

                self.notfound.update(matcher)

                self.notfound.update(publisher)

                self.notfound.update(version)

                self.notfound = list(self.notfound)

                assert self.illegal or self.notfound 

        def __str__(self):

                outstr = ""

                for x in self.illegal:

                        # Illegal FMRIs have their own __str__ method

                        outstr += "%s\n" % x

                if self.matcher or self.publisher or self.version:

                        outstr += _("No matching package could be found for "

                            "the following FMRIs in any of the catalogs for "

                            "the current publishers:\n")

                        for x in self.matcher:

                                outstr += _("%s (pattern did not match)\n") % x

                        for x in self.publisher:

                                outstr += _("%s (publisher did not "

                                    "match)\n") % x

                        for x in self.version:

                                outstr += _("%s (version did not match)\n") % x

                return outstr

# SearchExceptions

class SearchException(ApiException):

        """Based class used for all search-related api exceptions."""

        pass

class MainDictParsingException(SearchException):

        """This is used when the main dictionary could not parse a line."""

        def __init__(self, e):

                SearchException.__init__(self)

                self.e = e

        def __str__(self):

                return str(self.e)

class MalformedSearchRequest(SearchException):

        """Raised when the server cannot understand the format of the

        search request."""

        def __init__(self, url):

                SearchException.__init__(self)

                self.url = url