Source code for

# Copyright 2015 Hewlett-Packard Development Company, L.P.
# 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
# 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.

import datetime

import jsonschema
from jsonschema import exceptions as json_schema_exc

from ironic.common import exception
from ironic.common.i18n import _
from ironic.common import utils

SATA = 'sata'
"Serial AT Attachment"

SCSI = 'scsi'
"Small Computer System Interface"

SAS = 'sas'
"Serial Attached SCSI"

def _check_and_return_root_volumes(raid_config):
    """Returns root logical disks after validating RAID config.

    This method checks if multiple logical disks had 'is_root_volume'
    set to True and raises an exception if it is True. Otherwise,
    returns the root logical disk mentioned in the RAID config.

    :param raid_config: target RAID configuration or current RAID
    :returns: the dictionary for the root logical disk if it is
        present, otherwise None.
    :raises: InvalidParameterValue, if there were more than one
        root volume specified in the RAID configuration.
    logical_disks = raid_config['logical_disks']
    root_logical_disks = [x for x in logical_disks if x.get('is_root_volume')]
    if len(root_logical_disks) > 1:
        msg = _("Raid config cannot have more than one root volume. "
                "%d root volumes were specified") % len(root_logical_disks)
        raise exception.InvalidParameterValue(msg)

    if root_logical_disks:
        return root_logical_disks[0]

[docs] def validate_configuration(raid_config, raid_config_schema): """Validates the RAID configuration passed using JSON schema. This method validates a RAID configuration against a RAID configuration schema. :param raid_config: A dictionary containing RAID configuration information :param raid_config_schema: A dictionary which is the schema to be used for validation. :raises: InvalidParameterValue, if validation of the RAID configuration fails. """ try: jsonschema.validate(raid_config, raid_config_schema) except json_schema_exc.ValidationError as e: # NOTE: Even though e.message is deprecated in general, it is said # in jsonschema documentation to use this still. msg = _("RAID config validation error: %s") % e.message raise exception.InvalidParameterValue(msg) # Check if there are multiple root volumes specified. _check_and_return_root_volumes(raid_config)
[docs] def get_logical_disk_properties(raid_config_schema): """Get logical disk properties from RAID configuration schema. This method reads the logical properties and their textual description from the schema that is passed. :param raid_config_schema: A dictionary which is the schema to be used for getting properties that may be specified for the logical disk. :returns: A dictionary containing the logical disk properties as keys and a textual description for them as values. """ logical_disk_schema = raid_config_schema['properties']['logical_disks'] properties = logical_disk_schema['items']['properties'] return {prop: prop_dict['description'] for prop, prop_dict in properties.items()}
[docs] def update_raid_info(node, raid_config): """Update the node's information based on the RAID config. This method updates the node's information to make use of the configured RAID for scheduling purposes (through properties['capabilities'] and properties['local_gb']) and deploying purposes (using properties['root_device']). :param node: a node object :param raid_config: The dictionary containing the current RAID configuration. :raises: InvalidParameterValue, if 'raid_config' has more than one root volume or if['capabilities'] is malformed. """ current = raid_config.copy() current['last_updated'] = str(datetime.datetime.utcnow()) node.raid_config = current # Current RAID configuration can have 0 or 1 root volumes. If there # are > 1 root volumes, then it's invalid. We check for this condition # while accepting target RAID configuration, but this check is just in # place, if some drivers pass > 1 root volumes to this method. root_logical_disk = _check_and_return_root_volumes(raid_config) if root_logical_disk: # Update local_gb and root_device_hint properties = if root_logical_disk['size_gb'] != 'MAX': properties['local_gb'] = root_logical_disk['size_gb'] try: properties['root_device'] = ( root_logical_disk['root_device_hint']) except KeyError: pass properties['capabilities'] = utils.get_updated_capabilities( properties.get('capabilities', ''), {'raid_level': root_logical_disk['raid_level']}) = properties
[docs] def filter_target_raid_config( node, create_root_volume=True, create_nonroot_volumes=True): """Filter the target raid config based on root volume creation This method can be used by any raid interface which wants to filter out target raid config based on condition whether the root volume will be created or not. :param node: a node object :param create_root_volume: A boolean default value True governing if the root volume is returned else root volumes will be filtered out. :param create_nonroot_volumes: A boolean default value True governing if the non root volume is returned else non-root volumes will be filtered out. :raises: MissingParameterValue, if node.target_raid_config is missing or was found to be empty after skipping root volume and/or non-root volumes. :returns: It will return filtered target_raid_config """ if not node.target_raid_config: raise exception.MissingParameterValue( _("Node %s has no target RAID configuration.") % node.uuid) target_raid_config = node.target_raid_config.copy() error_msg_list = [] if not create_root_volume: target_raid_config['logical_disks'] = [ x for x in target_raid_config['logical_disks'] if not x.get('is_root_volume')] error_msg_list.append(_("skipping root volume")) if not create_nonroot_volumes: target_raid_config['logical_disks'] = [ x for x in target_raid_config['logical_disks'] if x.get('is_root_volume')] error_msg_list.append(_("skipping non-root volumes")) if not target_raid_config['logical_disks']: error_msg = _(' and ').join(error_msg_list) raise exception.MissingParameterValue( _("Node %(node)s has empty target RAID configuration " "after %(msg)s.") % {'node': node.uuid, 'msg': error_msg}) return target_raid_config