# vim: tabstop=4 shiftwidth=4 softtabstop=4

#

# Copyright 2012 Hewlett-Packard Development Company, L.P.

# Copyright (c) 2012 NTT DOCOMO, INC.

# Copyright 2014 International Business Machines Corporation

# All Rights Reserved.

#

# Copyright (c) 2014, 2016, Oracle and/or its affiliates. All rights reserved.

#

#    Licensed under the Apache License, Version 2.0 (the "License"); you may

#    not use this file except in compliance with the License. You may obtain

#    a copy of the License at

#

#         http://www.apache.org/licenses/LICENSE-2.0

#

#    Unless required by applicable law or agreed to in writing, software

#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT

#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the

#    License for the specific language governing permissions and limitations

#    under the License.

"""

Solaris Driver and supporting meta-classes.

"""

import errno

import os

import platform

import re

import select

import shutil

import socket

from subprocess import Popen, PIPE

import tempfile

from threading import Thread

import time

import urllib2

from urlparse import urlparse

from lockfile import LockFile, LockTimeout

from oslo_concurrency import processutils

from scp import SCPClient

from ironic.common import boot_devices, exception, images, keystone, states, \

    utils

from ironic.common.i18n import _, _LE, _LI, _LW

from ironic.conductor import task_manager

from ironic.conductor import utils as manager_utils

from ironic.db import api as dbapi

from ironic.drivers import base

from ironic.drivers.modules import ipmitool

from ironic.drivers import utils as driver_utils

PLATFORM = platform.system()

if PLATFORM != "SunOS":

    import tarfile

else:

    from pkg.fmri import is_valid_pkg_name

    from pkg.misc import valid_pub_prefix, valid_pub_url

AI_OPTS = [

    cfg.StrOpt('server',

               help='Host name for AI Server.'),

    cfg.StrOpt('username',

               help='Username to ssh to AI Server.'),

    cfg.StrOpt('password',

               help='Password for user to ssh to AI Server. If ssh_key_file '

                    'or ssh_key_contents are set, this config setting is used '

                    'to provide the passphrase if required. If an encrypted '

                    'key is used, set this to the passphrase.'),

    cfg.StrOpt('port',

               default='22',

               help='SSH port to use.'),

    cfg.StrOpt('timeout',

               default='10',

               help='SSH socket timeout value in seconds.'),

    cfg.StrOpt('deploy_interval',

               default='10',

               help='Interval in seconds to check AI deployment status.'),

    cfg.StrOpt('derived_manifest',

               default='file:///usr/lib/ironic/ironic-manifest.ksh',

               help='Derived Manifest used for deployment.'),

    cfg.StrOpt('ssh_key_file',

               help='SSH Filename to use.'),

    cfg.StrOpt('ssh_key_contents',

               help='Actual SSH Key contents to use.')

    ]

SOLARIS_IPMI_OPTS = [

    cfg.StrOpt('imagecache_dirname',

               default='/var/lib/ironic/images',

               help='Default path to image cache.'),

    cfg.StrOpt('imagecache_lock_timeout',

               default='60',

               help='Timeout to wait when attempting to lock refcount file.')

]

LOG = logging.getLogger(__name__)

CONF = cfg.CONF

OPT_GROUP = cfg.OptGroup(name='ai',

CONF.register_group(OPT_GROUP)

CONF.register_opts(AI_OPTS, OPT_GROUP)

SOLARIS_IPMI_GROUP = cfg.OptGroup(

    name="solaris_ipmi",

    title="Options defined in ironic.drivers.modules.solaris_ipmi")

CONF.register_group(SOLARIS_IPMI_GROUP)

CONF.register_opts(SOLARIS_IPMI_OPTS, SOLARIS_IPMI_GROUP)

VALID_ARCH = ['x86', 'SPARC']

VALID_ARCHIVE_SCHEMES = ["file", "http", "https", "glance"]

VALID_URI_SCHEMES = VALID_ARCHIVE_SCHEMES

DEFAULT_ARCHIVE_IMAGE_PATH = 'auto_install/manifest/default_archive.xml'

AI_STRING = "Automated Installation"

AI_SUCCESS_STRING = AI_STRING + " succeeded"

AI_FAILURE_STRING = AI_STRING + " failed"

AI_DEPLOY_STRING = AI_STRING + " started"

REQUIRED_PROPERTIES = {

    'ipmi_address': _("IP address or hostname of the node. Required."),

    'ipmi_username': _("username to use for IPMI connection. Required."),

    'ipmi_password': _("password to use for IPMI connection. Required.")

}

OPTIONAL_PROPERTIES = {

    'ai_manifest': _("Automated install manifest to be used for provisioning. "

                     "Optional."),

    'ai_service': _("Automated Install service name to use. Optional."),

    'archive_uri': _("URI of archive to deploy. Optional."),

    'fmri': _("List of IPS package FMRIs to be installed. "

              "Required if publishers property is set."),

    'install_profiles': _("List of configuration profiles to be applied "

                          "to the installation environment during an install. "

                          "Optional."),

    'ipmi_priv_level':

        _("privilege level; default is ADMINISTRATOR. "

          "One of %s. Optional.") % '. '.join(ipmitool.VALID_PRIV_LEVELS),

    'ipmi_target_address': _("destination address for bridged request. "

                             "Required only if ipmi_bridging is set "

                             "to \"single\" or \"dual\"."),

}

COMMON_PROPERTIES = REQUIRED_PROPERTIES.copy()

COMMON_PROPERTIES.update(OPTIONAL_PROPERTIES)

IPMI_PROPERTIES = [

    ('mac', '/System/host_primary_mac_address'),

    ('serial', '/System/serial_number'),

    ('model', '/System/model'),

    ('cpu_arch', '/System/Processors/architecture'),

    ('memory_mb', '/System/Memory/installed_memory'),

    ('cpus', '/System/Processors/installed_cpus'),

    ('datalinks', '/System/Networking/installed_eth_nics'),

    ('disks', '/System/Storage/installed_disks'),

    ('local_gb', '/System/Storage/installed_disk_size')

]

CPU_LOCATION = '/System/Processors/CPUs/CPU_%d/total_cores'

LAST_CMD_TIME = {}

def _ssh_execute(ssh_obj, ssh_cmd, raise_exception=True, err_msg=None):

    """Execute a command via SSH.

    :param ssh_obj: paramiko.SSHClient, an active ssh connection

    :param ssh_cmd: Command to execute over SSH.

    :param raise_exception: Wheter to raise exception or not

    :param err_msg: Custom error message to use

    :returns: tuple [stdout from command, returncode]

    :raises: SSHCommandFailed on an error from ssh, if specified to raise.

    """

    LOG.debug("_ssh_execute():ssh_cmd: %s" % (ssh_cmd))

    returncode = 0

    stdout = None

    try:

        stdout = processutils.ssh_execute(ssh_obj, ssh_cmd)[0]

    except Exception as err:

                  {'cmd': ssh_cmd, 'err': err})

        returncode = 1

        if raise_exception:

            if err_msg:

                raise SolarisIPMIError(msg=err_msg)

            else:

                raise exception.SSHCommandFailed(cmd=ssh_cmd)

    return stdout, returncode

def _parse_driver_info(node):

    """Gets the parameters required for ipmitool to access the node.

    Copied from ironic/drivers/modules/ipmitool.py. No differences.

    Copied locally as REQUIRED_PROPERTIES differs from standard ipmitool.

    :param node: the Node of interest.

    :returns: dictionary of parameters.

    :raises: InvalidParameterValue when an invalid value is specified

    :raises: MissingParameterValue when a required ipmi parameter is missing.

    """

    LOG.debug("_parse_driver_info()")

    info = node.driver_info or {}

    bridging_types = ['single', 'dual']

    missing_info = [key for key in REQUIRED_PROPERTIES if not info.get(key)]

    if missing_info:

    address = info.get('ipmi_address')

    username = info.get('ipmi_username')

    port = info.get('ipmi_terminal_port')

    priv_level = info.get('ipmi_priv_level', 'ADMINISTRATOR')

    bridging_type = info.get('ipmi_bridging', 'no')

    local_address = info.get('ipmi_local_address')

    transit_channel = info.get('ipmi_transit_channel')

    transit_address = info.get('ipmi_transit_address')

    target_channel = info.get('ipmi_target_channel')

    target_address = info.get('ipmi_target_address')

    # check if ipmi_bridging has proper value

    if bridging_type == 'no':

        # if bridging is not selected, then set all bridging params to None

    elif bridging_type in bridging_types:

        # check if the particular bridging option is supported on host

        if not ipmitool._is_option_supported('%s_bridge' % bridging_type):

            raise exception.InvalidParameterValue(_(

                "Value for ipmi_bridging is provided as %s, but IPMI "

                "bridging is not supported by the IPMI utility installed "

                "on host. Ensure ipmitool version is > 1.8.11"

            ) % bridging_type)

        # ensure that all the required parameters are provided

        params_undefined = [param for param, value in [

            ("ipmi_target_channel", target_channel),

            ('ipmi_target_address', target_address)] if value is None]

        if bridging_type == 'dual':

            params_undefined2 = [param for param, value in [

                ("ipmi_transit_channel", transit_channel),

                ('ipmi_transit_address', transit_address)

            ] if value is None]

            params_undefined.extend(params_undefined2)

        else:

            # if single bridging was selected, set dual bridge params to None

            transit_channel = transit_address = None

        # If the required parameters were not provided,

        # raise an exception

        if params_undefined:

            raise exception.MissingParameterValue(_(

                "%(param)s not provided") % {'param': params_undefined})

    else:

        raise exception.InvalidParameterValue(_(

            "Invalid value for ipmi_bridging: %(bridging_type)s,"

            " the valid value can be one of: %(bridging_types)s"

        ) % {'bridging_type': bridging_type,

             'bridging_types': bridging_types + ['no']})

    if priv_level not in ipmitool.VALID_PRIV_LEVELS:

        valid_priv_lvls = ', '.join(ipmitool.VALID_PRIV_LEVELS)

        raise exception.InvalidParameterValue(_(

            "Invalid privilege level value:%(priv_level)s, the valid value"

            " can be one of %(valid_levels)s") %

            {'priv_level': priv_level, 'valid_levels': valid_priv_lvls})

    return {

        'address': address,

        'username': username,

        'password': password,

        'port': port,

        'uuid': node.uuid,

        'priv_level': priv_level,

        'local_address': local_address,

        'transit_channel': transit_channel,

        'transit_address': transit_address,

        'target_channel': target_channel,

def _exec_ipmitool(driver_info, command):

    """Execute the ipmitool command.

    This uses the lanplus interface to communicate with the BMC device driver.

    Copied from ironic/drivers/modules/ipmitool.py. Only one difference.

    ipmitool.py version expects a string of space separated commands, and

    it splits this into an list using 'space' as delimiter.

    This causes setting of bootmode script for SPARC network boot to fail.

    Solaris versions takes a list() as command paramater, and therefore

    we don't need to split.

    :param driver_info: the ipmitool parameters for accessing a node.

    :param command: list() : the ipmitool command to be executed.

    :returns: (stdout, stderr) from executing the command.

    :raises: PasswordFileFailedToCreate from creating or writing to the

             temporary file.

    :raises: processutils.ProcessExecutionError from executing the command.

    """

    LOG.debug("SolarisDeploy._exec_ipmitool:driver_info: '%s', "

              "command: '%s'" % (driver_info, command))

    args = ['/usr/sbin/ipmitool',

            '-I',

            '-H',

            driver_info['address'],

            '-L', driver_info['priv_level']

            ]

    if driver_info['username']:

        args.append('-U')

        args.append(driver_info['username'])

    for name, option in ipmitool.BRIDGING_OPTIONS:

        if driver_info[name] is not None:

            args.append(option)

            args.append(driver_info[name])

    # specify retry timing more precisely, if supported

    num_tries = max(

        (CONF.ipmi.retry_timeout // CONF.ipmi.min_command_interval), 1)

    if ipmitool._is_option_supported('timing'):

        args.append('-R')

        args.append(str(num_tries))

        args.append('-N')

        args.append(str(CONF.ipmi.min_command_interval))

    end_time = (time.time() + CONF.ipmi.retry_timeout)

    while True:

        num_tries = num_tries - 1

        # NOTE(deva): ensure that no communications are sent to a BMC more

        #             often than once every min_command_interval seconds.

        time_till_next_poll = CONF.ipmi.min_command_interval - (

        if time_till_next_poll > 0:

            time.sleep(time_till_next_poll)

        # Resetting the list that will be utilized so the password arguments

        # from any previous execution are preserved.

        cmd_args = args[:]

        # 'ipmitool' command will prompt password if there is no '-f'

        # option, we set it to '\0' to write a password file to support

        # empty password

        with ipmitool._make_password_file(

                    driver_info['password'] or '\0'

                ) as pw_file:

            cmd_args.append('-f')

            cmd_args.append(pw_file)

            cmd_args = cmd_args + list(command)  # Append list, don't split

            try:

                out, err = utils.execute(*cmd_args)

                return out, err

            except processutils.ProcessExecutionError as e:

                with excutils.save_and_reraise_exception() as ctxt:

                    err_list = [x for x in ipmitool.IPMITOOL_RETRYABLE_FAILURES

                    if ((time.time() > end_time) or

                        (num_tries == 0) or

                            not err_list):

                        LOG.error(_LE('IPMI Error while attempting '

                                      '"%(cmd)s" for node %(node)s. '

                                      'Error: %(error)s'),

                                  {

                                      'node': driver_info['uuid'],

                                      'cmd': e.cmd,

                                      'error': e

                                  })

                    else:

                        ctxt.reraise = False

                        LOG.warning(_LW('IPMI Error encountered, retrying '

                                        '"%(cmd)s" for node %(node)s. '

                                        'Error: %(error)s'),

                                    {

                                        'node': driver_info['uuid'],

                                        'cmd': e.cmd,

                                        'error': e

                                    })

            finally:

                LAST_CMD_TIME[driver_info['address']] = time.time()

def _get_node_architecture(node):

    """Queries the node for architecture type

    :param node: the Node of interest.

    :returns: SPARC or X86 depending on architecture discovered

    :raises: IPMIFailure if ipmitool command fails

    """

    LOG.debug("SolarisDeploy._get_node_architecture")

    cpu_arch = node.properties.get('cpu_arch', None)

    if cpu_arch is None:

        LOG.info(_LI("Inspection not performed, retrieving architecture via "

                     "IPMI for node: %s"), node.uuid)

        ipmi_cmd_args = ['sunoem', 'getval', '/System/Processors/architecture']

        driver_info = _parse_driver_info(node)

        try:

            cpu_arch, _err = _exec_ipmitool(driver_info, ipmi_cmd_args)

        except Exception as err:

            LOG.error(_LE("Failed to get node architecture from IPMI : %s" %

            raise exception.IPMIFailure(cmd=err)

        propdict = {'cpu_arch': cpu_arch}

        node_properties = node.properties

        node_properties.update(propdict)

        node.properties = node_properties

        node.save()

        LOG.debug("SolarisDeploy._get_node_architecture: cpu_arch: '%s'"

                  % (cpu_arch))

    if 'SPARC' in cpu_arch:

        return 'SPARC'

    elif 'x86' in cpu_arch:

        return 'x86'

    else:

        raise SolarisIPMIError(msg="Unknown node architecture: %s"

                               % (cpu_arch))

def _check_deploy_state(task, node_uuid, deploy_thread):

    """ Check deployment state of a running install

    Check the deployment status for this node ideally this will be

    achieved via communicating with the AI Server and querying the

    telemetry data returned by the AI Client install to the AI Server.

    However until that is integrated we need to maintain a connection

    with the Serial Console of the node being installed and parse the

    output to the console made during an install.

    :param task: a TaskManager instance.

    :param deploy_thread: Threaded class monitor deployment status

    :returns: Nothing, raises loopingcall.LoopingCallDone() once

        node deployment status is determined as done or failed.

    """

    LOG.debug("_check_deploy_state()")