ansible/community.general
1
0
Fork 0
mirror of https://github.com/ansible-collections/community.general.git synced 2024-09-14 20:13:21 +02:00
Code Releases Activity
community.general/plugins/module_utils/hpc_system_firmware_utils.py

445 lines
21 KiB
Python
Raw Normal View History

firmware update
2024-02-01 10:04:55 +01:00
# !/usr/bin/python
# -*- coding: utf-8 -*-
# Copyright (c) 2021-2022 Hewlett Packard Enterprise, Inc. All rights reserved.
# GNU General Public License v3.0+ (see LICENSES/GPL-3.0-or-later.txt or https://www.gnu.org/licenses/gpl-3.0.txt)
# SPDX-License-Identifier: GPL-3.0-or-later
from __future__ import absolute_import, division, print_function
__metaclass__ = type
import os
import json
import subprocess
import time
from ansible_collections.community.general.plugins.module_utils.redfish_utils import RedfishUtils
from ansible.module_utils.urls import open_url
try:
from requests_toolbelt import MultipartEncoder
HAS_REQUESTS_TOOLBELT = True
except ImportError:
HAS_REQUESTS_TOOLBELT = False
comment
2024-02-07 06:22:52 +01:00
REQUESTS_TOOLBELT_REQUIRED = "Requests_toolbelt is required for this module"
firmware update
2024-02-01 10:04:55 +01:00
def has_requests_toolbelt(module):
"""
Check Request_toolbelt is installed
:param module:
"""
if not HAS_REQUESTS_TOOLBELT:
module.fail_json(msg=REQUESTS_TOOLBELT_REQUIRED)
supported_models = ["HPE CRAY XD220V", "HPE CRAY XD225V", "HPE CRAY XD295V", "HPE CRAY XD665", "HPE CRAY XD670"]
# To get inventory, update
supported_targets = {
"HPE CRAY XD220V": ["BMC", "BIOS", "MainCPLD", "HDDBPPIC", "PDBPIC"],
"HPE CRAY XD225V": ["BMC", "BIOS", "MainCPLD", "HDDBPPIC", "PDBPIC"],
"HPE CRAY XD295V": ["BMC", "BIOS", "MainCPLD", "HDDBPPIC", "PDBPIC"],
"HPE CRAY XD665": ["BMC", "BIOS", "RT_NVME", "RT_OTHER", "RT_SA", "PDB", "MainCPLD", "UBM6"],
"HPE CRAY XD670": ["BMCImage1", "BMCImage2", "BIOS", "BIOS2", "BPB_CPLD1", "BPB_CPLD2", "MB_CPLD1", "SCM_CPLD1"],
}
unsupported_targets = ["BMCImage1", "BPB_CPLD1", "BPB_CPLD2", "MB_CPLD1", "SCM_CPLD1"] # Only of Jakku
# BMCImage1 equivalent to BMC
# BPB_CPLD1 and BPB_CPLD2 together equivalent to BPB_CPLD
# MB_CPLD1 and SCM_CPLD1 together equivalent to MB_CPLD1_SCM_CPLD1
all_targets = ['BMC', 'BMCImage1', 'BMCImage2', 'BIOS', 'BIOS2', 'MainCPLD',
'MB_CPLD1', 'BPB_CPLD1', 'BPB_CPLD2', 'SCM_CPLD1', 'PDB', 'PDBPIC', 'HDDBPPIC', 'RT_NVME', 'RT_OTHER', 'RT_SA', 'UBM6']
reboot = {
"BIOS": ["AC_PC_redfish"],
"BIOS2": ["AC_PC_redfish"],
"MainCPLD": ["AC_PC_ipmi"],
"PDB": ["AC_PC_ipmi"],
"RT_NVME": ["AC_PC_redfish", "AC_PC_ipmi", "AC_PC_redfish"],
"RT_SA": ["AC_PC_redfish", "AC_PC_ipmi", "AC_PC_redfish"],
"RT_OTHER": ["AC_PC_redfish", "AC_PC_ipmi", "AC_PC_redfish"],
"HDDBPPIC": ["AC_PC_redfish"],
"PDBPIC": ["AC_PC_redfish"]
}
routing = {
"HPE CRAY XD220V": "0x34 0xa2 0x00 0x19 0xA9",
"HPE CRAY XD225V": "0x34 0xa2 0x00 0x19 0xA9",
"HPE CRAY XD295V": "0x34 0xa2 0x00 0x19 0xA9",
"HPE CRAY XD665": "0x34 0xA2 0x00 0x19 0xa9 0x00"
}
class CrayRedfishUtils(RedfishUtils):
def post_multi_request(self, uri, headers, payload):
username, password, basic_auth = self._auth_params(headers)
try:
resp = open_url(uri, data=payload, headers=headers, method="POST",
url_username=username, url_password=password,
force_basic_auth=basic_auth, validate_certs=False,
follow_redirects='all',
use_proxy=True, timeout=self.timeout)
resp_headers = dict((k.lower(), v) for (k, v) in resp.info().items())
return True
except Exception as e:
return False
def get_model(self):
response = self.get_request(self.root_uri + "/redfish/v1/Systems/Self")
if response['ret'] is False:
return "NA"
try:
if 'Model' in response['data']:
model = response['data'][u'Model']
if model is not None:
model = model[:15]
else:
model = 'None'
else:
model = 'None'
return model
except Exception:
if 'Model' in response:
model = response[u'Model']
if model is not None:
model = model[:15]
else:
model = 'None'
else:
model = 'None'
return model
def power_state(self):
response = self.get_request(self.root_uri + "/redfish/v1/Systems/Self")
if response['ret'] is False:
return "NA"
try:
if 'PowerState' in response['data']:
state = response['data'][u'PowerState']
if state is None:
state = 'None'
else:
state = 'None'
return state
except Exception:
if 'PowerState' in response:
state = response[u'PowerState']
if state is None:
state = 'None'
else:
state = 'None'
return state
def power_on(self):
payload = {"ResetType": "On"}
target_uri = "/redfish/v1/Systems/Self/Actions/ComputerSystem.Reset"
response1 = self.post_request(self.root_uri + target_uri, payload)
time.sleep(120)
def power_off(self):
payload = {"ResetType": "ForceOff"}
target_uri = "/redfish/v1/Systems/Self/Actions/ComputerSystem.Reset"
response1 = self.post_request(self.root_uri + target_uri, payload)
time.sleep(120)
def get_PS_CrayXD670(self, attr):
IP = attr.get('baseuri')
option = attr.get('power_state')
csv_file_name = attr.get('output_file_name')
if not os.path.exists(csv_file_name):
f = open(csv_file_name, "w")
to_write = "IP_Address, Model, Power_State\n"
f.write(to_write)
f.close()
model = self.get_model()
if model.upper() == "HPE CRAY XD670":
power_state = self.power_state()
if option.upper() == "NA":
lis = [IP, model, power_state]
elif option.upper() == "ON":
if power_state.upper() == "OFF":
self.power_on()
power_state = self.power_state()
lis = [IP, model, power_state]
elif option.upper() == "OFF":
if power_state.upper() == "ON":
self.power_off()
power_state = self.power_state()
lis = [IP, model, power_state]
else:
return {'ret': False, 'changed': True, 'msg': 'Must specify the correct required option for power_state'}
else:
lis = [IP, model, "unsupported_model"]
new_data = ", ".join(lis)
return {'ret': True, 'changed': True, 'msg': str(new_data)}
def target_supported(self, model, target):
if target in supported_targets[model.upper()]:
return True
return False
def get_fw_version(self, target):
try:
response = self.get_request(self.root_uri + "/redfish/v1/UpdateService/FirmwareInventory" + "/" + target)
try:
version = response['data']['Version']
return version
except Exception:
version = response['Version']
return version
except Exception:
return "failed_FI_GET_call/no_version_field"
def AC_PC_redfish(self):
payload = {"ResetType": "ForceRestart"}
target_uri = "/redfish/v1/Systems/Self/Actions/ComputerSystem.Reset"
response1 = self.post_request(self.root_uri + target_uri, payload)
time.sleep(180)
target_uri = "/redfish/v1/Chassis/Self/Actions/Chassis.Reset"
response2 = self.post_request(self.root_uri + target_uri, payload)
time.sleep(180)
return response1 or response2
def AC_PC_ipmi(self, IP, username, password, routing_value):
try:
command = 'ipmitool -I lanplus -H ' + IP + ' -U ' + username + ' -P ' + password + ' raw ' + routing_value
subprocess.run(command, shell=True, check=True, timeout=15, capture_output=True)
time.sleep(300)
return True
except Exception:
return False
def get_sys_fw_inventory(self, attr):
IP = attr.get('baseuri')
csv_file_name = attr.get('output_file_name')
if not os.path.exists(csv_file_name):
f = open(csv_file_name, "w")
to_write = """IP_Address, Model, BMC, BMCImage1, BMCImage2, BIOS, BIOS2, MainCPLD, MB_CPLD1,
BPB_CPLD1, BPB_CPLD2, SCM_CPLD1, PDB, PDBPIC, HDDBPPIC, RT_NVME, RT_OTHER, RT_SA, UBM6\n"""
f.write(to_write)
f.close()
model = self.get_model()
entry = []
entry.append(IP)
if model.upper() not in supported_models:
entry.append("unsupported_model")
for target in all_targets:
entry.append("NA")
else:
entry.append(model)
for target in all_targets:
if target in supported_targets[model.upper()]:
version = self.get_fw_version(target)
if version.startswith("failed"):
version = "NA" # "no_comp/no_version"
else:
version = "NA"
entry.append(version)
new_data = ", ".join(entry)
return {'ret': True, 'changed': True, 'msg': str(new_data)}
def helper_update(self, update_status, target, image_path, image_type, IP, username, password, model):
before_version = "failed"
if target != "BPB_CPLD" and target != "SCM_CPLD1" and target != "MB_CPLD1":
before_version = self.get_fw_version(target)
after_version = "NA"
else:
before_version = "NA"
if not before_version.startswith("failed"):
# proceed for update
response = self.get_request(self.root_uri + "/redfish/v1/UpdateService")
if response['ret'] is False:
update_status = "UpdateService api not found"
else:
data = response['data']
if 'MultipartHttpPushUri' in data:
headers = {'Expect': 'Continue', 'Content-Type': 'multipart/form-data'}
body = {}
if target != "BPB_CPLD":
targets_uri = '/redfish/v1/UpdateService/FirmwareInventory/' + target + '/'
body['UpdateParameters'] = (None, json.dumps({"Targets": [targets_uri]}), 'application/json')
else:
body['UpdateParameters'] = (None, json.dumps({"Targets":
['/redfish/v1/UpdateService/FirmwareInventory/BPB_CPLD1/',
'/redfish/v1/UpdateService/FirmwareInventory/BPB_CPLD2/']}),
'application/json')
body['OemParameters'] = (None, json.dumps({"ImageType": image_type}), 'application/json')
with open(image_path, 'rb') as image_path_rb:
body['UpdateFile'] = (image_path, image_path_rb, 'application/octet-stream')
encoder = MultipartEncoder(body)
body = encoder.to_string()
headers['Content-Type'] = encoder.content_type
response = self.post_multi_request(self.root_uri + data['MultipartHttpPushUri'],
headers=headers, payload=body)
if response is False:
update_status = "failed_POST"
else:
# Add time.sleep (for system to comeback after flashing)
time.sleep(300)
# Call reboot logic based on target
if target in reboot:
what_reboots = reboot[target]
for reb in what_reboots:
if reb == "AC_PC_redfish":
result = self.AC_PC_redfish()
if not result:
update_status = "reboot_failed"
break
time.sleep(300)
elif reb == "AC_PC_ipmi":
# based on the model end routing code changes
result = self.AC_PC_ipmi(IP, username, password, routing[model.upper()])
if not result:
update_status = "reboot_failed"
break
# if target=="MB_CPLD1" or "BPB" in target:
# turn node back to on -- call power_on_node function
# self.power_on()
# not required to power on the node as it useful only after physical POWER CYCLE and we can't keep the track of the
# physical power cycle so skipping it
if update_status.lower() == "success":
# call version of respective target and store versions after update
time.sleep(180) # extra time requiring as of now for systems under test
if target != "BPB_CPLD" and target != "SCM_CPLD1" and target != "MB_CPLD1":
after_version = self.get_fw_version(target)
else:
if target != "BPB_CPLD" and target != "SCM_CPLD1" and target != "MB_CPLD1":
after_version = "NA"
update_status = "failed"
if target != "BPB_CPLD" and target != "SCM_CPLD1" and target != "MB_CPLD1":
return before_version, after_version, update_status
else:
return update_status
def system_fw_update(self, attr):
IP = attr.get('baseuri')
username = attr.get('username')
password = attr.get('password')
image_type = attr.get('update_image_type')
update_status = "Success"
is_target_supported = False
image_path = "NA"
target = attr.get('update_target')
image_path_inputs = {
"HPE CRAY XD220V": attr.get('update_image_path_xd220V'),
"HPE CRAY XD225V": attr.get('update_image_path_xd225V'),
"HPE CRAY XD295V": attr.get('update_image_path_xd295V'),
"HPE CRAY XD665": attr.get('update_image_path_xd665'),
"HPE CRAY XD670": attr.get('update_image_path_xd670')}
csv_file_name = attr.get('output_file_name')
# Have a check that atleast one image path set based out of the above new logic
if not any(image_path_inputs.values()):
return {'ret': False, 'changed': True, 'msg': 'Must specify atleast one update_image_path'}
if target == "" or target.upper() in unsupported_targets:
return {'ret': False, 'changed': True, 'msg': 'Must specify the correct target for firmware update'}
model = self.get_model()
if not os.path.exists(csv_file_name):
f = open(csv_file_name, "w")
if target == "BPB_CPLD" or target == "SCM_CPLD1_MB_CPLD1":
to_write = "IP_Address, Model, Update_Status, Remarks\n"
else:
to_write = "IP_Address, Model, " + target + '_Pre_Ver, ' + target + '_Post_Ver, ' + "Update_Status\n"
f.write(to_write)
f.close()
# check if model is Cray XD670 and target is BMC assign default value of BMC as BMCImage1
if model.upper() == "HPE CRAY XD670" and target == "BMC":
target = "BMCImage1"
if model.upper() not in supported_models:
update_status = "unsupported_model"
if target == "SCM_CPLD1_MB_CPLD1" or target == "BPB_CPLD":
lis = [IP, model, update_status, "NA"]
else:
lis = [IP, model, "NA", "NA", update_status]
new_data = ", ".join(lis)
return {'ret': True, 'changed': True, 'msg': str(new_data)}
else:
image_path = image_path_inputs[model.upper()]
if model.upper() == "HPE CRAY XD670" and "CPLD" in target.upper():
power_state = self.power_state()
if power_state.lower() != "on":
update_status = "NA"
lis = [IP, model, update_status, "node is not ON, please power on the node"]
new_data = ", ".join(lis)
return {'ret': True, 'changed': True, 'msg': str(new_data)}
elif target == 'SCM_CPLD1_MB_CPLD1':
is_target_supported = True
image_paths = image_path_inputs["HPE CRAY XD670"].split()
if len(image_paths) != 2:
return {'ret': False, 'changed': True, 'msg': '''Must specify exactly 2 image_paths,
first for SCM_CPLD1 of Cray XD670 and second for MB_CPLD1 of Cray XD670'''}
for img_path in image_paths:
if not os.path.isfile(img_path):
return {'ret': False, 'changed': True,
'msg': '''Must specify correct image_paths for SCM_CPLD1_MB_CPLD1, first for SCM_CPLD1
of Cray XD670 and second for MB_CPLD1 of Cray XD670'''}
if target != "SCM_CPLD1_MB_CPLD1" and not os.path.isfile(image_path):
update_status = "NA_fw_file_absent"
if target == "BPB_CPLD":
lis = [IP, model, update_status, "NA"]
else:
lis = [IP, model, "NA", "NA", update_status]
new_data = ", ".join(lis)
return {'ret': True, 'changed': True, 'msg': str(new_data)}
else:
if target != "SCM_CPLD1_MB_CPLD1" and target != "BPB_CPLD":
is_target_supported = self.target_supported(model, target)
if model.upper() == "HPE CRAY XD670" and (target == "BMC" or target == "BPB_CPLD"):
is_target_supported = True
if not is_target_supported:
update_status = "target_not_supported"
if target == "SCM_CPLD1_MB_CPLD1" or target == "BPB_CPLD":
lis = [IP, model, update_status, "NA"]
else:
lis = [IP, model, "NA", "NA", update_status]
new_data = ", ".join(lis)
return {'ret': True, 'changed': True, 'msg': str(new_data)}
else:
# check if model is Cray XD670 and target is BMC assign default value of BMC as BMCImage1
if model.upper() == "HPE CRAY XD670" and target == "BMC":
target = "BMCImage1"
# call version of respective target and store versions before update
if target == "SCM_CPLD1_MB_CPLD1":
update_status = self.helper_update(update_status, "SCM_CPLD1", image_paths[0], image_type, IP, username, password, "HPE Cray XD670")
if update_status.lower() == "success":
# SCM has updates successfully, proceed for MB_CPLD1 update
# check node to be off -- call power_off_node function
power_state = self.power_state()
if power_state.lower() == "on":
self.power_off()
power_state = self.power_state()
if power_state.lower() == "on":
lis = [IP, model, "NA", "MB_CPLD1 requires node off, tried powering off the node, but failed to power off"]
update_status = self.helper_update(update_status, "MB_CPLD1",
image_paths[1], image_type, IP, username, password, "HPE Cray XD670")
if update_status.lower() == "success":
remarks = "Please plug out and plug in power cables physically"
else:
remarks = "Please reflash the firmware and DO NOT DO physical power cycle"
lis = [IP, model, update_status, remarks]
elif target == "BPB_CPLD":
update_status = self.helper_update(update_status, target, image_path, image_type, IP, username, password, model)
if update_status.lower() == "success":
remarks = "Please plug out and plug in power cables physically"
else:
remarks = "Please reflash the firmware and DO NOT DO physical power cycle"
lis = [IP, model, update_status, remarks]
else:
bef_ver, aft_ver, update_status = self.helper_update(update_status, target, image_path, image_type, IP, username, password, model)
lis = [IP, model, bef_ver, aft_ver, update_status]
new_data = ", ".join(lis)
return {'ret': True, 'changed': True, 'msg': str(new_data)}
Copy permalink