#!/usr/bin/python2.6

#

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

#

#

# pkg - package system client utility

#

# The client is going to maintain an on-disk cache of its state, so that

# startup assembly of the graph is reduced.

#

# Client graph is of the entire local catalog.  As operations progress, package

# states will change.

#

# Deduction operation allows the compilation of the local component of the

# catalog, only if an authoritative repository can identify critical files.

#

# Environment variables

#

# PKG_IMAGE - root path of target image

# PKG_IMAGE_TYPE [entire, partial, user] - type of image

#       XXX or is this in the Image configuration?

try:

        import calendar

        import collections

        import datetime

        import errno

        import fnmatch

        import getopt

        import gettext

        import glob

        import itertools

        import locale

        import logging

        import os

        import socket

        import sys

        import textwrap

        import time

        import traceback

        import pkg

        import pkg.actions as actions

        import pkg.client.api as api

        import pkg.client.api_errors as api_errors

        import pkg.client.bootenv as bootenv

        import pkg.client.history as history

        import pkg.client.progress as progress

        import pkg.client.linkedimage as li

        import pkg.client.publisher as publisher

        import pkg.fmri as fmri

        import pkg.misc as misc

        import pkg.portable as portable

        import pkg.version as version

        from pkg.client import global_settings

        from pkg.client.api import IMG_TYPE_ENTIRE, IMG_TYPE_PARTIAL, \

            IMG_TYPE_USER

        from pkg.client.debugvalues import DebugValues

        from pkg.client.history import (RESULT_CANCELED,

            RESULT_FAILED_BAD_REQUEST, RESULT_FAILED_CONFIGURATION,

            RESULT_FAILED_LOCKED, RESULT_FAILED_STORAGE,

            RESULT_FAILED_TRANSPORT, RESULT_FAILED_UNKNOWN,

            RESULT_FAILED_OUTOFMEMORY)

        from pkg.client.pkgdefs import *

        from pkg.misc import EmptyI, msg, PipeError

except KeyboardInterrupt:

        import sys

        sys.exit(1)

PKG_CLIENT_NAME = "pkg"

JUST_UNKNOWN = 0

JUST_LEFT = -1

JUST_RIGHT = 1

logger = global_settings.logger

valid_special_attrs = ["action.hash", "action.key", "action.name", "action.raw"]

valid_special_prefixes = ["action."]

def format_update_error(e):

        # This message is displayed to the user whenever an

        # ImageFormatUpdateNeeded exception is encountered.

        logger.error("\n")

        logger.error(str(e))

        logger.error(_("To continue, execute 'pkg update-format' as a "

            "privileged user and then try again.  Please note that updating "

            "the format of the image will render it unusable with older "

            "versions of the pkg(5) system."))

def error(text, cmd=None):

        """Emit an error message prefixed by the command name """

        if not isinstance(text, basestring):

                # Assume it's an object that can be stringified.

                text = str(text)

        # If the message starts with whitespace, assume that it should come

        # *before* the command-name prefix.

        text_nows = text.lstrip()

        ws = text[:len(text) - len(text_nows)]

        if cmd:

                text_nows = "%s: %s" % (cmd, text_nows)

                pkg_cmd = "pkg "

        else:

                pkg_cmd = "pkg: "

        # This has to be a constant value as we can't reliably get our actual

        # program name on all platforms.

        logger.error(ws + pkg_cmd + text_nows)

def usage(usage_error=None, cmd=None, retcode=EXIT_BADOPT, full=False):

        """Emit a usage message and optionally prefix it with a more

            specific error message.  Causes program to exit. """

        if usage_error:

                error(usage_error, cmd=cmd)

        basic_usage = {}

        adv_usage = {}

        basic_cmds = ["refresh", "install", "uninstall", "update", "list",

            "version"]

        basic_usage["install"] = _(

            "[-nvq] [-g path_or_uri ...] [--accept] [--licenses]\n"

            "            [--no-be-activate] [--no-index] [--no-refresh] [--deny-new-be |\n"

            "            --require-new-be] [--be-name name] [--reject pkg_fmri_pattern ... ]\n"

            "            pkg_fmri_pattern ...")

        basic_usage["uninstall"] = _(

            "[-nvq] [--no-be-activate] [--no-index] [--deny-new-be |\n"

            "            --require-new-be] [--be-name name] pkg_fmri_pattern ...")

        basic_usage["update"] = _(

            "[-fnvq] [-g path_or_uri ...] [--accept] [--licenses]\n"

            "            [--no-be-activate] [--no-index] [--no-refresh] [--deny-new-be |\n"

            "            --require-new-be] [--be-name name] [--reject pkg_fmri_pattern ...]\n"

            "            [pkg_fmri_pattern ...]")

        basic_usage["list"] = _(

            "[-Hafnsuv] [-g path_or_uri ...] [--no-refresh]\n"

            "            [pkg_fmri_pattern ...]")

        basic_usage["refresh"] = _("[--full] [publisher ...]")

        basic_usage["version"] = ""

        advanced_cmds = [

            "info",

            "contents",

            "search",

            "",

            "verify",

            "fix",

            "revert",

            "",

            "mediator",

            "set-mediator",

            "unset-mediator",

            "",

            "variant",

            "change-variant",

            "",

            "facet",

            "change-facet",

            "",

            "avoid",

            "unavoid",

            "",

            "freeze",

            "unfreeze",

            "",

            "property",

            "set-property",

            "add-property-value",

            "remove-property-value",

            "unset-property",

            "",

            "publisher",

            "set-publisher",

            "unset-publisher",

            "",

            "history",

            "purge-history",

            "",

            "rebuild-index",

            "update-format",

            "image-create",

            "",

            "attach-linked",

            "detach-linked",

            "list-linked",

            "audit-linked",

            "sync-linked",

            "property-linked",

        ]

        adv_usage["info"] = \

            _("[-lr] [-g path_or_uri ...] [--license] [pkg_fmri_pattern ...]")

        adv_usage["contents"] = _(

            "[-Hmr] [-a attribute=pattern ...] [-g path_or_uri ...]\n"

            "            [-o attribute ...] [-s sort_key] [-t action_type ...]\n"

            "            [pkg_fmri_pattern ...]")

        adv_usage["search"] = _(

            "[-HIaflpr] [-o attribute ...] [-s repo_uri] query")

        adv_usage["verify"] = _("[-Hqv] [pkg_fmri_pattern ...]")

        adv_usage["fix"] = _("[--accept] [--licenses] [pkg_fmri_pattern ...]")

        adv_usage["revert"] = _(

            "[-nv] [--no-be-activate] [--be-name name] [--deny-new-be |\n"

            "            --require-new-be] (--tagged tag-name ... | path-to-file ...)")

        adv_usage["image-create"] = _(

            "[-FPUfz] [--force] [--full|--partial|--user] [--zone]\n"

            "            [-k ssl_key] [-c ssl_cert] [--no-refresh]\n"

            "            [--variant <variant_spec>=<instance> ...]\n"

            "            [-g uri|--origin=uri ...] [-m uri|--mirror=uri ...]\n"

            "            [--facet <facet_spec>=(True|False) ...]\n"

            "            [(-p|--publisher) [<name>=]<repo_uri>] dir")

        adv_usage["change-variant"] = _(

            "[-nvq] [-g path_or_uri ...] [--accept] [--licenses]\n"

            "            [--no-be-activate] [--deny-new-be | --require-new-be]\n"

            "            [--be-name name] <variant_spec>=<instance> ...")

        adv_usage["change-facet"] = _(

            "[-nvq] [-g path_or_uri ...] [--accept] [--licenses]\n"

            "            [--no-be-activate] [--deny-new-be | --require-new-be]\n"

            "            [--be-name name] <facet_spec>=[True|False|None] ...")

        adv_usage["mediator"] = _("[-aH] [-F format] [<mediator> ...]")

        adv_usage["set-mediator"] = _(

            "[-nv] [-I <implementation>] [-V <version>] [--no-be-activate]\n"

            "            [--deny-new-be | --require-new-be] [--be-name name]\n"

            "            <mediator> ...")

        adv_usage["unset-mediator"] = _("[-nvIV] [--no-be-activate]\n"

            "            [--deny-new-be | --require-new-be] [--be-name name]\n"

            "            <mediator> ...")

        adv_usage["variant"] = _("[-H] [<variant_spec>]")

        adv_usage["facet"] = ("[-H] [<facet_spec>]")

        adv_usage["avoid"] = _("[pkg_fmri_pattern] ...")

        adv_usage["unavoid"] = _("[pkg_fmri_pattern] ...")

        adv_usage["freeze"] = _("[-n] [-c reason] [pkg_fmri_pattern] ...")

        adv_usage["unfreeze"] = _("[-n] [pkg_name_pattern] ...")

        adv_usage["set-property"] = _("propname propvalue")

        adv_usage["add-property-value"] = _("propname propvalue")

        adv_usage["remove-property-value"] = _("propname propvalue")

        adv_usage["unset-property"] = _("propname ...")

        adv_usage["property"] = _("[-H] [propname ...]")

        adv_usage["set-publisher"] = _("[-Ped] [-k ssl_key] [-c ssl_cert]\n"

            "            [-g origin_to_add|--add-origin=origin_to_add ...]\n"

            "            [-G origin_to_remove|--remove-origin=origin_to_remove ...]\n"

            "            [-m mirror_to_add|--add-mirror=mirror_to_add ...]\n"

            "            [-M mirror_to_remove|--remove-mirror=mirror_to_remove ...]\n"

            "            [-p repo_uri] [--enable] [--disable] [--no-refresh]\n"

            "            [--reset-uuid] [--non-sticky] [--sticky]\n"

            "            [--search-after=publisher]\n"

            "            [--search-before=publisher]\n"

            "            [--search-first]\n"

            "            [--approve-ca-cert=path_to_CA]\n"

            "            [--revoke-ca-cert=hash_of_CA_to_revoke]\n"

            "            [--unset-ca-cert=hash_of_CA_to_unset]\n"

            "            [--set-property name_of_property=value]\n"

            "            [--add-property-value name_of_property=value_to_add]\n"

            "            [--remove-property-value name_of_property=value_to_remove]\n"

            "            [--unset-property name_of_property_to_delete]\n"

            "            [publisher]")

        adv_usage["unset-publisher"] = _("publisher ...")

        adv_usage["publisher"] = _("[-HPn] [publisher ...]")

        adv_usage["history"] = _("[-Hl] [-t [time|time-time],...] [-n number] [-o column,...]")

        adv_usage["purge-history"] = ""

        adv_usage["rebuild-index"] = ""

        adv_usage["update-format"] = ""

        adv_usage["list-linked"] = _("-H")

        adv_usage["attach-linked"] = _(

            "[-fnvq] [--accept] [--licenses] [--no-index] [--no-refresh]\n"

            "            [--no-pkg-updates] [--linked-md-only]\n"

            "            [--allow-relink]\n"

            "            [--prop-linked <propname>=<propvalue> ...]\n"

            "            (-c|-p) <li-name> <dir>")

        adv_usage["detach-linked"] = _(

            "[-fnvq] [-a|-l <li-name>] [--linked-md-only]")

        adv_usage["property-linked"] = _("[-H] [-l <li-name>] [propname ...]")

        adv_usage["audit-linked"] = _("[-a|-l <li-name>]")

        adv_usage["sync-linked"] = _(

            "[-nvq] [--accept] [--licenses] [--no-index] [--no-refresh]\n"

            "            [--no-parent-sync] [--no-pkg-updates]\n"

            "            [--linked-md-only] [-a|-l <name>]")

        adv_usage["set-property-linked"] = _(

            "[-nvq] [--accept] [--licenses] [--no-index] [--no-refresh]\n"

            "            [--no-parent-sync] [--no-pkg-updates]\n"

            "            [--linked-md-only] <propname>=<propvalue> ...")

        def print_cmds(cmd_list, cmd_dic):

                for cmd in cmd_list:

                        if cmd is "":

                                logger.error("")

                        else:

                                if cmd not in cmd_dic:

                                        # this should never happen - callers

                                        # should check for valid subcommands

                                        # before calling usage(..)

                                        raise ValueError(

                                            "Unable to find usage str for %s" %

                                            cmd)

                                usage = cmd_dic[cmd]

                                if usage is not "":

                                        logger.error(

                                            "        pkg %(cmd)s %(usage)s" %

                                            locals())

                                else:

                                        logger.error("        pkg %s" % cmd)

        if not full and cmd:

                logger.error("Usage:")

                combined = {}

                combined.update(basic_usage)

                combined.update(adv_usage)

                print_cmds([cmd], combined)

                sys.exit(retcode)

        elif not full:

                # The full usage message isn't desired.

                logger.error(_("Try `pkg --help or -?' for more information."))

                sys.exit(retcode)

        logger.error(_("""\

Usage:

        pkg [options] command [cmd_options] [operands]

"""))

        logger.error(_("Basic subcommands:"))

        print_cmds(basic_cmds, basic_usage)

        logger.error(_("\nAdvanced subcommands:"))

        print_cmds(advanced_cmds, adv_usage)

        logger.error(_("""

Options:

        -R dir

        --help or -?

Environment:

        PKG_IMAGE"""))

        sys.exit(retcode)

def get_fmri_args(api_inst, pargs, cmd=None):

        """ Convenience routine to check that input args are valid fmris. """

        res = []

        errors = []

        for pat, err, pfmri, matcher in api_inst.parse_fmri_patterns(pargs):

                if not err:

                        res.append((pat, err, pfmri, matcher))

                        continue

                if isinstance(err, version.VersionError):

                        # For version errors, include the pattern so

                        # that the user understands why it failed.

                        errors.append("Illegal FMRI '%s': %s" % (pat,

                            err))

                else:

                        # Including the pattern is redundant for other

                        # exceptions.

                        errors.append(err)

        if errors:

                error("\n".join(str(e) for e in errors), cmd=cmd)

        return len(errors) == 0, res

def list_inventory(op, api_inst, pargs,

    li_parent_sync, list_all, list_installed_newest, list_newest,

    list_upgradable, omit_headers, origins, refresh_catalogs, summary,

    verbose):

        """List packages."""

        api_inst.progresstracker = get_tracker(quiet=omit_headers)

        variants = False

        pkg_list = api.ImageInterface.LIST_INSTALLED

        if list_all:

                variants = True

                pkg_list = api.ImageInterface.LIST_ALL

        elif list_installed_newest:

                pkg_list = api.ImageInterface.LIST_INSTALLED_NEWEST

        elif list_newest:

                pkg_list = api.ImageInterface.LIST_NEWEST

        elif list_upgradable:

                pkg_list = api.ImageInterface.LIST_UPGRADABLE

        if verbose:

                fmt_str = "%-76s %s"

        elif summary:

                fmt_str = "%-55s %s"

        else:

                fmt_str = "%-55s %-20s %s"

        # Each pattern in pats can be a partial or full FMRI, so

        # extract the individual components.  These patterns are

        # transformed here so that partial failure can be detected

        # when more than one pattern is provided.

        rval, res = get_fmri_args(api_inst, pargs, cmd=op)

        if not rval:

                return EXIT_OOPS

        api_inst.log_operation_start(op)

        if pkg_list != api_inst.LIST_INSTALLED and refresh_catalogs:

                # If the user requested packages other than those

                # installed, ensure that a refresh is performed if

                # needed since the catalog may be out of date or

                # invalid as a result of publisher information

                # changing (such as an origin uri, etc.).

                try:

                        api_inst.refresh()

                except api_errors.PermissionsException:

                        # Ignore permission exceptions with the

                        # assumption that an unprivileged user is

                        # executing this command and that the

                        # refresh doesn't matter.

                        pass

                except api_errors.CatalogRefreshException, e:

                        succeeded = display_catalog_failures(e,

                            ignore_perms_failure=True)

                        if succeeded != e.total:

                                # If total number of publishers does

                                # not match 'successful' number

                                # refreshed, abort.

                                return EXIT_OOPS

                except:

                        # Ignore the above error and just use what

                        # already exists.

                        pass

        state_map = [

            [(api.PackageInfo.INSTALLED, "i")],

            [(api.PackageInfo.FROZEN, "f")],

            [

                (api.PackageInfo.OBSOLETE, "o"),

                (api.PackageInfo.RENAMED, "r")

            ],

        ]

        # Now get the matching list of packages and display it.

        found = False

        ppub = api_inst.get_highest_ranked_publisher()

        if ppub:

                ppub = ppub.prefix

        try:

                res = api_inst.get_pkg_list(pkg_list, patterns=pargs,

                    raise_unmatched=True, repos=origins, variants=variants)

                        found = True

                        if not omit_headers:

                                if verbose:

                                        msg(fmt_str %

                                            ("FMRI", "IFO"))

                                elif summary:

                                        msg(fmt_str %

                                            ("NAME (PUBLISHER)",

                                            "SUMMARY"))

                                else:

                                        msg(fmt_str %

                                            ("NAME (PUBLISHER)",