#!/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, 2011, Oracle and/or its affiliates. All rights reserved.

#

import errno

import os

import urlparse

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

# dependency.

EmptyI = tuple()

class ApiException(Exception):

        def __init__(self, *args):

                Exception.__init__(self)

                self.__verbose_info = []

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

        def add_verbose_info(self, info):

                self.__verbose_info.extend(info)

        @property

        def verbose_info(self):

                return self.__verbose_info

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

        """Used to indicate that an image was found at a location other than

        '/' on the Solaris platform when requesting automatic image location

        discovery.  Clients should trap this exception and add their own

        messaging telling the user how to specify an image root explicitly

        for the location."""

        def __init__(self, root, live_root="/"):

                ApiException.__init__(self)

                self.root = root

                self.live_root = live_root

        def __str__(self):

                return _("pkg(5) image found at '%(found)s' instead of "

                    "'%(expected)s'.") % { "found": self.root,

                    "expected": self.live_root }

class ImageFormatUpdateNeeded(ApiException):

        """Used to indicate that an image cannot be used until its format is

        updated."""

        def __init__(self, path):

                ApiException.__init__(self)

                self.path = path

        def __str__(self):

                return _("The image rooted at %s is written in an older format "

                    "and must be updated before the requested operation can be "

                    "performed.") % self.path

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 as a privileged user.") % \

                            self.path

                else:

                        return _("""

Could not complete the operation because of insufficient permissions.

Please try the command again as a privileged user.

""")

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, nofiles=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

                self.nofiles               = nofiles

                self.solver_errors         = solver_errors

        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 isinstance(self.no_solution, list):

                                res.extend(self.no_solution)

                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]}]

                if self.nofiles:

                        res += [_("The following files are not packaged in this image:")]

                        res += ["\t%s" % f for f in self.nofiles]

                if self.solver_errors:

                        res += ["\n"]

                        res += [_("Solver dependency errors:")]

                        res.extend(self.solver_errors)

                return "\n".join(res)

class ConflictingActionError(ApiException):

        """Used to indicate that the imageplan would result in one or more sets

        of conflicting actions, meaning that more than one action would exist on

        the system with the same key attribute value in the same namespace.

        There are three categories, each with its own subclass:

          - multiple files delivered to the same path or drivers, users, groups,

            etc, delivered with the same key attribute;

          - multiple objects delivered to the same path which aren't the same

            type;

          - multiple directories, links, or hardlinks delivered to the same path

            but with conflicting attributes.

        """

        def __init__(self, data):

                self._data = data

class ConflictingActionErrors(ApiException):

        """A container for multiple ConflictingActionError exception objects

        that can be raised as a single exception."""

        def __init__(self, errors):

                self.__errors = errors

        def __str__(self):

                return "\n\n".join((str(err) for err in self.__errors))

class DuplicateActionError(ConflictingActionError):

        """Multiple actions of the same type have been delivered with the same

        key attribute (when not allowed)."""

        def __str__(self):

                pfmris = set((a[1] for a in self._data))

                kv = self._data[0][0].attrs[self._data[0][0].key_attr]

                action = self._data[0][0].name

                if len(pfmris) > 1:

                        s = _("The following packages all deliver %(action)s "