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

# Use is subject to license terms.

#

# pkgsend - publish package transactions

#

# Typical usage is

#

#       pkgsend open

#       [pkgsend summary]

#       pkgsend close

#

# A failed transaction can be cleared using

#

#       pkgsend close -A

import fnmatch

import getopt

import gettext

import os

import sys

import traceback

import warnings

import pkg.actions

import pkg.bundle

import pkg.fmri

import pkg.manifest

import pkg.publish.transaction as trans

from pkg.misc import msg, emsg, PipeError

nopub_actions = [ "unknown" ]

def error(text, cmd=None):

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

        if cmd:

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

        else:

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

def usage(usage_error=None, cmd=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, cmd=cmd)

        print _("""\

Usage:

        pkgsend [options] command [cmd_options] [operands]

Packager subcommands:

        pkgsend create-repository --set-property <section.property>=<value>

        pkgsend open [-en] pkg_fmri

        pkgsend add action arguments

        pkgsend import [-T file_pattern] bundlefile ...

        pkgsend include [-d basedir] .. [manifest] ...

        pkgsend close [-A | [--no-index] [--no-catalog]]

        pkgsend publish [ -d basedir] ... [--no-index] 

          [--fmri-in-manifest | pkg_fmri] [--no-catalog] [manifest] ...

        pkgsend generate [-T file_pattern] bundlefile ....

        pkgsend refresh-index

Options:

        -s repo_uri     target repository URI

        --help or -?    display usage message

Environment:

        PKG_REPO""")

        sys.exit(retcode)

def trans_create_repository(repo_uri, args):

        """Creates a new repository at the location indicated by repo_uri."""

        repo_props = {}

        opts, pargs = getopt.getopt(args, "", ["set-property="])

        for opt, arg in opts:

                if opt == "--set-property":

                        try:

                                prop, p_value = arg.split("=", 1)

                                p_sec, p_name = prop.split(".", 1)

                        except ValueError:

                                usage(_("property arguments must be of "

                                    "the form '<section.property>="

                                    "<value>'."), cmd="create-repository")

                        repo_props.setdefault(p_sec, {})

                        repo_props[p_sec][p_name] = p_value

        try:

                trans.Transaction(repo_uri, create_repo=True,

                    repo_props=repo_props)

        except trans.TransactionRepositoryConfigError, e:

                error(e, cmd="create-repository")

                emsg(_("Invalid repository configuration values were "

                    "specified using --set-property or required values are "

                    "missing.  Please provide the correct and/or required "

                    "values using the --set-property option."))

        except trans.TransactionError, e:

                error(e, cmd="create-repository")

                return 1

        return 0

def trans_open(repo_uri, args):

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

        parsed = []

        eval_form = True

        for opt, arg in opts:

                parsed.append(opt)

                if opt == "-e":

                        eval_form = True

                if opt == "-n":

                        eval_form = False

        if "-e" in parsed and "-n" in parsed:

                usage(_("only -e or -n may be specified"), cmd="open")

        if len(pargs) != 1:

                usage(_("open requires one package name"), cmd="open")

        t = trans.Transaction(repo_uri, pkg_name=pargs[0])

        if eval_form:

                msg("export PKG_TRANS_ID=%s" % t.open())

        else:

                msg(t.open())

        return 0

def trans_close(repo_uri, args):

        abandon = False

        trans_id = None

        refresh_index = True

        add_to_catalog = True

        opts, pargs = getopt.getopt(args, "At:", ["no-index", "no-catalog"])

        for opt, arg in opts:

                if opt == "-A":

                        abandon = True

                elif opt == "-t":

                        trans_id = arg

                elif opt == "--no-index":

                        refresh_index = False

                elif opt == "--no-catalog":

                        add_to_catalog = False

        if trans_id is None:

                try:

                        trans_id = os.environ["PKG_TRANS_ID"]

                except KeyError:

                        usage(_("No transaction ID specified using -t or in "

                            "$PKG_TRANS_ID."), cmd="close")

        t = trans.Transaction(repo_uri, trans_id=trans_id, 

            add_to_catalog=add_to_catalog)

        pkg_state, pkg_fmri = t.close(abandon, refresh_index)

        for val in (pkg_state, pkg_fmri):

                if val is not None:

                        msg(val)

        return 0

def trans_add(repo_uri, args):

        try:

                trans_id = os.environ["PKG_TRANS_ID"]

        except KeyError:

                usage(_("No transaction ID specified in $PKG_TRANS_ID"),

                    cmd="add")

        if not args:

                usage(_("No arguments specified for subcommand."), cmd="add")

        action, lp = pkg.actions.internalizelist(args[0], args[1:])

        if action.name in nopub_actions:

                error(_("invalid action for publication: %s") % action, cmd="add")

                return 1

        t = trans.Transaction(repo_uri, trans_id=trans_id)

        t.add(action)

        return 0

def trans_publish(repo_uri, fargs):

        opts, pargs = getopt.getopt(fargs, "d:", ["no-index", 

            "no-catalog", "fmri-in-manifest"])

        basedirs = []

        refresh_index = True

        add_to_catalog = True

        embedded_fmri = False

        for opt, arg in opts:

                if opt == "-d":

                        basedirs.append(arg)

                elif opt == "--no-index":

                        refresh_index = False

                elif opt == "--no-catalog":

                        add_to_catalog = False

                elif opt == "--fmri-in-manifest":

                        embedded_fmri = True

        if not pargs and not embedded_fmri:

                usage(_("No fmri argument specified for subcommand"),

                    cmd="publish")

        if not embedded_fmri:

                pkg_name = pargs[0]

                del pargs[0]

        if not pargs:

                filelist = [("<stdin>", sys.stdin)]

        else:

                try:

                        filelist = [(f, file(f)) for f in pargs]

                except IOError, e:

                        error(e, cmd="publish")

                        return 1

        lines = ""      # giant string of all input files concatenated together

        linecnts = []   # tuples of starting line number, ending line number

        linecounter = 0 # running total

        for filename, f in filelist:

                try:

                        data = f.read()

                except IOError, e:

                        error(e, cmd="publish")

                        return 1                

                lines += data

                linecnt = len(data.splitlines())

                linecnts.append((linecounter, linecounter + linecnt))

                linecounter += linecnt

        m = pkg.manifest.Manifest()

        try:

                m.set_content(lines)

        except pkg.actions.ActionError, e:

                lineno = e.lineno

                for i, tup in enumerate(linecnts):

                        if lineno > tup[0] and lineno <= tup[1]:

                                filename = filelist[i][0]

                                lineno -= tup[0]

                                break;

                else:

                        filename = "???"

                        lineno = "???"

                error(_("File %s line %s: %s") % (filename, lineno, e),

                    cmd="publish")

                return 1

        if embedded_fmri:

                if "pkg.fmri" not in m:

                        error(_("Manifest does not set fmri and " + 

                            "--fmri-in-manifest specified"))

                        return 1

                pkg_name = pkg.fmri.PkgFmri(m["pkg.fmri"]).get_short_fmri()

        t = trans.Transaction(repo_uri, pkg_name=pkg_name, refresh_index=refresh_index)

        t.open()

        for a in m.gen_actions():

                # don't publish this action

                if a.name == "set" and a.attrs["name"] in ["pkg.fmri", "fmri"]:

                        continue

                elif a.name in ["file", "license"]:

                        pkg.actions.set_action_data(a.hash, a, basedirs)

                elif a.name in nopub_actions:

                        error(_("invalid action for publication: %s") % action,

                            cmd="publish")

                        t.close(abandon=True)

                        return 1

                try:

                        t.add(a)

                except:

                        t.close(abandon=True)

                        raise

        pkg_state, pkg_fmri = t.close(abandon=False, 

            refresh_index=refresh_index, add_to_catalog=add_to_catalog)

        for val in (pkg_state, pkg_fmri):

                if val is not None:

                        msg(val)

        return 0

def trans_include(repo_uri, fargs, transaction=None):

        basedirs = []

        error_occurred = False

        opts, pargs = getopt.getopt(fargs, "d:")

        for opt, arg in opts:

                if opt == "-d":

                        basedirs.append(arg)

        if transaction == None:

                try:

                        trans_id = os.environ["PKG_TRANS_ID"]

                except KeyError:

                        usage(_("No transaction ID specified in $PKG_TRANS_ID"),

                            cmd="include")

                t = trans.Transaction(repo_uri, trans_id=trans_id)

        else:

                t = transaction

        if not pargs:

                filelist = [("<stdin>", sys.stdin)]

        else:

                try:

                        filelist = [(f, file(f)) for f in pargs]

                except IOError, e:

                        error(e, cmd="include")

                        return 1

        lines = []      # giant string of all input files concatenated together

        linecnts = []   # tuples of starting line number, ending line number

        linecounter = 0 # running total

        for filename, f in filelist:

                try:

                        data = f.read()

                except IOError, e:

                        error(e, cmd="include")

                        return 1                

                lines.append(data)

                linecnt = len(data.splitlines())

                linecnts.append((linecounter, linecounter + linecnt))

                linecounter += linecnt

        m = pkg.manifest.Manifest()

        try:

                m.set_content("\n".join(lines))

        except pkg.actions.ActionError, e:

                lineno = e.lineno

                for i, tup in enumerate(linecnts):

                        if lineno > tup[0] and lineno <= tup[1]:

                                filename = filelist[i][0]

                                lineno -= tup[0]

                                break;

                else:

                        filename = "???"

                        lineno = "???"

                error(_("File %s line %s: %s") % (filename, lineno, e),

                    cmd="include")

                return 1

        invalid_action = False

        for a in m.gen_actions():

                # don't publish this action

                if a.name == "set" and a.attrs["name"] in  ["pkg.fmri", "fmri"]:

                        continue

                elif a.name in ["file", "license"]:

                        pkg.actions.set_action_data(a.hash, a, basedirs)

                if a.name in nopub_actions:

                        error(_("invalid action for publication: %s") % str(a),

                            cmd="include")

                        invalid_action = True

                else:

                        t.add(a)

        if invalid_action:

                return 3

        else:

                return 0

def gen_actions(files, timestamp_files):

        for filename in files:

                bundle = pkg.bundle.make_bundle(filename)

                for action in bundle:

                        if action.name == "file":

                                basename = os.path.basename(action.attrs["path"])

                                for pattern in timestamp_files:

                                        if fnmatch.fnmatch(basename, pattern):

                                                break

                                else:

                                        try:

                                                del action.attrs["timestamp"]

                                        except KeyError:

                                                pass

                        yield (action, action.name in nopub_actions)

def trans_import(repo_uri, args):

        try:

                trans_id = os.environ["PKG_TRANS_ID"]

        except KeyError:

                print >> sys.stderr, \

                    _("No transaction ID specified in $PKG_TRANS_ID")

                sys.exit(1)

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

        timestamp_files = []

        for opt, arg in opts:

                if opt == "-T":

                        timestamp_files.append(arg)

        if not args:

                usage(_("No arguments specified for subcommand."),

                    cmd="import")

        t = trans.Transaction(repo_uri, trans_id=trans_id)

        for action, err in gen_actions(pargs, timestamp_files):

                        if err:

                                error(_("invalid action for publication: %s") %

                                    action, cmd="import")

                                t.close(abandon=True)

                                return 1

                        else:

                                t.add(action)

        return 0

def trans_generate(args):

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

        timestamp_files = []

        for opt, arg in opts:

                if opt == "-T":

                        timestamp_files.append(arg)

        if not args:

                usage(_("No arguments specified for subcommand."),

                    cmd="generate")

        for action, err in gen_actions(pargs, timestamp_files):

                if "path" in action.attrs and hasattr(action, "hash") \

                    and action.hash == "NOHASH":

                        action.hash = action.attrs["path"]

                print action

        return 0

def trans_refresh_index(repo_uri, args):

        """Refreshes the indices at the location indicated by repo_uri."""

        if args:

                usage(_("command does not take operands"),

                    cmd="refresh-index")

        try:

                t = trans.Transaction(repo_uri).refresh_index()

        except trans.TransactionError, e:

                error(e, cmd="refresh-index")

                return 1

        return 0

def main_func():

        # XXX /usr/lib/locale is OpenSolaris-specific.

        gettext.install("pkgsend", "/usr/lib/locale")