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

"""
aimanifest.py: aimanifest commandline wrapper around Manifest Input Module
"""

import errno
import gettext
import logging
import os
import sys

from optparse import OptionParser
from traceback import print_exc

import solaris_install.manifest_input as milib

from solaris_install.logger import InstallLogger
from solaris_install.manifest_input.mim import ManifestInput

_ = gettext.translation('aimanifest', '/usr/share/locale',
                        fallback=True).gettext

AIM_LOGGER = None
SCHEMA_FILE = "/usr/share/install/ai.dtd"

VALIDATE = True
NO_VALIDATE = False


class AimOptionParser(OptionParser):
    '''
    OptionParser which provides error_w_errno() to return a more correct errno
    '''

    def error_w_errno(self, errnum, message):
        '''
        Log and display a message, and exit with errnum status
        '''
        AIM_LOGGER.error(message)
        print >> sys.stderr, _("Usage:\n") + self.usage + "\n"
        print >> sys.stderr, os.path.basename(sys.argv[0]) + \
                                             ": error: " + message
        sys.exit(errnum)


def usage(argv):
    '''
    Assemble command usage string.
    '''

    name = os.path.basename(argv[0])
    usage_str = _(
        "    %s subcommand cmd_options\n" +
        "    subcommands:\n" +
        "    " + name + " set [-r] <path> <value>  " +
                  "Change value or add/change attributes\n" +
        "    " + name + " add [-r] <path> <value>  Add new element\n" +
        "    " + name + " get [-r] <path>          " +
                  "Retrieve element value or attributes\n" +
        "    " + name + " load [-i] <filename>     " +
                  "Load / incrementally overlay XML file\n" +
        "    " + name + " validate                 Validate XML data\n" +
        "\n    The -r option to set/add/get displays the path of " +
                  "the returned element\n" +
        "    in terms of node IDs.  This path may be used in " +
                  "subsequent calls to\n" +
        "    %s to specify the affected element more directly.\n") % (
        name, name)
    return usage_str


def _handle_error(error):
    '''
    Display the error message, log the whole traceback and set errno

    Args:
      error: exception containing message and, if IOError, an errno.
              Assume messages are localized.

    Returns:
      errno: EINVAL unless overridden by an IOError exception's errno.
    '''
    print >> sys.stderr, str(error)
    AIM_LOGGER.exception(str(error))
    rval = getattr(error, "errno", errno.EINVAL)

    # Handle the cases where the errno field exists in the exception
    # but is None or 0
    if not rval:
        rval = errno.EIO if isinstance(error, IOError) else errno.EINVAL
    return rval


def _log_final_status(mim, path=None):
    '''
    Log status.  Usually called after running a subcommand.  Checks to see if
    the manifest validates, when this information would be logged.  Does
    nothing if logging is disabled.

    Args:
      mim: Reference to the Manifest Input Module, needed for validation.

      path: Nodepath, used for printing only.
    '''
    if AIM_LOGGER.isEnabledFor(logging.INFO):
        try:
            mim.validate()
            validated = _("Pass")
        except (milib.MimError, IOError):
            validated = _("Fail")
        out = _("cmd:success, validation:") + validated
        if path:
            out += _(", node:") + path
        AIM_LOGGER.info(out)


def _setup_logging():
    '''
    Set up logging.

    If AIM_LOGFILE is set in the environment, enable logging to the file
    specified by AIM_LOGFILE.  Enable logging at the level specified by
    the environment variable AIM_LOGLEVEL if set, else set to the INFO level
    by default.  (These two variables (and logging here in general) is to
    support the Derived Manifest Module (DMM).
    '''
    # pylint: disable-msg=W0603
    global AIM_LOGGER

    logging.setLoggerClass(InstallLogger)
    AIM_LOGGER = logging.getLogger("aimanifest")
    logfile_name = os.environ.get("AIM_LOGFILE")
    if logfile_name is not None:
        logging.basicConfig(format="%(asctime)s: %(name)s: "
                                   "%(levelname)s: %(message)s",
                            datefmt="%H:%M:%S",
                            filename=logfile_name,
                            filemode="a")
        logging_level = os.environ.get("AIM_LOGLEVEL")
        if logging_level and logging_level.isdigit():
            AIM_LOGGER.setLevel(int(logging_level))
        else:
            AIM_LOGGER.setLevel(logging.INFO)
    else:
        AIM_LOGGER.setLevel(logging.NOTSET)


def _shutdown_logging():
    '''
    Shut down logging.
    '''
    logging.shutdown()


def _do_aimanifest(argv):
    '''
    Main.  See usage for argv details.
    '''

    usage_str = usage(argv)

    if len(argv) <= 1:
        AIM_LOGGER.error(_("Error: Missing subcommand"))
        print >> sys.stderr, _("Usage:\n") + usage_str
        return errno.EINVAL

    parser = AimOptionParser(usage=usage_str)
    parser.add_option("-i", "--incremental", dest="is_incremental",
                      default=False, action="store_true",
                      help=_("Do not clear data before adding new data"))
    parser.add_option("-r", dest="show_path", default=False,
                      action="store_true",
                      help=_("Return unique path to affected node"))

    (options, args) = parser.parse_args(argv[1:])
    len_args = len(args)
    command = args[0]
    path = args[1] if (len_args > 1) else None
    value = args[2] if (len_args > 2) else None

    cmds_r_option = ["add", "set", "get"]
    cmds_w_value_arg = ["add", "set"]
    cmds_wo_value_arg = ["get", "load"]
    cmds_w_no_args = ["validate"]

    if ((command in cmds_w_value_arg and (len_args < 3)) or
        (command in cmds_wo_value_arg and (len_args < 2))):
        parser.error_w_errno(errno.EINVAL, _("missing argument"))
    if ((command in cmds_w_value_arg and (len_args > 3)) or
        (command in cmds_wo_value_arg and (len_args > 2)) or
        (command in cmds_w_no_args and (len_args > 1))):
        parser.error_w_errno(errno.EINVAL, _("extra arguments given"))
    if (command != "load") and options.is_incremental:
        parser.error_w_errno(errno.EINVAL,
                     _("-i is not applicable for command given"))
    if command not in cmds_r_option and options.show_path:
        parser.error_w_errno(errno.EINVAL,
                     _("-r is not applicable for command given"))

    # Pass AIM_MANIFEST as the output file.
    try:
        mim = ManifestInput(os.environ.get("AIM_MANIFEST"), SCHEMA_FILE)
    except (milib.MimError, IOError) as err:
        return (_handle_error(err))

    # Note: warnings already localized.
    warnings = mim.get_warnings()
    if warnings is not None:
        for msg in warnings:
            print >> sys.stderr, msg
            AIM_LOGGER.error(msg)

    if (command == "set") or (command == "add"):
        AIM_LOGGER.info(_("command:%(mcommand)s, path:%(mpath)s, "
                "value:%(mvalue)s") %
                {"mcommand": command, "mpath": path, "mvalue": value})
        try:
            if command == "set":
                path = mim.set(path, value)
            else:
                path = mim.add(path, value)
            mim.commit(NO_VALIDATE)
        except (milib.MimError, IOError) as err:
            return (_handle_error(err))

        _log_final_status(mim, path)
        if options.show_path:
            # Localization not needed here.
            print path

    elif command == "get":
        AIM_LOGGER.info(_("command:%(mcommand)s, path:%(mpath)s") %
                {"mcommand": command, "mpath": path})
        try:
            (value, path) = mim.get(path)
        except (milib.MimError, IOError) as err:
            return (_handle_error(err))

        if value is None:
            value = "\"\""

        AIM_LOGGER.info(_("successful: returns value:%(mvalue)s, "
                      "path:%(mpath)s") % {"mvalue": value, "mpath": path})

        if not options.show_path:
            path = ""

        # Localization not needed here.
        print "%s %s" % (value, path)

    elif (command == "load"):
        # path arg holds the filename
        AIM_LOGGER.info(_("command:%(mcommand)s, "
                      "incremental:%(mincr)s, file:%(mfile)s") %
                    {"mcommand": command, "mincr": str(options.is_incremental),
                     "mfile": path})
        try:
            mim.load(path, options.is_incremental)
            mim.commit(NO_VALIDATE)
        except (milib.MimError, IOError) as err:
            return (_handle_error(err))

        # Note: warnings already localized.
        warnings = mim.get_warnings()
        if warnings is not None:
            for msg in warnings:
                print >> sys.stderr, msg
                AIM_LOGGER.error(msg)

        _log_final_status(mim, path)

    elif (command == "validate"):
        AIM_LOGGER.info(_("Command:%s") % command)
        try:
            mim.validate()
            AIM_LOGGER.info(_("Validation successful"))
        except milib.MimDTDInvalid as err:
            errorlist = err.errors
            for error in errorlist:
                # These messages come already localized.
                print >> sys.stderr, error
                AIM_LOGGER.error(error)
            return errno.EINVAL
        except (milib.MimError, IOError) as err:
            return (_handle_error(err))

    else:
        AIM_LOGGER.error(_("Invalid subcommand \"%s\"") % command)
        print >> sys.stderr, _("Usage:\n") + usage_str
        return errno.EINVAL

    return 0  # No errors


def main(argv):
    '''
    Main program.
    '''
    _setup_logging()
    rval = 1
    try:
        rval = _do_aimanifest(argv)
    except StandardError as err:
        # Catch unexpected exceptions, logging and displaying a traceback.
        print >> sys.stderr, str(err)
        AIM_LOGGER.exception(str(err))
        print_exc()
    _shutdown_logging()
    return rval


if __name__ == "__main__":
    sys.exit(main(sys.argv))