#!/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

#

"""

A/I Publish_Manifest

"""

import os.path

import sys

import StringIO

import gettext

import lxml.etree

import hashlib

from optparse import OptionParser

import osol_install.auto_install.AI_database as AIdb

import osol_install.auto_install.verifyXML as verifyXML

import osol_install.libaiscf as smf

INFINITY = str(0xFFFFFFFFFFFFFFFF)

IMG_AI_MANIFEST_SCHEMA = "auto_install/ai_manifest.rng"

    """

    Parse and validate options

    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.

    """

    # check that we got the install service's name and

    # get an AIservice object for requested service

    try:

    except KeyError:

    # get the service's data directory path and imagepath

    try:

        image_path = svc['image_path']

        port = svc['txt_record'].rsplit(':')[-1]

    service_dir = os.path.abspath("/var/ai/" + port)

    # check that the service and imagepath directories exist,

    # and the AI.db, criteria_schema.rng and ai_manifest.rng files

    # are present otherwise the service is misconfigured

    if not (os.path.isdir(service_dir) and

            os.path.exists(os.path.join(service_dir, "AI.db"))):

    return(files)

    """

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

             and instance tuples and values being the DB column names which

             collided

    """

        # 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

        # gather this criteria's values from the manifest

        # check "value" criteria here (check the criteria exists in DB, and

        # then find collisions)

            # only check criteria in use in the DB

                                            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

            db_criteria = AIdb.getSpecificCriteria(

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

            # None]

            for row in db_criteria:

                # check if the database and manifest values differ

                    # record manifest name, instance and criteria name

                    try:

                    except KeyError:

        # 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:

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

            # Inf.) but ensure both are not unbounded

            if(

               # Check for a range of -inf to inf -- not a valid range

               (man_criterion[0] == "unbounded" and

                man_criterion[1] == "unbounded"

               ) or

               # Check min > max -- range order reversed

               (

                (man_criterion[0] != "unbounded" and

                 man_criterion[1] != "unbounded"

                ) and

                (man_criterion[0] > man_criterion[1])

               )

              ):

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

                                   "is not a valid range (MIN > MAX) or "

                                   "(MIN and MAX unbounded).") % crit)

            # Clean-up NULL's and changed "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 to see that this criteria exists in the database columns

            if ('MIN' + crit not in AIdb.getCriteria(

            db_criteria = AIdb.getSpecificCriteria(

            # 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 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:

                    except KeyError:

    return collisions

    """

    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

          collisions - a dictionary with collisions, as produced by

                       find_colliding_criteria()

    """

    # 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],

                                               humanOutput=True,

                                               onlyUsed=False)

        # iterate over every criteria in the database

                                     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

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

                man_criterion = man_criterion[0]

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

                man_criterion = man_criterion[1]

            # 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)

              ):

                if (str(db_criterion).lower() != str(man_criterion).lower()):

                    raise SystemExit(_("Error:\tManifest has a range "

                                       "collision with manifest:%s/%i"

                                       "\n\tin criteria: %s!") %

                                     (man_inst[0], man_inst[1],

                                      crit.replace('MIN', '', 1).

                                      replace('MAX', '', 1)))

            # the range did not collide or this is a single value (if we

            # differ we can break out knowing we diverge for this

            # manifest/instance)

            elif(str(db_criterion).lower() != str(man_criterion).lower()):

                # manifests diverge (they don't collide)

                break

        # end of for loop and we never broke out (diverged)

        else:

            raise SystemExit(_("Error:\tManifest has same criteria as " +

                             (man_inst[0], man_inst[1]))

def insert_SQL(files):

    """

    Ensures all data is properly sanitized and formatted, then inserts it into

    the database

    Args: None

    Returns: None

    """

    query = "INSERT INTO manifests VALUES("

    # add the manifest name to the query string

    query += "'" + AIdb.sanitizeSQL(files.manifest_name) + "',"

    # check to see if manifest name is alreay in database (affects instance

    # number)

    if AIdb.sanitizeSQL(files.manifest_name) in \

        AIdb.getManNames(files.database.getQueue()):

            # database already has this manifest name get the number of

            # instances

        instance = AIdb.numInstances(AIdb.sanitizeSQL(files.manifest_name),

                                     files.database.getQueue())

    # this a new manifest

    else:

        instance = 0

    # actually add the instance to the query string

    query += str(instance) + ","

    # we need to fill in the criteria or NULLs for each criteria the database