#!/usr/bin/python2.7

#

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

#

#

# incorporator - an utility to incorporate packages in a repo

#

import subprocess

import json

import sys

import getopt

import re

import os.path

Werror = False	# set to true to exit with any warning

def warning(msg):

    if Werror == True:

        print >>sys.stderr, "ERROR: %s" % msg

        sys.exit(1)

    else:

        print >>sys.stderr, "WARNING: %s" % msg

class Incorporation(object):

    name = None

    version = '5.12'

    packages = {}

    def __init__(self, name, version):

        self.name = name

        self.version = version

        self.packages = {}

    def __package_to_str(self, name, version):

        # strip the :timestamp from the version string

        version = version.split(':', 1)[0]

        # strip the ,{build-release} from the version string

        version = re.sub(",[\d\.]+", "", version) 

        return "depend fmri=%s@%s facet.version-lock.%s=true type=incorporate" % (name, version, name)

    def add_package(self, name, version):

        self.packages[name] = version

    def __str__(self):

        result = """

set name=pkg.fmri value=pkg:/%s@%s

set name=info.classification value="org.opensolaris.category.2008:Meta Packages/Incorporations"

set name=org.opensolaris.consolidation value=userland

set name=pkg.depend.install-hold value=core-os.userland

set name=pkg.summary value="userland consolidation incorporation (%s)"

set name=pkg.description value="This incorporation constrains packages from the userland consolidation"

""" % (self.name, self.version, self.name)

        names = self.packages.keys()

        names.sort()

        for name in names:

            result += (self.__package_to_str(name, self.packages[name]) + '\n')

        return result

#

# This should probably use the pkg APIs at some point, but this appears to be

# a stable and less complicated interface to gathering information from the

# manifests in the package repo.

#

def get_incorporations(repository, publisher, inc_version='5.12'):

    tmp = subprocess.Popen(["/usr/bin/pkgrepo", "list", "-F", "json",

                                                        "-s", repository,

                                                        "-p", publisher],

                           stdout=subprocess.PIPE)

    incorporations = {}

    packages = json.load(tmp.stdout)

    # Check for multiple versions of packages in the repo, but keep track of

    # the latest one.

    versions = {}

    for package in packages:

        pkg_name = package['name']

        pkg_version = package['version']

        if pkg_name in versions:

            warning("%s is in the repo at multiple versions (%s, %s)" % (pkg_name, pkg_version, versions[pkg_name]))

            pkg_version = max(pkg_version, versions[pkg_name])

        versions[pkg_name] = pkg_version

    for package in packages:

        pkg_name = package['name']

        pkg_version = package['version']

        # skip older packages and those that don't want to be incorporated

        if 'pkg.tmp.incorporate' not in package or pkg_version != versions[pkg_name]:

            continue

        # a dict inside a list inside a dict

        incorporate = package['pkg.tmp.incorporate'][0]['value']

        for inc_name in incorporate:

            # if we haven't started to build this incorporation, create one.

            if inc_name not in incorporations:

                incorporations[inc_name] = Incorporation(inc_name, inc_version)

            # find the incorporation and add the package

            tmp = incorporations[inc_name]

            tmp.add_package(pkg_name, pkg_version)

    return incorporations

def main_func():

    global Werror

    try: 

        opts, pargs = getopt.getopt(sys.argv[1:], "c:s:p:v:d:w",

                                    ["repository=", "publisher=", "version=",

                                     "consolidation=", "destdir=", "Werror"])

    except getopt.GetoptError, e:

        usage(_("illegal option: %s") % e.opt)

    repository = None

    publisher = None

    version = None

    destdir = None

    consolidation = None

    for opt, arg in opts:

        if opt in ("-s", "--repository"):

            repository = arg

        elif opt in ("-p", "--publisher"):

            publisher = arg

        elif opt in ("-v", "--version"):

            version = arg

        elif opt in ("-d", "--destdir"):

            destdir = arg

        elif opt in ("-c", "--consolidation"):

            consolidation = arg

        elif opt in ("-w", "--Werror"):

            Werror = True

    incorporations = get_incorporations(repository, publisher, version)

    for incorporation_name in incorporations.keys():

        filename = ''

        if destdir != None:

            filename = destdir + '/'

        filename += os.path.basename(incorporation_name) + '.p5m'

        print("Writing %s manifest to %s" % (incorporation_name, filename))

        fd = open(filename, "w+")

        fd.write(str(incorporations[incorporation_name]))

        fd.close()

if __name__ == "__main__":

    main_func()