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

"""

AI publish_manifest

"""

import errno

import gettext

import logging

import lxml.etree

import os.path

import pwd

import shutil

import StringIO

import sys

from stat import S_IRUSR, S_IWUSR

from optparse import OptionParser

import osol_install.auto_install.AI_database as AIdb

import osol_install.auto_install.verifyXML as verifyXML

from osol_install.auto_install.installadm_common import validate_service_name

from osol_install.auto_install.properties import set_default, get_service_info

from solaris_install import _, AI_DATA, KSH93_SHEBANG, PYTHON_SHEBANG

INFINITY = str(0xFFFFFFFFFFFFFFFF)

IMG_AI_MANIFEST_DTD = "auto_install/ai.dtd"

SYS_AI_MANIFEST_DTD = "/usr/share/install/ai.dtd"

IMG_AI_MANIFEST_SCHEMA = "auto_install/ai_manifest.rng"

# Modes of operation.

DO_ADD = True

DO_UPDATE = False

# 0600 for chmod

PERM_OWNER_RW = S_IRUSR + S_IWUSR

# Eventually rename functions to convention.

# pylint: disable-msg=C0103

def get_add_usage():

    """

    get usage for add-manifest

    """

    return(_(

        'add-manifest\t-n|--service <svcname>\n'

        '\t\t-f|--file <manifest_file/script file> \n'

        '\t\t[-m|--manifest <manifest/script name>]\n'

        '\t\t[-c|--criteria <criteria=value|range> ... | \n'

        '\t\t -C|--criteria-file <criteria.xml>]  \n'

        '\t\t[-d|--default]'))

def get_update_usage():

    """

    get usage for update-manifest

    """

    return(_(

        'update-manifest\t-n|--service <svcname>\n'

        '\t\t-f|--file <manifest/script file> \n'

        '\t\t-m|--manifest <manifest/script name>'))

def parse_options(do_add, cmd_options=None):

    """

    Parse and validate options

    Args: Optional cmd_options, used for unit testing. Otherwise, cmd line

          options handled by OptionParser

    Returns: the DataFiles object populated and initialized

    Raises: The DataFiles initialization of manifest(s) A/I, SC, SMF looks for

            many error conditions and, when caught, are flagged to the user

            via raising SystemExit exceptions.

    """

    if do_add:

        usage = '\n' + get_add_usage()

    else:

        usage = '\n' + get_update_usage()

    parser = OptionParser(usage=usage)

    if do_add:

        parser.add_option("-c", "--criteria", dest="criteria_c",

                          action="append", default=[], help=_("Criteria: "

                          "<-c criteria=value|range> ..."), metavar="CRITERIA")

        parser.add_option("-C", "--criteria-file", dest="criteria_file",

                          default=None, help=_("Path to criteria XML file."))

        parser.add_option("-d", "--default", dest="set_as_default",

                          default=False, action='store_true',

                          help=_("Set manifest as default "))

    parser.add_option("-f", "--file", dest="manifest_path",

                      default=None, help=_("Path to manifest file "))

    parser.add_option("-m", "--manifest", dest="manifest_name",

                      default=None, help=_("Name of manifest"))

    parser.add_option("-n", "--service", dest="service_name",

                      default=None, help=_("Name of install service."))

    # Get the parsed options using parse_args().  We know we don't have

    # args, so we're just grabbing the first item of the tuple returned.

    options, args = parser.parse_args(cmd_options)

    if len(args):

        parser.error(_("Unexpected argument(s): %s" % args))

    if not do_add:

        options.criteria_file = None

        options.criteria_c = None

        options.set_as_default = False

    # options are:

    #    -c  criteria=<value/range> ...       (add only)

    #    -C  XML file with criteria specified (add only)

    #    -d  set manifest as default          (add only)

    #    -n  service name

    #    -f  path to manifest file

    #    -m  manifest name

    # check that we got the install service's name and an AI manifest.

    if options.manifest_path is None or options.service_name is None:

        parser.error(_("Missing one or more required options."))

    logging.debug("options = %s", options)

    # validate service name

    try:

        validate_service_name(options.service_name)

    except ValueError as err:

        parser.error(err)

    criteria_dict = None

    if do_add:

        # check that we aren't mixing -c and -C

        # Note: -c and -C will be accepted for add, not for update.

        if options.criteria_c and options.criteria_file:

            parser.error(_("Options used are mutually exclusive."))

        # if we have criteria from cmd line, convert into dictionary

        if options.criteria_c:

            try:

                criteria_dict = criteria_to_dict(options.criteria_c)

            except ValueError as err:

                parser.error(err)

        elif options.criteria_file:

            if not os.path.exists(options.criteria_file):

                parser.error(_("Unable to find criteria file: %s") %

                             options.criteria_file)

    # get AI service database info

    service_dir, dbname, image_path = get_service_info(options.service_name)

    try:

        files = DataFiles(service_dir=service_dir, image_path=image_path,

                      database_path=dbname,

                      manifest_file=options.manifest_path,

                      manifest_name=options.manifest_name,

                      criteria_dict=criteria_dict,

                      criteria_file=options.criteria_file,

                      service_name=options.service_name,

                      set_as_default=options.set_as_default)

    except (AssertionError, IOError, ValueError) as err:

        raise SystemExit(err)

    except (lxml.etree.LxmlError) as err:

        raise SystemExit(_("Error:\tmanifest error: %s") % err)

    return(files)

def criteria_to_dict(criteria):

    """

    Convert criteria list into dictionary. This function is intended to be

    called by a main function, or the options parser, so it can potentially

    raise the SystemExit exception.

    Args: criteria in list format: [ criteria=value, criteria=value, ... ]

                                 range (<lower>-<upper>)

    Returns: dictionary of criteria { criteria: value, criteria: value, ... }

    Raises: ValueError on malformed name=value strings in input list.

    """

    cri_dict = {}

    for entry in criteria:

        if entries[1]:

            if not entries[0]:

                raise ValueError(_("Missing criteria name in "

                                   "'%s'\n") % entry)

                raise ValueError(_("Duplicate criteria: '%s'\n") %

                             entries[0])

            elif not entries[2]:

                raise ValueError(_("Missing value for criteria "

                                   "'%s'\n") % entries[0])

        else:

            raise ValueError(_("Criteria must be of the form "

                               "<criteria>=<value>\n"))

    return cri_dict

def find_colliding_criteria(criteria, db, exclude_manifests=None):

    """

    Returns: A dictionary of colliding criteria with keys being manifest name

             and instance tuples and values being the DB column names which

             collided

    Args:    criteria - Criteria object holding the criteria that is to be

                        added/set for a manifest.

             db - AI_database object for the install service.

             exclude_manifests -A list of manifest names from DB to ignore.

                                This arg is passed in when we're calling this

                                function to find criteria collisions for an

                                already published manifest.

    Raises:  SystemExit if: criteria is not found in database

                            value is not valid for type (integer and

                            hexadecimal checks)

                            range is improper

    """

    class Fields(object):

        """

        Define convenience indexes

        """

        # manifest name is row index 0

        MANNAME = 0

        # manifest instance is row index 1

        MANINST = 1

        # criteria is row index 2 (when a single valued criteria)

        CRIT = 2

        # minimum criteria is row index 2 (when a range valued criteria)

        MINCRIT = 2

        # maximum criteria is row index 3 (when a range valued criteria)

        MAXCRIT = 3

    # collisions is a dictionary to hold keys of the form (manifest name,

    # instance) which will point to a comma-separated string of colliding

    # criteria

    collisions = dict()

    # verify each range criteria in the manifest is well formed and collect

    # collisions with database entries

    for crit in criteria:

        # gather this criteria's values from the manifest

        man_criterion = criteria[crit]

            # only check criteria in use in the DB

            if crit not in AIdb.getCriteria(db.getQueue(),

                                            onlyUsed=False, strip=False):

                raise SystemExit(_("Error:\tCriteria %s is not a " +

                                   "valid criteria!") % crit)

            # get all values in the database for this criteria (and

            # manifest/instance pairs for each value)

            db_criteria = AIdb.getSpecificCriteria(

                db.getQueue(), crit,

                provideManNameAndInstance=True,

                excludeManifests=exclude_manifests)

            # will iterate over a list of the form [manName, manInst, crit,

            # None]

            for row in db_criteria:

        # This is a range criteria.  (Check that ranges are valid, that

        # "unbounded" gets set to 0/+inf, ensure the criteria exists

        # in the DB, then look for collisions.)

        else:

            # Clean-up NULL's and change "unbounded"s to 0 and

            # really large numbers in case this Python does

            # not support IEEE754.  Note "unbounded"s are already

            # converted to lower case during manifest processing.

            if man_criterion[0] == "unbounded":

                man_criterion[0] = "0"

            if man_criterion[1] == "unbounded":

                man_criterion[1] = INFINITY

            if crit == "mac":

                # convert hex mac address (w/o colons) to a number

                try:

                    man_criterion[0] = long(str(man_criterion[0]).upper(), 16)

                    man_criterion[1] = long(str(man_criterion[1]).upper(), 16)

                except ValueError:

                    raise SystemExit(_("Error:\tCriteria %s "

                                       "is not a valid hexadecimal value") %

                                     crit)

            else:

                # this is a decimal value

                try:

                    man_criterion = [long(str(man_criterion[0]).upper()),

                                     long(str(man_criterion[1]).upper())]

                except ValueError:

                    raise SystemExit(_("Error:\tCriteria %s "

                                       "is not a valid integer value") % crit)

            # Check for a properly ordered range (with unbounded being 0 or

            # Inf.) but ensure both are not unbounded.

            # Check for:

            #       a range of zero to inf -- not a valid range

            #  and

            #       min > max -- range order reversed

            #

            if (man_criterion[0] == 0 and man_criterion[1] == long(INFINITY)):

                raise SystemExit(_("Error:\tCriteria %s is not a valid range, "

                                   "MIN and MAX unbounded.") % crit)

            if ((man_criterion[0] != 0 and

                 man_criterion[1] != long(INFINITY)) and

                (long(man_criterion[0]) > long(man_criterion[1]))):

                raise SystemExit(_("Error:\tCriteria %s is not a valid range, "

                                   "MIN > MAX.") % crit)

            # check to see that this criteria exists in the database columns

            man_crit = AIdb.getCriteria(db.getQueue(), onlyUsed=False,

                    strip=False)

            if 'MIN' + crit not in man_crit and 'MAX' + crit not in man_crit:

                raise SystemExit(_("Error:\tCriteria %s is not a "

                                   "valid criteria!") % crit)

            db_criteria = AIdb.getSpecificCriteria(

                db.getQueue(), 'MIN' + crit, 'MAX' + crit,

                provideManNameAndInstance=True,

                excludeManifests=exclude_manifests)

            # will iterate over a list of the form [manName, manInst, mincrit,

            # maxcrit]

            for row in db_criteria:

                # arbitrarily large number in case this Python does

                # not support IEEE754

                db_criterion = ["0", INFINITY]

                # now populate in valid database values (i.e. non-NULL values)

                if row[Fields.MINCRIT]:

                    db_criterion[0] = row[Fields.MINCRIT]

                if row[Fields.MAXCRIT]:

                    db_criterion[1] = row[Fields.MAXCRIT]

                if crit == "mac":

                    # use a hexadecimal conversion

                    db_criterion = [long(str(db_criterion[0]), 16),

                                    long(str(db_criterion[1]), 16)]

                else:

                    # these are decimal numbers

                    db_criterion = [long(str(db_criterion[0])),

                                    long(str(db_criterion[1]))]

                # these three criteria can determine if there's a range overlap

                if((man_criterion[1] >= db_criterion[0] and

                   db_criterion[1] >= man_criterion[0]) or

                   man_criterion[0] == db_criterion[1]):

                    # range overlap so record the collision

                    try:

                        collisions[row[Fields.MANNAME],

                                   row[Fields.MANINST]] += "MIN" + crit + ","

                        collisions[row[Fields.MANNAME],

                                   row[Fields.MANINST]] += "MAX" + crit + ","

                    except KeyError:

                        collisions[row[Fields.MANNAME],

                                   row[Fields.MANINST]] = "MIN" + crit + ","

                        collisions[row[Fields.MANNAME],

                                   row[Fields.MANINST]] += "MAX" + crit + ","

    return collisions

def find_colliding_manifests(criteria, db, collisions, append_manifest=None):

    """

    For each manifest/instance pair in collisions check that the manifest

    criteria diverge (i.e. are not exactly the same) and that the ranges do not

    collide for ranges.

    Raises if: a range collides, or if the manifest has the same criteria as a

    manifest already in the database (SystemExit raised)

    Returns: Nothing

    Args: criteria - Criteria object holding the criteria that is to be

                     added/set for a manifest.

          db - AI_database object for the install service.

          collisions - a dictionary with collisions, as produced by

                       find_colliding_criteria()

          append_manifest - name of manifest we're appending criteria to.

                            This arg is passed in when we're calling this

                            function to find criteria collisions for an

                            already published manifest that we're appending

                            criteria to.

    """

    # If we're appending criteria to an already published manifest, get a

    # dictionary of the criteria that's already published for that manifest.

    if append_manifest is not None:

        published_criteria = AIdb.getManifestCriteria(append_manifest, 0,

                                                      db.getQueue(),

                                                      humanOutput=True,

                                                      onlyUsed=False)

    # check every manifest in collisions to see if manifest collides (either

    # identical criteria, or overlaping ranges)

    for man_inst in collisions:

        # get all criteria from this manifest/instance pair

        db_criteria = AIdb.getManifestCriteria(man_inst[0],

                                               man_inst[1],

                                               db.getQueue(),

                                               humanOutput=True,

                                               onlyUsed=False)

        # iterate over every criteria in the database

        for crit in AIdb.getCriteria(db.getQueue(),

                                     onlyUsed=False, strip=False):

            # Get the criteria name (i.e. no MIN or MAX)

            crit_name = crit.replace('MIN', '', 1).replace('MAX', '', 1)

            # Set man_criterion to the key of the DB criteria or None

            man_criterion = criteria[crit_name]

            if man_criterion and crit.startswith('MIN'):

                man_criterion = man_criterion[0]

            elif man_criterion and crit.startswith('MAX'):

                man_criterion = man_criterion[1]

            # If man_criterion is still None, and if we're appending criteria

            # to an already published manifest, look for criteria in the

            # published set of criteria for the manifest we're appending to

            # as well, because existing criteria might cause a collision,

            # which we need to compare for.

            if man_criterion is None and append_manifest is not None:

                man_criterion = published_criteria[str(crit)]

                # replace database NULL's with Python None

                if man_criterion == '':

                    man_criterion = None

            # set the database criteria

            if db_criteria[str(crit)] == '':

                # replace database NULL's with a Python None

                db_criterion = None

            else:

                db_criterion = db_criteria[str(crit)]

            # Replace unbounded's in the criteria (i.e. 0/+inf)

            # with a Python None.

            if isinstance(man_criterion, basestring) and \

               man_criterion == "unbounded":

                man_criterion = None

            # check to determine if this is a range collision by using

            # collisions and if not are the manifests divergent

            if((crit.startswith('MIN') and

                collisions[man_inst].find(crit + ",") != -1) or

               (crit.startswith('MAX') and

                collisions[man_inst].find(crit + ",") != -1)