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

#

PKG_CLIENT_NAME = "pkgrepo"

# pkgrepo exit codes

EXIT_OK      = 0

EXIT_OOPS    = 1

EXIT_BADOPT  = 2

EXIT_PARTIAL = 3

# listing constants

LISTING_FORMATS = ("json", "json-formatted", "tsv")

# globals

tmpdirs = []

import atexit

import collections

import copy

import errno

import getopt

import gettext

import locale

import logging

import shlex

import shutil

import sys

import tempfile

import textwrap

import traceback

import warnings

from pkg.client import global_settings

from pkg.client.debugvalues import DebugValues

from pkg.misc import msg, PipeError

import pkg

import pkg.catalog

import pkg.client.api_errors as apx

import pkg.client.pkgdefs as pkgdefs

import pkg.client.progress

import pkg.client.publisher as publisher

import pkg.client.transport.transport as transport

import pkg.misc as misc

import pkg.server.repository as sr

logger = global_settings.logger

@atexit.register

def cleanup():

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

        for d in tmpdirs:

                shutil.rmtree(d, True)

def error(text, cmd=None):

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

        if cmd:

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

                pkg_cmd = "pkgrepo "

        else:

                pkg_cmd = "pkgrepo: "

                # 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 get_tracker(quiet=False):

        if quiet:

                progtrack = pkg.client.progress.QuietProgressTracker()

        else:

                try:

                        progtrack = \

                            pkg.client.progress.FancyUNIXProgressTracker()

                except pkg.client.progress.ProgressTrackerException:

                        progtrack = \

                            pkg.client.progress.CommandLineProgressTracker()

        return progtrack

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 `pkgrepo --help or -?' for more "

                    "information."))

                sys.exit(retcode)

        msg(_("""\

Usage:

        pkgrepo [options] command [cmd_options] [operands]

Subcommands:

     pkgrepo create [--version ver] uri_or_path

     pkgrepo add-publisher -s repo_uri_or_path publisher ...

     pkgrepo get [-F format] [-p publisher ...] -s repo_uri_or_path 

         [--key ssl_key ... --cert ssl_cert ...] [section/property ...]

     pkgrepo info [-F format] [-H] [-p publisher ...] -s repo_uri_or_path

         [--key ssl_key ... --cert ssl_cert ...]

     pkgrepo list [-F format] [-H] [-p publisher ...] -s repo_uri_or_path 

         [--key ssl_key ... --cert ssl_cert ...] [pkg_fmri_pattern ...]

     pkgrepo rebuild [-p publisher ...] -s repo_uri_or_path [--key ssl_key ...

         --cert ssl_cert ...] [--no-catalog] [--no-index]

     pkgrepo refresh [-p publisher ...] -s repo_uri_or_path [--key ssl_key ...

         --cert ssl_cert ...] [--no-catalog] [--no-index]

     pkgrepo remove [-n] [-p publisher ...] -s repo_uri_or_path

         pkg_fmri_pattern ...

     pkgrepo set [-p publisher ...] -s repo_uri_or_path

         section/property[+|-]=[value] ... or

         section/property[+|-]=([value]) ...

     pkgrepo verify [-p publisher ...] -s repo_uri_or_path

     pkgrepo fix [-v] [-p publisher ...] -s repo_uri_or_path

     pkgrepo help

     pkgrepo version

Options:

        --help or -?

            Displays a usage message."""))

        sys.exit(retcode)

class OptionError(Exception):

        """Option exception. """

        def __init__(self, *args):

                Exception.__init__(self, *args)

def parse_uri(uri):

        """Parse the repository location provided and attempt to transform it

        into a valid repository URI.

        """

        return publisher.RepositoryURI(misc.parse_uri(uri))

def subcmd_remove(conf, args):

        subcommand = "remove"

        opts, pargs = getopt.getopt(args, "np:s:")

        dry_run = False

        pubs = set()

        for opt, arg in opts:

                if opt == "-n":

                        dry_run = True

                elif opt == "-p":

                        pubs.add(arg)

                elif opt == "-s":

                        conf["repo_uri"] = parse_uri(arg)

        if not pargs:

                usage(_("At least one package pattern must be provided."),

                    cmd=subcommand)

        # Get repository object.

        if not conf.get("repo_uri", None):

                usage(_("A package repository location must be provided "

                    "using -s."), cmd=subcommand)

        repo = get_repo(conf, read_only=False, subcommand=subcommand)

        if "all" in pubs:

                pubs = set()

        # Find matching packages.

        try:

                matching, refs = repo.get_matching_fmris(pargs, pubs=pubs)

        except apx.PackageMatchErrors, e:

                error(str(e), cmd=subcommand)

                return EXIT_OOPS

        if dry_run:

                # Don't make any changes; display list of packages to be

                # removed and exit.

                packages = set(f for m in matching.values() for f in m)

                count = len(packages)

                plist = "\n".join("\t%s" % p for p in sorted(packages))

                logger.info(_("%(count)d package(s) will be removed:\n"

                    "%(plist)s") % locals())

                return EXIT_OK

        progtrack = get_tracker()

        packages = collections.defaultdict(list)

        for m in matching.values():

                for f in m:

                        packages[f.publisher].append(f)

        for pub in packages:

                logger.info(_("Removing packages for publisher %s ...") % pub)

                repo.remove_packages(packages[pub], progtrack=progtrack,

                    pub=pub)

                if len(packages) > 1:

                        # Add a newline between each publisher.

                        logger.info("")

        return EXIT_OK

def get_repo(conf, read_only=True, subcommand=None):

        """Return the repository object for current program configuration."""

        repo_uri = conf["repo_uri"]

        if repo_uri.scheme != "file":

                usage(_("Network repositories are not currently supported "

                    "for this operation."), cmd=subcommand)

        path = repo_uri.get_pathname()

        if not path:

                # Bad URI?

                raise sr.RepositoryInvalidError(str(repo_uri))

        return sr.Repository(read_only=read_only, root=path)

def setup_transport(conf, subcommand=None, verbose=False, ssl_key=None,

    ssl_cert=None):

        repo_uri = conf.get("repo_uri", None)

        if not repo_uri:

                usage(_("No repository location specified."), cmd=subcommand)

        temp_root = misc.config_temp_root()

        tmp_dir = tempfile.mkdtemp(dir=temp_root)

        tmpdirs.append(tmp_dir)

        incoming_dir = tempfile.mkdtemp(dir=temp_root)

        tmpdirs.append(incoming_dir)

        cache_dir = tempfile.mkdtemp(dir=temp_root)

        tmpdirs.append(cache_dir)

        # Create transport and transport config.

        xport, xport_cfg = transport.setup_transport()

        xport_cfg.add_cache(cache_dir, readonly=False)

        xport_cfg.incoming_root = incoming_dir

        # Configure target publisher.

        src_pub = transport.setup_publisher(str(repo_uri), "target", xport,

            xport_cfg, remote_prefix=True, ssl_key=ssl_key, ssl_cert=ssl_cert)

        return xport, src_pub, tmp_dir

def subcmd_add_publisher(conf, args):

        """Add publisher(s) to the specified repository."""

        subcommand = "add-publisher"

        opts, pargs = getopt.getopt(args, "s:")

        for opt, arg in opts:

                if opt == "-s":

                        conf["repo_uri"] = parse_uri(arg)

        repo_uri = conf.get("repo_uri", None)

        if not repo_uri:

                usage(_("No repository location specified."), cmd=subcommand)

        if repo_uri.scheme != "file":

                usage(_("Network repositories are not currently supported "

                    "for this operation."), cmd=subcommand)

        if not pargs:

                usage(_("At least one publisher must be specified"),

                    cmd=subcommand)

        abort = False

        for pfx in pargs:

                if not misc.valid_pub_prefix(pfx):

                        error(_("Invalid publisher prefix '%s'") % pfx,

                            cmd=subcommand)

                        abort = True

        if abort:

                return EXIT_OOPS

        repo = get_repo(conf, read_only=False, subcommand=subcommand)

        make_default = not repo.publishers

        existing = repo.publishers & set(pargs)

        # Elide the publishers that already exist, but retain the order

        # publishers were specified in.

        new_pubs = [

            pfx for pfx in pargs

            if pfx not in repo.publishers

        ]

        # Tricky logic; _set_pub will happily add new publishers if necessary

        # and not set any properties if you didn't specify any.

        rval = _set_pub(conf, subcommand, {}, new_pubs, repo)

        if make_default:

                # No publisher existed previously, so set the default publisher

                # to be the first new one that was added.

                _set_repo(conf, subcommand, { "publisher": {

                    "prefix": new_pubs[0] } }, repo)

        if rval == EXIT_OK and existing:

                # Some of the publishers that were requested for addition

                # were already known.

                error(_("specified publisher(s) already exist: %s") %

                    ", ".join(existing), cmd=subcommand)

                if new_pubs:

                        return EXIT_PARTIAL

                return EXIT_OOPS

        return rval

def subcmd_create(conf, args):

        """Create a package repository at the given location."""

        subcommand = "create"

        opts, pargs = getopt.getopt(args, "s:", ["version="])

        version = None

        for opt, arg in opts:

                if opt == "-s":

                        conf["repo_uri"] = parse_uri(arg)

                elif opt == "--version":

                        # This option is currently private and allows creating a

                        # repository with a specific format based on version.

                        try:

                                version = int(arg)

                        except ValueError:

                                usage(_("Version must be an integer value."),

                                    cmd=subcommand)

        if len(pargs) > 1:

                usage(_("Only one repository location may be specified."),

                    cmd=subcommand)

        elif pargs:

                conf["repo_uri"] = parse_uri(pargs[0])

        repo_uri = conf.get("repo_uri", None)

        if not repo_uri:

                usage(_("No repository location specified."), cmd=subcommand)

        if repo_uri.scheme != "file":

                usage(_("Network repositories are not currently supported "

                    "for this operation."), cmd=subcommand)

        # Attempt to create a repository at the specified location.  Allow

        # whatever exceptions are raised to bubble up.

        sr.repository_create(repo_uri, version=version)

        return EXIT_OK

def subcmd_get(conf, args):

        """Display repository properties."""

        subcommand = "get"

        omit_headers = False

        out_format = "default"

        pubs = set()

        key = None

        cert = None

        opts, pargs = getopt.getopt(args, "F:Hp:s:", ["key=", "cert="])

        for opt, arg in opts:

                if opt == "-F":

                        out_format = arg

                        if out_format not in LISTING_FORMATS:

                                usage(_("Unrecognized format %(format)s."

                                    " Supported formats: %(valid)s") % \

                                    { "format": out_format,

                                    "valid": LISTING_FORMATS }, cmd=subcommand)

                                return EXIT_OOPS

                elif opt == "-H":

                        omit_headers = True

                elif opt == "-p":

                        pubs.add(arg)

                elif opt == "-s":

                        conf["repo_uri"] = parse_uri(arg)

                elif opt == "--key":

                        key = arg

                elif opt == "--cert":

                        cert = arg

        # Setup transport so configuration can be retrieved.

        if not conf.get("repo_uri", None):

                usage(_("A package repository location must be provided "

                    "using -s."), cmd=subcommand)

        xport, xpub, tmp_dir = setup_transport(conf, subcommand=subcommand,

            ssl_key=key, ssl_cert=cert)

        # Get properties.

        if pubs:

                return _get_pub(conf, subcommand, xport, xpub, omit_headers,

                    out_format, pubs, pargs)

        return _get_repo(conf, subcommand, xport, xpub, omit_headers,

            out_format, pargs)

def _get_repo(conf, subcommand, xport, xpub, omit_headers, out_format, pargs):

        """Display repository properties."""

        # Configuration index is indexed by section name and property name.

        # Retrieve and flatten it to simplify listing process.

        stat_idx = xport.get_status(xpub)

        cfg_idx = stat_idx.get("repository", {}).get("configuration", {})

        props = set()

        # Set minimum widths for section and property name columns by using the

        # length of the column headers.

        max_sname_len = len(_("SECTION"))

        max_pname_len = len(_("PROPERTY"))

        for sname in cfg_idx:

                max_sname_len = max(max_sname_len, len(sname))

                for pname in cfg_idx[sname]:

                        max_pname_len = max(max_pname_len, len(pname))

                        props.add("/".join((sname, pname)))

        req_props = set(pargs)

        if len(req_props) >= 1:

                found = props & req_props

                notfound = req_props - found

                del props

        else:

                found = props

                notfound = set()

        def gen_listing():

                for prop in sorted(found):

                        sname, pname = prop.rsplit("/", 1)

                        sval = cfg_idx[sname][pname]

                        yield {

                            "section": sname,

                            "property": pname,

                            "value": sval,

                        }

        #    SECTION PROPERTY VALUE

        #    <sec_1> <prop_1> <prop_1_value>

        #    <sec_2> <prop_2> <prop_2_value>

        #    ...

        field_data = {

            "section" : [("default", "json", "tsv"), _("SECTION"), ""],

            "property" : [("default", "json", "tsv"), _("PROPERTY"), ""],

            "value" : [("default", "json", "tsv"), _("VALUE"), ""],

        }

        desired_field_order = (_("SECTION"), _("PROPERTY"), _("VALUE"))

        # Default output formatting.

        def_fmt = "%-" + str(max_sname_len) + "s %-" + str(max_pname_len) + \

            "s %s"

        if found or (not req_props and out_format == "default"):

                # print without trailing newline.

                sys.stdout.write(misc.get_listing(desired_field_order,

                    field_data, gen_listing(), out_format, def_fmt,

                    omit_headers))