#!/usr/bin/python2.4

#

# 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 2008 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 getopt

import gettext

import itertools

import os

import socket

import sys

import traceback

import urllib2

import urlparse

import datetime

import time

import calendar

import OpenSSL.crypto

from pkg.client import global_settings

import pkg.client.bootenv as bootenv

import pkg.client.image as image

import pkg.client.filelist as filelist

import pkg.client.progress as progress

import pkg.client.history as history

import pkg.client.api as api

import pkg.client.api_errors as api_errors

import pkg.search_errors as search_errors

import pkg.fmri as fmri

import pkg.misc as misc

from pkg.misc import msg, emsg, PipeError

import pkg.version

import pkg.Uuid25

import pkg

from pkg.client.history import RESULT_FAILED_UNKNOWN

from pkg.client.history import RESULT_CANCELED

from pkg.client.history import RESULT_FAILED_TRANSPORT

from pkg.client.history import RESULT_SUCCEEDED

from pkg.client.history import RESULT_FAILED_SEARCH

from pkg.client.history import RESULT_FAILED_STORAGE

from pkg.client.retrieve import ManifestRetrievalError

from pkg.client.retrieve import DatastreamRetrievalError

CLIENT_API_VERSION = 0

PKG_CLIENT_NAME = "pkg"

def error(text):

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

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

        emsg(ws + "pkg: " + text_nows)

def usage(usage_error = None):

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

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

        if usage_error:

                error(usage_error)

        emsg(_("""\

Usage:

        pkg [options] command [cmd_options] [operands]

Basic subcommands:

        pkg install [-nvq] package...

        pkg uninstall [-nrvq] package...

        pkg list [-aHsuvf] [package...]

        pkg image-update [-nvq]

        pkg refresh [--full]

        pkg version

        pkg help

Advanced subcommands:

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

        pkg search [-lrI] [-s server] token

        pkg verify [-fHqv] [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] -a <prefix>=<url> dir

        pkg set-property propname propvalue

        pkg unset-property propname ...

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

        pkg set-authority [-P] [-k ssl_key] [-c ssl_cert] [--reset-uuid]

            [-O origin_url] [-m mirror to add | --add-mirror=mirror to add]

            [-M mirror to remove | --remove-mirror=mirror to remove] authority

        pkg unset-authority authority ...

        pkg authority [-HP] [authname]

        pkg history [-Hl]

        pkg purge-history

        pkg rebuild-index

Options:

        -R dir

Environment:

        PKG_IMAGE"""))

        sys.exit(2)

# 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 = " (Failure of consistent use " + \

    "of pfexec when running pkg commands is often a source 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):

        all_known = False

        display_headers = True

        upgradable_only = False

        verbose = False

        summary = False

        all_versions = True

        opts, pargs = getopt.getopt(args, "aHsuvf")

        for opt, arg in opts:

                if opt == "-a":

                        all_known = True

                elif opt == "-H":

                        display_headers = False

                elif opt == "-s":

                        summary = True

                elif opt == "-u":

                        upgradable_only = True

                elif opt == "-v":

                        verbose = True

                elif opt == "-f":

                        all_versions = False

        if summary and verbose:

                usage(_("-s and -v may not be combined"))

        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 1

        img.history.operation_name = "list"

        img.load_catalogs(progress.NullProgressTracker())

        seen_one_pkg = False

        found = False

        try:

                most_recent = {}

                installed = []

                res = img.inventory(pargs, all_known)

                # All_Versions reduces the output so that only the most recent

                # version and installed version of packages appear.

                if all_versions:

                        for pfmri, state in res:

                                if state["state"] == "installed":

                                        installed.append((pfmri, state))

                                hv = pfmri.get_pkg_stem(include_pkg=False)

                                if hv in most_recent:

                                        stored_pfmri, stored_state = \

                                            most_recent[hv]

                                        if pfmri.is_successor(stored_pfmri):

                                                most_recent[hv] = (pfmri, state)

                                else:

                                        most_recent[hv] = (pfmri, state)

                        res = installed + most_recent.values()

                        # This method is necessary because fmri.__cmp__ does

                        # not provide the desired ordering. It uses the same

                        # ordering on package names as fmri.__cmp__ but it

                        # reverse sorts on version, so that 98 comes before 97.

                        # Also, authorities are taken into account so that

                        # preferred authorities come before others. Finally,

                        # authorties are presented in alphabetical order.

                        def __fmri_cmp((f1, s1), (f2, s2)):

                                t = cmp(f1.pkg_name, f2.pkg_name)

                                if t != 0:

                                        return t

                                t = cmp(f2, f1)

                                if t != 0:

                                        return t

                                if f1.preferred_authority():

                                        return -1

                                if f2.preferred_authority():

                                        return 1

                                return cmp(f1.get_authority(),

                                    f2.get_authority())

                        res.sort(cmp=__fmri_cmp)

                prev_pfmri_str = ""

                prev_state = None

                for pfmri, state in res:

                        if all_versions and prev_pfmri_str and \

                            prev_pfmri_str == pfmri.get_short_fmri() and \

                            prev_state == state:

                                continue

                        prev_pfmri_str = pfmri.get_short_fmri()

                        prev_state = state

                        seen_one_pkg = True

                        if upgradable_only and not state["upgradable"]:

                                continue

                        if not found:

                                if display_headers:

                                        if verbose:

                                                msg(fmt_str % \

                                                    ("FMRI", "STATE", "UFIX"))

                                        elif summary:

                                                msg(fmt_str % \

                                                    ("NAME (AUTHORITY)",

                                                    "SUMMARY"))

                                        else:

                                                msg(fmt_str % \

                                                    ("NAME (AUTHORITY)",

                                                    "VERSION", "STATE", "UFIX"))

                                found = True

                        ufix = "%c%c%c%c" % \

                            (state["upgradable"] and "u" or "-",

                            state["frozen"] and "f" or "-",

                            state["incorporated"] and "i" or "-",

                            state["excludes"] and "x" or "-")

                        if pfmri.preferred_authority():

                                auth = ""

                        else:

                                auth = " (" + pfmri.get_authority() + ")"

                        if verbose:

                                pf = pfmri.get_fmri(img.get_default_authority())

                                msg("%-64s %-10s %s" % (pf, state["state"],

                                    ufix))

                        elif summary:

                                pf = pfmri.get_name() + auth

                                m = img.get_manifest(pfmri, filtered=True)

                                msg(fmt_str % (pf, m.get("description", "")))

                        else:

                                pf = pfmri.get_name() + auth

                                msg(fmt_str % (pf, pfmri.get_version(),

                                    state["state"], ufix))

                if not found:

                        if not seen_one_pkg and not all_known:

                                emsg(_("no packages installed"))

                                img.history.operation_result = \

                                    history.RESULT_NOTHING_TO_DO

                                return 1

                        if upgradable_only:

                                if pargs:

                                        emsg(_("No specified packages have " \

                                            "available updates"))

                                else:

                                        emsg(_("No installed packages have " \

                                            "available updates"))

                                img.history.operation_result = \

                                    history.RESULT_NOTHING_TO_DO

                                return 1

                        img.history.operation_result = \

                            history.RESULT_NOTHING_TO_DO

                        return 1

                img.history.operation_result = history.RESULT_SUCCEEDED

                return 0

        except api_errors.InventoryException, e:

                if e.illegal:

                        for i in e.illegal:

                                error(i)

                        img.history.operation_result = \

                            history.RESULT_FAILED_BAD_REQUEST

                        return 1

                if all_known:

                        state = image.PKG_STATE_KNOWN

                else:

                        state = image.PKG_STATE_INSTALLED

                for pat in e.notfound:

                        error(_("no packages matching '%s' %s") % (pat, state))

                img.history.operation_result = history.RESULT_NOTHING_TO_DO

                return 1

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)

        img.load_catalogs(progresstracker)

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

        any_errors = False

        repairs = []

        for f 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())

                        msg(_("Created ZFS snapshot: %s" % be.snapshot_name))

                except RuntimeError, e:

                        msg(_("Unable to create ZFS snapshot: %s") % e)

                success = img.repair(repairs, progresstracker)

                if not success:

                        return 1

        return 0

def verify_image(img, args):

        opts, pargs = getopt.getopt(args, "vfqH")

        quiet = verbose = False

        # for now, always check contents of files

        forever = display_headers = True

        for opt, arg in opts:

                if opt == "-H":

                        display_headers = False

                if opt == "-v":

                        verbose = True

                elif opt == "-f":

                        forever = True

                elif opt == "-q":

                        quiet = True

                        display_headers = False

        if verbose and quiet:

                usage(_("verify: -v and -q may not be combined"))

        progresstracker = get_tracker(quiet)

        if not check_fmri_args(pargs):

                return 1

        img.load_catalogs(progresstracker)

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

        if illegals:

                for i in illegals:

                        emsg(str(i))

                return 1

        any_errors = False

        header = False

        for f in fmris:

                pkgerr = False

                for err in img.verify(f, progresstracker,

                    verbose=verbose, forever=forever):

                        #

                        # Eventually this code should probably

                        # move into the progresstracker

                        #

                        if not pkgerr:

                                if display_headers and not header:

                                        msg("%-50s %7s" % ("PACKAGE", "STATUS"))

                                        header = True

                                if not quiet:

                                        msg("%-50s %7s" % (f.get_pkg_stem(),

                                            "ERROR"))

                                pkgerr = True

                        if not quiet:

                                msg("\t%s" % err[0].distinguished_name())

                                for x in err[1]:

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

                if verbose and not pkgerr:

                        if display_headers and not header:

                                msg("%-50s %7s" % ("PACKAGE", "STATUS"))

                                header = True

                        msg("%-50s %7s" % (f.get_pkg_stem(), "OK"))

                any_errors = any_errors or pkgerr

        if fmris:

                progresstracker.verify_done()

        if notfound:

                if fmris:

                        emsg()

                emsg(_("""\

pkg: no packages matching the following patterns you specified are

installed on the system.\n"""))