# Copyright 2018 DMTF. 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.
from oslo_log import log
import sushy
from ironic.common import exception
from ironic.common.i18n import _
from ironic.common import metrics_utils
from ironic.common import states
from ironic.conductor import periodics
from ironic.conductor import utils as manager_utils
from ironic.conf import CONF
from ironic.drivers import base
from ironic.drivers.modules import deploy_utils
from ironic.drivers.modules.redfish import utils as redfish_utils
from ironic import objects
LOG = log.getLogger(__name__)
METRICS = metrics_utils.get_metrics_logger(__name__)
registry_fields = ('attribute_type', 'allowable_values', 'lower_bound',
'max_length', 'min_length', 'read_only',
'reset_required', 'unique', 'upper_bound')
BIOS_REBOOT_STATES = {
sushy.BootProgressStates.OS_BOOT_STARTED,
sushy.BootProgressStates.OS_RUNNING,
}
_DII_STATE = 'redfish_bios_state'
_REBOOT_REQUESTED = 'reboot_requested'
_REQUESTED_BIOS_ATTRS = 'requested_bios_attrs'
[docs]
class RedfishBIOS(base.BIOSInterface):
_APPLY_CONFIGURATION_ARGSINFO = {
'settings': {
'description': (
'A list of BIOS settings to be applied'
),
'required': True
}
}
def _parse_allowable_values(self, node, allowable_values):
"""Convert the BIOS registry allowable_value list to expected strings
:param allowable_values: list of dicts of valid values for enumeration
:returns: list containing only allowable value names
"""
# Get name from ValueName if it exists, otherwise use ValueDisplayName
new_list = []
for dic in allowable_values:
key = dic.get('ValueName') or dic.get('ValueDisplayName')
if key:
new_list.append(key)
else:
LOG.warning('Cannot detect the value name for enumeration '
'item %(item)s for node %(node)s',
{'item': dic, 'node': node.uuid})
return new_list
[docs]
def cache_bios_settings(self, task):
"""Store or update the current BIOS settings for the node.
Get the current BIOS settings and store them in the bios_settings
database table.
:param task: a TaskManager instance containing the node to act on.
:raises: RedfishConnectionError when it fails to connect to Redfish
:raises: RedfishError on an error from the Sushy library
:raises: UnsupportedDriverExtension if the system does not support BIOS
settings
"""
node_id = task.node.id
system = redfish_utils.get_system(task.node)
try:
attributes = system.bios.attributes
except sushy.exceptions.MissingAttributeError:
error_msg = _('Cannot fetch BIOS attributes for node %s, '
'BIOS settings are not supported.') % task.node.uuid
LOG.error(error_msg)
raise exception.UnsupportedDriverExtension(error_msg)
settings = []
# Convert Redfish BIOS attributes to Ironic BIOS settings
if attributes:
settings = [{'name': k, 'value': v}
for k, v in attributes.items()]
# Get the BIOS Registry
registry_attributes = []
try:
bios_registry = system.bios.get_attribute_registry()
if bios_registry:
registry_attributes = bios_registry.registry_entries.attributes
except Exception as e:
LOG.info('Cannot get BIOS Registry attributes for node %(node)s, '
'Error %(exc)s.', {'node': task.node.uuid, 'exc': e})
# TODO(bfournier): use a common list for registry field names
# e.g. registry_fields = objects.BIOSSetting.registry_fields
# The BIOS registry will contain more entries than the BIOS settings
# Find the registry entry matching the setting name and get the fields
if registry_attributes:
for setting in settings:
reg = next((r for r in registry_attributes
if r.name == setting['name']), None)
fields = [attr for attr in dir(reg)
if not attr.startswith("_")]
settable_keys = [f for f in fields if f in registry_fields]
# Set registry fields to current values
for k in settable_keys:
setting[k] = getattr(reg, k, None)
if k == "allowable_values" and isinstance(setting[k],
list):
setting[k] = self._parse_allowable_values(
task.node, setting[k])
LOG.debug('Cache BIOS settings for node %(node_uuid)s',
{'node_uuid': task.node.uuid})
create_list, update_list, delete_list, nochange_list = (
objects.BIOSSettingList.sync_node_setting(
task.context, node_id, settings))
if create_list:
objects.BIOSSettingList.create(
task.context, node_id, create_list)
if update_list:
objects.BIOSSettingList.save(
task.context, node_id, update_list)
if delete_list:
delete_names = [d['name'] for d in delete_list]
objects.BIOSSettingList.delete(
task.context, node_id, delete_names)
[docs]
@base.service_step(priority=0, requires_ramdisk=False)
@base.clean_step(priority=0, requires_ramdisk=False)
@base.deploy_step(priority=0)
@base.cache_bios_settings
def factory_reset(self, task):
"""Reset the BIOS settings of the node to the factory default.
:param task: a TaskManager instance containing the node to act on.
:raises: RedfishConnectionError when it fails to connect to Redfish
:raises: RedfishError on an error from the Sushy library
"""
system = redfish_utils.get_system(task.node)
try:
bios = system.bios
except sushy.exceptions.MissingAttributeError:
error_msg = (_('Redfish BIOS factory reset failed for node '
'%s, because BIOS settings are not supported.') %
task.node.uuid)
LOG.error(error_msg)
raise exception.RedfishError(error=error_msg)
node = task.node
info = node.driver_internal_info
bios_state = info.get(_DII_STATE) or {}
reboot_requested = bios_state.get(_REBOOT_REQUESTED, False)
if not reboot_requested:
LOG.debug('Factory reset BIOS configuration for node %(node)s',
{'node': node.uuid})
try:
bios.reset_bios()
except sushy.exceptions.SushyError as e:
error_msg = (_('Redfish BIOS factory reset failed for node '
'%(node)s. Error: %(error)s') %
{'node': node.uuid, 'error': e})
LOG.error(error_msg)
raise exception.RedfishError(error=error_msg)
self._set_reboot_requested(
task,
attributes=None)
return self.post_reset(task)
else:
current_attrs = bios.attributes
LOG.debug('Post factory reset, BIOS configuration for node '
'%(node_uuid)s: %(attrs)r',
{'node_uuid': node.uuid, 'attrs': current_attrs})
self._clear_reboot_requested(task)
[docs]
@base.service_step(priority=0, argsinfo=_APPLY_CONFIGURATION_ARGSINFO,
requires_ramdisk=False)
@base.clean_step(priority=0, argsinfo=_APPLY_CONFIGURATION_ARGSINFO,
requires_ramdisk=False)
@base.deploy_step(priority=0, argsinfo=_APPLY_CONFIGURATION_ARGSINFO)
@base.cache_bios_settings
def apply_configuration(self, task, settings):
"""Apply the BIOS settings to the node.
:param task: a TaskManager instance containing the node to act on.
:param settings: a list of BIOS settings to be updated.
:raises: RedfishConnectionError when it fails to connect to Redfish
:raises: RedfishError on an error from the Sushy library
"""
system = redfish_utils.get_system(task.node)
try:
bios = system.bios
except sushy.exceptions.MissingAttributeError:
error_msg = (_('Redfish BIOS factory reset failed for node '
'%s, because BIOS settings are not supported.') %
task.node.uuid)
LOG.error(error_msg)
raise exception.RedfishError(error=error_msg)
# Convert Ironic BIOS settings to Redfish BIOS attributes
attributes = {s['name']: s['value'] for s in settings}
info = task.node.driver_internal_info
bios_state = info.get(_DII_STATE) or {}
reboot_requested = bios_state.get(_REBOOT_REQUESTED, False)
if not reboot_requested:
# Check if all requested settings already match the current
# BIOS values. When a client of the Ironic API re-sends
# the same request after a successful apply, this avoids an
# unnecessary reboot cycle.
current_attrs = bios.attributes or {}
try:
pending_attrs = bios.pending_attributes
except (sushy.exceptions.SushyError, AttributeError):
pending_attrs = {}
if not isinstance(pending_attrs, dict):
pending_attrs = {}
all_match = True
for s in settings:
name, value = s['name'], s['value']
if current_attrs.get(name) != value:
all_match = False
break
if name in pending_attrs:
if pending_attrs[name] != value:
# A conflicting pending change exists.
all_match = False
break
if all_match:
LOG.info('All requested BIOS settings for node '
'%(node_uuid)s already match the current '
'values, skipping apply and reboot.',
{'node_uuid': task.node.uuid})
return
# Step 1: Apply settings and issue a reboot
LOG.debug('Apply BIOS configuration for node %(node_uuid)s: '
'%(settings)r', {'node_uuid': task.node.uuid,
'settings': settings})
apply_time = None
try:
if bios.supported_apply_times and (
sushy.APPLY_TIME_ON_RESET in
bios.supported_apply_times):
apply_time = sushy.APPLY_TIME_ON_RESET
except AttributeError:
LOG.warning('SupportedApplyTimes attribute missing for BIOS'
' configuration on node %(node_uuid)s: ',
{'node_uuid': task.node.uuid})
try:
bios.set_attributes(attributes, apply_time=apply_time)
except sushy.exceptions.SushyError as e:
error_msg = (_('Redfish BIOS apply configuration failed for '
'node %(node)s. Error: %(error)s') %
{'node': task.node.uuid, 'error': e})
LOG.error(error_msg)
raise exception.RedfishError(error=error_msg)
self._set_reboot_requested(
task,
attributes)
return self.post_configuration(task, settings)
else:
# Step 2: Verify requested BIOS settings applied
requested_attrs = (
bios_state.get(_REQUESTED_BIOS_ATTRS)
or info.get(_REQUESTED_BIOS_ATTRS))
LOG.debug('Verify BIOS configuration for node %(node_uuid)s: '
'%(attrs)r', {'node_uuid': task.node.uuid,
'attrs': requested_attrs})
self._clear_reboot_requested(task)
attrs_not_updated = self._get_unapplied_bios_attrs(
task, requested_attrs, bios)
if attrs_not_updated:
LOG.debug('BIOS settings %(attrs)s for node %(node_uuid)s '
'not updated.', {'attrs': attrs_not_updated,
'node_uuid': task.node.uuid})
self._set_step_failed(task, attrs_not_updated)
else:
LOG.debug('Verification of BIOS settings for node '
'%(node_uuid)s successful.',
{'node_uuid': task.node.uuid})
[docs]
def post_reset(self, task):
"""Perform post reset action to apply the BIOS factory reset.
Extension point to allow vendor implementations to extend this class
and override this method to perform a custom action to apply the BIOS
factory reset to the Redfish service. The default implementation
performs a reboot.
:param task: a TaskManager instance containing the node to act on.
"""
return deploy_utils.reboot_to_finish_step(task)
[docs]
def post_configuration(self, task, settings):
"""Perform post configuration action to store the BIOS settings.
Extension point to allow vendor implementations to extend this class
and override this method to perform a custom action to write the BIOS
settings to the Redfish service. The default implementation performs
a reboot.
:param task: a TaskManager instance containing the node to act on.
:param settings: a list of BIOS settings to be updated.
"""
return deploy_utils.reboot_to_finish_step(task)
[docs]
def get_properties(self):
"""Return the properties of the interface.
:returns: dictionary of <property name>:<property description> entries.
"""
return redfish_utils.COMMON_PROPERTIES.copy()
[docs]
def validate(self, task):
"""Validates the driver information needed by the redfish driver.
:param task: a TaskManager instance containing the node to act on.
:raises: InvalidParameterValue on malformed parameter(s)
:raises: MissingParameterValue on missing parameter(s)
"""
redfish_utils.parse_driver_info(task.node)
def _get_unapplied_bios_attrs(self, task, requested_attrs, bios):
"""Return requested BIOS attrs that have not yet been applied.
:param task: a TaskManager instance containing the node to act on.
:param requested_attrs: the requested BIOS attributes to update.
:param bios: BIOS resource object from the system.
:returns: dict of attributes not yet applied, empty if all applied.
"""
bios.refresh(force=True)
current_attrs = bios.attributes
pending_attrs = bios.pending_attributes
if not isinstance(pending_attrs, dict):
pending_attrs = {}
attrs_not_updated = {}
for attr in requested_attrs:
if requested_attrs[attr] != current_attrs.get(attr):
attrs_not_updated[attr] = requested_attrs[attr]
elif attr in pending_attrs:
attrs_not_updated[attr] = requested_attrs[attr]
return attrs_not_updated
def _set_reboot_requested(self, task, attributes):
"""Set driver_internal_info flags for reboot requested.
:param task: a TaskManager instance containing the node to act on.
:param attributes: the requested BIOS attributes to update.
"""
node = task.node
bios_state = {_REBOOT_REQUESTED: True}
if attributes:
bios_state[_REQUESTED_BIOS_ATTRS] = attributes
node.set_driver_internal_info(_DII_STATE, bios_state)
node.save()
disable_ramdisk = deploy_utils.is_ramdisk_disabled(node)
# polling=True tells the IPA heartbeat handler to stand down so
# that only our periodic task (_query_bios_apply_status) drives
# step completion. When ramdisk is active (polling=False), both
# the heartbeat and the periodic task may race; the exclusive
# lock in continue_node_clean/deploy/service ensures only one
# wins.
deploy_utils.set_async_step_flags(task.node, reboot=True,
skip_current_step=False,
polling=disable_ramdisk)
def _clear_reboot_requested(self, task):
"""Clear driver_internal_info flags after reboot completed.
:param task: a TaskManager instance containing the node to act on.
"""
node = task.node
node.del_driver_internal_info(_DII_STATE)
# Drop legacy fields if present from older runs.
node.del_driver_internal_info('post_bios_reboot_requested')
node.del_driver_internal_info(_REQUESTED_BIOS_ATTRS)
node.save()
def _set_step_failed(self, task, attrs_not_updated):
"""Fail the cleaning or deployment step and log the error.
:param task: a TaskManager instance containing the node to act on.
:param attrs_not_updated: the BIOS attributes that were not updated.
"""
error_msg = (_('Redfish BIOS apply_configuration step failed for node '
'%(node)s. Attributes %(attrs)s are not updated.') %
{'node': task.node.uuid, 'attrs': attrs_not_updated})
last_error = (_('Redfish BIOS apply_configuration step failed. '
'Attributes %(attrs)s are not updated.') %
{'attrs': attrs_not_updated})
deploy_utils.step_error_handler(task, error_msg, last_error)
@METRICS.timer('RedfishBIOS._query_bios_apply_status')
@periodics.node_periodic(
purpose='checking async redfish BIOS apply/reset status',
spacing=CONF.redfish.firmware_update_status_interval,
filters={'reserved': False,
'provision_state_in': {states.CLEANWAIT,
states.SERVICEWAIT,
states.DEPLOYWAIT}},
predicate_extra_fields=['driver_internal_info'],
predicate=lambda n: n.driver_internal_info.get(_DII_STATE),
)
def _query_bios_apply_status(self, task, manager, context):
self._check_node_redfish_bios_apply(task)
@METRICS.timer('RedfishBIOS._check_node_redfish_bios_apply')
def _check_node_redfish_bios_apply(self, task):
node = task.node
bios_state = node.driver_internal_info.get(_DII_STATE) or {}
if not bios_state:
LOG.debug('BIOS state cleared for node %(node)s before periodic '
'could process it (likely a timeout race).',
{'node': node.uuid})
return
try:
system = redfish_utils.get_system(node)
except (exception.RedfishError,
exception.RedfishConnectionError,
sushy.exceptions.SushyError) as e:
LOG.warning('Unable to query Redfish system for node %(node)s '
'while waiting for BIOS reboot completion: '
'%(error)s',
{'node': node.uuid, 'error': e})
return
last_state = system.boot_progress.last_state
if last_state is not None:
# BootProgress is reported — touch provisioning to prevent the
# global timeout from firing while we observe meaningful progress.
node.touch_provisioning()
if last_state not in BIOS_REBOOT_STATES:
LOG.debug('Node %(node)s boot progress: %(state)s. '
'Waiting for boot progress to reach OS started.',
{'node': node.uuid, 'state': last_state})
return
# When BootProgress is unavailable (last_state is None), fall
# through to the attrs check below. Do NOT touch provisioning
# so the global timeout remains the safety net.
requested_attrs = bios_state.get(_REQUESTED_BIOS_ATTRS)
if requested_attrs:
attrs_not_updated = self._get_unapplied_bios_attrs(
task, requested_attrs, system.bios)
if attrs_not_updated:
LOG.debug('BIOS settings %(attrs)s for node %(node_uuid)s '
'not yet applied; continue polling.',
{'attrs': attrs_not_updated,
'node_uuid': node.uuid})
return
LOG.info('Detected post-BIOS reboot completion for node %(node)s, '
'resuming the current step.',
{'node': node.uuid})
if node.clean_step:
manager_utils.notify_conductor_resume_clean(task)
elif node.service_step:
manager_utils.notify_conductor_resume_service(task)
elif node.deploy_step:
manager_utils.notify_conductor_resume_deploy(task)
