#!/usr/bin/python

#

# 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 (c) 2008, 2010, Oracle and/or its affiliates. All rights reserved.

#

import os

import urlparse

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

# dependency.

EmptyI = tuple()

class ApiException(Exception):

        def __unicode__(self):

                # To workaround python issues 6108 and 2517, this provides a

                # a standard wrapper for this class' exceptions so that they

                # have a chance of being stringified correctly.

                return unicode(str(self))

class ImageLockedError(ApiException):

        """Used to indicate that the image is currently locked by another thread

        or process and cannot be modified."""

        def __init__(self, hostname=None, pid=None, pid_name=None):

                ApiException.__init__(self)

                self.hostname = hostname

                self.pid = pid

                self.pid_name = pid_name

        def __str__(self):

                if self.pid is not None and self.pid_name is not None and \

                    self.hostname is not None:

                        return _("The image cannot be modified as it is "

                            "currently in use by another package client: "

                            "%(pid_name)s on %(host)s, pid %(pid)s.") % {

                            "pid_name": self.pid_name, "pid": self.pid,

                            "host": self.hostname }

                if self.pid is not None and self.pid_name is not None:

                        return _("The image cannot be modified as it is "

                            "currently in use by another package client: "

                            "%(pid_name)s on an unknown host, pid %(pid)s.") % {

                            "pid_name": self.pid_name, "pid": self.pid }

                elif self.pid is not None:

                        return _("The image cannot be modified as it is "

                            "currently in use by another package client: "

                            "pid %(pid)s on %(host)s.") % {

                            "pid": self.pid, "host": self.hostname }

                return _("The image cannot be modified as it is currently "

                    "in use by another package client.")

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 PlanPrepareException(ApiException):

        """Base exception class for plan preparation errors."""

        pass

class InvalidPackageErrors(ApiException):

        """Used to indicate that the requested operation could not be completed

        as one or more packages contained invalid metadata."""

        def __init__(self, errors):

                """'errors' should be a list of exceptions or strings

                indicating what packages had errors and why."""

                ApiException.__init__(self)

                self.errors = errors

        def __str__(self):

                return _("The requested operation cannot be completed due "

                    "to invalid package metadata.  Details follow:\n\n"

                    "%s") % "\n".join(str(e) for e in self.errors)

class LicenseAcceptanceError(ApiException):

        """Used to indicate that license-related errors occurred during

        plan evaluation or execution."""

        def __init__(self, pfmri, src=None, dest=None, accepted=None,

            displayed=None):

                ApiException.__init__(self)

                self.fmri = pfmri

                self.src = src

                self.dest = dest

                self.accepted = accepted

                self.displayed = displayed

class PkgLicenseErrors(PlanPrepareException):

        """Used to indicate that plan evaluation or execution failed due

        to license-related errors for a package."""

        def __init__(self, errors):

                """'errors' should be a list of LicenseAcceptanceError

                exceptions."""

                PlanPrepareException.__init__(self)

                self.__errors = errors

        @property

        def errors(self):

                """A list of LicenseAcceptanceError exceptions."""

                return self.__errors

class PlanLicenseErrors(PlanPrepareException):

        """Used to indicate that image plan evaluation or execution failed due

        to license-related errors."""

        def __init__(self, pp_errors):

                """'errors' should be a list of PkgLicenseErrors exceptions."""

                PlanPrepareException.__init__(self)

                self.__errors = pkgs = {}

                for pp_err in pp_errors:

                        for e in pp_err.errors:

                                pkgs.setdefault(str(e.fmri), []).append(e)

        @property

        def errors(self):

                """Returns a dictionary indexed by package FMRI string of

                lists of LicenseAcceptanceError exceptions."""

                return self.__errors

        def __str__(self):

                """Returns a string representation of the license errors."""

                output = ""

                for sfmri in self.__errors:

                        output += ("-" * 40) + "\n"

                        output += _("Package: %s\n\n") % sfmri

                        for e in self.__errors[sfmri]:

                                lic_name = e.dest.attrs["license"]

                                output += _("License: %s\n") % lic_name

                                if e.dest.must_accept and not e.accepted:

                                        output += _("  License requires "

                                            "acceptance.")

                                if e.dest.must_display and not e.displayed:

                                        output += _("  License must be viewed.")

                                output += "\n"

                return output

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

        pass

class AlreadyExecutedException(ApiException):

        pass

class ImageplanStateException(ApiException):

        def __init__(self, state):

                ApiException.__init__(self)

                self.state = state

class InvalidPlanError(ApiException):

        """Used to indicate that the image plan is no longer valid, likely as a

        result of an image state change since the plan was created."""

        def __str__(self):

                return _("The plan for the current operation is no longer "

                    "valid.  The image has likely been modified by another "

                    "process or client.  Please try the operation again.")

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.") % 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,

            badarch=EmptyI, installed=EmptyI, multispec=EmptyI,

            no_solution=False, no_version=EmptyI, missing_dependency=EmptyI,

            wrong_publishers=EmptyI, obsolete=EmptyI):

                ApiException.__init__(self)

                self.unmatched_fmris       = unmatched_fmris

                self.multiple_matches      = multiple_matches

                self.missing_matches       = missing_matches

                self.illegal               = illegal

                self.badarch               = badarch

                self.installed             = installed

                self.multispec             = multispec

                self.obsolete = obsolete

                self.no_solution           = no_solution

                self.no_version            = no_version

                self.missing_dependency    = missing_dependency

                self.wrong_publishers      = wrong_publishers

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

                        s = _("The following patterns only matched packages "

                            "that are from publishers other than that which "

                            "supplied the already installed version of this package")

                        res += [s]

                        res += ["\t%s: %s" % (p[0], ", ".join(p[1])) for p in self.wrong_publishers]

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

                        s = _("'%s' matches no installed packages")

                        res += [ s % p for p in self.missing_matches ]

                if self.illegal:

                        s = _("'%s' is an illegal fmri")

                        res += [ s % p for p in self.illegal ]

                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]

                if self.multispec:

                        s = _("The following different patterns specify the"

                              "same package(s):")

                        res += [s]

                        for t in self.multispec:

                                res += [

                                        ", ".join(

                                        [t[i] for i in range(1, len(t))])

                                        + ": %s" % t[0]

                                        ]

                if self.no_solution:

                        res += [_("No solution was found to satisfy constraints")]

                if self.no_version:

                        res += self.no_version

                if self.missing_dependency:

                        res += [_("Package %(pkg)s is missing a dependency: "

                            "%(dep)s") %

                            {"pkg": self.missing_dependency[0],

                             "dep": self.missing_dependency[1]}]

                return "\n".join(res)

class ActionExecutionError(ApiException):

        """Used to indicate that action execution (such as install, remove,

        etc.) failed even though the action is valid.

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

        application (or unapplication) of the action to the system, and is most

        likely not an error in the pkg(5) code."""

        def __init__(self, action, details=None, error=None, fmri=None,

            use_errno=None):

                """'action' is the object for the action that failed during the

                requested operation.

                'details' is an optional message explaining what operation

                failed, why it failed, and why it cannot continue.  It should

                also include a suggestion as to how to resolve the situation

                if possible.

                'error' is an optional exception object that may have been

                raised when the operation failed.

                'fmri' is an optional package FMRI indicating what package

                was being operated on at the time the error occurred.

                'use_errno' is an optional boolean value indicating whether

                the strerror() text of the exception should be used.  If

                'details' is provided, the default value is False, otherwise

                True."""

                assert (details or error)

                self.action = action

                self.details = details

                self.error = error

                self.fmri = fmri

                if use_errno == None:

                        # If details were provided, don't use errno unless

                        # explicitly requested.

                        use_errno = not details

                self.use_errno = use_errno

        def __str__(self):

                errno = ""

                if self.use_errno and self.error and \

                    hasattr(self.error, "errno"):

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

                            os.strerror(self.error.errno))

                details = self.details or ""

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

                # useful.

                if not errno and not details:

                        return str(self.error)

                if errno and details:

                        details = "%s: %s" % (errno, details)

                if details and not self.fmri:

                        details = _("Requested operation failed for action "

                            "%(action)s:\n%(details)s") % {

                            "action": self.action,

                            "details": msg }

                elif details:

                        details = _("Requested operation failed for package "

                            "%(fmri)s:\n%(details)s") % { "fmri": self.fmri,

                            "details": details }

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

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

class CatalogRefreshException(ApiException):

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

                ApiException.__init__(self)

                self.failed = failed

                self.total = total

                self.succeeded = succeeded

                self.errmessage = errmessage

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