upstream/oracle/userland-gate: comparison components/openstack/ironic/files/drivers/modules/solaris

equal deleted inserted replaced

-:a477397bba8b
+:c9748fcc32de
 # 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, 2015, Oracle and/or its affiliates. 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
 #
 #    under the License.
 """
 Solaris Driver and supporting meta-classes.
 """
+import errno
 import os
 import platform
 import re
 import select
 import shutil
 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_utils import excutils
 from scp import SCPClient
 from ironic.common import boot_devices, exception, images, keystone, states, \
 utils
-from ironic.common.i18n import _, _LW
+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.openstack.common import log as logging
-from ironic.openstack.common import loopingcall, processutils
+from ironic.openstack.common import loopingcall
 PLATFORM = platform.system()
 if PLATFORM != "SunOS":
 import tarfile
 else:
 from pkg.misc import valid_pub_prefix, valid_pub_url
 AI_OPTS = [
 cfg.StrOpt('server',
-default='None',
 help='Host name for AI Server.'),
 cfg.StrOpt('username',
-default='None',
 help='Username to ssh to AI Server.'),
 cfg.StrOpt('password',
-default='None',
+help='Password for user to ssh to AI Server. If ssh_key_file '
-help='Password for user to ssh to AI Server.'),
+'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='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',
-default='None',
 help='SSH Filename to use.'),
 cfg.StrOpt('ssh_key_contents',
-default='None',
 help='Actual SSH Key contents to use.')
 ]
 AUTH_OPTS = [
 cfg.StrOpt('auth_strategy',
 }
 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 = {}
 TIMING_SUPPORT = None
 SINGLE_BRIDGE_SUPPORT = None
 DUAL_BRIDGE_SUPPORT = None
 :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.debug(_("Cannot execute SSH cmd %(cmd)s. Reason: %(err)s.") %
 {'cmd': ssh_cmd, 'err': err})
 args = ['/usr/sbin/ipmitool',
 '-I',
 'lanplus',
 '-H',
 driver_info['address'],
-'-L', driver_info.get('priv_level')
+'-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'):
-num_tries = max(
-(CONF.ipmi.retry_timeout // CONF.ipmi.min_command_interval), 1)
 args.append('-R')
 args.append(str(num_tries))
 args.append('-N')
 args.append(str(CONF.ipmi.min_command_interval))
-# 'ipmitool' command will prompt password if there is no '-f' option,
+end_time = (time.time() + CONF.ipmi.retry_timeout)
-# we set it to '\0' to write a password file to support empty password
-with ipmitool._make_password_file(driver_info['password'] or '\0') \
+while True:
-as pw_file:
+num_tries = num_tries - 1
-args.append('-f')
-args.append(pw_file)
-args = args + list(command)  # Append as a list don't split(" ")
 # 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)
-try:
+# Resetting the list that will be utilized so the password arguments
-out, err = utils.execute(*args)
+# from any previous execution are preserved.
-finally:
+cmd_args = args[:]
-LAST_CMD_TIME[driver_info['address']] = time.time()
+# 'ipmitool' command will prompt password if there is no '-f'
-return out, err
+# 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 e.message]
+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")
-ipmi_cmd_args = ['sunoem', 'getval', '/System/Processors/architecture']
+cpu_arch = node.properties.get('cpu_arch', None)
-driver_info = _parse_driver_info(node)
+if cpu_arch is None:
-try:
+LOG.info(_LI("Inspection not performed, retrieving architecture via "
-out, _err = _exec_ipmitool(driver_info, ipmi_cmd_args)
+"IPMI for node: %s"), node.uuid)
-except Exception:
+ipmi_cmd_args = ['sunoem', 'getval', '/System/Processors/architecture']
-raise exception.IPMIFailure(cmd=ipmi_cmd_args)
+driver_info = _parse_driver_info(node)
+try:
-LOG.debug("SolarisDeploy._get_node_architecture: arch: '%s'" % (out))
+cpu_arch, _err = _exec_ipmitool(driver_info, ipmi_cmd_args)
+except Exception as err:
-if 'SPARC' in out:
+LOG.error(_LE("Failed to get node architecture from IPMI : %s" %
+(err)))
+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 out:
+elif 'x86' in cpu_arch:
 return 'x86'
 else:
-raise SolarisIPMIError(msg="Unknown node architecture: %s" % (out))
+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
 deploy_thread.stop()
 if deploy_thread.state in [states.DEPLOYING, states.DEPLOYWAIT]:
 # Update node with done/fail state
 if task.node:
 task.node.provision_state = states.DEPLOYFAIL
-task.node.last_error = "Failed to find node."
+task.node.last_error = "Failed to find node whilst " + \
+"transitioning to '%s' state." % \
+(task.node.target_provision_state)
 task.node.target_provision_state = states.NOSTATE
 task.node.save()
 raise loopingcall.LoopingCallDone()
 except Exception as err:
 LOG.info(_("During check_deploy_state, node %(node)s could "
-"not be retrieved: %(err)") %
+"not be retrieved: %(err)s") %
 {'node': node_uuid, 'err': err})
 # Thread should have stopped already, but lets make sure.
 deploy_thread.stop()
 if deploy_thread.state in [states.DEPLOYING, states.DEPLOYWAIT]:
 # Update node with done/fail state
 if task.node:
-task.node.last_error = "Failed to find node."
+task.node.last_error = "Failed to find node whilst " + \
+"transitioning to '%s' state." % \
+(task.node.target_provision_state)
 task.node.provision_state = states.DEPLOYFAIL
 task.node.target_provision_state = states.NOSTATE
 task.node.save()
 raise loopingcall.LoopingCallDone()
 LOG.debug("_check_deploy_state().cur_node.target_provision_state: %s" %
 (cur_node.target_provision_state))
+LOG.debug("_check_deploy_state().cur_node.provision_state: %s" %
+(cur_node.provision_state))
 if deploy_thread.state not in [states.DEPLOYING, states.DEPLOYWAIT]:
 LOG.debug("_check_deploy_state().done: %s" % (deploy_thread.state))
 # Node has completed deployment, success or failure
 LOG.debug("_check_deploy_state().deploying: %s" %
 (deploy_thread.state))
 cur_node.provision_state = states.DEPLOYING
 cur_node.save()
-elif cur_node.target_provision_state == states.NOSTATE:
+elif cur_node.target_provision_state == states.AVAILABLE or \
+cur_node.target_provision_state == states.NOSTATE:
 # Node was most likely deleted so end deployment completion checking
 LOG.debug("_check_deploy_state().deleted: %s" %
 (cur_node.target_provision_state))
+deploy_thread.stop()
+raise loopingcall.LoopingCallDone()
+elif cur_node.provision_state == states.DEPLOYFAIL:
+# Node deployment as for some reason failed already, exist thread
+LOG.debug("_check_deploy_state().deploy_failed: %s" %
+(cur_node.provision_state))
 deploy_thread.stop()
 raise loopingcall.LoopingCallDone()
 def _url_exists(url):
 # Check if reference count is zero if so remove
 # refcount file and image file
 if int(ref_count) <= 0:
 lock.release()
-os.remove(ref_filename)
+try:
-os.remove(image_path)
+os.remove(ref_filename)
+except OSError as err:
+if err.errno != errno.ENOENT:
+raise
+try:
+os.remove(image_path)
+except OSError as err:
+if err.errno != errno.ENOENT:
+raise
 else:
 fp.seek(0)
 fp.write(ref_count)
 if release:
 lock.release()
 cmd = ["/usr/bin/curl", "-sS", "-o", temp_uri, uri]
 pc = Popen(cmd, stdout=PIPE, stderr=PIPE)
 _stdout, err = pc.communicate()
 if pc.returncode != 0:
 err_msg = _("Failed to retrieve image: %s") % err
+_image_refcount_adjust(temp_uri, -1)
 raise SolarisIPMIError(msg=err_msg)
 # Release acquired lock now that file is retrieved
 lock.release()
 # as noted above Caller is responsible for its removal
 LOG.error(_("Unable to fetch image: uri %s: %s") % (uri, err))
 if url.scheme == "glance":
 _image_refcount_adjust(temp_uri, -1)
 else:
-os.remove(temp_uri)
+try:
+os.remove(temp_uri)
+except OSError as err:
+if err.errno != errno.ENOENT:
+raise
 raise
 return temp_uri
 raise SolarisIPMIError(msg=err_msg)
 return mount_dir, temp_uar
-def _umount_archive(mount_dir, temp_uar):
+def _umount_archive(mount_dir):
 """ Unmount archive and remove mount point directory
 :param mount_dir: Path to mounted archive
 :param temp_uar: Path to glance local uar to remove
 """
-LOG.debug("SolarisDeploy._umount_archive:mount_dir: '%s', temp_uar: %s" %
+LOG.debug("SolarisDeploy._umount_archive:mount_dir: '%s'" % (mount_dir))
-(mount_dir, temp_uar))
 cmd = ["/usr/sbin/umount", mount_dir]
 pc = Popen(cmd, stdout=PIPE, stderr=PIPE)
 _stdout, err = pc.communicate()
 if pc.returncode != 0:
 if PLATFORM == "SunOS":
 mount_dir, temp_uar = _mount_archive(task, archive_uri)
 try:
 _iso, uuid = _get_archive_iso_and_uuid(mount_dir)
 except:
-_umount_archive(mount_dir, temp_uar)
+_umount_archive(mount_dir)
 raise
-_umount_archive(mount_dir, temp_uar)
+_umount_archive(mount_dir)
 else:
 temp_uar = _fetch_uri(task, archive_uri)
 try:
 _iso, uuid = _get_archive_iso_and_uuid(temp_uar)
 except:
 LOG.debug("SolarisDeploy.validate()")
 LOG.debug(task.context.auth_token)
 # Validate IPMI credentials by getting node architecture
 try:
-_arch = _get_node_architecture(task.node)
+_cpu_arch = _get_node_architecture(task.node)
 except Exception as err:
 raise exception.InvalidParameterValue(_(err))
 if not driver_utils.get_node_mac_addresses(task):
 raise exception.InvalidParameterValue(
 _validate_ai_manifest(task)
 # Try to get the URL of the Ironic API
 try:
 CONF.conductor.api_url or keystone.get_service_url()
-except (exception.CatalogFailure,
+except (exception.KeystoneFailure,
-exception.CatalogNotFound,
+exception.KeystoneUnauthorized,
-exception.CatalogUnauthorized):
+exception.CatalogNotFound):
 raise exception.InvalidParameterValue(_(
 "Couldn't get the URL of the Ironic API service from the "
 "configuration file or Keystone catalog."))
 # Validate driver_info by parsing contents
 :param task: a TaskManager instance.
 :returns: deploy state DEPLOYWAIT.
 """
 LOG.debug("SolarisDeploy.deploy()")
-arch = _get_node_architecture(task.node)
+cpu_arch = _get_node_architecture(task.node)
 # Ensure persistence is false so net boot only occurs once
-if arch == 'x86':
+if cpu_arch == 'x86':
 # Set boot device to PXE network boot
 dev_cmd = 'pxe'
-elif arch == 'SPARC':
+elif cpu_arch == 'SPARC':
 # Set bootmode script to network DHCP
 dev_cmd = 'wanboot'
 else:
 raise exception.InvalidParameterValue(
-_("Invalid node architecture of '%s'.") % (arch))
+_("Invalid node architecture of '%s'.") % (cpu_arch))
 manager_utils.node_set_boot_device(task, dev_cmd,
 persistent=False)
 manager_utils.node_power_action(task, states.REBOOT)
 """
 LOG.debug("SolarisDeploy.prepare()")
 ai_manifest = task.node.driver_info.get('ai_manifest', None)
 ai_service = task.node.driver_info.get('ai_service', None)
-arch = _get_node_architecture(task.node)
+cpu_arch = _get_node_architecture(task.node)
 archive_uri = task.node.driver_info.get('archive_uri', None)
 fmri = task.node.driver_info.get('fmri', None)
 install_profiles = task.node.driver_info.get('install_profiles', None)
 publishers = task.node.driver_info.get('publishers', None)
 sc_profiles = task.node.driver_info.get('sc_profiles', None)
 elif ai_service:
 # Instantiate AIService object for this node/service
 aiservice = AIService(task, ai_service)
 else:
 # IPS Install, ensure default architecture service exists
-if arch == "x86":
+if cpu_arch == "x86":
 ai_service = "default-i386"
-elif arch == 'SPARC':
+elif cpu_arch == 'SPARC':
 ai_service = "default-sparc"
 else:
 raise exception.InvalidParameterValue(
-_("Invalid node architecture of '%s'.") % (arch))
+_("Invalid node architecture of '%s'.") % (cpu_arch))
 # Instantiate AIService object for this node/service
 aiservice = AIService(task, ai_service)
 # Check if AI Service exists, raise exception of not
 # Client exists remove it
 aiservice.delete_client(mac)
 # Recreate new ai client for this mac address
 new_uri, auth_token = _format_archive_uri(task, archive_uri)
-aiservice.create_client(mac, arch, new_uri, auth_token,
+aiservice.create_client(mac, cpu_arch, new_uri, auth_token,
 publishers, fmri)
 # 3. (Re)Create AI Manifest for each port/Mac specified for this
 #    Node. Manifest name will be MAC address stripped of colons
 manifest_name = mac.replace(':', '')
 :param task: a TaskManager instance.
 """
 LOG.debug("SolarisDeploy.clean_up()")
 ai_service = task.node.driver_info.get('ai_service', None)
-arch = _get_node_architecture(task.node)
+cpu_arch = _get_node_architecture(task.node)
 archive_uri = task.node.driver_info.get('archive_uri', None)
 # Instantiate AIService object for this node/service
 if archive_uri:
 aiservice = AIService(task, _get_archive_uuid(task))
 elif ai_service:
 aiservice = AIService(task, ai_service)
 else:
-if arch == "x86":
+if cpu_arch == "x86":
 ai_service = "default-i386"
-elif arch == 'SPARC':
+elif cpu_arch == 'SPARC':
 ai_service = "default-sparc"
 else:
 raise exception.InvalidParameterValue(
-_("Invalid node architecture of '%s'.") % (arch))
+_("Invalid node architecture of '%s'.") % (cpu_arch))
 aiservice = AIService(task, ai_service)
 # Check if AI Service exists, log message if already removed
 if not aiservice.exists:
 # There is nothing to clean up as service removed
 if task is None:
 return [boot_devices.PXE, boot_devices.DISK, boot_devices.CDROM,
 boot_devices.BIOS, boot_devices.SAFE]
 else:
 # Get architecture of node and return supported boot devices
-arch = _get_node_architecture(task.node)
+cpu_arch = _get_node_architecture(task.node)
-if arch == 'x86':
+if cpu_arch == 'x86':
 return [boot_devices.PXE, boot_devices.DISK,
 boot_devices.CDROM, boot_devices.BIOS,
 boot_devices.SAFE]
-elif arch == 'SPARC':
+elif cpu_arch == 'SPARC':
 return [boot_devices.DISK, 'wanboot']
 else:
 raise exception.InvalidParameterValue(
-_("Invalid node architecture of '%s'.") % (arch))
+_("Invalid node architecture of '%s'.") % (cpu_arch))
 @task_manager.require_exclusive_lock
 def set_boot_device(self, task, device, persistent=False):
 """Set the boot device for the task's node.
 :raises: IPMIFailure on an error from ipmitool.
 """
 LOG.debug("SolarisManagement.set_boot_device: %s" % device)
-arch = _get_node_architecture(task.node)
+cpu_arch = _get_node_architecture(task.node)
 archive_uri = task.node.driver_info.get('archive_uri')
 publishers = task.node.driver_info.get('publishers')
 fmri = task.node.driver_info.get('fmri')
-if arch == 'x86':
+if cpu_arch == 'x86':
 if device not in self.get_supported_boot_devices(task=task):
 raise exception.InvalidParameterValue(_(
 "Invalid boot device %s specified.") % device)
 cmd = ["chassis", "bootdev", device]
 if persistent:
-cmd = cmd + " options=persistent"
+cmd.append("options=persistent")
-elif arch == 'SPARC':
+elif cpu_arch == 'SPARC':
 # Set bootmode script to network DHCP or disk
 if device == 'wanboot':
 boot_cmd = 'set /HOST/bootmode script="'
 script_str = 'boot net:dhcp - install'
 if archive_uri:
 raise exception.InvalidParameterValue(_(
 "SPARC firmware bootmode script length exceeds 255:"
 " %s") % script_str)
 boot_cmd += script_str + '"'
 cmd = ['sunoem', 'cli', boot_cmd]
-elif device == 'disk':
+elif device == boot_devices.DISK:
 cmd = ['sunoem', 'cli',
 'set /HOST/bootmode script=""']
 else:
 raise exception.InvalidParameterValue(_(
 "Invalid boot device %s specified.") % (device))
 else:
 raise exception.InvalidParameterValue(
-_("Invalid node architecture of '%s'.") % (arch))
+_("Invalid node architecture of '%s'.") % (cpu_arch))
 driver_info = _parse_driver_info(task.node)
 try:
 _out, _err = _exec_ipmitool(driver_info, cmd)
 except (exception.PasswordFileFailedToCreate,
 :persistent: Whether the boot device will persist to all
 future boots or not, None if it is unknown.
 """
 LOG.debug("SolarisManagement.get_boot_device")
-arch = _get_node_architecture(task.node)
+cpu_arch = _get_node_architecture(task.node)
 driver_info = _parse_driver_info(task.node)
 response = {'boot_device': None, 'persistent': None}
-if arch == 'x86':
+if cpu_arch == 'x86':
 cmd = ["chassis", "bootparam", "get", "5"]
-elif arch == 'SPARC':
+elif cpu_arch == 'SPARC':
 cmd = ['sunoem', 'getval', '/HOST/bootmode/script']
 else:
 raise exception.InvalidParameterValue(
-_("Invalid node architecture of '%s'.") % (arch))
+_("Invalid node architecture of '%s'.") % (cpu_arch))
 try:
 out, _err = _exec_ipmitool(driver_info, cmd)
 except (exception.PasswordFileFailedToCreate,
 processutils.ProcessExecutionError) as err:
 'Error: %(error)s'),
 {'node': driver_info['uuid'],
 'cmd': cmd, 'error': err})
 raise exception.IPMIFailure(cmd=cmd)
-if arch == 'x86':
+if cpu_arch == 'x86':
 re_obj = re.search('Boot Device Selector : (.+)?\n', out)
 if re_obj:
 boot_selector = re_obj.groups('')[0]
 if 'PXE' in boot_selector:
 response['boot_device'] = boot_devices.PXE
 response['boot_device'] = boot_devices.BIOS
 elif 'CD/DVD' in boot_selector:
 response['boot_device'] = boot_devices.CDROM
 response['persistent'] = 'Options apply to all future boots' in out
-elif arch == 'SPARC':
+elif cpu_arch == 'SPARC':
 if "net:dhcp" in out:
 response['boot_device'] = 'wanboot'
 else:
-response['boot_device'] = 'disk'
+response['boot_device'] = boot_devices.DISK
 LOG.debug(response)
 return response
 def get_sensors_data(self, task):
 """Get sensors data.
 """
 driver_info = _parse_driver_info(task.node)
 # with '-v' option, we can get the entire sensor data including the
 # extended sensor informations
-cmd = "-v sdr"
+cmd = ['sdr', '-v']
 try:
 out, _err = _exec_ipmitool(driver_info, cmd)
 except (exception.PasswordFileFailedToCreate,
 processutils.ProcessExecutionError) as err:
 raise exception.FailedToGetSensorData(node=task.node.uuid,
 error=err)
 return ipmitool._parse_ipmi_sensors_data(task.node, out)
+class SolarisInspect(base.InspectInterface):
+"""Inspect class for solaris nodes."""
+def get_properties(self):
+"""Return Solaris driver properties"""
+return COMMON_PROPERTIES
+def validate(self, task):
+"""Validate driver_info containts IPMI credentials.
+Ensure 'driver_info' containers the required IPMI
+properties used to access a nodes properties.
+:param task: a TaskManager instance
+:raises: InvalidParameterValue if required IPMI parameters
+are missing.
+:raises: MissingParameterValue if a required parameter is missing.
+"""
+_parse_driver_info(task.node)
+def inspect_hardware(self, task):
+"""Inspect hardware to get the hardware properties.
+Inspects hardware to get the defined IPMI_PROPERTIES.
+Failure occures if any of the defined IPMI_PROPERTIES are not
+determinable from the node.
+:param task: a TaskManager instance
+:raises: HardwareInspectionFailure if properties could
+not be retrieved successfully.
+:returns: the resulting state of inspection.
+"""
+LOG.debug("SolarisInspect.inspect_hardware")
+ipmi_props = self._get_ipmi_properties(task)
+keys, _none = zip(*IPMI_PROPERTIES)
+vallist = [line.split(': ')[1]
+for line in ipmi_props.strip().splitlines()]
+propdict = dict(zip(keys, vallist))
+# Installed memory size is returned in GB, Nova assumes this is MB
+# so convert if returned in GB
+memsize, memtype = propdict['memory_mb'].split(' ')
+if memtype == 'GB':
+propdict['memory_mb'] = int(memsize) * 1024
+else:
+propdict['memory_mb'] = int(memsize)
+cpu_props = self._get_cpu_cores(task, propdict['cpus'])
+vallist = [line.split(': ')[1]
+for line in cpu_props.strip().splitlines()]
+total_cores = sum(map(int, vallist))
+propdict['cores'] = total_cores
+node_properties = task.node.properties
+node_properties.update(propdict)
+task.node.properties = node_properties
+task.node.save()
+self._create_port_if_not_exist(task.node, node_properties['mac'])
+LOG.info(_LI("Node %s inspected."), task.node.uuid)
+return states.MANAGEABLE
+def _get_ipmi_properties(self, task):
+"""Retrieve IPMI_PROPERTIES from node
+:param task: a TaskManager instance.
+:returns: ipmitool retrieved property values
+"""
+fh = tempfile.NamedTemporaryFile()
+for _none, prop in IPMI_PROPERTIES:
+fh.write('sunoem getval %s\n' % prop)
+fh.seek(0)
+cmd = ["exec", fh.name]
+driver_info = _parse_driver_info(task.node)
+try:
+out, _err = _exec_ipmitool(driver_info, cmd)
+except (exception.PasswordFileFailedToCreate,
+processutils.ProcessExecutionError) as err:
+LOG.warning(_LW('IPMI inspect properties failed for node %(node)s '
+'when executing "ipmitool %(cmd)s". '
+'Error: %(error)s'),
+{'node': task.node.uuid,
+'cmd': cmd, 'error': err})
+raise exception.IPMIFailure(cmd=cmd)
+fh.close()
+return out
+def _get_cpu_cores(self, task, cpus):
+"""Retrieve IPMI_PROPERTIES from node
+:param task: a TaskManager instance.
+:param cpus: CPU numbers to use.
+:returns: ipmitool retrieved property values
+"""
+fh = tempfile.NamedTemporaryFile()
+for i in range(int(cpus)):
+fh.write('sunoem getval %s\n' % (CPU_LOCATION % i))
+fh.seek(0)
+cmd = ["exec", fh.name]
+driver_info = _parse_driver_info(task.node)
+try:
+out, _err = _exec_ipmitool(driver_info, cmd)
+except (exception.PasswordFileFailedToCreate,
+processutils.ProcessExecutionError) as err:
+LOG.warning(_LW('IPMI CPU inspection failed for node %(node)s '
+'when executing "ipmitool %(cmd)s". '
+'Error: %(error)s'),
+{'node': task.node.uuid,
+'cmd': cmd, 'error': err})
+raise exception.IPMIFailure(cmd=cmd)
+fh.close()
+return out
+def _create_port_if_not_exist(self, node, mac):
+"""Create ironic port if not existing for this MAC
+:param task: Node to creaate port for.
+:param mac: MAC address to use for port.
+"""
+node_id = node.id
+port_dict = {'address': mac, 'node_id': node_id}
+mydbapi = dbapi.get_instance()
+try:
+mydbapi.create_port(port_dict)
+LOG.info(_LI("Port created for MAC address %(mac)s for node "
+"%(node)s."), {'mac': mac, 'node': node.uuid})
+except exception.MACAlreadyExists:
+LOG.warn(_LW("Port already exists for MAC address %(mac)s "
+"for node %(node)s."),
+{'mac': mac, 'node': node.uuid})
 class AIService():
 """AI Service"""
 remote_iso = os.path.join("/tmp", uuid) + ".iso"
 try:
 self.copy_remote_file(iso, remote_iso)
 except:
 if PLATFORM == "SunOS":
-_umount_archive(mount_dir, temp_uar)
+_umount_archive(mount_dir)
 if urlparse(archive_uri).scheme == "glance":
 _image_refcount_adjust(temp_uar, -1)
 else:
 shutil.rmtree(os.path.dirname(iso))
 _image_refcount_adjust(temp_uar, -1)
 self._profiles = []
 except Exception as _err:
 self.delete_remote_file(remote_iso)
 if PLATFORM == "SunOS":
-_umount_archive(mount_dir, temp_uar)
+_umount_archive(mount_dir)
 else:
 _image_refcount_adjust(temp_uar, -1)
 raise AICreateServiceFail(
 _("Failed to create AI Service %s") % (uuid))
 # 4. Remove copy of AI ISO on AI Server
 self.delete_remote_file(remote_iso)
 if PLATFORM == "SunOS":
 # 5. Unmount UAR
-_umount_archive(mount_dir, temp_uar)
+_umount_archive(mount_dir)
 # 6. Decrement reference count for image
 if temp_uar is not None:
 _image_refcount_adjust(temp_uar, -1)
 _stdout, _rc = _ssh_execute(self.ssh_obj, ai_cmd)
 except Exception as _err:
 raise AIDeleteServiceFail(
 _("Failed to delete AI Service %s") % (self.name))
-def create_client(self, mac, arch, archive_uri, auth_token,
+def create_client(self, mac, cpu_arch, archive_uri, auth_token,
 publishers, fmri):
 """Create a client associated with this service
 :param mac: MAC Address of client to create
-:param arch: Machine architecture for this node
+:param cpu_arch: Machine architecture for this node
 :param archive_uri: URI of archive to install node from
 :param auth_token: Authorization token for glance UAR retrieval
 :param publishers: IPS publishers list in name@origin format
 :param fmri: IPS package FMRIs to install
 :returns: Nothing exception raised if deletion fails
 LOG.debug("AIService.create_client():mac: %s" % (mac))
 ai_cmd = "/usr/bin/pfexec /usr/sbin/installadm create-client -e " + \
 mac + " -n " + self.name
 # Add specific boot arguments for 'x86' clients only
-if arch == 'x86':
+if cpu_arch == 'x86':
 ai_cmd += " -b install=true,console=ttya"
 if archive_uri:
 ai_cmd += ",archive_uri=%s" % (archive_uri)
 _stdout, _rc = _ssh_execute(self.ssh_obj, ai_cmd)
 except Exception as _err:
 raise AICreateClientFail(_("Failed to create AI Client %s") %
 (mac))
-# If arch x86 customize grub reducing grub menu timeout to 0
+# If cpu_arch x86 customize grub reducing grub menu timeout to 0
-if arch == 'x86':
+if cpu_arch == 'x86':
 custom_grub = "/tmp/%s.grub" % (mac)
 ai_cmd = "/usr/bin/pfexec /usr/sbin/installadm export -e " + \
 mac + " -G | /usr/bin/sed -e 's/timeout=30/timeout=0/'" + \
 " > %s" % (custom_grub)
 try:
 """Generate SSH Dictionary for SSH Connection via paramiko
 :returns: dictionary for paramiko connection
 """
 LOG.debug("AIService._get_ssh_dict()")
-if not CONF.ai.server or not CONF.ai.username:
+if not CONF.ai.server or CONF.ai.server == "None" or \
+not CONF.ai.username or CONF.ai.username == "None":
 raise exception.InvalidParameterValue(_(
 "SSH server and username must be set."))
 ssh_dict = {
 'host': CONF.ai.server,
 lines = list_out.splitlines()
 # Get index into string for client/manifest/profile names
 # client/manifest/profile names are all in 2nd column of output
 if len(lines) > 1:
-col_start = lines[1].index(" --")
+col_start = lines[1].index(" --") + 1
+col_end = lines[1][col_start:].index(" --") + 1 + col_start
 for line in range(2, len(lines)):
-names.append(lines[line][col_start:].split()[0])
+if lines[line][col_start:col_end].strip():
+names.append(lines[line][col_start:col_end].strip())
 LOG.debug("AIService._parse_names():names: %s" % (names))
 return names

branch	s11u3-sru
changeset 6035	c9748fcc32de
parent 4508	d8924d870370