# -*- coding: utf-8 -*-
#
# Copyright 2014 Red Hat, Inc.
# All Rights Reserved.
# Copyright (c) 2017-2018 Dell Inc. or its subsidiaries.
#
# 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.
"""
DRAC management interface
"""
from ironic_lib import metrics_utils
from oslo_log import log as logging
from oslo_utils import importutils
from ironic.common import boot_devices
from ironic.common import exception
from ironic.common.i18n import _, _LE
from ironic.conductor import task_manager
from ironic.drivers import base
from ironic.drivers.modules.drac import common as drac_common
from ironic.drivers.modules.drac import job as drac_job
drac_exceptions = importutils.try_import('dracclient.exceptions')
LOG = logging.getLogger(__name__)
METRICS = metrics_utils.get_metrics_logger(__name__)
# This dictionary is used to map boot device names between two (2) name
# spaces. The name spaces are:
#
# 1) ironic boot devices
# 2) iDRAC boot sources
#
# Mapping can be performed in both directions.
#
# The keys are ironic boot device types. Each value is a list of strings
# that appear in the identifiers of iDRAC boot sources.
#
# The iDRAC represents boot sources with class DCIM_BootSourceSetting
# [1]. Each instance of that class contains a unique identifier, which
# is called an instance identifier, InstanceID,
#
# An InstanceID contains the Fully Qualified Device Descriptor (FQDD) of
# the physical device that hosts the boot source [2].
#
# [1] "Dell EMC BIOS and Boot Management Profile", Version 4.0.0, July
# 10, 2017, Section 7.2 "Boot Management", pp. 44-47 --
# http://en.community.dell.com/techcenter/extras/m/white_papers/20444495/download
# [2] "Lifecycle Controller Version 3.15.15.15 User's Guide", Dell EMC,
# 2017, Table 13, "Easy-to-use Names of System Components", pp. 71-74 --
# http://topics-cdn.dell.com/pdf/idrac9-lifecycle-controller-v3.15.15.15_users-guide2_en-us.pdf
_BOOT_DEVICES_MAP = {
boot_devices.DISK: ['AHCI', 'Disk', 'RAID'],
boot_devices.PXE: ['NIC'],
boot_devices.CDROM: ['Optical'],
}
_DRAC_BOOT_MODES = ['Bios', 'Uefi']
# BootMode constant
_NON_PERSISTENT_BOOT_MODE = 'OneTime'
def _get_boot_device(node, drac_boot_devices=None):
client = drac_common.get_drac_client(node)
try:
boot_modes = client.list_boot_modes()
next_boot_modes = [mode.id for mode in boot_modes if mode.is_next]
if _NON_PERSISTENT_BOOT_MODE in next_boot_modes:
next_boot_mode = _NON_PERSISTENT_BOOT_MODE
else:
next_boot_mode = next_boot_modes[0]
if drac_boot_devices is None:
drac_boot_devices = client.list_boot_devices()
# It is possible for there to be no boot device.
boot_device = None
if next_boot_mode in drac_boot_devices:
drac_boot_device = drac_boot_devices[next_boot_mode][0]
for key, value in _BOOT_DEVICES_MAP.items():
for id_component in value:
if id_component in drac_boot_device.id:
boot_device = key
break
if boot_device:
break
return {'boot_device': boot_device,
'persistent': next_boot_mode != _NON_PERSISTENT_BOOT_MODE}
except (drac_exceptions.BaseClientException, IndexError) as exc:
LOG.error(_LE('DRAC driver failed to get next boot mode for '
'node %(node_uuid)s. Reason: %(error)s.'),
{'node_uuid': node.uuid, 'error': exc})
raise exception.DracOperationError(error=exc)
def _get_next_persistent_boot_mode(node):
client = drac_common.get_drac_client(node)
try:
boot_modes = client.list_boot_modes()
except drac_exceptions.BaseClientException as exc:
LOG.error('DRAC driver failed to get next persistent boot mode for '
'node %(node_uuid)s. Reason: %(error)s',
{'node_uuid': node.uuid, 'error': exc})
raise exception.DracOperationError(error=exc)
next_persistent_boot_mode = None
for mode in boot_modes:
if mode.is_next and mode.id != _NON_PERSISTENT_BOOT_MODE:
next_persistent_boot_mode = mode.id
break
if not next_persistent_boot_mode:
message = _('List of boot modes, %(list_boot_modes)s, does not '
'contain a persistent mode') % {
'list_boot_modes': boot_modes}
LOG.error('DRAC driver failed to get next persistent boot mode for '
'node %(node_uuid)s. Reason: %(message)s',
{'node_uuid': node.uuid, 'message': message})
raise exception.DracOperationError(error=message)
return next_persistent_boot_mode
def _is_boot_order_flexibly_programmable(persistent, bios_settings):
return persistent and 'SetBootOrderFqdd1' in bios_settings
def _flexibly_program_boot_order(device, drac_boot_mode):
if device == boot_devices.DISK:
if drac_boot_mode == 'Bios':
bios_settings = {'SetBootOrderFqdd1': 'HardDisk.List.1-1'}
else:
# 'Uefi'
bios_settings = {
'SetBootOrderFqdd1': '*.*.*', # Disks, which are all else
'SetBootOrderFqdd2': 'NIC.*.*',
'SetBootOrderFqdd3': 'Optical.*.*',
'SetBootOrderFqdd4': 'Floppy.*.*',
}
elif device == boot_devices.PXE:
bios_settings = {'SetBootOrderFqdd1': 'NIC.*.*'}
else:
# boot_devices.CDROM
bios_settings = {'SetBootOrderFqdd1': 'Optical.*.*'}
return bios_settings
def set_boot_device(node, device, persistent=False):
"""Set the boot device for a node.
Set the boot device to use on next boot of the node.
:param node: an ironic node object.
:param device: the boot device, one of
:mod:`ironic.common.boot_devices`.
:param persistent: Boolean value. True if the boot device will
persist to all future boots, False if not.
Default: False.
:raises: DracOperationError on an error from python-dracclient.
"""
drac_job.validate_job_queue(node)
client = drac_common.get_drac_client(node)
try:
drac_boot_devices = client.list_boot_devices()
current_boot_device = _get_boot_device(node, drac_boot_devices)
# If we are already booting from the right device, do nothing.
if current_boot_device == {'boot_device': device,
'persistent': persistent}:
LOG.debug('DRAC already set to boot from %s', device)
return
persistent_boot_mode = _get_next_persistent_boot_mode(node)
drac_boot_device = None
for drac_device in drac_boot_devices[persistent_boot_mode]:
for id_component in _BOOT_DEVICES_MAP[device]:
if id_component in drac_device.id:
drac_boot_device = drac_device.id
break
if drac_boot_device:
break
if drac_boot_device:
if persistent:
boot_list = persistent_boot_mode
else:
boot_list = _NON_PERSISTENT_BOOT_MODE
client.change_boot_device_order(boot_list, drac_boot_device)
else:
# No DRAC boot device of the type requested by the argument
# 'device' is present. This is normal for UEFI boot mode,
# following deployment's writing of the operating system to
# disk. It can also occur when a server has not been
# powered on after a new boot device has been installed.
#
# If the boot order is flexibly programmable, use that to
# attempt to detect and boot from a device of the requested
# type during the next boot. That avoids the need for an
# extra reboot. Otherwise, this function cannot satisfy the
# request, because it was called with an invalid device.
bios_settings = client.list_bios_settings(by_name=True)
if _is_boot_order_flexibly_programmable(persistent, bios_settings):
drac_boot_mode = bios_settings['BootMode'].current_value
if drac_boot_mode not in _DRAC_BOOT_MODES:
message = _("DRAC reported unknown boot mode "
"'%(drac_boot_mode)s'") % {
'drac_boot_mode': drac_boot_mode}
LOG.error('DRAC driver failed to change boot device order '
'for node %(node_uuid)s. Reason: %(message)s.',
{'node_uuid': node.uuid, 'message': message})
raise exception.DracOperationError(error=message)
flexibly_program_settings = _flexibly_program_boot_order(
device, drac_boot_mode)
client.set_bios_settings(flexibly_program_settings)
else:
raise exception.InvalidParameterValue(
_("set_boot_device called with invalid device "
"'%(device)s' for node %(node_id)s.") %
{'device': device, 'node_id': node.uuid})
client.commit_pending_bios_changes()
except drac_exceptions.BaseClientException as exc:
LOG.error(_LE('DRAC driver failed to change boot device order for '
'node %(node_uuid)s. Reason: %(error)s.'),
{'node_uuid': node.uuid, 'error': exc})
raise exception.DracOperationError(error=exc)
[docs]class DracManagement(base.ManagementInterface):
[docs] def get_properties(self):
"""Return the properties of the interface."""
return drac_common.COMMON_PROPERTIES
@METRICS.timer('DracManagement.validate')
[docs] def validate(self, task):
"""Validate the driver-specific info supplied.
This method validates whether the 'driver_info' property of the
supplied node contains the required information for this driver to
manage the node.
:param task: a TaskManager instance containing the node to act on.
:raises: InvalidParameterValue if required driver_info attribute
is missing or invalid on the node.
"""
return drac_common.parse_driver_info(task.node)
@METRICS.timer('DracManagement.get_supported_boot_devices')
[docs] def get_supported_boot_devices(self, task):
"""Get a list of the supported boot devices.
:param task: a TaskManager instance containing the node to act on.
:returns: A list with the supported boot devices defined
in :mod:`ironic.common.boot_devices`.
"""
return list(_BOOT_DEVICES_MAP.keys())
@METRICS.timer('DracManagement.get_boot_device')
[docs] def get_boot_device(self, task):
"""Get the current boot device for a node.
Returns the current boot device of the node.
:param task: a TaskManager instance containing the node to act on.
:raises: DracOperationError on an error from python-dracclient.
:returns: a dictionary containing:
:boot_device: the boot device, one of
:mod:`ironic.common.boot_devices` or None if it is unknown.
:persistent: whether the boot device will persist to all future
boots or not, None if it is unknown.
"""
node = task.node
boot_device = node.driver_internal_info.get('drac_boot_device')
if boot_device is not None:
return boot_device
return _get_boot_device(node)
@METRICS.timer('DracManagement.set_boot_device')
@task_manager.require_exclusive_lock
[docs] def set_boot_device(self, task, device, persistent=False):
"""Set the boot device for a node.
Set the boot device to use on next reboot of the node.
:param task: a TaskManager instance containing the node to act on.
:param device: the boot device, one of
:mod:`ironic.common.boot_devices`.
:param persistent: Boolean value. True if the boot device will
persist to all future boots, False if not.
Default: False.
:raises: InvalidParameterValue if an invalid boot device is specified.
"""
node = task.node
if device not in _BOOT_DEVICES_MAP:
raise exception.InvalidParameterValue(
_("set_boot_device called with invalid device '%(device)s' "
"for node %(node_id)s.") % {'device': device,
'node_id': node.uuid})
# NOTE(ifarkas): DRAC interface doesn't allow changing the boot device
# multiple times in a row without a reboot. This is
# because a change need to be committed via a
# configuration job, and further configuration jobs
# cannot be created until the previous one is processed
# at the next boot. As a workaround, saving it to
# driver_internal_info and committing the change during
# power state change.
driver_internal_info = node.driver_internal_info
driver_internal_info['drac_boot_device'] = {'boot_device': device,
'persistent': persistent}
node.driver_internal_info = driver_internal_info
node.save()
@METRICS.timer('DracManagement.get_sensors_data')
[docs] def get_sensors_data(self, task):
"""Get sensors data.
:param task: a TaskManager instance.
:raises: FailedToGetSensorData when getting the sensor data fails.
:raises: FailedToParseSensorData when parsing sensor data fails.
:returns: returns a consistent format dict of sensor data grouped by
sensor type, which can be processed by Ceilometer.
"""
raise NotImplementedError()