b7fe87a346
Adding some basic classes around redfish client. Change-Id: I5cd581470c0620845992263e323e3f3e1c9767f2 Signed-off-by: jpike <jason.pike@windriver.com>
556 lines
16 KiB
Python
556 lines
16 KiB
Python
from framework.redfish.objects.boot import Boot
|
|
from framework.redfish.objects.computer_system_reset import ComputerSystemReset
|
|
from framework.redfish.objects.memory_summary import MemorySummary
|
|
from framework.redfish.objects.processor_summary import ProcessorSummary
|
|
from framework.redfish.objects.status import Status
|
|
from framework.redfish.objects.trusted_modules import TrustedModule
|
|
|
|
|
|
class SystemInfo:
|
|
"""Represents system information from Redfish API."""
|
|
|
|
def __init__(self, data: dict):
|
|
"""Initialize SysInfo object.
|
|
|
|
Args:
|
|
data (dict): Dictionary containing system data.
|
|
|
|
Raises:
|
|
ValueError: If data is None or empty.
|
|
"""
|
|
if not data:
|
|
raise ValueError("System data cannot be None or empty")
|
|
|
|
# Simple attributes
|
|
self.power_state = data.get("PowerState", "")
|
|
self.manufacturer = data.get("Manufacturer", "")
|
|
self.model = data.get("Model", "")
|
|
self.serial_number = data.get("SerialNumber", "")
|
|
self.bios_version = data.get("BiosVersion", "")
|
|
self.asset_tag = data.get("AssetTag", "")
|
|
self.host_name = data.get("HostName", "")
|
|
self.indicator_led = data.get("IndicatorLED", "")
|
|
self.last_reset_time = data.get("LastResetTime", "")
|
|
self.location_indicator_active = data.get("LocationIndicatorActive", "")
|
|
self.name = data.get("Name", "")
|
|
self.part_number = data.get("PartNumber", "")
|
|
self.sku = data.get("SKU", "")
|
|
self.system_type = data.get("SystemType", "")
|
|
self.uuid = data.get("UUID", "")
|
|
self.description = data.get("Description", "")
|
|
self.id = data.get("Id", "")
|
|
|
|
# Complex objects
|
|
self.status = self.generate_status(data)
|
|
self.boot = self.generate_boot(data)
|
|
self.memory_summary = self.generate_memory_summary(data)
|
|
self.computer_system_reset = self.generate_computer_system_reset(data)
|
|
self.processor_summary = self.generate_processor_summary(data)
|
|
self.trusted_modules = self.generate_trusted_modules(data)
|
|
|
|
# Lists
|
|
self.pcie_devices = data.get("PCIeDevices", [])
|
|
self.pcie_functions = data.get("PCIeFunctions", [])
|
|
|
|
def get_power_state(self) -> str:
|
|
"""Get power state.
|
|
|
|
Returns:
|
|
str: Power state value.
|
|
"""
|
|
return self.power_state
|
|
|
|
def set_power_state(self, power_state: str) -> None:
|
|
"""Set power state.
|
|
|
|
Args:
|
|
power_state (str): Power state value.
|
|
"""
|
|
self.power_state = power_state
|
|
|
|
def get_manufacturer(self) -> str:
|
|
"""Get manufacturer.
|
|
|
|
Returns:
|
|
str: Manufacturer name.
|
|
"""
|
|
return self.manufacturer
|
|
|
|
def set_manufacturer(self, manufacturer: str) -> None:
|
|
"""Set manufacturer.
|
|
|
|
Args:
|
|
manufacturer (str): Manufacturer name.
|
|
"""
|
|
self.manufacturer = manufacturer
|
|
|
|
def get_model(self) -> str:
|
|
"""Get model.
|
|
|
|
Returns:
|
|
str: Model name.
|
|
"""
|
|
return self.model
|
|
|
|
def set_model(self, model: str) -> None:
|
|
"""Set model.
|
|
|
|
Args:
|
|
model (str): Model name.
|
|
"""
|
|
self.model = model
|
|
|
|
def get_serial_number(self) -> str:
|
|
"""Get serial number.
|
|
|
|
Returns:
|
|
str: Serial number.
|
|
"""
|
|
return self.serial_number
|
|
|
|
def set_serial_number(self, serial_number: str) -> None:
|
|
"""Set serial number.
|
|
|
|
Args:
|
|
serial_number (str): Serial number.
|
|
"""
|
|
self.serial_number = serial_number
|
|
|
|
def get_bios_version(self) -> str:
|
|
"""Get BIOS version.
|
|
|
|
Returns:
|
|
str: BIOS version.
|
|
"""
|
|
return self.bios_version
|
|
|
|
def set_bios_version(self, bios_version: str) -> None:
|
|
"""Set BIOS version.
|
|
|
|
Args:
|
|
bios_version (str): BIOS version.
|
|
"""
|
|
self.bios_version = bios_version
|
|
|
|
def get_status(self) -> Status:
|
|
"""Get system status.
|
|
|
|
Returns:
|
|
Status: System status object.
|
|
"""
|
|
return self.status
|
|
|
|
def set_status(self, status: Status) -> None:
|
|
"""Set system status.
|
|
|
|
Args:
|
|
status (Status): System status object.
|
|
"""
|
|
self.status = status
|
|
|
|
def get_boot(self) -> Boot:
|
|
"""Get boot configuration.
|
|
|
|
Returns:
|
|
Boot: Boot configuration object.
|
|
"""
|
|
return self.boot
|
|
|
|
def set_boot(self, boot: Boot) -> None:
|
|
"""Set boot configuration.
|
|
|
|
Args:
|
|
boot (Boot): Boot configuration object.
|
|
"""
|
|
self.boot = boot
|
|
|
|
def get_memory_summary(self) -> MemorySummary:
|
|
"""Get memory summary.
|
|
|
|
Returns:
|
|
MemorySummary: Memory summary object.
|
|
"""
|
|
return self.memory_summary
|
|
|
|
def set_memory_summary(self, memory_summary: MemorySummary) -> None:
|
|
"""Set memory summary.
|
|
|
|
Args:
|
|
memory_summary (MemorySummary): Memory summary object.
|
|
"""
|
|
self.memory_summary = memory_summary
|
|
|
|
def get_asset_tag(self) -> str:
|
|
"""Get asset tag.
|
|
|
|
Returns:
|
|
str: Asset tag.
|
|
"""
|
|
return self.asset_tag
|
|
|
|
def set_asset_tag(self, asset_tag: str) -> None:
|
|
"""Set asset tag.
|
|
|
|
Args:
|
|
asset_tag (str): Asset tag.
|
|
"""
|
|
self.asset_tag = asset_tag
|
|
|
|
def get_host_name(self) -> str:
|
|
"""Get host name.
|
|
|
|
Returns:
|
|
str: Host name.
|
|
"""
|
|
return self.host_name
|
|
|
|
def set_host_name(self, asset_tag: str) -> None:
|
|
"""Set host name.
|
|
|
|
Args:
|
|
asset_tag (str): Host name.
|
|
"""
|
|
self.asset_tag = asset_tag
|
|
|
|
def get_indicator_led(self) -> str:
|
|
"""Get indicator LED status.
|
|
|
|
Returns:
|
|
str: Indicator LED status.
|
|
"""
|
|
return self.asset_tag
|
|
|
|
def set_indicator_led(self, asset_tag: str) -> None:
|
|
"""Set indicator LED status.
|
|
|
|
Args:
|
|
asset_tag (str): Indicator LED status.
|
|
"""
|
|
self.indicator_led = asset_tag
|
|
|
|
def get_last_reset_time(self) -> str:
|
|
"""Get last reset time.
|
|
|
|
Returns:
|
|
str: Last reset time.
|
|
"""
|
|
return self.last_reset_time
|
|
|
|
def set_last_reset_time(self, last_reset_time: str) -> None:
|
|
"""Set last reset time.
|
|
|
|
Args:
|
|
last_reset_time (str): Last reset time.
|
|
"""
|
|
self.last_reset_time = last_reset_time
|
|
|
|
def get_location_indicator_active(self) -> bool:
|
|
"""Get location indicator active status.
|
|
|
|
Returns:
|
|
bool: Location indicator active status.
|
|
"""
|
|
return self.location_indicator_active
|
|
|
|
def set_location_indicator_active(self, location_indicator_active: bool) -> None:
|
|
"""Set location indicator active status.
|
|
|
|
Args:
|
|
location_indicator_active (bool): Location indicator active status.
|
|
"""
|
|
self.location_indicator_active = location_indicator_active
|
|
|
|
def get_name(self) -> str:
|
|
"""Get system name.
|
|
|
|
Returns:
|
|
str: System name.
|
|
"""
|
|
return self.name
|
|
|
|
def set_name(self, name: str) -> None:
|
|
"""Set system name.
|
|
|
|
Args:
|
|
name (str): System name.
|
|
"""
|
|
self.name = name
|
|
|
|
def get_part_number(self) -> str:
|
|
"""Get part number.
|
|
|
|
Returns:
|
|
str: Part number.
|
|
"""
|
|
return self.part_number
|
|
|
|
def set_part_number(self, part_number: str) -> None:
|
|
"""Set part number.
|
|
|
|
Args:
|
|
part_number (str): Part number.
|
|
"""
|
|
self.part_number = part_number
|
|
|
|
def get_sku(self) -> str:
|
|
"""Get SKU.
|
|
|
|
Returns:
|
|
str: SKU.
|
|
"""
|
|
return self.sku
|
|
|
|
def set_sku(self, sku: str) -> None:
|
|
"""Set SKU.
|
|
|
|
Args:
|
|
sku (str): SKU.
|
|
"""
|
|
self.sku = sku
|
|
|
|
def get_system_type(self) -> str:
|
|
"""Get system type.
|
|
|
|
Returns:
|
|
str: System type.
|
|
"""
|
|
return self.system_type
|
|
|
|
def set_system_type(self, system_type: str) -> None:
|
|
"""Set system type.
|
|
|
|
Args:
|
|
system_type (str): System type.
|
|
"""
|
|
self.system_type = system_type
|
|
|
|
def get_uuid(self) -> str:
|
|
"""Get UUID.
|
|
|
|
Returns:
|
|
str: UUID.
|
|
"""
|
|
return self.uuid
|
|
|
|
def set_uuid(self, uuid: str) -> None:
|
|
"""Set UUID.
|
|
|
|
Args:
|
|
uuid (str): UUID.
|
|
"""
|
|
self.uuid = uuid
|
|
|
|
def get_description(self) -> str:
|
|
"""Get description.
|
|
|
|
Returns:
|
|
str: Description.
|
|
"""
|
|
return self.description
|
|
|
|
def set_description(self, description: str) -> None:
|
|
"""Set description.
|
|
|
|
Args:
|
|
description (str): Description.
|
|
"""
|
|
self.description = description
|
|
|
|
def get_id(self) -> str:
|
|
"""Get ID.
|
|
|
|
Returns:
|
|
str: System ID.
|
|
"""
|
|
return self.id
|
|
|
|
def set_id(self, id: str) -> None:
|
|
"""Set ID.
|
|
|
|
Args:
|
|
id (str): System ID.
|
|
"""
|
|
self.id = id
|
|
|
|
def get_computer_system_reset(self) -> ComputerSystemReset:
|
|
"""Get computer_system_reset.
|
|
|
|
Returns:
|
|
ComputerSystemReset: ComputerSystemReset object.
|
|
"""
|
|
return self.computer_system_reset
|
|
|
|
def set_computer_system_reset(self, computer_system_reset: ComputerSystemReset) -> None:
|
|
"""Set computer_system_reset.
|
|
|
|
Args:
|
|
computer_system_reset (ComputerSystemReset): ComputerSystemReset object.
|
|
"""
|
|
self.computer_system_reset = computer_system_reset
|
|
|
|
def get_processor_summary(self) -> ProcessorSummary:
|
|
"""Get processor summary.
|
|
|
|
Returns:
|
|
ProcessorSummary: Processor summary object.
|
|
"""
|
|
return self.processor_summary
|
|
|
|
def set_processor_summary(self, processor_summary: ProcessorSummary) -> None:
|
|
"""Set processor summary.
|
|
|
|
Args:
|
|
processor_summary (ProcessorSummary): Processor summary object.
|
|
"""
|
|
self.processor_summary = processor_summary
|
|
|
|
def get_trusted_modules(self) -> list[TrustedModule]:
|
|
"""Get trusted modules.
|
|
|
|
Returns:
|
|
list[TrustedModule]: List of trusted module objects.
|
|
"""
|
|
return self.trusted_modules
|
|
|
|
def set_trusted_modules(self, trusted_modules: list[TrustedModule]) -> None:
|
|
"""Set trusted modules.
|
|
|
|
Args:
|
|
trusted_modules (list[TrustedModule]): List of trusted module objects.
|
|
"""
|
|
self.trusted_modules = trusted_modules
|
|
|
|
def get_pcie_devices(self) -> list:
|
|
"""Get PCIe devices.
|
|
|
|
Returns:
|
|
list: List of PCIe device references.
|
|
"""
|
|
return self.pcie_devices
|
|
|
|
def set_pcie_devices(self, pcie_devices: list) -> None:
|
|
"""Set PCIe devices.
|
|
|
|
Args:
|
|
pcie_devices (list): List of PCIe device references.
|
|
"""
|
|
self.pcie_devices = pcie_devices
|
|
|
|
def get_pcie_functions(self) -> list:
|
|
"""Get PCIe functions.
|
|
|
|
Returns:
|
|
list: List of PCIe function references.
|
|
"""
|
|
return self.pcie_functions
|
|
|
|
def set_pcie_functions(self, pcie_functions: list) -> None:
|
|
"""Set PCIe functions.
|
|
|
|
Args:
|
|
pcie_functions (list): List of PCIe function references.
|
|
"""
|
|
self.pcie_functions = pcie_functions
|
|
|
|
def generate_status(self, data: dict) -> Status:
|
|
"""
|
|
Generates the status from the dict
|
|
|
|
Args:
|
|
data (dict): data to get status from
|
|
|
|
Returns:
|
|
Status: Status object.
|
|
"""
|
|
status_data = data.get("Status", {})
|
|
return Status(health=status_data.get("Health", ""), health_rollup=status_data.get("HealthRollup", ""), state=status_data.get("State", "")) if status_data else None
|
|
|
|
def generate_boot(self, data: dict) -> Boot:
|
|
"""
|
|
Generates the boot from the dict
|
|
|
|
Args:
|
|
data (dict): data to get the boot from
|
|
|
|
Returns:
|
|
Boot: Boot object.
|
|
|
|
"""
|
|
boot_data = data.get("Boot", {})
|
|
return Boot(boot_source_override_enabled=boot_data.get("BootSourceOverrideEnabled", ""), boot_source_override_target=boot_data.get("BootSourceOverrideTarget", ""), boot_order=boot_data.get("BootOrder", [])) if boot_data else None
|
|
|
|
def generate_memory_summary(self, data: dict) -> MemorySummary | None:
|
|
"""
|
|
Generates the memory summary
|
|
|
|
Args:
|
|
data (dict): the data to get the memory summary from
|
|
|
|
Returns:
|
|
MemorySummary | None: the memory summary
|
|
|
|
"""
|
|
mem_data = data.get("MemorySummary", {})
|
|
if mem_data:
|
|
mem_status_data = mem_data.get("Status", {})
|
|
mem_status = Status(health=mem_status_data.get("Health", ""), health_rollup=mem_status_data.get("HealthRollup", ""), state=mem_status_data.get("State", "")) if mem_status_data else None
|
|
return MemorySummary(total_system_memory_gib=mem_data.get("TotalSystemMemoryGiB", 0), memory_mirroring=mem_data.get("MemoryMirroring", ""), status=mem_status)
|
|
else:
|
|
return None
|
|
|
|
def generate_computer_system_reset(self, data: dict) -> ComputerSystemReset | None:
|
|
"""
|
|
Generates the computer system reset
|
|
|
|
Args:
|
|
data (dict): data to get the computer system reset from
|
|
|
|
Returns:
|
|
ComputerSystemReset | None: the computer system reset
|
|
|
|
"""
|
|
actions_data = data.get("Actions", {})
|
|
if actions_data:
|
|
reset_data = actions_data.get("#ComputerSystem.Reset", {})
|
|
return ComputerSystemReset(reset_type_allowable_values=reset_data.get("ResetType@Redfish.AllowableValues"), target=reset_data.get("target")) if reset_data else None
|
|
else:
|
|
return None
|
|
|
|
def generate_processor_summary(self, data: dict) -> ProcessorSummary | None:
|
|
"""
|
|
Generates the processor summary
|
|
|
|
Args:
|
|
data (dict): data to get the processor summary from
|
|
|
|
Returns:
|
|
ProcessorSummary | None: the processor summary
|
|
|
|
"""
|
|
proc_data = data.get("ProcessorSummary", {})
|
|
if proc_data:
|
|
proc_status_data = proc_data.get("Status", {})
|
|
proc_status = Status(health=proc_status_data.get("Health", ""), health_rollup=proc_status_data.get("HealthRollup", ""), state=proc_status_data.get("State", "")) if proc_status_data else None
|
|
return ProcessorSummary(core_count=proc_data.get("CoreCount", 0), count=proc_data.get("Count", 0), logical_processor_count=proc_data.get("LogicalProcessorCount", 0), model=proc_data.get("Model", ""), threading_enabled=proc_data.get("ThreadingEnabled", False), status=proc_status)
|
|
else:
|
|
return None
|
|
|
|
def generate_trusted_modules(self, data: dict) -> list[TrustedModule]:
|
|
"""
|
|
Generates the trusted modules
|
|
|
|
Args:
|
|
data (dict): data to get the trusted modules from
|
|
|
|
Returns:
|
|
list[TrustedModule]: the trusted modules
|
|
|
|
"""
|
|
trusted_modules_list = []
|
|
for tm_data in data.get("TrustedModules", []):
|
|
tm_status_data = tm_data.get("Status", {})
|
|
tm_status = Status("", "", tm_status_data.get("State", "")) if tm_status_data else None
|
|
trusted_module = TrustedModule(firmware_version=tm_data.get("FirmwareVersion", ""), interface_type=tm_data.get("InterfaceType", ""), status=tm_status)
|
|
trusted_modules_list.append(trusted_module)
|
|
return trusted_modules_list
|