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

#

import calendar

import errno

import getopt

import gettext

import locale

import os

import shutil

import sys

import tempfile

import traceback

import urllib

import warnings

import pkg.catalog as catalog

import pkg.client.progress as progress

import pkg.fmri

import pkg.manifest as manifest

import pkg.client.api_errors as apx

import pkg.client.pkgdefs as pkgdefs

import pkg.client.publisher as publisher

import pkg.client.transport.transport as transport

import pkg.misc as misc

import pkg.p5p

import pkg.pkgsubprocess as subprocess

import pkg.publish.transaction as trans

import pkg.server.repository as sr

import pkg.version as version

from pkg.client import global_settings

from pkg.misc import emsg, get_pkg_otw_size, msg, PipeError

from pkg.client.debugvalues import DebugValues

# Globals

archive = False

cache_dir = None

src_cat = None

download_start = False

tmpdirs = []

temp_root = None

xport = None

xport_cfg = None

dest_xport = None

targ_pub = None

target = None

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 + "pkgrecv: " + text_nows)

def usage(usage_error=None, retcode=2):

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

        error message.  Causes program to exit."""

        if usage_error:

                error(usage_error)

        msg(_("""\

Usage:

        pkgrecv [-s src_uri] [-a] [-d (path|dest_uri)] [-c cache_dir]

            [-kr] [-m match] [-n] [--raw] [--key src_key --cert src_cert]

            [--dkey dest_key --dcert dest_cert]

            (fmri|pattern) ...

        pkgrecv [-s src_repo_uri] --newest

        pkgrecv [-s src_repo_uri] [-d path] [-p publisher ...]

            [--key src_key --cert src_cert] [-n] --clone

Options:

        -a              Store the retrieved package data in a pkg(5) archive

                        at the location specified by -d.  The file may not

                        already exist, and this option may only be used with

                        filesystem-based destinations.

        -c cache_dir    The path to a directory that will be used to cache

                        downloaded content.  If one is not supplied, the

                        client will automatically pick a cache directory.

                        In the case where a download is interrupted, and a

                        cache directory was automatically chosen, use this

                        option to resume the download.

        -d path_or_uri  The filesystem path or URI of the target repository to

                        republish packages to.  The target must already exist.

                        New repositories can be created using pkgrepo(1).

        -h              Display this usage message.

        -k              Keep the retrieved package content compressed, ignored

                        when republishing.  Should not be used with pkgsend.

        -m match        Controls matching behaviour using the following values:

                            all-timestamps (default)

                                includes all matching timestamps (implies

                                all-versions)

                            all-versions

                                includes all matching versions

                            latest

                                includes only the latest version of each package

        -n              Perform a trial run with no changes made.

        -p publisher    Only clone the given publisher. Can be specified

                        multiple times. Only valid with --clone.

        -r              Recursively evaluates all dependencies for the provided

                        list of packages and adds them to the list.

        -s src_repo_uri A URI representing the location of a pkg(5)

                        repository to retrieve package data from.

        --clone         Make an exact copy of the source repository. By default,

                        the clone operation will only succeed if publishers in 

                        the  source  repository  are  also  present  in  the

                        destination.  By using -p, the operation can be limited

                        to  specific  publishers  which  will  be  added  to the

                        destination repository if not already present.

                        Packages in the destination repository which are not in

                        the source will be removed.

                        Cloning will leave the destination repository altered in

                        case of an error.

        --newest        List the most recent versions of the packages available

                        from the specified repository and exit.  (All other

                        options except -s will be ignored.)

        --raw           Retrieve and store the raw package data in a set of

                        directory structures by stem and version at the location

                        specified by -d.  May only be used with filesystem-

                        based destinations.  This can be used with pkgsend(1)

                        include to conveniently modify and republish packages,

                        perhaps by correcting file contents or providing

                        additional package metadata.

        --key src_key   Specify a client SSL key file to use for pkg retrieval.

        --cert src_cert Specify a client SSL certificate file to use for pkg

                        retrieval.

        --dkey dest_key Specify a client SSL key file to use for pkg

                        publication.

        --dcert dest_cert Specify a client SSL certificate file to use for pkg

                          publication.

Environment:

        PKG_DEST        Destination directory or URI

        PKG_SRC         Source URI or path"""))

        sys.exit(retcode)

def cleanup(caller_error=False):

        """To be called at program finish."""

        for d in tmpdirs:

                # If the cache_dir is in the list of directories that should

                # be cleaned up, but we're exiting with an error, then preserve

                # the directory so downloads may be resumed.

                if d == cache_dir and caller_error and download_start:

                        error(_("\n\nCached files were preserved in the "

                            "following directory:\n\t%s\nUse pkgrecv -c "

                            "to resume the interrupted download.") % cache_dir)

                        continue

                shutil.rmtree(d, ignore_errors=True)

        if caller_error and dest_xport and targ_pub and not archive:

                try:

                        dest_xport.publish_refresh_packages(targ_pub)

                except apx.TransportError:

                        # If this fails, ignore it as this was a last ditch

                        # attempt anyway.

                        pass

def abort(err=None, retcode=1):

        """To be called when a fatal error is encountered."""

        if err:

                # Clear any possible output first.

                msg("")

                error(err)

        cleanup(caller_error=True)

        sys.exit(retcode)

def get_tracker():

        try:

                progresstracker = \

                    progress.FancyUNIXProgressTracker()

        except progress.ProgressTrackerException:

                progresstracker = progress.CommandLineProgressTracker()

        progresstracker.set_major_phase(progresstracker.PHASE_UTILITY)

        return progresstracker

def get_manifest(pfmri, xport_cfg, contents=False):

        m = None

        pkgdir = xport_cfg.get_pkg_dir(pfmri)

        mpath = xport_cfg.get_pkg_pathname(pfmri)

        if not os.path.exists(mpath):

                m = xport.get_manifest(pfmri)

        else:

                # A FactoredManifest is used here to reduce peak memory

                # usage (notably when -r was specified).

                try:

                        m = manifest.FactoredManifest(pfmri, pkgdir)

                except:

                        abort(err=_("Unable to parse manifest '%(mpath)s' for "

                            "package '%(pfmri)s'") % locals())

        if contents:

                return m.tostr_unsorted()

        return m

def expand_fmri(pfmri, constraint=version.CONSTRAINT_AUTO):

        """Find matching fmri using CONSTRAINT_AUTO cache for performance.

        Returns None if no matching fmri is found."""

        if isinstance(pfmri, str):

                pfmri = pkg.fmri.PkgFmri(pfmri, "5.11")

        # Iterate in reverse so newest version is evaluated first.

        versions = [e for e in src_cat.fmris_by_version(pfmri.pkg_name)]

        for v, fmris in reversed(versions):

                for f in fmris:

                        if not pfmri.version or \

                            f.version.is_successor(pfmri.version, constraint):

                                return f

        return

def get_dependencies(fmri_list, xport_cfg, tracker):

        old_limit = sys.getrecursionlimit()

        # The user may be recursing 'entire' or 'redistributable'.

        sys.setrecursionlimit(3000)

        s = set()

        for f in fmri_list:

                _get_dependencies(s, f, xport_cfg, tracker)

        # Restore the previous default.

        sys.setrecursionlimit(old_limit)

        return list(s)

def _get_dependencies(s, pfmri, xport_cfg, tracker):

        """Expand all dependencies."""

        # XXX???

        # tracker.evaluate_progress(pkgfmri=pfmri)

        s.add(pfmri)

        m = get_manifest(pfmri, xport_cfg)

        for a in m.gen_actions_by_type("depend"):

                for fmri_str in a.attrlist("fmri"):

                        new_fmri = expand_fmri(fmri_str)

                        if new_fmri and new_fmri not in s:

                                _get_dependencies(s, new_fmri, xport_cfg, tracker)

        return s

def get_sizes(mfst):

        """Takes a manifest and return

        (get_bytes, get_files, send_bytes, send_comp_bytes) tuple."""

        getb = 0

        getf = 0

        sendb = 0

        sendcb = 0

        for a in mfst.gen_actions():

                if a.has_payload:

                        getb += get_pkg_otw_size(a)

                        getf += 1

                        sendb += int(a.attrs.get("pkg.size", 0))

                        sendcb += int(a.attrs.get("pkg.csize", 0))

                        if a.name == "signature":

                                getf += len(a.get_chain_certs())

                                getb += a.get_action_chain_csize()

        return getb, getf, sendb, sendcb

def add_hashes_to_multi(mfst, multi):

        """Takes a manifest and a multi object and adds the hashes to the multi

        object."""

        for a in mfst.gen_actions():

                if a.has_payload:

                        multi.add_action(a)

def prune(fmri_list, all_versions, all_timestamps):

        """Returns a filtered version of fmri_list based on the provided

        parameters."""

        if all_timestamps:

                pass

        elif all_versions:

                dedup = {}

                for f in fmri_list:

                        dedup.setdefault(f.get_short_fmri(), []).append(f)

                fmri_list = [sorted(dedup[f], reverse=True)[0] for f in dedup]

        else:

                dedup = {}

                for f in fmri_list:

                        dedup.setdefault(f.pkg_name, []).append(f)

                fmri_list = [sorted(dedup[f], reverse=True)[0] for f in dedup]

        return fmri_list

def fetch_catalog(src_pub, tracker, txport, target_catalog,

    include_updates=False):

        """Fetch the catalog from src_uri.

	target_catalog is a hint about whether this is a destination catalog,

	which helps the progress tracker render the refresh output properly."""

        src_uri = src_pub.repository.origins[0].uri

        tracker.refresh_start(1, full_refresh=True,

            target_catalog=target_catalog)

        tracker.refresh_start_pub(src_pub)

        if not src_pub.meta_root:

                # Create a temporary directory for catalog.

                cat_dir = tempfile.mkdtemp(dir=temp_root,

                    prefix=global_settings.client_name + "-")

                tmpdirs.append(cat_dir)

                src_pub.meta_root = cat_dir

        src_pub.transport = txport

        try:

                src_pub.refresh(full_refresh=True, immediate=True,

                    progtrack=tracker, include_updates=include_updates)

        except apx.TransportError, e:

                # Assume that a catalog doesn't exist for the target publisher,

                # and drive on.  If there was an actual failure due to a

                # transport issue, let the failure happen whenever some other

                # operation is attempted later.

                return catalog.Catalog(read_only=True)

        finally:

                tracker.refresh_end_pub(src_pub)

                tracker.refresh_done()

        return src_pub.catalog

def main_func():

        global archive, cache_dir, download_start, xport, xport_cfg, \

            dest_xport, temp_root, targ_pub, target

        all_timestamps = True

        all_versions = False

        dry_run = False

        keep_compressed = False

        list_newest = False

        recursive = False

        src_uri = None

        incoming_dir = None

        src_pub = None

        raw = False

        key = None

        cert = None

        dkey = None

        dcert = None

        publishers = []

        clone = False

        temp_root = misc.config_temp_root()

        gettext.install("pkg", "/usr/share/locale",

            codeset=locale.getpreferredencoding())

        global_settings.client_name = "pkgrecv"

        target = os.environ.get("PKG_DEST", None)

        src_uri = os.environ.get("PKG_SRC", None)

        try:

                opts, pargs = getopt.getopt(sys.argv[1:], "ac:D:d:hkm:np:rs:",

                    ["cert=", "key=", "dcert=", "dkey=", "newest", "raw",

                    "debug=", "clone"])

        except getopt.GetoptError, e:

                usage(_("Illegal option -- %s") % e.opt)

        for opt, arg in opts:

                if opt == "-a":

                        archive = True

                elif opt == "-c":

                        cache_dir = arg

                elif opt == "--clone":

                        clone = True

                elif opt == "-d":

                        target = arg

                elif opt == "-D" or opt == "--debug":

                        if arg in ["plan", "transport"]:

                                key = arg

                                value = "True"

                        else:

                                try:

                                        key, value = arg.split("=", 1)

                                except (AttributeError, ValueError):

                                        usage(_("%(opt)s takes argument of form "

                                            "name=value, not %(arg)s") % {

                                            "opt":  opt, "arg": arg })

                        DebugValues.set_value(key, value)

                elif opt == "-h":

                        usage(retcode=0)

                elif opt == "-k":

                        keep_compressed = True

                elif opt == "-m":

                        if arg == "all-timestamps":

                                all_timestamps = True

                                all_versions = False

                        elif arg == "all-versions":

                                all_timestamps = False

                                all_versions = True

                        elif arg == "latest":

                                all_timestamps = False

                                all_versions = False

                        else:

                                usage(_("Illegal option value -- %s") % arg)

                elif opt == "-n":

                        dry_run = True

                elif opt == "-p":

                        publishers.append(arg)

                elif opt == "-r":

                        recursive = True

                elif opt == "-s":

                        src_uri = arg

                elif opt == "--newest":

                        list_newest = True

                elif opt == "--raw":

                        raw = True

                elif opt == "--key":

                        key = arg

                elif opt == "--cert":

                        cert = arg

                elif opt == "--dkey":

                        dkey = arg

                elif opt == "--dcert":

                        dcert = arg

        if not list_newest and not target:

                usage(_("a destination must be provided"))

        if not src_uri:

                usage(_("a source repository must be provided"))

        else:

                src_uri = misc.parse_uri(src_uri)

        if not cache_dir:

                cache_dir = tempfile.mkdtemp(dir=temp_root,

                    prefix=global_settings.client_name + "-")

                # Only clean-up cache dir if implicitly created by pkgrecv.

                # User's cache-dirs should be preserved

                tmpdirs.append(cache_dir)

        else:

                if clone:

                        usage(_("--clone can not be used with -c.\n"