def get_power_state(self, task): """Gets the current power state. :param task: a TaskManager instance. :returns: one of :mod:`ironic.common.states` POWER_OFF, POWER_ON or ERROR. :raises: OneViewError if fails to retrieve power state of OneView resource """ oneview_client = common.get_hponeview_client() server_hardware = task.node.driver_info.get('server_hardware_uri') try: server_hardware = oneview_client.server_hardware.get( server_hardware) except client_exception.HPOneViewException as exc: LOG.error( "Error getting power state for node %(node)s. Error:" "%(error)s", { 'node': task.node.uuid, 'error': exc }) raise exception.OneViewError(error=exc) else: power_state = server_hardware.get('powerState') return GET_POWER_STATE_MAP.get(power_state)
def set_onetime_boot(task): """Set onetime boot to server hardware. Change the onetime boot option of an OneView server hardware. :param task: a task from TaskManager. """ driver_internal_info = task.node.driver_internal_info next_boot_device = driver_internal_info.get('next_boot_device') if next_boot_device: boot_device = next_boot_device.get('boot_device') persistent = next_boot_device.get('persistent') if not persistent: client = common.get_hponeview_client() server_hardware = task.node.driver_info.get('server_hardware_uri') ilo_client = common.get_ilorest_client(client, server_hardware) boot_device = BOOT_DEVICE_MAP_ILO.get(boot_device) body = { "Boot": { "BootSourceOverrideTarget": boot_device, "BootSourceOverrideEnabled": "Once" } } ilo_client.patch(path=ILO_SYSTEM_PATH, body=body, headers=ILO_REQUEST_HEADERS)
def set_boot_device(task): """Sets the boot device for a node. Sets the boot device to use on next reboot of the node. :param task: a task from TaskManager. :raises: InvalidParameterValue if an invalid boot device is specified. :raises: OneViewError if the communication with OneView fails """ oneview_client = common.get_hponeview_client() common.ensure_server_profile(task) driver_internal_info = task.node.driver_internal_info next_boot_device = driver_internal_info.get('next_boot_device') if next_boot_device: boot_device = next_boot_device.get('boot_device') persistent = next_boot_device.get('persistent') if boot_device not in sorted(BOOT_DEVICE_MAP_ONEVIEW): raise exception.InvalidParameterValue( _("Invalid boot device %s specified.") % boot_device) LOG.debug( "Setting boot device to %(boot_device)s and " "persistent to %(persistent)s for node %(node)s", { "boot_device": boot_device, "persistent": persistent, "node": task.node.uuid }) profile = task.node.driver_info.get('applied_server_profile_uri') boot_device = BOOT_DEVICE_MAP_ONEVIEW.get(boot_device) try: server_profile = oneview_client.server_profiles.get(profile) boot = server_profile.get('boot', {}) order = boot.get('order', []) if boot_device in order: order.remove(boot_device) order.insert(0, boot_device) boot['order'] = order server_profile['boot'] = boot oneview_client.server_profiles.update(server_profile, profile) set_onetime_boot(task) driver_internal_info.pop('next_boot_device', None) task.node.driver_internal_info = driver_internal_info task.node.save() except client_exception.HPOneViewException as oneview_exc: msg = (_("Error setting boot device on OneView. Error: %s") % oneview_exc) raise exception.OneViewError(error=msg) else: LOG.debug( "Not going to set boot device because there is no " "'next_boot_device' on driver_internal_info " "for the %(node)s", {"node": task.node.uuid})
def get_boot_device(self, task): """Get the current boot device from the node. Gets the boot device from the node 'next_boot_device on driver_internal_info namespace if exists. Gets through a request to OneView otherwise. :param task: a task from TaskManager. :returns: a dictionary containing: :boot_device: the boot device, one of :mod:`ironic.common.boot_devices` [PXE, DISK, CDROM] :persistent: Whether the boot device will persist to all future boots or not, None if it is unknown. :raises: InvalidParameterValue if the boot device is unknown :raises: OneViewError if the communication with OneView fails """ oneview_client = common.get_hponeview_client() driver_internal_info = task.node.driver_internal_info next_boot_device = driver_internal_info.get('next_boot_device') if next_boot_device: return next_boot_device driver_info = task.node.driver_info server_profile = driver_info.get('applied_server_profile_uri') try: profile = oneview_client.server_profiles.get(server_profile) primary_device = None boot = profile.get('boot', {}) boot_order = boot.get('order', []) if boot_order: primary_device = boot_order[0] except client_exception.HPOneViewException as exc: msg = _("Error on node: %(node)s while getting Server Profile: " "%(profile)s of the from OneView. Error: %(error)s.") % { 'profile': server_profile, 'node': task.node.uuid, 'error': exc } raise exception.OneViewError(msg) if primary_device not in BOOT_DEVICE_MAP_ONEVIEW_REV: raise exception.InvalidParameterValue( _("Unsupported boot device %(device)s for node: %(node)s") % { "device": primary_device, "node": task.node.uuid }) boot_device = { 'boot_device': BOOT_DEVICE_MAP_ONEVIEW_REV.get(primary_device), 'persistent': not _is_onetime_boot(task) } return boot_device
def set_power_state(self, task, power_state, timeout=None): """Set the power state of the task's node. :param task: a TaskManager instance. :param power_state: The desired power state POWER_ON, POWER_OFF or REBOOT from :mod:`ironic.common.states`. :param timeout: timeout (in seconds) positive integer (> 0) for any power state. ``None`` indicates to use default timeout. :raises: InvalidParameterValue if an invalid power state was specified. :raises: PowerStateFailure if the power couldn't be set to power_state. :raises: OneViewError if OneView fails setting the power state. """ client = common.get_hponeview_client() if deploy_utils.is_node_in_use_by_oneview(task.node): raise exception.PowerStateFailure(_( "Cannot set power state '%(power_state)s' to node %(node)s. " "The node is in use by OneView.") % {'power_state': power_state, 'node': task.node.uuid}) if power_state not in SET_POWER_STATE_MAP: raise exception.InvalidParameterValue( _("set_power_state called with invalid power state %s.") % power_state) LOG.debug('Setting power state of node %(node_uuid)s to ' '%(power_state)s', {'node_uuid': task.node.uuid, 'power_state': power_state}) server_hardware = task.node.driver_info.get('server_hardware_uri') timeout = (-1 if timeout is None else timeout) try: if power_state == states.POWER_ON: management.set_boot_device(task) client.server_hardware.update_power_state( SET_POWER_STATE_MAP.get(power_state), server_hardware, timeout=timeout) elif power_state == states.REBOOT: client.server_hardware.update_power_state( SET_POWER_STATE_MAP.get(states.POWER_OFF), server_hardware, timeout=timeout) management.set_boot_device(task) client.server_hardware.update_power_state( SET_POWER_STATE_MAP.get(states.POWER_ON), server_hardware, timeout=timeout) else: client.server_hardware.update_power_state( SET_POWER_STATE_MAP.get(power_state), server_hardware, timeout=timeout) except client_exception.HPOneViewException as exc: raise exception.OneViewError( _("Error setting power state: %s") % exc)
def _is_onetime_boot(task): """Check onetime boot from server hardware. Check if the onetime boot option of an OneView server hardware is set to 'Once' in iLO. :param task: a task from TaskManager. :returns: Boolean value. True if onetime boot is 'Once' False otherwise. """ client = common.get_hponeview_client() server_hardware = task.node.driver_info.get('server_hardware_uri') ilo_client = common.get_ilorest_client(client, server_hardware) response = ilo_client.get(path=ILO_SYSTEM_PATH, headers=ILO_REQUEST_HEADERS) boot = response.dict.get('Boot') onetime_boot = boot.get('BootSourceOverrideEnabled') return onetime_boot == 'Once'
def deallocate_server_hardware_from_ironic(task): """Deallocate Server Hardware from ironic. :param task: a TaskManager object :raises OneViewError: if an error occurs while deallocating the Server Hardware to ironic """ node = task.node oneview_client = common.get_hponeview_client() if is_node_in_use_by_ironic(node): oneview_info = common.get_oneview_info(node) server_profile_uri = oneview_info.get('applied_server_profile_uri') try: task.driver.power.set_power_state(task, states.POWER_OFF) oneview_client.server_profiles.delete(server_profile_uri) _del_applied_server_profile_uri_field(node) LOG.info( "Server Profile %(server_profile_uri)s was deleted " "from node %(node_uuid)s in OneView.", { 'server_profile_uri': server_profile_uri, 'node_uuid': node.uuid }) except client_exception.HPOneViewException as e: msg = (_("Error while deleting applied Server Profile from node " "%(node_uuid)s. Error: %(error)s") % { 'node_uuid': node.uuid, 'error': e }) raise exception.OneViewError(error=msg) else: LOG.warning( "Cannot deallocate node %(node_uuid)s " "in OneView because it is not in use by " "ironic.", {'node_uuid': node.uuid})
def is_node_in_use_by_ironic(node): """Check if node is in use by ironic in OneView. :param node: an ironic node object. :returns: Boolean value. True if node is in use by ironic, False otherwise. :raises OneViewError: if not possible to get OneView's information for the given node, if not possible to retrieve Server Hardware from OneView. """ oneview_client = common.get_hponeview_client() positive = _("Node '%s' is in use by Ironic.") % node.uuid negative = _("Node '%s' is not in use by Ironic.") % node.uuid def predicate(server_hardware, applied_sp_uri): # Check if Profile exists in Oneview and it is equals of the one # applied by ironic return _is_node_in_use(server_hardware, applied_sp_uri, by_oneview=False) return _check_applied_server_profile(oneview_client, node, predicate, positive, negative)
def __init__(self): super(OneViewAgentDeploy, self).__init__() self.client = common.get_hponeview_client() self.oneview_client = common.get_oneview_client()
def test_get_hponeview_client(self, mock_hponeview_client): common.get_hponeview_client() mock_hponeview_client.assert_called_once_with(self.config)
def __init__(self): super(OneViewPower, self).__init__() self.client = common.get_hponeview_client() self.oneview_client = common.get_oneview_client()
def allocate_server_hardware_to_ironic(node, server_profile_name): """Allocate Server Hardware to ironic. :param node: an ironic node object. :param server_profile_name: a formatted string with the Server Profile name. :raises OneViewError: if an error occurs while allocating the Server Hardware to ironic or the node is already in use by OneView. """ oneview_client = common.get_hponeview_client() node_in_use_by_oneview = is_node_in_use_by_oneview(node) if not node_in_use_by_oneview: oneview_info = common.get_oneview_info(node) applied_sp_uri = node.driver_info.get('applied_server_profile_uri') sh_uri = oneview_info.get("server_hardware_uri") spt_uri = oneview_info.get("server_profile_template_uri") server_hardware = oneview_client.server_hardware.get(sh_uri) if not server_hardware: msg = _("An error occurred during allocating server hardware to " "ironic. Server hardware: %s not found.") % sh_uri raise exception.OneViewError(error=msg) # Don't have Server Profile on OneView but has # `applied_server_profile_uri` on driver_info if not server_hardware.get('serverProfileUri') and applied_sp_uri: _del_applied_server_profile_uri_field(node) LOG.info( "Inconsistent 'applied_server_profile_uri' parameter " "value in driver_info. There is no Server Profile " "applied to node %(node_uuid)s. Value deleted.", {"node_uuid": node.uuid}) # applied_server_profile_uri exists and is equal to Server profile # applied on Hardware. Do not apply again. if (applied_sp_uri and server_hardware.get('serverProfileUri') == applied_sp_uri): LOG.info( "The Server Profile %(applied_sp_uri)s was already applied " "by ironic on node %(node_uuid)s. Reusing.", { "node_uuid": node.uuid, "applied_sp_uri": applied_sp_uri }) return try: applied_profile = _create_profile_from_template( oneview_client, server_profile_name, sh_uri, spt_uri) _add_applied_server_profile_uri_field(node, applied_profile) LOG.info( "Server Profile %(server_profile_uuid)s was successfully" " applied to node %(node_uuid)s.", { "node_uuid": node.uuid, "server_profile_uuid": applied_profile.get('uri') }) except client_exception.HPOneViewInvalidResource as e: LOG.error( "An error occurred during allocating server " "hardware to ironic during prepare: %s", e) raise exception.OneViewError(error=e) else: msg = _("Node %s is already in use by OneView.") % node.uuid raise exception.OneViewError(error=msg)