#!/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 2009 Sun Microsystems, Inc.  All rights reserved.

# Use is subject to license terms.

#

# pkg - package system client utility

#

# We use urllib2 for GET and POST operations, but httplib for PUT and DELETE

# operations.

#

# 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?

import calendar

import datetime

import errno

import getopt

import gettext

import itertools

import locale

import logging

import os

import socket

import sys

import textwrap

import time

import traceback

import urllib2

import urlparse

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.image as image

import pkg.client.imagetypes as imgtypes

import pkg.client.progress as progress

import pkg.client.publisher as publisher

import pkg.fmri as fmri

import pkg.misc as misc

import pkg.version as version

from pkg.client import global_settings

from pkg.client.debugvalues import DebugValues

from pkg.client.history import (RESULT_CANCELED, RESULT_FAILED_BAD_REQUEST,

    RESULT_FAILED_CONFIGURATION, RESULT_FAILED_TRANSPORT, RESULT_FAILED_UNKNOWN,

    RESULT_FAILED_OUTOFMEMORY)

from pkg.misc import EmptyI, msg, PipeError

CLIENT_API_VERSION = 26

PKG_CLIENT_NAME = "pkg"

JUST_UNKNOWN = 0

JUST_LEFT = -1

JUST_RIGHT = 1

#pkg exit codes

EXIT_OK      = 0

EXIT_OOPS    = 1

EXIT_BADOPT  = 2

EXIT_PARTIAL = 3

EXIT_NOP     = 4

EXIT_NOTLIVE = 5

logger = global_settings.logger

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

valid_special_prefixes = ["action."]

def error(text, cmd=None):

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

        if cmd:

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

                pkg_cmd = "pkg "

        else:

                pkg_cmd = "pkg: "

                # If we get passed something like an Exception, we can convert

                # it down to a string.

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

        # 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=2, 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)

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

Basic subcommands:

        pkg install [-nvq] [--no-refresh] [--no-index] package...

        pkg uninstall [-nrvq] [--no-index] package...

        pkg list [-Hafnsuv] [--no-refresh] [package...]

        pkg image-update [-fnvq] [--be-name name] [--no-refresh] [--no-index]

        pkg refresh [--full] [publisher ...]

        pkg version

Advanced subcommands:

        pkg info [-lr] [--license] [pkg_fmri_pattern ...]

        pkg search [-alprI] [-s server] query

        pkg verify [-Hqv] [pkg_fmri_pattern ...]

        pkg fix [pkg_fmri_pattern ...]

        pkg contents [-Hmr] [-o attribute ...] [-s sort_key]

            [-t action_type ... ] [pkg_fmri_pattern ...]

        pkg image-create [-fFPUz] [--force] [--full|--partial|--user] [--zone]

            [-k ssl_key] [-c ssl_cert] [--no-refresh]

            [--variant <variant_spec>=<instance>] 

            [--facet <facet_spec>=[True,False]]

            (-p|--publisher) name=uri dir

        pkg change-variant [-nvq] [--be-name name] <variant_spec>=<instance>

            [<variant_spec>=<instance> ...]

        pkg change-facet -nvq [--be-name name] <facet_spec>=[True|False|None] ...

        pkg variant -H [<variant_spec>]

        pkg facet -H [<facet_spec>]

        pkg set-property propname propvalue

        pkg unset-property propname ...

        pkg property [-H] [propname ...]

        pkg set-publisher [-Ped] [-k ssl_key] [-c ssl_cert]

            [-g origin_to_add | --add-origin=origin_to_add]

            [-G origin_to_remove | --remove-origin=origin_to_remove]

            [-m mirror_to_add | --add-mirror=mirror_to_add]

            [-M mirror_to_remove | --remove-mirror=mirror_to_remove]

            [--enable] [--disable] [--no-refresh] [--reset-uuid] 

            [--non-sticky] [--sticky] [--search-after=publisher]

            [--search-before=publisher] publisher

        pkg unset-publisher publisher ...

        pkg publisher [-HPn] [publisher ...]

        pkg history [-Hl]

        pkg purge-history

        pkg rebuild-index

Options:

        -R dir

        --help or -?

Environment:

        PKG_IMAGE"""))

        sys.exit(retcode)

# XXX Subcommands to implement:

#        pkg image-set name value

#        pkg image-unset name

#        pkg image-get [name ...]

INCONSISTENT_INDEX_ERROR_MESSAGE = "The search index appears corrupted.  " + \

    "Please rebuild the index with 'pkg rebuild-index'."

PROBLEMATIC_PERMISSIONS_ERROR_MESSAGE = "\n(Failure of consistent use " + \

    "of pfexec when executing pkg commands is often a\nsource of this problem.)"

def check_fmri_args(args):

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

        ret = True

        for x in args:

                try:

                        #

                        # Pass a bogus build release-- needed to satisfy

                        # fmri's checks in the common case that a version but

                        # no build release was specified by the user.

                        #

                        fmri.MatchingPkgFmri(x, build_release="1.0")

                except fmri.IllegalFmri, e:

                        error(e)

                        ret = False

        return ret

def list_inventory(img, args):

        """List packages."""

        opts, pargs = getopt.getopt(args, "Hafnsuv", ["no-refresh"])

        display_headers = True

        refresh_catalogs = True

        pkg_list = api.ImageInterface.LIST_INSTALLED

        summary = False

        verbose = False

        variants = False

        ltypes = set()

        for opt, arg in opts:

                if opt == "-H":

                        display_headers = False

                elif opt == "-a":

                        ltypes.add(opt)

                        pkg_list = api.ImageInterface.LIST_INSTALLED_NEWEST

                elif opt == "-f":

                        ltypes.add(opt)

                        pkg_list = api.ImageInterface.LIST_ALL

                        variants = True

                elif opt == "-n":

                        ltypes.add(opt)

                        pkg_list = api.ImageInterface.LIST_NEWEST

                elif opt == "-s":

                        summary = True

                elif opt == "-u":

                        ltypes.add(opt)

                        pkg_list = api.ImageInterface.LIST_UPGRADABLE

                elif opt == "-v":

                        verbose = True

                elif opt == "--no-refresh":

                        refresh_catalogs = False

        allowed = [

            ("-a", ("-f", "-s", "-v")),

            ("-u", ("-s", "-v")),

            ("-n", ("-s", "-v")),

        ]

        if "-f" in ltypes and "-a" not in ltypes:

                usage(_("-f may only be used in combination with -a"),

                    cmd="list")

        for ltype, permitted in allowed:

                if ltype in ltypes:

                        ltypes.discard(ltype)

                        diff = ltypes.difference(permitted)

                        if not diff:

                                # Only allowed options used.

                                continue

                        usage(_("%(opts)s may not be used with %(opt)s") % {

                            "opts": ", ".join(diff), "opt": ltype })

        if summary and verbose:

                usage(_("-s and -v may not be combined"), cmd="list")

        if verbose:

                fmt_str = "%-64s %-10s %s"

        elif summary:

                fmt_str = "%-30s %s"

        else:

                fmt_str = "%-45s %-15s %-10s %s"

        if not check_fmri_args(pargs):

                return EXIT_OOPS

        api_inst = __api_alloc(img, quiet=not display_headers)

        if api_inst == None:

                return EXIT_OOPS

        api_inst.log_operation_start("list")

        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.UPGRADABLE, "u")],

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

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

            (api.PackageInfo.RENAMED, "r")],

            [(api.PackageInfo.EXCLUDES, "x")],

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

        ]

        pats = EmptyI

        if pargs:

                pats = pargs

        found = False

        ppub = api_inst.get_preferred_publisher().prefix

        try:

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

                    variants=variants)

                for pt, summ, cats, states in res:

                        found = True

                        if display_headers:

                                if verbose:

                                        msg(fmt_str % \

                                            ("FMRI", "STATE", "UFOXI"))

                                elif summary:

                                        msg(fmt_str % \

                                            ("NAME (PUBLISHER)",

                                            "SUMMARY"))

                                else:

                                        msg(fmt_str % \

                                            ("NAME (PUBLISHER)",

                                            "VERSION", "STATE", "UFOXI"))

                                display_headers = False

                        ufoxi = ""

                        for sentry in state_map:

                                for s, v in sentry:

                                        if s in states:

                                                st = v

                                                break

                                        else:

                                                st = "-"

                                ufoxi += st

                        pub, stem, ver = pt

                        if pub == ppub:

                                spub = ""

                        else:

                                spub = " (" + pub + ")"

                        # Check for installed state first.

                        st_str = ""

                        if api.PackageInfo.INSTALLED in states:

                                st_str = _("installed")

                        else:

                                st_str = _("known")

                        if verbose:

                                pfmri = "pkg://%s/%s@%s" % (pub, stem, ver)

                                msg("%-64s %-10s %s" % (pfmri, st_str, ufoxi))

                                continue

                        pf = stem + spub

                        if summary:

                                msg(fmt_str % (pf, summ))

                                continue

                        sver = version.Version.split(ver)[-1]

                        msg(fmt_str % (pf, sver, st_str, ufoxi))

                if not found:

                        if pargs:

                                raise api_errors.InventoryException(

                                    notfound=pargs)

                        if pkg_list == api_inst.LIST_INSTALLED:

                                logger.error(_("no packages installed"))

                                api_inst.log_operation_end(

                                    result=history.RESULT_NOTHING_TO_DO)

                                return EXIT_OOPS

                        if pkg_list == api_inst.LIST_UPGRADABLE:

                                if pargs:

                                        logger.error(_("No specified packages "

                                            "have newer versions available."))

                                else:

                                        logger.error(_("No installed packages "

                                            "have newer versions available."))

                                api_inst.log_operation_end(

                                    result=history.RESULT_NOTHING_TO_DO)

                                return EXIT_OOPS

                        api_inst.log_operation_end(

                            result=history.RESULT_NOTHING_TO_DO)

                        return EXIT_OOPS

                api_inst.log_operation_end()

                return EXIT_OK

        except api_errors.InventoryException, e:

                if e.illegal:

                        for i in e.illegal:

                                error(i)

                        api_inst.log_operation_end(

                            result=history.RESULT_FAILED_BAD_REQUEST)

                        return EXIT_OOPS

                if pkg_list == api.ImageInterface.LIST_ALL:

                        state = _("known")

                elif pkg_list == api.ImageInterface.LIST_INSTALLED_NEWEST:

                        state = _("known or installed")

                else:

                        state = _("installed")

                for pat in e.notfound:

                        error(_("no packages matching "

                            "'%(pattern)s' %(state)s") %

                            { "pattern": pat, "state": state })

                api_inst.log_operation_end(result=history.RESULT_NOTHING_TO_DO)

                return EXIT_OOPS

def get_tracker(quiet=False):

        if quiet:

                progresstracker = progress.QuietProgressTracker()

        else:

                try:

                        progresstracker = \

                            progress.FancyUNIXProgressTracker()

                except progress.ProgressTrackerException:

                        progresstracker = progress.CommandLineProgressTracker()

        return progresstracker

def fix_image(img, args):

        progresstracker = get_tracker(False)

        fmris, notfound, illegals = img.installed_fmris_from_args(args)

        any_errors = False

        repairs = []

        for f, fstate in fmris:

                failed_actions = []

                for err in img.verify(f, progresstracker,

                    verbose=True, forever=True):

                        if not failed_actions:

                                msg("Verifying: %-50s %7s" %

                                    (f.get_pkg_stem(), "ERROR"))

                        act = err[0]

                        failed_actions.append(act)

                        msg("\t%s" % act.distinguished_name())

                        for x in err[1]:

                                msg("\t\t%s" % x)

                if failed_actions:

                        repairs.append((f, failed_actions))

        # Repair anything we failed to verify

        if repairs:

                # Create a snapshot in case they want to roll back

                try:

                        be = bootenv.BootEnv(img.get_root())

                        if be.exists():

                                msg(_("Created ZFS snapshot: %s" %

                                    be.snapshot_name))

                except RuntimeError:

                        pass # Error is printed by the BootEnv call.

                try:

                        success = img.repair(repairs, progresstracker)