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

#

#

#    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 oslo_config import cfg

from oslo_log import log as logging

from oslo_service import loopingcall

from oslo_utils import excutils, strutils

from scp import SCPClient

import six

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

from ironic import objects

PLATFORM = platform.system()

if PLATFORM != "SunOS":

    import tarfile

else:

    from pkg.fmri import IllegalFmri, PkgFmri

    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',

                         title='Options for the Solaris driver')

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."),

    'publishers': _("List of IPS publishers to install from, in the format "

                    "name@origin. Required if fmri property is set."),

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

                     "to an installed system. Optional."),

    'ipmi_port': _("remote IPMI RMCP port. Optional."),

    'ipmi_priv_level':

        _("privilege level; default is ADMINISTRATOR. "

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

    'ipmi_bridging': _("bridging_type; default is \"no\". One of \"single\", "

                       "\"dual\", \"no\". Optional."),

    'ipmi_transit_channel': _("transit channel for bridged request. Required "

                              "only if ipmi_bridging is set to \"dual\"."),

    'ipmi_transit_address': _("transit address for bridged request. Required "

                              "only if ipmi_bridging is set to \"dual\"."),

    'ipmi_target_channel': _("destination channel for bridged request. "

                             "Required only if ipmi_bridging is set to "

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

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

                             "Required only if ipmi_bridging is set "

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

    'ipmi_local_address': _("local IPMB address for bridged requests. "

                            "Used only if ipmi_bridging is set "

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

    'ipmi_protocol_version': _('the version of the IPMI protocol; default '

                               'is "2.0". One of "1.5", "2.0". Optional.'),

    'ipmi_force_boot_device': _("Whether Ironic should specify the boot "

                                "device to the BMC each time the server "

                                "is turned on, eg. because the BMC is not "

                                "capable of remembering the selected boot "

                                "device across power cycles; default value "

                                "is False. Optional.")

}

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:

        LOG.error(_LE("Cannot execute SSH cmd %(cmd)s. Reason: %(err)s.") %

                  {'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:

        raise exception.MissingParameterValue(_(

            "Missing the following IPMI credentials in node's"

            " driver_info: %s.") % missing_info)

    address = info.get('ipmi_address')

    username = info.get('ipmi_username')

    password = six.text_type(info.get('ipmi_password', ''))

    dest_port = info.get('ipmi_port')

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

    protocol_version = str(info.get('ipmi_protocol_version', '2.0'))

    force_boot_device = info.get('ipmi_force_boot_device', False)

    if not username:

        LOG.warning(_LW('ipmi_username is not defined or empty for node %s: '

                        'NULL user will be utilized.') % node.uuid)

    if not password:

        LOG.warning(_LW('ipmi_password is not defined or empty for node %s: '

                        'NULL password will be utilized.') % node.uuid)

    if protocol_version not in ipmitool.VALID_PROTO_VERSIONS:

        valid_versions = ', '.join(ipmitool.VALID_PROTO_VERSIONS)

        raise exception.InvalidParameterValue(_(

            "Invalid IPMI protocol version value %(version)s, the valid "

            "value can be one of %(valid_versions)s") %

            {'version': protocol_version, 'valid_versions': valid_versions})

    if port is not None:

        port = utils.validate_network_port(port, 'ipmi_terminal_port')

    if dest_port is not None:

        dest_port = utils.validate_network_port(dest_port, 'ipmi_port')

    # check if ipmi_bridging has proper value

    if bridging_type == 'no':

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

        (local_address, transit_channel, transit_address, target_channel,

         target_address) = (None,) * 5

    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,

        'dest_port': dest_port,

        '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,

        'target_address': target_address,

        'protocol_version': protocol_version,

        'force_boot_device': force_boot_device

    }

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

    ipmi_version = ('lanplus'

                    if driver_info['protocol_version'] == '2.0'

                    else 'lan')

            '-I',

            ipmi_version,

            '-H',

            driver_info['address'],

            '-L', driver_info['priv_level']

            ]

    if driver_info['dest_port']:

        args.append('-p')

        args.append(driver_info['dest_port'])

    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 - (

            time.time() - LAST_CMD_TIME.get(driver_info['address'], 0))

        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 x in six.text_type(e)]

                    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)

            propdict = {'cpu_arch': cpu_arch.split(":")[1].strip()}

            node_properties = node.properties

            node_properties.update(propdict)

            node.properties = node_properties

            node.save()

        except Exception as err:

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

                      (err)))

            raise exception.IPMIFailure(cmd=err)

        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.