class FansListField(Sensor):
"""The Fan device/s associated with Thermal."""
indicator_led = base.MappedField('IndicatorLED',
res_maps.INDICATOR_LED_VALUE_MAP)
"""The state of the indicator LED, used to identify the fan"""
manufacturer = base.Field('Manufacturer')
"""This is the manufacturer of this Fan"""
max_reading_range = base.Field('MaxReadingRange',
adapter=utils.int_or_none)
"""Maximum value for Reading"""
min_reading_range = base.Field('MinReadingRange',
adapter=utils.int_or_none)
"""Minimum value for Reading"""
model = base.Field('Model')
"""The model of this Fan"""
part_number = base.Field('PartNumber')
"""Part number of this Fan"""
reading = base.Field('Reading', adapter=utils.int_or_none)
"""Current Fan Speed"""
reading_units = base.MappedField('ReadingUnits',
the_maps.FAN_READING_UNITS_MAP)
"""Units in which the reading and thresholds are measured"""
serial_number = base.Field('SerialNumber')
"""Serial number of this Fan"""
class Task(base.ResourceBase):
identity = base.Field('Id', required=True)
"""The Task identity"""
name = base.Field('Name', required=True)
"""The Task name"""
description = base.Field('Description')
"""The Task description"""
task_monitor = base.Field('TaskMonitor')
"""An opaque URL that the client can use to monitor an asynchronous
operation"""
start_time = base.Field('StartTime')
"""Start time of the Task"""
end_time = base.Field('EndTime')
"""End time of the Task"""
percent_complete = base.Field('PercentComplete', adapter=utils.int_or_none)
"""Percentage complete of the Task"""
task_state = base.MappedField('TaskState', task_maps.TASK_STATE_VALUE_MAP)
"""The Task state"""
task_status = base.MappedField('TaskStatus', res_maps.HEALTH_VALUE_MAP)
"""The Task status"""
messages = base.MessageListField("Messages")
"""List of :class:`.MessageListField` with messages from the Task"""
def __init__(self, connector, identity, redfish_version=None,
registries=None, json_doc=None):
"""A class representing a Task
:param connector: A Connector instance
:param identity: The identity of the task
:param redfish_version: The version of RedFish. Used to construct
the object according to schema of the given version.
:param registries: Dict of Redfish Message Registry objects to be
used in any resource that needs registries to parse messages
:param field_data: the data to use populating the fields
"""
super(Task, self).__init__(
connector, identity, redfish_version, registries,
json_doc=json_doc)
@property
def is_processing(self):
"""Indicates if the Task is processing"""
return self.status_code == http_client.ACCEPTED
def parse_messages(self):
"""Parses the messages"""
for m in self.messages:
message_registry.parse_message(self._registries, m)
class PowerSupplyListField(base.ListField):
"""The power supplies associated with this Power resource"""
firmware_version = base.Field('FirmwareVersion')
"""The firmware version for this Power Supply"""
identity = base.Field('MemberId')
"""Identifier of the Power Supply"""
indicator_led = base.MappedField('IndicatorLed',
res_maps.INDICATOR_LED_VALUE_MAP)
"""The state of the indicator LED, used to identify the power supply"""
input_ranges = InputRangeListField('InputRanges', default=[])
"""This is the input ranges that the power supply can use"""
last_power_output_watts = base.Field('LastPowerOutputWatts',
adapter=utils.int_or_none)
"""The average power output of this Power Supply"""
line_input_voltage = base.Field('LineInputVoltage',
adapter=utils.int_or_none)
"""The line input voltage at which the Power Supply is operating"""
line_input_voltage_type = base.MappedField(
'LineInputVoltageType',
pow_maps.LINE_INPUT_VOLTAGE_TYPE_MAP)
"""The line voltage type supported as an input to this Power Supply"""
manufacturer = base.Field('Manufacturer')
"""This is the manufacturer of this power supply"""
model = base.Field('Model')
"""The model number for this Power Supply"""
name = base.Field('Name')
"""Name of the Power Supply"""
part_number = base.Field('PartNumber')
"""The part number for this Power Supply"""
power_capacity_watts = base.Field('PowerCapacityWatts',
adapter=utils.int_or_none)
"""The maximum capacity of this Power Supply"""
power_supply_type = base.MappedField('PowerSupplyType',
pow_maps.POWER_SUPPLY_TYPE_MAP)
"""The Power Supply type (AC or DC)"""
serial_number = base.Field('SerialNumber')
"""The serial number for this Power Supply"""
spare_part_number = base.Field('SparePartNumber')
"""The spare part number for this Power Supply"""
status = common.StatusField('Status')
"""Status of the sensor"""
class BootField(base.CompositeField):
allowed_values = base.Field(
'*****@*****.**', adapter=list)
enabled = base.MappedField('BootSourceOverrideEnabled',
sys_maps.BOOT_SOURCE_ENABLED_MAP)
mode = base.MappedField('BootSourceOverrideMode',
sys_maps.BOOT_SOURCE_MODE_MAP)
target = base.MappedField('BootSourceOverrideTarget',
sys_maps.BOOT_SOURCE_TARGET_MAP)
class StatusField(base.CompositeField):
"""This Field describes the status of a resource and its children.
This field shall contain any state or health properties of a resource.
"""
health = base.MappedField('Health', res_maps.HEALTH_VALUE_MAP)
"""Represents health of resource w/o considering its dependent resources"""
health_rollup = base.MappedField('HealthRollup', res_maps.HEALTH_VALUE_MAP)
"""Represents health state of resource and its dependent resources"""
state = base.MappedField('State', res_maps.STATE_VALUE_MAP)
"""Indicates the known state of the resource, such as if it is enabled."""
class PhysicalSecurity(base.CompositeField):
intrusion_sensor = base.MappedField('IntrusionSensor',
cha_maps.CHASSIS_INTRUSION_SENSOR_MAP)
"""IntrusionSensor
This indicates the known state of the physical security sensor, such as if
it is hardware intrusion detected.
"""
intrusion_sensor_number = base.Field('IntrusionSensorNumber')
"""A numerical identifier to represent the physical security sensor"""
intrusion_sensor_re_arm = (base.MappedField(
'IntrusionSensorReArm', cha_maps.CHASSIS_INTRUSION_SENSOR_RE_ARM_MAP))
"""This indicates how the Normal state to be restored"""
class Drive(base.ResourceBase):
"""This class represents the Drive resource"""
capacity_bytes = base.Field('CapacityBytes', adapter=int)
"""The size in bytes of this Drive"""
media_type = base.MappedField('MediaType', mappings.MEDIA_TYPE_MAP)
"""The type of media contained in this drive"""
protocol = base.MappedField('Protocol', mappings.DEVICE_PROTOCOLS_MAP)
"""The protocol this drive is using to communicate to the storage
controller."""
rotation_speed_rpm = base.Field('RotationSpeedRPM', adapter=int)
"""The rotation speed of this Drive in Revolutions per Minute (RPM)."""
class IPv6AddressField(base.CompositeField):
address = base.Field('Address')
"""This is the IPv6 Address."""
prefix_length = base.Field('PrefixLength', adapter=utils.int_or_none)
"""This is the IPv6 Address Prefix Length."""
address_origin = base.MappedField('AddressOrigin',
fab_maps.ADDRESS_ORIGIN_IPv6_VALUE_MAP)
"""This indicates how the address was determined."""
address_state = base.MappedField('AddressState',
fab_maps.ADDRESS_STATE_VALUE_MAP)
"""The current state of this address as defined in RFC 4862."""
class MessageListField(base.ListField):
"""List of messages with details of settings update status"""
message_id = base.Field('MessageId', required=True)
"""The key for this message which can be used
to look up the message in a message registry
"""
message = base.Field('Message')
"""Human readable message, if provided"""
severity = base.MappedField('Severity',
res_maps.SEVERITY_VALUE_MAP)
"""Severity of the error"""
resolution = base.Field('Resolution')
"""Used to provide suggestions on how to resolve
the situation that caused the error
"""
_related_properties = base.Field('RelatedProperties')
"""List of properties described by the message"""
message_args = base.Field('MessageArgs')
"""List of message substitution arguments for the message
class MessageDictionaryField(base.DictionaryField):
description = base.Field('Description', required=True)
"""Indicates how and when the message is returned by the Redfish service"""
message = base.Field('Message', required=True)
"""Template text of the message
Template can include placeholders for message arguments in form
%<integer> where <integer> denotes a position passed from MessageArgs.
"""
number_of_args = base.Field('NumberOfArgs', required=True)
"""Number of arguments to be expected to be passed in as MessageArgs
for this message
"""
param_types = base.Field('ParamTypes',
adapter=lambda x:
[res_maps.PARAMTYPE_VALUE_MAP[v]
for v in x])
"""Mapped MessageArg types, in order, for the message"""
resolution = base.Field('Resolution', required=True)
"""Suggestions on how to resolve the situation that caused the error"""
severity = base.MappedField('Severity',
res_maps.SEVERITY_VALUE_MAP,
required=True)
"""Mapped severity of the message"""
class InputRangeListField(base.ListField):
"""This type describes an input range for a power supply"""
input_type = base.MappedField('InputType',
pow_maps.POWER_SUPPLY_INPUT_TYPE_MAP)
"""The Input type (AC or DC)"""
maximum_frequency_hz = base.Field('MaximumFrequencyHz',
adapter=utils.int_or_none)
"""The maximum line input frequency at which this power supply input range
is effective"""
maximum_voltage = base.Field('MaximumVoltage', adapter=utils.int_or_none)
"""The maximum line input voltage at which this power supply input range
is effective"""
minimum_frequency_hz = base.Field('MinimumFrequencyHz',
adapter=utils.int_or_none)
"""The minimum line input frequency at which this power supply input range
is effective"""
minimum_voltage = base.Field('MinimumVoltage', adapter=utils.int_or_none)
"""The minimum line input voltage at which this power supply input range
is effective"""
output_wattage = base.Field('OutputWattage', adapter=utils.int_or_none)
"""The maximum capacity of this Power Supply when operating in this input
class ResourceBlock(base.ResourceBase):
composition_status = CompositionStatusField('CompositionStatus',
required=True)
"""The composition state of resource block"""
description = base.Field('Description')
"""The resource block description"""
identity = base.Field('Id', required=True)
"""The resource block identity string"""
name = base.Field('Name', required=True)
"""The resource block name"""
resource_block_type = base.MappedField(
'ResourceBlockType',
res_maps.RESOURCE_BLOCK_TYPE_VALUE_MAP,
required=True)
"""The type of resource block"""
status = common.StatusField('Status')
"""The status of resource block"""
def __init__(self, connector, identity, redfish_version=None):
"""A class representing a ResourceBlock
:param connector: A Connector instance
:param identity: The identity of the ResourceBlock resource
:param redfish_version: The version of RedFish. Used to construct
the object according to schema of given version.
"""
super(ResourceBlock, self).__init__(connector, identity,
redfish_version)
class ComplexResource(resource_base.ResourceBase):
string = resource_base.Field('String', required=True)
integer = resource_base.Field('Integer', adapter=int)
nested = NestedTestField('Nested')
non_existing_nested = NestedTestField('NonExistingNested')
non_existing_mapped = resource_base.MappedField('NonExistingMapped',
MAPPING)
class IdentifiersListField(base.ListField):
"""This type describes any additional identifiers for a resource."""
durable_name = base.Field('DurableName')
"""This indicates the world wide, persistent name of the resource."""
durable_name_format = base.MappedField('DurableNameFormat',
res_maps.DUR_NAME_FORMAT_VALUE_MAP)
"""This represents the format of the DurableName property."""
class ComplexResource(resource_base.ResourceBase):
string = resource_base.Field('String', required=True)
integer = resource_base.Field('Integer', adapter=int)
nested = NestedTestField('Nested')
mapped_list = resource_base.MappedListField('MappedList', MAPPING)
field_list = TestListField('ListField')
dictionary = TestDictionaryField('Dictionary')
non_existing_nested = NestedTestField('NonExistingNested')
non_existing_mapped = resource_base.MappedField('NonExistingMapped',
MAPPING)
class SimpleUpdateActionField(common.ActionField):
image_uri = base.Field('ImageURI')
"""The URI of the software image to be installed"""
targets = base.Field('Targets')
"""The array of URIs indicating where the update image is to be""" + \
"""applied"""
transfer_protocol = base.MappedField(
'TransferProtocol', up_maps.TRANSFER_PROTOCOL_TYPE_VALUE_MAP)
"""The network protocol used by the Update Service"""
class HPELogicalDrive(base.ResourceBase):
"""This class represents the LogicalDrives resource"""
identity = base.Field('Id')
name = base.Field('Name')
description = base.Field('Description')
capacity_mib = base.Field('CapacityMiB', adapter=int)
raid = base.MappedField('Raid', mappings.RAID_LEVEL_MAP)
class HPEPhysicalDrive(base.ResourceBase):
"""This class represents the HPEPhysicalDrives resource"""
identity = base.Field('Id', required=True)
name = base.Field('Name')
description = base.Field('Description')
capacity_mib = base.Field('CapacityMiB', adapter=int)
media_type = base.MappedField('MediaType', mappings.MEDIA_TYPE_MAP)
rotational_speed_rpm = base.Field('RotationalSpeedRpm', adapter=int)
class Processor(base.ResourceBase):
identity = base.Field('Id', required=True)
"""The processor identity string"""
socket = base.Field('Socket')
"""The socket or location of the processor"""
# TODO(deray): Create mappings for the processor_type
processor_type = base.Field('ProcessorType')
"""The type of processor"""
processor_architecture = base.MappedField(
'ProcessorArchitecture', sys_maps.PROCESSOR_ARCH_VALUE_MAP)
"""The architecture of the processor"""
# TODO(deray): Create mappings for the instruction_set
instruction_set = base.Field('InstructionSet')
"""The instruction set of the processor"""
manufacturer = base.Field('Manufacturer')
"""The processor manufacturer"""
model = base.Field('Model')
"""The product model number of this device"""
max_speed_mhz = base.Field('MaxSpeedMHz', adapter=utils.int_or_none)
"""The maximum clock speed of the processor in MHz."""
processor_id = ProcessorIdField('ProcessorId')
"""The processor id"""
status = common.StatusField('Status')
"""The processor status"""
total_cores = base.Field('TotalCores', adapter=utils.int_or_none)
"""The total number of cores contained in this processor"""
total_threads = base.Field('TotalThreads', adapter=utils.int_or_none)
"""The total number of execution threads supported by this processor"""
def __init__(self, connector, identity, redfish_version=None):
"""A class representing a Processor
:param connector: A Connector instance
:param identity: The identity of the processor
:param redfish_version: The version of RedFish. Used to construct
the object according to schema of the given version.
"""
super(Processor, self).__init__(connector, identity, redfish_version)
class IPv4AddressField(base.CompositeField):
address = base.Field('Address')
"""This is the IPv4 Address."""
gateway = base.Field('Gateway')
"""This is the IPv4 gateway for this address."""
subnet_mask = base.Field('SubnetMask')
"""This is the IPv4 Subnet mask."""
address_origin = base.MappedField('AddressOrigin',
fab_maps.ADDRESS_ORIGIN_IPv4_VALUE_MAP)
"""This indicates how the address was determined."""
class TaskService(base.ResourceBase):
identity = base.Field('Id', required=True)
"""The task service identity"""
name = base.Field('Name', required=True)
"""The task service name"""
service_enabled = base.Field('ServiceEnabled')
"""The status of whether this service is enabled"""
status = common.StatusField('Status')
"""The status of the task service"""
overwrite_policy = base.MappedField(
'CompletedTaskOverWritePolicy', ts_maps.OVERWRITE_POLICY_VALUE_MAP)
"""The overwrite policy for completed tasks"""
event_on_task_state_change = base.Field(
'LifeCycleEventOnTaskStateChange', adapter=bool)
"""Whether a task state change sends an event"""
def __init__(self, connector, identity, redfish_version=None,
registries=None):
"""A class representing a TaskService
:param connector: A Connector instance
:param identity: The identity of the TaskService resource
:param redfish_version: The version of RedFish. Used to construct
the object according to schema of given version
:param registries: Dict of Redfish Message Registry objects to be
used in any resource that needs registries to parse messages
"""
super(TaskService, self).__init__(
connector, identity, redfish_version, registries)
@property
@utils.cache_it
def tasks(self):
"""Property to reference `TaskCollection` instance
It is set once when the first time it is queried. On refresh,
this property is marked as stale (greedy-refresh not done).
Here the actual refresh of the sub-resource happens, if stale.
"""
return task.TaskCollection(
self._conn, utils.get_sub_resource_path_by(self, 'Tasks'),
redfish_version=self.redfish_version,
registries=self.registries)
class ConnectedEntitiesListField(base.ListField):
"""All the entities connected to this endpoint."""
pci_class_code = base.Field('PciClassCode')
"""The Class Code, Subclass code, and Programming Interface code of
this PCIe function."""
pci_function_number = base.Field('PciFunctionNumber',
adapter=utils.int_or_none)
"""The PCI ID of the connected entity."""
entity_pci_id = PciIdField('EntityPciId')
"""The PCI ID of the connected entity."""
identifiers = common.IdentifiersListField('Identifiers', default=[])
"""Identifiers for the remote entity."""
entity_role = base.MappedField('EntityRole',
fab_maps.ENTITY_ROLE_VALUE_MAP)
"""The role of the connected entity."""
entity_type = base.MappedField('EntityType',
fab_maps.ENTITY_TYPE_VALUE_MAP)
"""The type of the connected entity."""
class Fabric(base.ResourceBase):
"""Fabric resource
The Fabric represents a simple fabric consisting of one or more
switches, zero or more endpoints, and zero or more zones.
"""
identity = base.Field('Id', required=True)
"""Identifier for the fabric"""
name = base.Field('Name', required=True)
"""The fabric name"""
description = base.Field('Description')
"""The fabric description"""
max_zones = base.Field('MaxZones', adapter=utils.int_or_none)
"""The maximum number of zones the switch can currently configure"""
status = common.StatusField('Status')
"""The fabric status"""
fabric_type = base.MappedField('FabricType',
res_maps.PROTOCOL_TYPE_VALUE_MAP)
"""The protocol being sent over this fabric"""
def __init__(self,
connector,
identity,
redfish_version=None,
registries=None):
"""A class representing a Fabric
:param connector: A Connector instance
:param identity: The identity of the Fabric resource
:param redfish_version: The version of RedFish. Used to construct
the object according to schema of the given version.
:param registries: Dict of Redfish Message Registry objects to be
used in any resource that needs registries to parse messages
"""
super(Fabric, self).__init__(connector, identity, redfish_version,
registries)
@property
@utils.cache_it
def endpoints(self):
return fab_endpoint.EndpointCollection(
self._conn, utils.get_sub_resource_path_by(self, 'Endpoints'),
self.redfish_version, self.registries)
class IPTransportDetailsListField(base.ListField):
"""IP transport details
This array contains details for each IP transport supported by this
endpoint. The array structure can be used to model multiple IP addresses
for this endpoint.
"""
port = base.Field('Port', adapter=utils.int_or_none)
"""The UDP or TCP port number used by the Endpoint."""
transport_protocol = base.MappedField('TransportProtocol',
res_maps.PROTOCOL_TYPE_VALUE_MAP)
"""The protocol used by the connection entity."""
ipv4_address = IPv4AddressField('IPv4Address')
"""The IPv4 address object."""
ipv6_address = IPv6AddressField('IPv6Address')
"""The IPv6 address object."""
class CompositionStatusField(base.CompositeField):
composition_state = base.MappedField('CompositionState',
res_maps.COMPOSITION_STATE_VALUE_MAP,
required=True)
"""Inform the client, state of the resource block"""
max_compositions = base.Field('MaxCompositions')
"""The maximum number of compositions"""
number_of_compositions = base.Field('NumberOfCompositions')
"""The number of compositions"""
reserved_state = base.Field('Reserved')
"""Inform the resource block has been identified by a client"""
sharing_capable = base.Field('SharingCapable')
"""Indicates if this Resource Block is capable of participating in
multiple compositions simultaneously"""
sharing_enabled = base.Field('SharingEnabled')
"""Indicates if this Resource Block is allowed to participate in
class Endpoint(base.ResourceBase):
"""This class represents a fabric endpoint.
It represents the properties of an entity that sends or receives protocol
defined messages over a transport.
"""
identity = base.Field('Id', required=True)
"""Identifier for the endpoint"""
name = base.Field('Name', required=True)
"""The endpoint name"""
description = base.Field('Description')
"""The endpoint description"""
status = common.StatusField('Status')
"""The endpoint status"""
host_reservation_memory_bytes = base.Field('HostReservationMemoryBytes',
adapter=utils.int_or_none)
"""The amount of memory in Bytes that the Host should allocate to connect
to this endpoint.
"""
endpoint_protocol = base.MappedField('EndpointProtocol',
res_maps.PROTOCOL_TYPE_VALUE_MAP)
"""The protocol supported by this endpoint."""
pci_id = PciIdField('PciId')
"""The PCI ID of the endpoint."""
IP_transport_details = IPTransportDetailsListField('IPTransportDetails')
"""This array contains details for each IP transport supported by this
endpoint. The array structure can be used to model multiple IP addresses
for this endpoint."""
connected_entities = ConnectedEntitiesListField('ConnectedEntities')
"""All entities connected to this endpoint."""
class BIOSPendingSettings(base.ResourceBase):
"""Class that defines the functionality for BIOS pending settings."""
boot_mode = base.MappedField(["Attributes", "BootMode"],
mappings.GET_BIOS_BOOT_MODE_MAP)
def set_pending_boot_mode(self, boot_mode):
"""Sets the boot mode of the system for next boot.
:param boot_mode: either sys_cons.BIOS_BOOT_MODE_LEGACY_BIOS,
sys_cons.BIOS_BOOT_MODE_UEFI.
"""
bios_properties = {
'BootMode': mappings.GET_BIOS_BOOT_MODE_MAP_REV.get(boot_mode)
}
if boot_mode == sys_cons.BIOS_BOOT_MODE_UEFI:
bios_properties['UefiOptimizedBoot'] = 'Enabled'
self.update_bios_data_by_patch(bios_properties)
def update_bios_data_by_post(self, data):
"""Update bios data by post
:param data: default bios config data
"""
bios_settings_data = {'Attributes': data}
self._conn.post(self.path, data=bios_settings_data)
def update_bios_data_by_patch(self, data):
"""Update bios data by patch
:param data: default bios config data
"""
bios_settings_data = {'Attributes': data}
self._conn.patch(self.path, data=bios_settings_data)
class Manager(base.ResourceBase):
firmware_version = base.Field('FirmwareVersion')
"""The manager firmware version"""
graphical_console = RemoteAccessField('GraphicalConsole')
"""A dictionary containing the remote access support service via
graphical console (e.g. KVMIP) and max concurrent sessions
"""
serial_console = RemoteAccessField('SerialConsole')
"""A dictionary containing the remote access support service via
serial console (e.g. Telnet, SSH, IPMI) and max concurrent sessions
"""
command_shell = RemoteAccessField('CommandShell')
"""A dictionary containing the remote access support service via
command shell (e.g. Telnet, SSH) and max concurrent sessions
"""
description = base.Field('Description')
"""The manager description"""
identity = base.Field('Id', required=True)
"""The manager identity string"""
name = base.Field('Name')
"""The manager name"""
model = base.Field('Model')
"""The manager model"""
manager_type = base.MappedField('ManagerType',
mgr_maps.MANAGER_TYPE_VALUE_MAP)
"""The manager type"""
uuid = base.Field('UUID')
"""The manager UUID"""
_actions = ActionsField('Actions', required=True)
def __init__(self, connector, identity, redfish_version=None):
"""A class representing a Manager
:param connector: A Connector instance
:param identity: The identity of the Manager resource
:param redfish_version: The version of RedFish. Used to construct
the object according to schema of the given version.
"""
super(Manager, self).__init__(connector, identity, redfish_version)
def get_supported_graphical_console_types(self):
"""Get the supported values for Graphical Console connection types.
:returns: A set of supported values.
"""
if (not self.graphical_console
or not self.graphical_console.connect_types_supported):
LOG.warning(
'Could not figure out the supported values for '
'remote access via graphical console for Manager %s',
self.identity)
return set(mgr_maps.GRAPHICAL_CONSOLE_VALUE_MAP_REV)
return set([
mgr_maps.GRAPHICAL_CONSOLE_VALUE_MAP[v]
for v in set(mgr_maps.GRAPHICAL_CONSOLE_VALUE_MAP).intersection(
self.graphical_console.connect_types_supported)
])
def get_supported_serial_console_types(self):
"""Get the supported values for Serial Console connection types.
:returns: A set of supported values.
"""
if (not self.serial_console
or not self.serial_console.connect_types_supported):
LOG.warning(
'Could not figure out the supported values for '
'remote access via serial console for Manager %s',
self.identity)
return set(mgr_maps.SERIAL_CONSOLE_VALUE_MAP_REV)
return set([
mgr_maps.SERIAL_CONSOLE_VALUE_MAP[v]
for v in set(mgr_maps.SERIAL_CONSOLE_VALUE_MAP).intersection(
self.serial_console.connect_types_supported)
])
def get_supported_command_shell_types(self):
"""Get the supported values for Command Shell connection types.
:returns: A set of supported values.
"""
if (not self.command_shell
or not self.command_shell.connect_types_supported):
LOG.warning(
'Could not figure out the supported values for '
'remote access via command shell for Manager %s',
self.identity)
return set(mgr_maps.COMMAND_SHELL_VALUE_MAP_REV)
return set([
mgr_maps.COMMAND_SHELL_VALUE_MAP[v]
for v in set(mgr_maps.COMMAND_SHELL_VALUE_MAP).intersection(
self.command_shell.connect_types_supported)
])
def _get_reset_action_element(self):
reset_action = self._actions.reset
if not reset_action:
raise exceptions.MissingActionError(action='#Manager.Reset',
resource=self._path)
return reset_action
def get_allowed_reset_manager_values(self):
"""Get the allowed values for resetting the manager.
:returns: A set of allowed values.
:raises: MissingAttributeError, if Actions/#Manager.Reset attribute
not present.
"""
reset_action = self._get_reset_action_element()
if not reset_action.allowed_values:
LOG.warning(
'Could not figure out the allowed values for the '
'reset manager action for Manager %s', self.identity)
return set(mgr_maps.RESET_MANAGER_VALUE_MAP_REV)
return set([
mgr_maps.RESET_MANAGER_VALUE_MAP[v]
for v in set(mgr_maps.RESET_MANAGER_VALUE_MAP).intersection(
reset_action.allowed_values)
])
def reset_manager(self, value):
"""Reset the manager.
:param value: The target value.
:raises: InvalidParameterValueError, if the target value is not
allowed.
"""
valid_resets = self.get_allowed_reset_manager_values()
if value not in valid_resets:
raise exceptions.InvalidParameterValueError(
parameter='value', value=value, valid_values=valid_resets)
value = mgr_maps.RESET_MANAGER_VALUE_MAP_REV[value]
target_uri = self._get_reset_action_element().target_uri
LOG.debug('Resetting the Manager %s ...', self.identity)
self._conn.post(target_uri, data={'ResetType': value})
LOG.info('The Manager %s is being reset', self.identity)
class NestedTestField(resource_base.CompositeField):
string = resource_base.Field('String', required=True)
integer = resource_base.Field('Integer', adapter=int)
nested_field = resource_base.Field(['Object', 'Field'], required=True)
mapped = resource_base.MappedField('Mapped', MAPPING)
non_existing = resource_base.Field('NonExisting', default=3.14)
class Chassis(base.ResourceBase):
"""Chassis resource
The Chassis represents the physical components of a system. This
resource represents the sheet-metal confined spaces and logical zones
such as racks, enclosures, chassis and all other containers.
"""
chassis_type = base.MappedField('ChassisType',
cha_maps.CHASSIS_TYPE_VALUE_MAP,
required=True)
"""The type of physical form factor of the chassis"""
identity = base.Field('Id', required=True)
"""Identifier for the chassis"""
name = base.Field('Name', required=True)
"""The chassis name"""
asset_tag = base.Field('AssetTag')
"""The user assigned asset tag of this chassis"""
depth_mm = base.Field('DepthMm')
"""Depth in millimeters
The depth of the chassis. The value of this property shall represent
the depth (length) of the chassis (in millimeters) as specified by the
manufacturer.
"""
description = base.Field('Description')
"""The chassis description"""
height_mm = base.Field('HeightMm')
"""Height in millimeters
The height of the chassis. The value of this property shall represent
the height of the chassis (in millimeters) as specified by the
manufacturer.
"""
indicator_led = base.MappedField('IndicatorLED',
res_maps.INDICATOR_LED_VALUE_MAP)
"""The state of the indicator LED, used to identify the chassis"""
manufacturer = base.Field('Manufacturer')
"""The manufacturer of this chassis"""
model = base.Field('Model')
"""The model number of the chassis"""
part_number = base.Field('PartNumber')
"""The part number of the chassis"""
physical_security = PhysicalSecurity('PhysicalSecurity')
"""PhysicalSecurity
This value of this property shall contain the sensor state of the physical
security.
"""
power_state = base.MappedField('PowerState',
res_maps.POWER_STATE_VALUE_MAP)
"""The current power state of the chassis"""
serial_number = base.Field('SerialNumber')
"""The serial number of the chassis"""
sku = base.Field('SKU')
"""Stock-keeping unit number (SKU)
The value of this property shall be the stock-keeping unit number for
this chassis.
"""
status = common.StatusField('Status')
"""Status and Health
This property describes the status and health of the chassis and its
children.
"""
uuid = base.Field('UUID')
"""The Universal Unique Identifier (UUID) for this Chassis."""
weight_kg = base.Field('WeightKg')
"""Weight in kilograms
The value of this property shall represent the published mass (commonly
referred to as weight) of the chassis (in kilograms).
"""
width_mm = base.Field('WidthMm')
"""Width in millimeters
The value of this property shall represent the width of the chassis
(in millimeters) as specified by the manufacturer.
"""
_actions = ActionsField('Actions')
def __init__(self,
connector,
identity,
redfish_version=None,
registries=None):
"""A class representing a Chassis
:param connector: A Connector instance
:param identity: The identity of the Chassis resource
:param redfish_version: The version of RedFish. Used to construct
the object according to schema of the given version.
:param registries: Dict of Redfish Message Registry objects to be
used in any resource that needs registries to parse messages
"""
super(Chassis, self).__init__(connector, identity, redfish_version,
registries)
def _get_reset_action_element(self):
reset_action = self._actions.reset
if not reset_action:
raise exceptions.MissingActionError(action='#Chassis.Reset',
resource=self._path)
return reset_action
def get_allowed_reset_chassis_values(self):
"""Get the allowed values for resetting the chassis.
:returns: A set of allowed values.
:raises: MissingAttributeError, if Actions/#Chassis.Reset attribute
not present.
"""
reset_action = self._get_reset_action_element()
if not reset_action.allowed_values:
LOG.warning(
'Could not figure out the allowed values for the '
'reset chassis action for Chassis %s', self.identity)
return set(res_maps.RESET_TYPE_VALUE_MAP_REV)
return set([
res_maps.RESET_TYPE_VALUE_MAP[v]
for v in set(res_maps.RESET_TYPE_VALUE_MAP).intersection(
reset_action.allowed_values)
])
def reset_chassis(self, value):
"""Reset the chassis.
:param value: The target value.
:raises: InvalidParameterValueError, if the target value is not
allowed.
"""
valid_resets = self.get_allowed_reset_chassis_values()
if value not in valid_resets:
raise exceptions.InvalidParameterValueError(
parameter='value', value=value, valid_values=valid_resets)
value = res_maps.RESET_TYPE_VALUE_MAP_REV[value]
target_uri = self._get_reset_action_element().target_uri
LOG.debug('Resetting the Chassis %s ...', self.identity)
self._conn.post(target_uri, data={'ResetType': value})
LOG.info('The Chassis %s is being reset', self.identity)
def set_indicator_led(self, state):
"""Set IndicatorLED to the given state.
:param state: Desired LED state, lit (INDICATOR_LED_LIT), blinking
(INDICATOR_LED_BLINKING), off (INDICATOR_LED_OFF)
:raises: InvalidParameterValueError, if any information passed is
invalid.
"""
if state not in res_maps.INDICATOR_LED_VALUE_MAP_REV:
raise exceptions.InvalidParameterValueError(
parameter='state',
value=state,
valid_values=list(res_maps.INDICATOR_LED_VALUE_MAP_REV))
data = {'IndicatorLED': res_maps.INDICATOR_LED_VALUE_MAP_REV[state]}
self._conn.patch(self.path, data=data)
self.invalidate()
@property
@utils.cache_it
def managers(self):
"""A list of managers for this chassis.
Returns a list of `Manager` objects representing the managers
that manage this chassis.
:raises: MissingAttributeError if '@odata.id' field is missing.
:returns: A list of `Manager` instances
"""
paths = utils.get_sub_resource_path_by(self, ["Links", "ManagedBy"],
is_collection=True)
return [
manager.Manager(self._conn, path, self.redfish_version,
self.registries) for path in paths
]
@property
@utils.cache_it
def systems(self):
"""A list of systems residing in this chassis.
Returns a list of `System` objects representing systems being
mounted in this chassis/cabinet.
:raises: MissingAttributeError if '@odata.id' field is missing.
:returns: A list of `System` instances
"""
paths = utils.get_sub_resource_path_by(self,
["Links", "ComputerSystems"],
is_collection=True)
from sushy.resources.system import system
return [
system.System(self._conn, path, self.redfish_version,
self.registries) for path in paths
]
@property
@utils.cache_it
def power(self):
"""Property to reference `Power` instance
It is set once when the first time it is queried. On refresh,
this property is marked as stale (greedy-refresh not done).
Here the actual refresh of the sub-resource happens, if stale.
"""
return power.Power(self._conn,
utils.get_sub_resource_path_by(self, 'Power'),
self.redfish_version, self.registries)
@property
@utils.cache_it
def thermal(self):
"""Property to reference `Thermal` instance
It is set once when the first time it is queried. On refresh,
this property is marked as stale (greedy-refresh not done).
Here the actual refresh of the sub-resource happens, if stale.
"""
return thermal.Thermal(self._conn,
utils.get_sub_resource_path_by(self, 'Thermal'),
self.redfish_version, self.registries)
