def get_system_thermal (system):
system = int (system)
view_helper.run_pre_check (pre_check.pre_check_function_call, command_name_enum.get_blade_state,
device_id = system)
query_temp = [
(controls.server_health.show_temperature_health, {"serverid" : system})
]
query_fan = [
(controls.server_health.show_fan_health, {"serverid" : system})
]
result_temp = execute_get_request_queries (query_temp)
result_fan = execute_get_request_queries (query_fan)
temps = parse_sensor_list (sensors = result_temp, convert_reading = True, convert_number = True,
sensor_type = "Sensor")
fans = parse_sensor_list (sensors = result_fan, convert_reading = True, convert_number = False,
sensor_type = "Fan")
result = {}
view_helper.append_response_information (result, result_temp)
view_helper.append_response_information (result, result_fan)
if (temps):
result["temps"] = temps
if (fans):
result["fans"] = fans
result["ID"] = system
return view_helper.return_redfish_resource ("system_thermal", values = result)
def get_pmdu_power_meter (patch = dict ()):
if (not patch):
view_helper.run_pre_check (pre_check.pre_check_function_call,
command_name_enum.get_rm_state)
query = [
(controls.manage_powermeter.get_rack_power_limit_policy, {}),
(controls.manage_powermeter.get_rack_power_throttle_status, {}),
(controls.manage_powermeter.get_rack_power_reading, {}),
(controls.manage_powermeter.get_rack_pru_fw_version, {})
]
result = execute_get_request_queries (query)
if ("Feed1PowerStatus" in result):
if (result["Feed1PowerStatus"] == "Healthy"):
result["Feed1PowerStatus"] = ""
if ("Feed2PowerStatus" in result):
if (result["Feed2PowerStatus"] == "Healthy"):
result["Feed2PowerStatus"] = ""
if ("IsDcThrottleEnabled" in result):
result["IsDcThrottleEnabled"] = enums.Boolean (result["IsDcThrottleEnabled"],
convert = True)
if ("IsDcThrottleActive" in result):
result["IsDcThrottleActive"] = enums.Boolean (result["IsDcThrottleActive"], convert = True)
if ("IsAlertEnabled" in result):
result["IsAlertEnabled"] = enums.Boolean (result["IsAlertEnabled"], convert = True)
if ("IsAlertActive" in result):
result["IsAlertActive"] = enums.Boolean (result["IsAlertActive"], convert = True)
view_helper.update_and_replace_status_information (result, patch)
return view_helper.return_redfish_resource ("pmdu_power_meter", values = result)
def get_bmc_log_services(slot_id):
pre_check_slot_id(slot_id)
query = [(controls.manage_bmc.get_bmc_attention_led_status, {}),
(controls.manage_bmc.get_bmc_slot_id, {})]
result = execute_get_request_queries(query)
return view_helper.return_redfish_resource("bmc_log_service",
values=result)
def get_system_log (system):
system = int (system)
view_helper.run_pre_check (pre_check.pre_check_function_call, command_name_enum.get_blade_state,
device_id = system)
result = {"ID" : system}
return view_helper.return_redfish_resource ("system_log", values = result)
def get_system_bios_config (system, patch = dict ()):
system = int (system)
if (not patch):
view_helper.run_pre_check (pre_check.pre_check_function_call,
command_name_enum.get_blade_state, device_id = system)
query = [
(controls.bladebios_lib.get_server_bios_config, {"serverid" : system})
]
result = execute_get_request_queries (query, {"ID" : system})
configs = []
if ("AvailableConfigName" in result):
configs.append ({"Config_Name" : result["AvailableConfigName"]})
else:
config_list = result.get ("AvailableConfigurations", {})
if (config_list):
i = 1
while i in config_list:
configs.append (config_list[i])
i += 1
result["AvailableConfigs"] = configs
view_helper.update_and_replace_status_information (result, patch)
return view_helper.return_redfish_resource ("system_bios_cfg", values = result)
def get_rack_inventory ():
view_helper.run_pre_check (pre_check.pre_check_function_call, command_name_enum.get_rm_state)
query = [
(controls.bladeinfo_lib.manager_inventory, {"mode" : "pmdu"})
]
result = execute_get_request_queries (query)
parsed = [None] * len (result)
if (result[completion_code.cc_key] == completion_code.success):
for i, item in result.items ():
try:
idx = int (i) - 1
if ("Port_Present" in item):
item["Port_Present"] = enums.Boolean (item["Port_Present"], convert = True)
if ("Port_State" in item):
item["Port_State"] = enums.PowerState (item["Port_State"], convert = True)
parsed[idx] = item
del result[i]
except ValueError:
pass
parsed = filter (None, parsed)
if (parsed):
result["list"] = parsed
return view_helper.return_redfish_resource ("rack_inventory", values = result)
def get_bmc_networkprotocol(slot_id, patch=dict()):
pre_check_slot_id(slot_id)
query = [(controls.manage_bmc.show_bmc_hostname, {}),
(controls.manage_bmc.get_bmc_slot_id, {})]
result = execute_get_request_queries(query)
view_helper.update_and_replace_status_information(result, patch)
return view_helper.return_redfish_resource("bmc_networkprotocol",
values=result)
def get_accounts():
pre_check_function_call(command_name_enum.get_rm_state)
query = [(controls.manage_user.user_list_all, {})]
result = execute_get_request_queries(query)
return view_helper.return_redfish_resource("accounts", values=result)
def get_chassis_power(slot_id):
pre_check_slot_id(slot_id)
query = [(controls.manage_bmc.get_bmc_slot_id, {}),
(controls.chassis_system_power.get_chassis_power, {})]
result = execute_get_request_queries(query)
return view_helper.return_redfish_resource("chassis_power", values=result)
def get_rack_manager_tftp ():
view_helper.run_pre_check (pre_check.pre_check_function_call, command_name_enum.get_rm_state)
query = [
(controls.manage_rack_manager.manager_tftp_server_listfiles, {})
]
result = execute_get_request_queries (query)
return view_helper.return_redfish_resource ("rack_manager_tftp", values = result)
def get_rack_manager_thermal ():
view_helper.run_pre_check (pre_check.pre_check_function_call, command_name_enum.get_rm_state)
query = [
(controls.manage_rack_manager.get_sensor_objects, {})
]
result = execute_get_request_queries (query)
return view_helper.return_redfish_resource ("rack_manager_thermal", values = result)
def get_bmc_log(slot_id):
pre_check_slot_id(slot_id)
query = [(controls.manage_bmc.get_bmc_attention_led_status, {}),
(controls.manage_bmc.get_bmc_slot_id, {})]
result = execute_get_request_queries(query)
result["DateTime"] = datetime.datetime.fromtimestamp(
time.time()).strftime('%Y-%m-%d %H:%M:%S')
return view_helper.return_redfish_resource("bmc_log", values=result)
def get_bmc_log_entries(slot_id):
pre_check_slot_id(slot_id)
query = [(controls.manage_logentry.get_event_log_all, {}),
(controls.manage_bmc.get_bmc_slot_id, {})]
result = execute_get_request_queries(query)
return view_helper.return_redfish_resource("bmc_log_entries",
values=result)
def get_rack_manager_ethernets ():
view_helper.run_pre_check (pre_check.pre_check_function_call, command_name_enum.get_rm_state)
query = [
(controls.manage_network.display_cli_interfaces, {})
]
result = execute_get_request_queries (query)
return view_helper.return_redfish_resource ("rack_manager_ethernets", values = result)
def get_switch_chassis ():
view_helper.run_pre_check (pre_check.pre_check_function_call, command_name_enum.get_rm_state)
query = [
(models.switch_manager.getswitch (load_config.switch_ip, "").getswitch_info, {})
]
result = execute_get_request_queries (query)
return view_helper.return_redfish_resource ("switch_chassis", values = result)
def get_rack_chassis ():
view_helper.run_pre_check (pre_check.pre_check_function_call, command_name_enum.get_rm_state)
query = [
(controls.manage_rack_manager.read_fru, {"boardtype" : "rm_mb"})
]
result = execute_get_request_queries (query)
return view_helper.return_redfish_resource ("rack_chassis", values = result)
def get_bmc(slot_id, patch=dict()):
pre_check_slot_id(slot_id)
query = [(controls.manage_fwversion.get_ocsfwversion, {}),
(controls.manage_bmc.show_bmc_time, {
"edm": True
}), (controls.manage_bmc.get_bmc_slot_id, {})]
result = execute_get_request_queries(query)
view_helper.update_and_replace_status_information(result, patch)
return view_helper.return_redfish_resource("bmc", values=result)
def post_bmc_fw_update_state(slot_id):
pre_check_slot_id(slot_id)
result = {}
validation = {
"Action" : parameter_parser ("action", str)
}
params = validate_action_parameters(validation)
result = controls.manage_bmc.get_bmc_fwupdate_state(**params)
if result[completion_code.cc_key] == completion_code.failure:
return check_action_result(result)
return view_helper.return_redfish_resource ("bmc_fw_update_state", values = result)
def get_bmc_log_entry(slot_id, entry):
pre_check_slot_id(slot_id)
query = [(controls.manage_logentry.get_event_log, {
"log_id": entry
}), (controls.manage_bmc.get_bmc_slot_id, {})]
result = execute_get_request_queries(query)
if "Id" not in result:
raise HTTPError(status=404)
return view_helper.return_redfish_resource("bmc_log_entry", values=result)
def get_chassis(slot_id, patch=dict()):
pre_check_slot_id(slot_id)
query = [(controls.manage_bmc.get_bmc_slot_id, {}),
(controls.manage_bmc.get_bmc_attention_led_status, {}),
(controls.chassis_system.get_chassis_power_state, {}),
(controls.chassis_system.get_chassis_fru, {})]
result = execute_get_request_queries(query)
view_helper.update_and_replace_status_information(result, patch)
return view_helper.return_redfish_resource("chassis", values=result)
def get_account(account, patch=dict()):
if (not patch):
view_helper.verify_account_name(account)
pre_check_function_call(command_name_enum.get_rm_state)
query = [(controls.manage_user.get_groupname_from_username, {
"username": account
})]
result = execute_get_request_queries(query, {"Account": account})
view_helper.update_and_replace_status_information(result, patch)
return view_helper.return_redfish_resource("account", values=result)
def get_system_log_entries (system):
system = int (system)
view_helper.run_pre_check (pre_check.pre_check_function_call, command_name_enum.get_blade_state,
device_id = system)
query = [
(controls.bladelog_lib.read_server_log, {"serverid": system, "raw_output": False})
]
result = execute_get_request_queries (query)
result["EntryID"] = system
return view_helper.return_redfish_resource ("system_log_entries", values = result)
def get_session (session):
view_helper.run_pre_check (pre_check.pre_check_function_call, command_name_enum.get_rm_state)
query = [
(controls.manage_rack_manager.manager_session, {"sessionid": int(session)})
]
result = execute_get_request_queries (query, {"ID" : session})
for error in result.get (view_helper.response_status_key, []):
if ("Invalid session id" in error.get (completion_code.desc, "")):
raise HTTPError (status = 404)
return view_helper.return_redfish_resource ("session", values = result)
def get_system (system, patch = dict ()):
system = int (system)
if (not patch):
view_helper.run_pre_check (pre_check.pre_check_function_call,
command_name_enum.get_blade_state, device_id = system)
query = [
(controls.bladeinfo_lib.system_info_call, {"bladeId" : system}),
(controls.bladepowerstate_lib.get_server_default_powerstate, {"serverid" : system}),
(controls.bladetpmphypresence_lib.get_tpm_physical_presence, {"serverid" : system}),
(controls.bladenextboot_lib.get_nextboot, {"serverid" : system})
]
result = view_helper.flatten_nested_objects (
execute_get_request_queries (query, {"ID" : system}))
for health in ["Server_Status_HealthRollUp", "Server_Status_Health",
"Server_ProcessorSummary_Status_HealthRollUp", "Server_ProcessorSummary_Status_Health",
"Server_MemorySummary_Status_HealthRollUp", "Server_MemorySummary_Status_Health"]:
if (health in result):
result[health] = enums.Health (result[health], convert = True)
for state in ["Server_Status_State", "Server_ProcessorSummary_Status_State",
"Server_MemorySummary_Status_State"]:
if (state in result):
result[state] = enums.State (result[state], convert = True)
for state in ["Sever_PowerState", "Default_Power_State"]:
if (state in result):
result[state] = enums.PowerState (result[state], convert = True)
if ("BootSourceOverrideTarget" in result):
result["BootSourceOverrideTarget"] = enums.BootSourceOverrideTarget (
result["BootSourceOverrideTarget"], convert = True)
if ("BootSourceOverrideMode" in result):
result["bootSourceOverrideMode"] = enums.BootSourceOverrideMode (
result["BootSourceOverrideMode"], convert = True)
if ("PhysicalPresence" in result):
result["PhysicalPresence"] = enums.Boolean (result["PhysicalPresence"], convert = True)
if (result.get ("BootSourceOverrideTarget", "") == enums.BootSourceOverrideTarget.NONE):
result["BootSourceOverrideEnabled"] = enums.BootSourceOverrideEnabled (
enums.BootSourceOverrideEnabled.DISABLED)
else:
if ("BootSourceOverrideEnabled" in result):
result["BootSourceOverrideEnabled"] = enums.BootSourceOverrideEnabled (
result["BootSourceOverrideEnabled"], convert = True)
view_helper.update_and_replace_status_information (result, patch)
return view_helper.return_redfish_resource ("system", values = result)
def get_rack_manager_log ():
view_helper.run_pre_check (pre_check.pre_check_function_call, command_name_enum.get_rm_state)
query = [
(controls.manage_rack_manager.show_rack_manager_log_status, {})
]
result = execute_get_request_queries (query)
if ("TelemetryDaemonStatus" in result):
result["TelemetryDaemonStatus"] = enums.State (result["TelemetryDaemonStatus"],
convert = True)
return view_helper.return_redfish_resource ("rack_manager_log", values = result)
def get_chassis_storage_enclosure_thermal(slot_id, se_id):
pre_check_slot_id(slot_id)
if (not (1 <= int(se_id) and int(se_id) <= 4)):
raise HTTPError(status=404)
query = [(controls.storage_enclosure.get_storage_enclosure_thermal, {
"expander_id": int(se_id)
})]
result = execute_get_request_queries(query)
return view_helper.return_redfish_resource(
"chassis_storage_enclosure_thermal", values=result)
def post_bmc_master_write_read(slot_id):
pre_check_slot_id(slot_id)
result = {}
validation = {
"Bus" : parameter_parser ("bus", str),
"SlaveAddress": parameter_parser("slaveaddress", str),
"ReadCount": parameter_parser("readcount", str),
"WriteData": parameter_parser("writedata", str)
}
params = validate_action_parameters(validation)
result = controls.manage_bmc.bmc_i2c_master_write_read(**params)
if result[completion_code.cc_key] == completion_code.failure:
return check_action_result(result)
return view_helper.return_redfish_resource ("bmc_master_write_read", values = result)
def get_switch_thermal ():
view_helper.run_pre_check (pre_check.pre_check_function_call, command_name_enum.get_rm_state)
query = [
(models.switch_manager.getswitch (load_config.switch_ip, "").getswitch_info, {})
]
result = execute_get_request_queries (query)
if ("TemperatureSensorState" in result):
result["TemperatureSensorState"] = str (enums.Health (
str(result["TemperatureSensorState"]), convert = True))
return view_helper.return_redfish_resource ("switch_thermal", values = result)
def get_rack_manager_log_entries ():
view_helper.run_pre_check (pre_check.pre_check_function_call, command_name_enum.get_rm_state)
query = [
(controls.manage_rack_manager.get_rack_manager_log,
{"filename": telemetry_log_path, "raw": False})
]
result = execute_get_request_queries (query)
if (("members" in result) and (completion_code.cc_key in result)):
for value in result["members"].itervalues ():
value["Severity"] = enums.Health (value["Severity"], convert = True)
return view_helper.return_redfish_resource ("rack_manager_log_entries", values = result)
def get_pmdu_chassis ():
view_helper.run_pre_check (pre_check.pre_check_function_call, command_name_enum.get_rm_state)
if ((pre_check.get_mode () == rm_mode_enum.rowmanager) or
(pre_check.get_mode () == rm_mode_enum.standalone_rackmanager)):
board = "row_pib"
else:
board = "rm_pib"
query = [
(controls.manage_rack_manager.read_fru, {"boardtype" : board})
]
result = execute_get_request_queries (query)
return view_helper.return_redfish_resource ("pmdu_chassis", values = result)
