#!/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

#

#

#

import errno

import operator

import os

import six

import xml.parsers.expat as expat

from functools import total_ordering

from six.moves.urllib.parse import urlsplit

# pkg classes

import pkg.client.pkgdefs as pkgdefs

# 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 add_verbose_info(self, info):

                self.__verbose_info.extend(info)

        @property

        def verbose_info(self):

                return self.__verbose_info

class SuidUnsupportedError(ApiException):

        def __str__(self):

                return _("""

The pkg client api module can not be invoked from an setuid executable.""")

class HistoryException(ApiException):

        """Private base exception class for all History exceptions."""

        def __init__(self, *args):

                Exception.__init__(self, *args)

                self.error = args[0]

        def __str__(self):

                return str(self.error)

class HistoryLoadException(HistoryException):

        """Used to indicate that an unexpected error occurred while loading

        History operation information.

        The first argument should be an exception object related to the

        error encountered.

        """

        def __init__(self, *args):

                HistoryException.__init__(self, *args)

                self.parse_failure = isinstance(self.error, expat.ExpatError)

class HistoryRequestException(HistoryException):

        """Used to indicate that invalid time / range values were provided to

        history API functions."""

        pass

class HistoryStoreException(HistoryException):

        """Used to indicate that an unexpected error occurred while storing

        History operation information.

        The first argument should be an exception object related to the

        error encountered.

        """

        pass

class HistoryPurgeException(HistoryException):

        """Used to indicate that an unexpected error occurred while purging

        History operation information.

        The first argument should be an exception object related to the

        error encountered.

        """

        pass

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} on {host}, pid {pid}.").format(

                            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} on an unknown host, pid {pid}.").format(

                            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} on {host}.").format(

                            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

        def __str__(self):

                return _("No image rooted at '{0}'").format(self.user_dir)

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 {0} is written in an older format "

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

                    "performed.").format(self.path)

class ImageInsufficentSpace(ApiException):

        """Used when insuffcient space exists for proposed operation"""

        def __init__(self, needed, avail, use):

                self.needed = needed

                self.avail = avail

                self.use = use

        def __str__(self):

                from pkg.misc import bytes_to_str

                return _("Insufficient disk space available ({avail}) "

                    "for estimated need ({needed}) for {use}").format(

                    avail=bytes_to_str(self.avail),

                    needed=bytes_to_str(self.needed),

                    use=self.use

                   )

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"

                    "{0}").format("\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: {0}\n\n").format(sfmri)

                        for e in self.__errors[sfmri]:

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

                                output += _("License: {0}\n").format(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}' "

                    "for package '{fmri}'.").format(states=self.states,

                    fmri=self.fmri)

class IpkgOutOfDateException(ApiException):

        def __str__(self):

                return _("pkg(5) out of date")

class ImageUpdateOnLiveImageException(ApiException):

        def __str__(self):

                return _("Requested operation cannot be performed "

                    "in live image.")

class RebootNeededOnLiveImageException(ApiException):

        def __str__(self):

                return _("Requested operation cannot be performed "

                    "in live image.")

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 {0}\nbecause of "

                            "insufficient permissions. Please try the "

                            "command again as a privileged user.").format(

                            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 {0}\nbecause the file is "

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

                    "operation again.").format(self.path)

class UnprivilegedUserError(PermissionsException):

        def __init__(self, path):

                PermissionsException.__init__(self, path)

        def __str__(self):

                return _("Insufficient access to complete the requested "

                    "operation.\nPlease try the operation again as a "

                    "privileged user.")

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 {0}: "

                            "read-only filesystem.").format(self.path)

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

                        "filesystem.")

class InvalidLockException(ApiException):

        def __init__(self, path):

                ApiException.__init__(self)

                self.path = path

        def __str__(self):

                return _("Unable to obtain or operate on lock at {0}.\n"

                    "Please try the operation again as a privileged "

                    "user.").format(self.path)

class PackageMatchErrors(ApiException):

        """Used to indicate which patterns were not matched or illegal during

        a package name matching operation."""

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

            illegal=EmptyI, multispec=EmptyI):

                ApiException.__init__(self)

                self.unmatched_fmris = unmatched_fmris

                self.multiple_matches = multiple_matches

                self.illegal = illegal

                self.multispec = multispec

        def __str__(self):

                res = []

                if self.unmatched_fmris:

                        s = _("The following pattern(s) did not match any "

                            "packages:")

                        res += [s]

                        res += ["\t{0}".format(p) for p in self.unmatched_fmris]

                if self.multiple_matches:

                        s = _("'{0}' matches multiple packages")

                        for p, lst in self.multiple_matches:

                                res.append(s.format(p))

                                for pfmri in lst:

                                        res.append("\t{0}".format(pfmri))

                if self.illegal:

                        s = _("'{0}' is an illegal FMRI")

                        res += [ s.format(p) for p in self.illegal ]

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

                                    + ": {0}".format(t[0])

                                ]

                return "\n".join(res)

class PlanCreationException(ApiException):

        def __init__(self,

            already_installed=EmptyI,

            badarch=EmptyI,

            illegal=EmptyI,

            installed=EmptyI,

            invalid_mediations=EmptyI,

            linked_pub_error=EmptyI,

            missing_dependency=EmptyI,

            missing_matches=EmptyI,

            multiple_matches=EmptyI,

            multispec=EmptyI,

            no_solution=False,

            no_tmp_origins=False,

            no_version=EmptyI,

            not_avoided=EmptyI,

            nofiles=EmptyI,

            obsolete=EmptyI,

            pkg_updates_required=EmptyI,

            rejected_pats=EmptyI,