# Copyright 2016 FUJITSU LIMITED # # 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. """ eLCM functionality. """ import collections import time from oslo_serialization import jsonutils import requests import six from scciclient.irmc import scci """ List of profile names """ PROFILE_BIOS_CONFIG = 'BiosConfig' PROFILE_RAID_CONFIG = 'RAIDAdapter' """ List of URL paths for profiles """ URL_PATH_PROFILE_MGMT = '/rest/v1/Oem/eLCM/ProfileManagement/' """ List of request params for profiles """ PARAM_PATH_SYSTEM_CONFIG = 'Server/SystemConfig/' PARAM_PATH_BIOS_CONFIG = PARAM_PATH_SYSTEM_CONFIG + PROFILE_BIOS_CONFIG PARAM_PATH_HW_CONFIG = 'Server/HWConfigurationIrmc/Adapters/' PARAM_PATH_RAID_CONFIG = PARAM_PATH_HW_CONFIG + PROFILE_RAID_CONFIG """ Timeout values """ PROFILE_CREATE_TIMEOUT = 300 # 300 secs PROFILE_SET_TIMEOUT = 300 # 300 secs BIOS_CONFIG_SESSION_TIMEOUT = 30 * 60 # 30 mins RAID_CONFIG_SESSION_TIMEOUT = 30 * 60 # 30 mins BIOS_CONFIGURATION_DICTIONARY = { "boot_option_filter": "CsmConfig_BootOptionFilter", "boot_removable_media_enabled": "BootConfig_BootRemovableMediaEnabled", "check_controllers_health_status_enabled": "BootConfig_CheckControllersHealthStatusEnabled", "cpu_active_processor_cores": "CpuConfig_ActiveProcessorCores", "cpu_adjacent_cache_line_prefetch_enabled": "CpuConfig_AdjacentCacheLinePrefetchEnabled", "cpu_dcu_ip_prefetch_enabled": "CpuConfig_DcuIpPrefetchEnabled", "cpu_early_snoop": "CpuConfig_EarlySnoop", "cpu_energy_performance_mode": "CpuConfig_EnergyPerformanceMode", "cpu_enhanced_speed_step_enabled": "CpuConfig_EnhancedSpeedStepEnabled", "cpu_execute_disable_bit_enabled": "CpuConfig_ExecuteDisableBitEnabled", "cpu_frequency_floor_overwrite_enabled": "CpuConfig_FrequencyFloorOverwriteEnabled", "cpu_hardware_prefetcher_enabled": "CpuConfig_HardwarePrefetcherEnabled", "cpu_power_technology": "CpuConfig_PowerTechnology", "cpu_turbo_mode_enabled": "CpuConfig_TurboModeEnabled", "cpu_uncore_frequencey_override_enabled": "CpuConfig_UncoreFrequenceyOverrideEnabled", "cpu_vt_enabled": "CpuConfig_VtEnabled", "flash_write_enabled": "SecurityConfig_FlashWriteEnabled", "hyper_threading_enabled": "CpuConfig_HyperThreadingEnabled", "keep_void_boot_options_enabled": "BootConfig_KeepVoidBootOptionsEnabled", "launch_csm_enabled": "CsmConfig_LaunchCsmEnabled", "limit_cpu_id_maximum_enabled": "CpuConfig_LimitCpuIdMaximumEnabled", "memory_mode": "MemoryConfig_MemoryMode", "network_stack_enabled": "NetworkStackConfig_Enabled", "os_energy_performance_override_enabled": "CpuConfig_OsEnergyPerformanceOverrideEnabled", "pci_aspm_support": "PciConfig_ASPMSupport", "pci_above_4g_decoding_enabled": "PciConfig_Above4GDecodingEnabled", "pending_tpm_operation": "TpmConfig_PendingTpmOperation", "power_on_source": "PowerConfig_PowerOnSource", "power_wake_on_lan_boot": "PowerConfig_WakeOnLanBoot", "pxe_boot_option_retry": "BootConfig_PxeBootOptionRetry", "pxe_option_rom_policy": "CsmConfig_PxeOptionRomPolicy", "quiet_boot_enabled": "BootConfig_QuietBootEnabled", "sas_sata_driver": "OnboardDeviceConfig_SasSataDriver", "sas_sata_enabled": "OnboardDeviceConfig_SasSataEnabled", "sas_sata_option_rom_enabled": "OnboardDeviceConfig_SasSataOptionRomEnabled", "sata_controller_enabled": "SataConfig_SataControllerEnabled", "sata_mode": "SataConfig_SataMode", "secure_boot_control_enabled": "SecurityConfig_SecureBootControlEnabled", "secure_boot_mode": "SecurityConfig_SecureBootMode", "single_root_io_virtualization_support_enabled": "PciConfig_SingleRootIOVirtualizationSupportEnabled", "storage_option_rom_policy": "CsmConfig_StorageOptionRomPolicy", "tpm_hash_policy": "TpmConfig_HashPolicy", "tpm_state_enabled": "TpmConfig_TpmStateEnabled", "usb_legacy_support": "UsbConfig_LegacySupport", "usb_port_disable": "UsbConfig_PortDisable", "usb_xhci_mode": "UsbConfig_XHCIMode", "video_option_rom_policy": "CsmConfig_VideoOptionRomPolicy" } class ELCMInvalidResponse(scci.SCCIError): def __init__(self, message): super(ELCMInvalidResponse, self).__init__(message) class ELCMProfileNotFound(scci.SCCIError): def __init__(self, message): super(ELCMProfileNotFound, self).__init__(message) class ELCMSessionNotFound(scci.SCCIError): def __init__(self, message): super(ELCMSessionNotFound, self).__init__(message) class ELCMSessionTimeout(scci.SCCIError): def __init__(self, message): super(ELCMSessionTimeout, self).__init__(message) class SecureBootConfigNotFound(scci.SCCIError): def __init__(self, message): super(SecureBootConfigNotFound, self).__init__(message) class ELCMValueError(scci.SCCIError): def __init__(self, message): super(ELCMValueError, self).__init__(message) class BiosConfigNotFound(scci.SCCIError): def __init__(self, message): super(BiosConfigNotFound, self).__init__(message) def _parse_elcm_response_body_as_json(response): """parse eLCM response body as json data eLCM response should be in form of: _ Key1: value1 <-- optional --> Key2: value2 <-- optional --> KeyN: valueN <-- optional --> - CRLF - JSON string - :param response: eLCM response :return: json object if success :raise ELCMInvalidResponse: if the response does not contain valid json data. """ try: body = response.text body_parts = body.split('\r\n') if len(body_parts) > 0: return jsonutils.loads(body_parts[-1]) else: return None except (TypeError, ValueError): raise ELCMInvalidResponse('eLCM response does not contain valid json ' 'data. Response is "%s".' % body) def elcm_request(irmc_info, method, path, **kwargs): """send an eLCM request to the server :param irmc_info: dict of iRMC params to access the server node { 'irmc_address': host, 'irmc_username': user_id, 'irmc_password': password, 'irmc_port': 80 or 443, default is 443, 'irmc_auth_method': 'basic' or 'digest', default is 'basic', 'irmc_client_timeout': timeout, default is 60, 'irmc_verify_ca': Either a boolean, in which case it controls whether we verify the server's TLS certificate, or a string, in which case it must be a path to a CA bundle to use. Defaults to ``False``. ... } :param method: request method such as 'GET', 'POST' :param path: url path for eLCM request :returns: requests.Response from SCCI server :raises SCCIInvalidInputError: if port and/or auth_method params are invalid :raises SCCIClientError: if SCCI failed """ host = irmc_info['irmc_address'] port = irmc_info.get('irmc_port', 443) auth_method = irmc_info.get('irmc_auth_method', 'basic') userid = irmc_info['irmc_username'] password = irmc_info['irmc_password'] client_timeout = irmc_info.get('irmc_client_timeout', 60) verify = irmc_info.get('irmc_verify_ca', False) # Request headers, params, and data headers = kwargs.get('headers', {'Accept': 'application/json'}) params = kwargs.get('params') data = kwargs.get('data') auth_obj = None try: protocol = {80: 'http', 443: 'https'}[port] auth_obj = { 'basic': requests.auth.HTTPBasicAuth(userid, password), 'digest': requests.auth.HTTPDigestAuth(userid, password) }[auth_method.lower()] except KeyError: raise scci.SCCIInvalidInputError( ("Invalid port %(port)d or " + "auth_method for method %(auth_method)s") % {'port': port, 'auth_method': auth_method}) try: r = requests.request(method, protocol + '://' + host + path, headers=headers, params=params, data=data, verify=verify, timeout=client_timeout, allow_redirects=False, auth=auth_obj) except requests.exceptions.RequestException as requests_exception: raise scci.SCCIClientError(requests_exception) # Process status_code 401 if r.status_code == 401: raise scci.SCCIClientError('UNAUTHORIZED') return r def elcm_profile_get_versions(irmc_info): """send an eLCM request to get profile versions :param irmc_info: node info :returns: dict object of profiles if succeed { "Server":{ "@Version": "1.01", "AdapterConfigIrmc":{ "@Version": "1.00" }, "HWConfigurationIrmc":{ "@Version": "1.00" }, "SystemConfig":{ "IrmcConfig":{ "@Version": "1.02" }, "BiosConfig":{ "@Version": "1.02" } } } } :raises: SCCIClientError if SCCI failed """ # Send GET request to the server resp = elcm_request(irmc_info, method='GET', path=URL_PATH_PROFILE_MGMT + 'version') if resp.status_code == 200: return _parse_elcm_response_body_as_json(resp) else: raise scci.SCCIClientError(('Failed to get profile versions with ' 'error code %s' % resp.status_code)) def elcm_profile_list(irmc_info): """send an eLCM request to list all profiles :param irmc_info: node info :returns: dict object of profiles if succeed { 'Links': { 'profileStore': [ { '@odata.id': id1 }, { '@odata.id': id2 }, { '@odata.id': idN }, ] } } :raises: SCCIClientError if SCCI failed """ # Send GET request to the server resp = elcm_request(irmc_info, method='GET', path=URL_PATH_PROFILE_MGMT) if resp.status_code == 200: return _parse_elcm_response_body_as_json(resp) else: raise scci.SCCIClientError(('Failed to list profiles with ' 'error code %s' % resp.status_code)) def elcm_profile_get(irmc_info, profile_name): """send an eLCM request to get profile data :param irmc_info: node info :param profile_name: name of profile :returns: dict object of profile data if succeed :raises: ELCMProfileNotFound if profile does not exist :raises: SCCIClientError if SCCI failed """ # Send GET request to the server resp = elcm_request(irmc_info, method='GET', path=URL_PATH_PROFILE_MGMT + profile_name) if resp.status_code == 200: return _parse_elcm_response_body_as_json(resp) elif resp.status_code == 404: raise ELCMProfileNotFound('Profile "%s" not found ' 'in the profile store.' % profile_name) else: raise scci.SCCIClientError(('Failed to get profile "%(profile)s" with ' 'error code %(error)s' % {'profile': profile_name, 'error': resp.status_code})) def elcm_profile_create(irmc_info, param_path): """send an eLCM request to create profile To create a profile, a new session is spawned with status 'running'. When profile is created completely, the session ends. :param irmc_info: node info :param param_path: path of profile :returns: dict object of session info if succeed { 'Session': { 'Id': id 'Status': 'activated' ... } } :raises: SCCIClientError if SCCI failed """ # Send POST request to the server # NOTE: This task may take time, so set a timeout _irmc_info = dict(irmc_info) _irmc_info['irmc_client_timeout'] = PROFILE_CREATE_TIMEOUT resp = elcm_request(_irmc_info, method='POST', path=URL_PATH_PROFILE_MGMT + 'get', params={'PARAM_PATH': param_path}) if resp.status_code == 202: return _parse_elcm_response_body_as_json(resp) else: raise scci.SCCIClientError(('Failed to create profile for path ' '"%(param_path)s" with error code ' '%(error)s' % {'param_path': param_path, 'error': resp.status_code})) def elcm_profile_set(irmc_info, input_data): """send an eLCM request to set param values To apply param values, a new session is spawned with status 'running'. When values are applied or error, the session ends. :param irmc_info: node info :param input_data: param values to apply, eg. { 'Server': { 'SystemConfig': { 'BiosConfig': { '@Processing': 'execute', -- config data -- } } } } :returns: dict object of session info if succeed { 'Session': { 'Id': id 'Status': 'activated' ... } } :raises: SCCIClientError if SCCI failed """ # Prepare the data to apply if isinstance(input_data, dict): data = jsonutils.dumps(input_data) else: data = input_data # Send POST request to the server # NOTE: This task may take time, so set a timeout _irmc_info = dict(irmc_info) _irmc_info['irmc_client_timeout'] = PROFILE_SET_TIMEOUT content_type = 'application/x-www-form-urlencoded' if input_data['Server'].get('HWConfigurationIrmc'): content_type = 'application/json' resp = elcm_request(_irmc_info, method='POST', path=URL_PATH_PROFILE_MGMT + 'set', headers={'Content-type': content_type}, data=data) if resp.status_code == 202: return _parse_elcm_response_body_as_json(resp) else: raise scci.SCCIClientError(('Failed to apply param values with ' 'error code %(error)s' % {'error': resp.status_code})) def elcm_profile_delete(irmc_info, profile_name): """send an eLCM request to delete a profile :param irmc_info: node info :param profile_name: name of profile :raises: ELCMProfileNotFound if the profile does not exist :raises: SCCIClientError if SCCI failed """ # Send DELETE request to the server resp = elcm_request(irmc_info, method='DELETE', path=URL_PATH_PROFILE_MGMT + profile_name) if resp.status_code == 200: # Profile deleted return elif resp.status_code == 404: # Profile not found raise ELCMProfileNotFound('Profile "%s" not found ' 'in the profile store.' % profile_name) else: raise scci.SCCIClientError(('Failed to delete profile "%(profile)s" ' 'with error code %(error)s' % {'profile': profile_name, 'error': resp.status_code})) def elcm_session_list(irmc_info): """send an eLCM request to list all sessions :param irmc_info: node info :returns: dict object of sessions if succeed { 'SessionList': { 'Contains': [ { 'Id': id1, 'Name': name1 }, { 'Id': id2, 'Name': name2 }, { 'Id': idN, 'Name': nameN }, ] } } :raises: SCCIClientError if SCCI failed """ # Send GET request to the server resp = elcm_request(irmc_info, method='GET', path='/sessionInformation/') if resp.status_code == 200: return _parse_elcm_response_body_as_json(resp) else: raise scci.SCCIClientError(('Failed to list sessions with ' 'error code %s' % resp.status_code)) def elcm_session_get_status(irmc_info, session_id): """send an eLCM request to get session status :param irmc_info: node info :param session_id: session id :returns: dict object of session info if succeed { 'Session': { 'Id': id 'Status': status ... } } :raises: ELCMSessionNotFound if the session does not exist :raises: SCCIClientError if SCCI failed """ # Send GET request to the server resp = elcm_request(irmc_info, method='GET', path='/sessionInformation/%s/status' % session_id) if resp.status_code == 200: return _parse_elcm_response_body_as_json(resp) elif resp.status_code == 404: raise ELCMSessionNotFound('Session "%s" does not exist' % session_id) else: raise scci.SCCIClientError(('Failed to get status of session ' '"%(session)s" with error code %(error)s' % {'session': session_id, 'error': resp.status_code})) def elcm_session_get_log(irmc_info, session_id): """send an eLCM request to get session log :param irmc_info: node info :param session_id: session id :returns: dict object of session log if succeed { 'Session': { 'Id': id ... } } :raises: ELCMSessionNotFound if the session does not exist :raises: SCCIClientError if SCCI failed """ # Send GET request to the server resp = elcm_request(irmc_info, method='GET', path='/sessionInformation/%s/log' % session_id) if resp.status_code == 200: return _parse_elcm_response_body_as_json(resp) elif resp.status_code == 404: raise ELCMSessionNotFound('Session "%s" does not exist' % session_id) else: raise scci.SCCIClientError(('Failed to get log of session ' '"%(session)s" with error code %(error)s' % {'session': session_id, 'error': resp.status_code})) def elcm_session_terminate(irmc_info, session_id): """send an eLCM request to terminate a session :param irmc_info: node info :param session_id: session id :raises: ELCMSessionNotFound if the session does not exist :raises: SCCIClientError if SCCI failed """ # Send DELETE request to the server resp = elcm_request(irmc_info, method='DELETE', path='/sessionInformation/%s/terminate' % session_id) if resp.status_code == 200: return elif resp.status_code == 404: raise ELCMSessionNotFound('Session "%s" does not exist' % session_id) else: raise scci.SCCIClientError(('Failed to terminate session ' '"%(session)s" with error code %(error)s' % {'session': session_id, 'error': resp.status_code})) def elcm_session_delete(irmc_info, session_id, terminate=False): """send an eLCM request to remove a session from the session list :param irmc_info: node info :param session_id: session id :param terminate: a running session must be terminated before removing :raises: ELCMSessionNotFound if the session does not exist :raises: SCCIClientError if SCCI failed """ # Terminate the session first if needs to if terminate: # Get session status to check session = elcm_session_get_status(irmc_info, session_id) status = session['Session']['Status'] # Terminate session if it is activated or running if status == 'running' or status == 'activated': elcm_session_terminate(irmc_info, session_id) # Send DELETE request to the server resp = elcm_request(irmc_info, method='DELETE', path='/sessionInformation/%s/remove' % session_id) if resp.status_code == 200: return elif resp.status_code == 404: raise ELCMSessionNotFound('Session "%s" does not exist' % session_id) else: raise scci.SCCIClientError(('Failed to remove session ' '"%(session)s" with error code %(error)s' % {'session': session_id, 'error': resp.status_code})) def _process_session_data(irmc_info, operation, session_id, session_timeout=BIOS_CONFIG_SESSION_TIMEOUT): """process session for Bios config backup/restore or RAID config operation :param irmc_info: node info :param operation: one of 'BACKUP_BIOS', 'RESTORE_BIOS' or 'CONFIG_RAID' :param session_id: session id :param session_timeout: session timeout :return: a dict with following values: { 'bios_config': , 'warning': } or { 'raid_config': , 'warning': } """ session_expiration = time.time() + session_timeout while time.time() < session_expiration: # Get session status to check session = elcm_session_get_status(irmc_info=irmc_info, session_id=session_id) status = session['Session']['Status'] if status == 'running' or status == 'activated': # Sleep a bit time.sleep(5) elif status == 'terminated regularly': result = {} if operation == 'BACKUP_BIOS': # Bios profile is created, get the data now result['bios_config'] = elcm_profile_get( irmc_info=irmc_info, profile_name=PROFILE_BIOS_CONFIG) elif operation == 'RESTORE_BIOS': # Bios config applied successfully pass elif operation == 'CONFIG_RAID': # Getting raid config result['raid_config'] = elcm_profile_get(irmc_info, PROFILE_RAID_CONFIG) # Cleanup operation by deleting related session and profile. # In case of error, report it as warning instead of error. try: elcm_session_delete(irmc_info=irmc_info, session_id=session_id, terminate=True) if operation == 'CONFIG_RAID': return result # FIXME: Currently, creating a profile will restart the # machine, which will cause an error during IPI installation, # so temporarily comment out the operation of deleting the # profile. # elcm_profile_delete(irmc_info=irmc_info, # profile_name=PROFILE_BIOS_CONFIG) except scci.SCCIError as e: result['warning'] = e return result else: # Error occurred, get session log to see what happened session_log = elcm_session_get_log(irmc_info=irmc_info, session_id=session_id) raise scci.SCCIClientError( ('Failed to %(operation)s config. ' 'Session log is "%(session_log)s".' % {'operation': operation, 'session_log': jsonutils.dumps(session_log)})) else: raise ELCMSessionTimeout( ('Failed to %(operation)s config. ' 'Session %(session_id)s log is timeout.' % {'operation': operation, 'session_id': session_id})) def backup_bios_config(irmc_info): """backup current bios configuration This function sends a BACKUP BIOS request to the server. Then when the bios config data are ready for retrieving, it will return the data to the caller. Note that this operation may take time. :param irmc_info: node info :return: a dict with following values: { 'bios_config': , 'warning': } """ result = {} # 1. Make sure there is no BiosConfig profile in the store try: # Get the profile first, if not found, then an exception # will be raised. result['bios_config'] = elcm_profile_get( irmc_info=irmc_info, profile_name=PROFILE_BIOS_CONFIG) # FIXME: Currently, creating a profile will restart the machine, # which will cause an error during IPI installation, # so temporarily comment out the operation of deleting the profile. # Profile found, delete it # elcm_profile_delete(irmc_info=irmc_info, # profile_name=PROFILE_BIOS_CONFIG) except ELCMProfileNotFound: # 2. Send request to create a new profile for BiosConfig session = elcm_profile_create(irmc_info=irmc_info, param_path=PARAM_PATH_BIOS_CONFIG) # 3. Profile creation is in progress, we monitor the session session_timeout = irmc_info.get('irmc_bios_session_timeout', BIOS_CONFIG_SESSION_TIMEOUT) return _process_session_data( irmc_info=irmc_info, operation='BACKUP_BIOS', session_id=session['Session']['Id'], session_timeout=session_timeout) return result def restore_bios_config(irmc_info, bios_config): """restore bios configuration This function sends a RESTORE BIOS request to the server. Then when the bios is ready for restoring, it will apply the provided settings and return. Note that this operation may take time. :param irmc_info: node info :param bios_config: bios config """ def _process_bios_config(): try: if isinstance(bios_config, dict): input_data = bios_config else: input_data = jsonutils.loads(bios_config) # The input data must contain flag "@Processing":"execute" in the # equivalent section. bios_cfg = input_data['Server']['SystemConfig']['BiosConfig'] bios_cfg['@Processing'] = 'execute' return input_data except (TypeError, ValueError, KeyError): raise scci.SCCIInvalidInputError( ('Invalid input bios config "%s".' % bios_config)) # 1. Parse the bios config and create the input data input_data = _process_bios_config() # FIXME: Currently, creating a profile will restart the machine, # which will cause an error during IPI installation, # so temporarily comment out the operation of deleting the profile. # 2. Make sure there is no BiosConfig profile in the store # try: # Get the profile first, if not found, then an exception # will be raised. # elcm_profile_get(irmc_info=irmc_info, # profile_name=PROFILE_BIOS_CONFIG) # Profile found, delete it # elcm_profile_delete(irmc_info=irmc_info, # profile_name=PROFILE_BIOS_CONFIG) # except ELCMProfileNotFound: # Ignore this error as it's not an error in this case # pass # 3. Send a request to apply the param values session = elcm_profile_set(irmc_info=irmc_info, input_data=input_data) # 4. Param values applying is in progress, we monitor the session session_timeout = irmc_info.get('irmc_bios_session_timeout', BIOS_CONFIG_SESSION_TIMEOUT) _process_session_data(irmc_info=irmc_info, operation='RESTORE_BIOS', session_id=session['Session']['Id'], session_timeout=session_timeout) def get_secure_boot_mode(irmc_info): """Get the status if secure boot is enabled or not. :param irmc_info: node info. :raises: SecureBootConfigNotFound, if there is no configuration for secure boot mode in the bios. :return: True if secure boot mode is enabled on the node, False otherwise. """ result = backup_bios_config(irmc_info=irmc_info) try: bioscfg = result['bios_config']['Server']['SystemConfig']['BiosConfig'] return bioscfg['SecurityConfig']['SecureBootControlEnabled'] except KeyError: msg = ("Failed to get secure boot mode from server %s. Upgrading iRMC " "firmware may resolve this issue." % irmc_info['irmc_address']) raise SecureBootConfigNotFound(msg) def set_secure_boot_mode(irmc_info, enable): """Enable/Disable secure boot on the server. :param irmc_info: node info :param enable: True, if secure boot needs to be enabled for next boot, else False. """ bios_config_data = { 'Server': { '@Version': '1.01', 'SystemConfig': { 'BiosConfig': { '@Version': '1.01', 'SecurityConfig': { 'SecureBootControlEnabled': enable } } } } } restore_bios_config(irmc_info=irmc_info, bios_config=bios_config_data) def _update_raid_input_data(target_raid_config, raid_input): """Process raid input data. :param target_raid_config: node raid info :param raid_input: raid information for creating via eLCM :raises ELCMValueError: raise msg if wrong input :return: raid_input: raid input data which create raid configuration { "Server":{ "HWConfigurationIrmc":{ "@Processing":"execute", "Adapters":{ "RAIDAdapter":[ { "@AdapterId":"RAIDAdapter0", "@ConfigurationType":"Addressing", "LogicalDrives":{ "LogicalDrive":[ { "@Number":0, "@Action":"Create", "RaidLevel":"1" } ] } } ] }, "@Version":"1.00" }, "@Version":"1.01" } } """ logical_disk_list = target_raid_config['logical_disks'] raid_input['Server']['HWConfigurationIrmc'].update({'@Processing': 'execute'}) array_info = raid_input['Server']['HWConfigurationIrmc']['Adapters'][ 'RAIDAdapter'][0] array_info['LogicalDrives'] = {'LogicalDrive': []} array_info['Arrays'] = {'Array': []} for i, logical_disk in enumerate(logical_disk_list): physical_disks = logical_disk.get('physical_disks') # Auto create logical drive along with random physical disks. # Allow auto create along with raid 10 and raid 50 # with specific physical drive. if not physical_disks or logical_disk['raid_level'] \ in ('10', '50'): array_info['LogicalDrives']['LogicalDrive'].append( {'@Action': 'Create', 'RaidLevel': logical_disk['raid_level'], 'InitMode': 'fast'}) array_info['LogicalDrives']['LogicalDrive'][i].update({ "@Number": i}) else: # Create array disks with specific physical servers arrays = { "@Number": i, "@ConfigurationType": "Setting", "PhysicalDiskRefs": { "PhysicalDiskRef": [] } } lo_drive = { "@Number": i, "@Action": "Create", "RaidLevel": "", "ArrayRefs": { "ArrayRef": [ ] }, "InitMode": "fast" } array_info['Arrays']['Array'].append(arrays) array_info['LogicalDrives']['LogicalDrive'].append(lo_drive) lo_drive.update({'RaidLevel': logical_disk['raid_level']}) lo_drive['ArrayRefs']['ArrayRef'].append({"@Number": i}) for element in logical_disk['physical_disks']: arrays['PhysicalDiskRefs']['PhysicalDiskRef'].append({ '@Number': element}) if logical_disk['size_gb'] != "MAX": # Ensure correctly order these items in dict size = collections.OrderedDict() size['@Unit'] = 'GB' size['#text'] = logical_disk['size_gb'] array_info['LogicalDrives']['LogicalDrive'][i]['Size'] = size return raid_input def get_raid_adapter(irmc_info): """Collect raid information on the server. :param irmc_info: node info :returns: raid_adapter: get latest raid adapter information """ # Update raid adapter, due to raid adapter cannot auto update after # created raid configuration. _create_raid_adapter_profile(irmc_info) return elcm_profile_get(irmc_info, PROFILE_RAID_CONFIG) def _get_existing_logical_drives(raid_adapter): """Collect existing logical drives on the server. :param raid_adapter: raid adapter info :returns: existing_logical_drives: get logical drive on server """ existing_logical_drives = [] logical_drives = raid_adapter['Server']['HWConfigurationIrmc'][ 'Adapters']['RAIDAdapter'][0].get('LogicalDrives') if logical_drives is not None: for drive in logical_drives['LogicalDrive']: existing_logical_drives.append(drive['@Number']) return existing_logical_drives def _create_raid_adapter_profile(irmc_info): """Attempt delete exist adapter then create new raid adapter on the server. :param irmc_info: node info :returns: result: a dict with following values: { 'raid_config': , 'warning': } """ try: # Attempt erase exist adapter on BM Server elcm_profile_delete(irmc_info, PROFILE_RAID_CONFIG) except ELCMProfileNotFound: # Ignore this error as it's not an error in this case pass session = elcm_profile_create(irmc_info, PARAM_PATH_RAID_CONFIG) # Monitoring currently session until done. session_timeout = irmc_info.get('irmc_raid_session_timeout', RAID_CONFIG_SESSION_TIMEOUT) return _process_session_data(irmc_info, 'CONFIG_RAID', session['Session']['Id'], session_timeout) def create_raid_configuration(irmc_info, target_raid_config): """Process raid_input then perform raid configuration into server. :param irmc_info: node info :param target_raid_config: node raid information """ if len(target_raid_config['logical_disks']) < 1: raise ELCMValueError(message="logical_disks must not be empty") # Check RAID config in the new RAID adapter. Must be erased before # create new RAID config. raid_adapter = get_raid_adapter(irmc_info) logical_drives = raid_adapter['Server']['HWConfigurationIrmc'][ 'Adapters']['RAIDAdapter'][0].get('LogicalDrives') session_timeout = irmc_info.get('irmc_raid_session_timeout', RAID_CONFIG_SESSION_TIMEOUT) if logical_drives is not None: # Delete exist logical drives in server. # NOTE(trungnv): Wait session complete and raise error if # delete raid config during FGI(Foreground Initialization) in-progress # in previous mechanism. delete_raid_configuration(irmc_info) # Updating raid adapter profile after deleted profile. raid_adapter = get_raid_adapter(irmc_info) # Create raid configuration based on target_raid_config of node raid_input = _update_raid_input_data(target_raid_config, raid_adapter) session = elcm_profile_set(irmc_info, raid_input) # Monitoring raid creation session until done. _process_session_data(irmc_info, 'CONFIG_RAID', session['Session']['Id'], session_timeout) def delete_raid_configuration(irmc_info): """Delete whole raid configuration or one of logical drive on the server. :param irmc_info: node info """ # Attempt to get raid configuration on BM Server raid_adapter = get_raid_adapter(irmc_info) existing_logical_drives = _get_existing_logical_drives(raid_adapter) # Ironic requires delete_configuration first. Will pass if blank raid # configuration in server. if not existing_logical_drives: return raid_adapter['Server']['HWConfigurationIrmc'].update({ '@Processing': 'execute'}) logical_drive = raid_adapter['Server']['HWConfigurationIrmc'][ 'Adapters']['RAIDAdapter'][0]['LogicalDrives']['LogicalDrive'] for drive in logical_drive: drive['@Action'] = 'Delete' # Attempt to delete logical drive in the raid config session = elcm_profile_set(irmc_info, raid_adapter) # Monitoring raid config delete session until done. session_timeout = irmc_info.get('irmc_raid_session_timeout', RAID_CONFIG_SESSION_TIMEOUT) _process_session_data(irmc_info, 'CONFIG_RAID', session['Session']['Id'], session_timeout) # Attempt to delete raid adapter elcm_profile_delete(irmc_info, PROFILE_RAID_CONFIG) def set_bios_configuration(irmc_info, settings): """Set BIOS configurations on the server. :param irmc_info: node info :param settings: Dictionary containing the BIOS configuration. :raise: BiosConfigNotFound, if there is wrong settings for bios configuration. """ bios_config_data = { 'Server': { 'SystemConfig': { 'BiosConfig': {} } } } versions = elcm_profile_get_versions(irmc_info) server_version = versions['Server'].get('@Version') bios_version = \ versions['Server']['SystemConfig']['BiosConfig'].get('@Version') if server_version: bios_config_data['Server']['@Version'] = server_version if bios_version: (bios_config_data['Server']['SystemConfig']['BiosConfig'] ['@Version']) = bios_version configs = {} for setting_param in settings: setting_name = setting_param.get("name") setting_value = setting_param.get("value") # Revert-conversion from a string of True/False to boolean. # It will be raise failed if put "True" or "False" string value. if isinstance(setting_value, six.string_types): if setting_value.lower() == "true": setting_value = True elif setting_value.lower() == "false": setting_value = False try: type_config, config = BIOS_CONFIGURATION_DICTIONARY[ setting_name].split("_") if type_config in configs.keys(): configs[type_config][config] = setting_value else: configs.update({type_config: {config: setting_value}}) except KeyError: raise BiosConfigNotFound("Invalid BIOS setting: %s" % setting_param) bios_config_data['Server']['SystemConfig']['BiosConfig'].update(configs) restore_bios_config(irmc_info, bios_config_data) def get_bios_settings(irmc_info): """Get the current BIOS settings on the server :param irmc_info: node info. :returns: a list of dictionary BIOS settings """ bios_config = backup_bios_config(irmc_info)['bios_config'] bios_config_data = bios_config['Server']['SystemConfig']['BiosConfig'] settings = [] # TODO(trungnv): Allow working with multi levels of BIOS dictionary. for setting_param in BIOS_CONFIGURATION_DICTIONARY: type_config, config = BIOS_CONFIGURATION_DICTIONARY[ setting_param].split("_") if config in bios_config_data.get(type_config, {}): value = six.text_type(bios_config_data[type_config][config]) settings.append({'name': setting_param, 'value': value}) return settings