Use Sushy caching decorators
Sushy's caching utility decorators are used now and as a side effect lot of handcrafted caching code has been reduced. Also version of Sushy dependency is set to >=1.7.0 Change-Id: I608478f72d4e49f562f4ef9edfdfce057631f39d
This commit is contained in:
parent
5927a933c5
commit
efbb63d1af
|
@ -13,6 +13,7 @@
|
|||
# under the License.
|
||||
|
||||
from sushy.resources import base
|
||||
from sushy import utils as sushy_utils
|
||||
|
||||
from proliantutils.redfish.resources.account_service import account
|
||||
from proliantutils.redfish import utils
|
||||
|
@ -25,29 +26,10 @@ class HPEAccountService(base.ResourceBase):
|
|||
from sushy
|
||||
"""
|
||||
|
||||
_accounts = None
|
||||
|
||||
@property
|
||||
@sushy_utils.cache_it
|
||||
def accounts(self):
|
||||
"""Property to provide instance of HPEAccountCollection
|
||||
|
||||
"""
|
||||
if self._accounts is None:
|
||||
self._accounts = account.HPEAccountCollection(
|
||||
"""Property to provide instance of HPEAccountCollection"""
|
||||
return account.HPEAccountCollection(
|
||||
self._conn, utils.get_subresource_path_by(self, 'Accounts'),
|
||||
redfish_version=self.redfish_version)
|
||||
|
||||
self._accounts.refresh(force=False)
|
||||
return self._accounts
|
||||
|
||||
def _do_refresh(self, force):
|
||||
"""Do custom resource specific refresh activities
|
||||
|
||||
On refresh, all sub-resources are marked as stale, i.e.
|
||||
greedy-refresh not done for them unless forced by ``force``
|
||||
argument.
|
||||
"""
|
||||
super(HPEAccountService, self)._do_refresh(force)
|
||||
|
||||
if self._accounts is not None:
|
||||
self._accounts.invalidate(force)
|
||||
|
|
|
@ -15,6 +15,7 @@
|
|||
__author__ = 'HPE'
|
||||
|
||||
from sushy.resources.manager import manager
|
||||
from sushy import utils as sushy_utils
|
||||
|
||||
from proliantutils.redfish.resources.manager import virtual_media
|
||||
from proliantutils.redfish import utils
|
||||
|
@ -27,8 +28,6 @@ class HPEManager(manager.Manager):
|
|||
from sushy
|
||||
"""
|
||||
|
||||
_virtual_media = None
|
||||
|
||||
def set_license(self, key):
|
||||
"""Set the license on a redfish system
|
||||
|
||||
|
@ -40,29 +39,13 @@ class HPEManager(manager.Manager):
|
|||
self._conn.post(license_service_uri, data=data)
|
||||
|
||||
@property
|
||||
@sushy_utils.cache_it
|
||||
def virtual_media(self):
|
||||
"""Property to provide reference to `VirtualMediaCollection` instance.
|
||||
|
||||
It is calculated once when the first time it is queried. On refresh,
|
||||
this property gets reset.
|
||||
"""
|
||||
if self._virtual_media is None:
|
||||
self._virtual_media = virtual_media.VirtualMediaCollection(
|
||||
self._conn,
|
||||
utils.get_subresource_path_by(self, 'VirtualMedia'),
|
||||
return virtual_media.VirtualMediaCollection(
|
||||
self._conn, utils.get_subresource_path_by(self, 'VirtualMedia'),
|
||||
redfish_version=self.redfish_version)
|
||||
|
||||
self._virtual_media.refresh(force=False)
|
||||
return self._virtual_media
|
||||
|
||||
def _do_refresh(self, force):
|
||||
"""Do custom resource specific refresh activities
|
||||
|
||||
On refresh, all sub-resources are marked as stale, i.e.
|
||||
greedy-refresh not done for them unless forced by ``force``
|
||||
argument.
|
||||
"""
|
||||
super(HPEManager, self)._do_refresh(force)
|
||||
|
||||
if self._virtual_media is not None:
|
||||
self._virtual_media.invalidate(force)
|
||||
|
|
|
@ -14,6 +14,7 @@
|
|||
|
||||
import sushy
|
||||
from sushy.resources import base
|
||||
from sushy import utils as sushy_utils
|
||||
|
||||
from proliantutils import exception
|
||||
from proliantutils import log
|
||||
|
@ -46,30 +47,19 @@ class BIOSSettings(base.ResourceBase):
|
|||
cpu_vt = base.MappedField(["Attributes", "ProcVirtualization"],
|
||||
mappings.CPUVT_MAP)
|
||||
|
||||
_iscsi_resource = None
|
||||
_bios_mappings = None
|
||||
|
||||
_pending_settings = None
|
||||
_boot_settings = None
|
||||
_base_configs = None
|
||||
|
||||
@property
|
||||
@sushy_utils.cache_it
|
||||
def pending_settings(self):
|
||||
"""Property to provide reference to bios_pending_settings instance
|
||||
|
||||
It is calculated once when the first time it is queried. On refresh,
|
||||
this property gets reset.
|
||||
"""
|
||||
if self._pending_settings is None:
|
||||
self._pending_settings = BIOSPendingSettings(
|
||||
self._conn,
|
||||
utils.get_subresource_path_by(
|
||||
return BIOSPendingSettings(
|
||||
self._conn, utils.get_subresource_path_by(
|
||||
self, ["@Redfish.Settings", "SettingsObject"]),
|
||||
redfish_version=self.redfish_version)
|
||||
|
||||
self._pending_settings.refresh(force=False)
|
||||
return self._pending_settings
|
||||
|
||||
@property
|
||||
def default_settings(self):
|
||||
"""Property to provide default BIOS settings
|
||||
|
@ -79,90 +69,57 @@ class BIOSSettings(base.ResourceBase):
|
|||
return self._get_base_configs().default_config
|
||||
|
||||
@property
|
||||
@sushy_utils.cache_it
|
||||
def boot_settings(self):
|
||||
"""Property to provide reference to bios boot instance
|
||||
|
||||
It is calculated once when the first time it is queried. On refresh,
|
||||
this property gets reset.
|
||||
"""
|
||||
if self._boot_settings is None:
|
||||
self._boot_settings = BIOSBootSettings(
|
||||
self._conn,
|
||||
utils.get_subresource_path_by(
|
||||
return BIOSBootSettings(
|
||||
self._conn, utils.get_subresource_path_by(
|
||||
self, ["Oem", "Hpe", "Links", "Boot"]),
|
||||
redfish_version=self.redfish_version)
|
||||
|
||||
self._boot_settings.refresh(force=False)
|
||||
return self._boot_settings
|
||||
|
||||
@property
|
||||
@sushy_utils.cache_it
|
||||
def iscsi_resource(self):
|
||||
"""Property to provide reference to bios iscsi resource instance
|
||||
|
||||
It is calculated once when the first time it is queried. On refresh,
|
||||
this property gets reset.
|
||||
"""
|
||||
if self._iscsi_resource is None:
|
||||
self._iscsi_resource = iscsi.ISCSIResource(
|
||||
self._conn,
|
||||
utils.get_subresource_path_by(
|
||||
return iscsi.ISCSIResource(
|
||||
self._conn, utils.get_subresource_path_by(
|
||||
self, ["Oem", "Hpe", "Links", "iScsi"]),
|
||||
redfish_version=self.redfish_version)
|
||||
|
||||
self._iscsi_resource.refresh(force=False)
|
||||
return self._iscsi_resource
|
||||
|
||||
@property
|
||||
@sushy_utils.cache_it
|
||||
def bios_mappings(self):
|
||||
"""Property to provide reference to bios mappings instance
|
||||
|
||||
It is calculated once when the first time it is queried. On refresh,
|
||||
this property gets reset.
|
||||
"""
|
||||
if self._bios_mappings is None:
|
||||
self._bios_mappings = BIOSMappings(
|
||||
self._conn,
|
||||
utils.get_subresource_path_by(
|
||||
return BIOSMappings(
|
||||
self._conn, utils.get_subresource_path_by(
|
||||
self, ["Oem", "Hpe", "Links", "Mappings"]),
|
||||
redfish_version=self.redfish_version)
|
||||
|
||||
self._bios_mappings.refresh(force=False)
|
||||
return self._bios_mappings
|
||||
|
||||
@sushy_utils.cache_it
|
||||
def _get_base_configs(self):
|
||||
"""Method that returns object of bios base configs."""
|
||||
if self._base_configs is None:
|
||||
self._base_configs = BIOSBaseConfigs(
|
||||
return BIOSBaseConfigs(
|
||||
self._conn, utils.get_subresource_path_by(
|
||||
self, ["Oem", "Hpe", "Links", "BaseConfigs"]),
|
||||
redfish_version=self.redfish_version)
|
||||
|
||||
self._base_configs.refresh(force=False)
|
||||
return self._base_configs
|
||||
|
||||
def update_bios_to_default(self):
|
||||
"""Updates bios default settings"""
|
||||
self.pending_settings.update_bios_data_by_post(
|
||||
self._get_base_configs().default_config)
|
||||
|
||||
def _do_refresh(self, force):
|
||||
"""Do custom resource specific refresh activities
|
||||
|
||||
On refresh, all sub-resources are marked as stale, i.e.
|
||||
greedy-refresh not done for them unless forced by ``force``
|
||||
argument.
|
||||
"""
|
||||
if self._pending_settings is not None:
|
||||
self._pending_settings.invalidate(force)
|
||||
if self._boot_settings is not None:
|
||||
self._boot_settings.invalidate(force)
|
||||
if self._base_configs is not None:
|
||||
self._base_configs.invalidate(force)
|
||||
if self._iscsi_resource is not None:
|
||||
self._iscsi_resource.invalidate(force)
|
||||
if self._bios_mappings is not None:
|
||||
self._bios_mappings.invalidate(force)
|
||||
|
||||
|
||||
class BIOSBaseConfigs(base.ResourceBase):
|
||||
"""Class that defines the functionality for BIOS base configuration."""
|
||||
|
|
|
@ -14,50 +14,25 @@
|
|||
# License for the specific language governing permissions and limitations
|
||||
# under the License.
|
||||
|
||||
from proliantutils.redfish.resources.system import constants as sys_cons
|
||||
from proliantutils.redfish.resources.system import mappings as sys_map
|
||||
from sushy.resources import base
|
||||
from sushy.resources.system import ethernet_interface
|
||||
from sushy import utils as sushy_utils
|
||||
|
||||
|
||||
class HealthStatusField(base.CompositeField):
|
||||
state = base.MappedField(
|
||||
'State', sys_map.HEALTH_STATE_VALUE_MAP)
|
||||
health = base.MappedField('Health', sys_map.HEALTH_VALUE_MAP)
|
||||
from proliantutils.redfish.resources.system import constants as sys_cons
|
||||
|
||||
|
||||
class EthernetInterface(base.ResourceBase):
|
||||
"""This class represents the EthernetInterfaces resource"""
|
||||
|
||||
identity = base.Field('Id', required=True)
|
||||
"""The Ethernet Interface identity string"""
|
||||
|
||||
name = base.Field('Name')
|
||||
"""The name of the resource or array element"""
|
||||
|
||||
description = base.Field('Description')
|
||||
"""Description"""
|
||||
|
||||
permanent_mac_address = base.Field('PermanentMACAddress')
|
||||
"""This is the permanent MAC address assigned to this interface (port) """
|
||||
|
||||
mac_address = base.Field('MACAddress')
|
||||
"""This is the currently configured MAC address of the interface."""
|
||||
|
||||
speed_mbps = base.Field('SpeedMbps')
|
||||
"""This is the current speed in Mbps of this interface."""
|
||||
|
||||
status = HealthStatusField("Status")
|
||||
EthernetInterface = ethernet_interface.EthernetInterface
|
||||
|
||||
|
||||
class EthernetInterfaceCollection(base.ResourceCollectionBase):
|
||||
|
||||
_summary = None
|
||||
|
||||
@property
|
||||
def _resource_type(self):
|
||||
return EthernetInterface
|
||||
|
||||
@property
|
||||
@sushy_utils.cache_it
|
||||
def summary(self):
|
||||
"""property to return the summary MAC addresses and state
|
||||
|
||||
|
@ -69,7 +44,6 @@ class EthernetInterfaceCollection(base.ResourceCollectionBase):
|
|||
consumes the data in this format.
|
||||
Note: 'Id' is referred to as "Port number".
|
||||
"""
|
||||
if self._summary is None:
|
||||
mac_dict = {}
|
||||
for eth in self.get_members():
|
||||
if eth.mac_address is not None:
|
||||
|
@ -79,14 +53,4 @@ class EthernetInterfaceCollection(base.ResourceCollectionBase):
|
|||
sys_cons.HEALTH_STATE_ENABLED):
|
||||
mac_dict.update(
|
||||
{'Port ' + eth.identity: eth.mac_address})
|
||||
self._summary = mac_dict
|
||||
return self._summary
|
||||
|
||||
def _do_refresh(self, force):
|
||||
"""Do custom resource specific refresh activities
|
||||
|
||||
On refresh, all sub-resources are marked as stale, i.e.
|
||||
greedy-refresh not done for them unless forced by ``force``
|
||||
argument.
|
||||
"""
|
||||
self._summary = None
|
||||
return mac_dict
|
||||
|
|
|
@ -13,6 +13,7 @@
|
|||
# under the License.
|
||||
|
||||
from sushy.resources import base
|
||||
from sushy import utils as sushy_utils
|
||||
|
||||
from proliantutils.redfish import utils
|
||||
|
||||
|
@ -25,8 +26,6 @@ class ISCSIResource(base.ResourceBase):
|
|||
"""
|
||||
iscsi_initiator = base.Field("iSCSIInitiatorName")
|
||||
|
||||
_iscsi_settings = None
|
||||
|
||||
def is_iscsi_boot_supported(self):
|
||||
"""Checks whether iscsi boot is supported or not.
|
||||
|
||||
|
@ -39,32 +38,18 @@ class ISCSIResource(base.ResourceBase):
|
|||
['@Redfish.Settings', 'SettingsObject'])
|
||||
|
||||
@property
|
||||
@sushy_utils.cache_it
|
||||
def iscsi_settings(self):
|
||||
"""Property to provide reference to iSCSI settings instance
|
||||
|
||||
It is calculated once when the first time it is queried. On refresh,
|
||||
this property gets reset.
|
||||
"""
|
||||
if self._iscsi_settings is None:
|
||||
self._iscsi_settings = ISCSISettings(
|
||||
self._conn,
|
||||
utils.get_subresource_path_by(
|
||||
return ISCSISettings(
|
||||
self._conn, utils.get_subresource_path_by(
|
||||
self, ["@Redfish.Settings", "SettingsObject"]),
|
||||
redfish_version=self.redfish_version)
|
||||
|
||||
self._iscsi_settings.refresh(force=False)
|
||||
return self._iscsi_settings
|
||||
|
||||
def _do_refresh(self, force):
|
||||
"""Do custom resource specific refresh activities
|
||||
|
||||
On refresh, all sub-resources are marked as stale, i.e.
|
||||
greedy-refresh not done for them unless forced by ``force``
|
||||
argument.
|
||||
"""
|
||||
if self._iscsi_settings is not None:
|
||||
self._iscsi_settings.invalidate(force)
|
||||
|
||||
|
||||
class ISCSISettings(base.ResourceBase):
|
||||
"""Class that represents the iSCSI settings.
|
||||
|
|
|
@ -15,6 +15,7 @@
|
|||
import logging
|
||||
|
||||
from sushy.resources import base
|
||||
from sushy import utils as sushy_utils
|
||||
|
||||
LOG = logging.getLogger(__name__)
|
||||
|
||||
|
@ -32,64 +33,34 @@ class PCIDevice(base.ResourceBase):
|
|||
|
||||
sub_class_code = base.Field('SubclassCode')
|
||||
|
||||
_nic_capacity = None
|
||||
|
||||
def _do_refresh(self, force):
|
||||
"""Do custom resource specific refresh activities
|
||||
|
||||
On refresh, all sub-resources are marked as stale, i.e.
|
||||
greedy-refresh not done for them unless forced by ``force``
|
||||
argument.
|
||||
"""
|
||||
self._nic_capacity = None
|
||||
|
||||
@property
|
||||
@sushy_utils.cache_it
|
||||
def nic_capacity(self):
|
||||
if self._nic_capacity is None:
|
||||
for item in self.name.split():
|
||||
if 'Gb' in item:
|
||||
capacity = item.strip('Gb')
|
||||
self._nic_capacity = (
|
||||
int(capacity) if capacity.isdigit() else 0)
|
||||
break
|
||||
else:
|
||||
self._nic_capacity = 0
|
||||
return self._nic_capacity
|
||||
return int(capacity) if capacity.isdigit() else 0
|
||||
return 0
|
||||
|
||||
|
||||
class PCIDeviceCollection(base.ResourceCollectionBase):
|
||||
|
||||
_gpu_devices = None
|
||||
_max_nic_capacity = None
|
||||
|
||||
@property
|
||||
def _resource_type(self):
|
||||
return PCIDevice
|
||||
|
||||
@property
|
||||
@sushy_utils.cache_it
|
||||
def gpu_devices(self):
|
||||
if self._gpu_devices is None:
|
||||
self._gpu_devices = []
|
||||
gpu_devices = []
|
||||
for member in self.get_members():
|
||||
if member.class_code in CLASSCODE_FOR_GPU_DEVICES:
|
||||
if member.sub_class_code in SUBCLASSCODE_FOR_GPU_DEVICES:
|
||||
self._gpu_devices.append(member)
|
||||
return self._gpu_devices
|
||||
|
||||
def _do_refresh(self, force):
|
||||
"""Do custom resource specific refresh activities
|
||||
|
||||
On refresh, all sub-resources are marked as stale, i.e.
|
||||
greedy-refresh not done for them unless forced by ``force``
|
||||
argument.
|
||||
"""
|
||||
self._gpu_devices = None
|
||||
self._max_nic_capacity = None
|
||||
gpu_devices.append(member)
|
||||
return gpu_devices
|
||||
|
||||
@property
|
||||
@sushy_utils.cache_it
|
||||
def max_nic_capacity(self):
|
||||
"""Gets the maximum NIC capacity"""
|
||||
if self._max_nic_capacity is None:
|
||||
self._max_nic_capacity = (
|
||||
str(max([m.nic_capacity for m in self.get_members()])) + 'Gb')
|
||||
return self._max_nic_capacity
|
||||
return str(max([m.nic_capacity for m in self.get_members()])) + 'Gb'
|
||||
|
|
|
@ -14,6 +14,8 @@
|
|||
|
||||
import logging
|
||||
|
||||
from sushy import utils as sushy_utils
|
||||
|
||||
from proliantutils.redfish.resources.system.storage import logical_drive
|
||||
from proliantutils.redfish.resources.system.storage import physical_drive
|
||||
from proliantutils.redfish import utils
|
||||
|
@ -40,149 +42,102 @@ class HPEArrayController(base.ResourceBase):
|
|||
location = base.Field('Location')
|
||||
"""Controller slot location"""
|
||||
|
||||
_logical_drives = None
|
||||
_physical_drives = None
|
||||
|
||||
@property
|
||||
@sushy_utils.cache_it
|
||||
def logical_drives(self):
|
||||
"""Gets the resource HPELogicalDriveCollection of ArrayControllers"""
|
||||
|
||||
if self._logical_drives is None:
|
||||
self._logical_drives = (
|
||||
logical_drive.HPELogicalDriveCollection(
|
||||
return logical_drive.HPELogicalDriveCollection(
|
||||
self._conn, utils.get_subresource_path_by(
|
||||
self, ['Links', 'LogicalDrives']),
|
||||
redfish_version=self.redfish_version))
|
||||
|
||||
self._logical_drives.refresh(force=False)
|
||||
return self._logical_drives
|
||||
redfish_version=self.redfish_version)
|
||||
|
||||
@property
|
||||
@sushy_utils.cache_it
|
||||
def physical_drives(self):
|
||||
"""Gets the resource HPEPhysicalDriveCollection of ArrayControllers"""
|
||||
|
||||
if self._physical_drives is None:
|
||||
self._physical_drives = (
|
||||
physical_drive.HPEPhysicalDriveCollection(
|
||||
return physical_drive.HPEPhysicalDriveCollection(
|
||||
self._conn, utils.get_subresource_path_by(
|
||||
self, ['Links', 'PhysicalDrives']),
|
||||
redfish_version=self.redfish_version))
|
||||
|
||||
self._physical_drives.refresh(force=False)
|
||||
return self._physical_drives
|
||||
|
||||
def _do_refresh(self, force):
|
||||
"""Do custom resource specific refresh activities
|
||||
|
||||
On refresh, all sub-resources are marked as stale, i.e.
|
||||
greedy-refresh not done for them unless forced by ``force``
|
||||
argument.
|
||||
"""
|
||||
super(HPEArrayController, self)._do_refresh(force)
|
||||
|
||||
if self._physical_drives is not None:
|
||||
self._physical_drives.invalidate(force)
|
||||
if self._logical_drives is not None:
|
||||
self._logical_drives.invalidate(force)
|
||||
redfish_version=self.redfish_version)
|
||||
|
||||
|
||||
class HPEArrayControllerCollection(base.ResourceCollectionBase):
|
||||
"""This class represents the collection of HPEArrayControllers"""
|
||||
|
||||
_logical_drives_maximum_size_mib = None
|
||||
_physical_drives_maximum_size_mib = None
|
||||
_has_ssd = None
|
||||
_has_rotational = None
|
||||
_logical_raid_levels = None
|
||||
_drive_rotational_speed_rpm = None
|
||||
_get_models = None
|
||||
_get_default_controller = None
|
||||
|
||||
@property
|
||||
def _resource_type(self):
|
||||
return HPEArrayController
|
||||
|
||||
@property
|
||||
@sushy_utils.cache_it
|
||||
def logical_drives_maximum_size_mib(self):
|
||||
"""Gets the biggest logical drive
|
||||
|
||||
:returns the size in MiB.
|
||||
"""
|
||||
if self._logical_drives_maximum_size_mib is None:
|
||||
self._logical_drives_maximum_size_mib = (
|
||||
utils.max_safe([member.logical_drives.maximum_size_mib
|
||||
for member in self.get_members()]))
|
||||
return self._logical_drives_maximum_size_mib
|
||||
return utils.max_safe([member.logical_drives.maximum_size_mib
|
||||
for member in self.get_members()])
|
||||
|
||||
@property
|
||||
@sushy_utils.cache_it
|
||||
def physical_drives_maximum_size_mib(self):
|
||||
"""Gets the biggest disk
|
||||
|
||||
:returns the size in MiB.
|
||||
"""
|
||||
if self._physical_drives_maximum_size_mib is None:
|
||||
self._physical_drives_maximum_size_mib = (
|
||||
utils.max_safe([member.physical_drives.maximum_size_mib
|
||||
for member in self.get_members()]))
|
||||
return self._physical_drives_maximum_size_mib
|
||||
return utils.max_safe([member.physical_drives.maximum_size_mib
|
||||
for member in self.get_members()])
|
||||
|
||||
@property
|
||||
@sushy_utils.cache_it
|
||||
def has_ssd(self):
|
||||
"""Return true if any of the drive under ArrayControllers is ssd"""
|
||||
|
||||
if self._has_ssd is None:
|
||||
self._has_ssd = False
|
||||
for member in self.get_members():
|
||||
if member.physical_drives.has_ssd:
|
||||
self._has_ssd = True
|
||||
break
|
||||
return self._has_ssd
|
||||
return True
|
||||
return False
|
||||
|
||||
@property
|
||||
@sushy_utils.cache_it
|
||||
def has_rotational(self):
|
||||
"""Return true if any of the drive under ArrayControllers is ssd"""
|
||||
|
||||
if self._has_rotational is None:
|
||||
self._has_rotational = False
|
||||
for member in self.get_members():
|
||||
if member.physical_drives.has_rotational:
|
||||
self._has_rotational = True
|
||||
break
|
||||
return self._has_rotational
|
||||
return True
|
||||
return False
|
||||
|
||||
@property
|
||||
@sushy_utils.cache_it
|
||||
def logical_raid_levels(self):
|
||||
"""Gets the raid level for each logical volume
|
||||
|
||||
:returns the set of list of raid levels configured
|
||||
"""
|
||||
if self._logical_raid_levels is None:
|
||||
self._logical_raid_levels = set()
|
||||
lg_raid_lvls = set()
|
||||
for member in self.get_members():
|
||||
self._logical_raid_levels.update(
|
||||
member.logical_drives.logical_raid_levels)
|
||||
return self._logical_raid_levels
|
||||
lg_raid_lvls.update(member.logical_drives.logical_raid_levels)
|
||||
return lg_raid_lvls
|
||||
|
||||
@property
|
||||
@sushy_utils.cache_it
|
||||
def drive_rotational_speed_rpm(self):
|
||||
"""Gets the set of rotational speed of the HDD drives"""
|
||||
|
||||
if self._drive_rotational_speed_rpm is None:
|
||||
self._drive_rotational_speed_rpm = set()
|
||||
drv_rot_speed_rpm = set()
|
||||
for member in self.get_members():
|
||||
self._drive_rotational_speed_rpm.update(
|
||||
drv_rot_speed_rpm.update(
|
||||
member.physical_drives.drive_rotational_speed_rpm)
|
||||
return self._drive_rotational_speed_rpm
|
||||
return drv_rot_speed_rpm
|
||||
|
||||
@property
|
||||
@sushy_utils.cache_it
|
||||
def get_default_controller(self):
|
||||
"""Gets default array controller
|
||||
|
||||
:returns default array controller
|
||||
"""
|
||||
if self._get_default_controller is None:
|
||||
self._get_default_controller = self.get_members()[0]
|
||||
return self._get_default_controller
|
||||
return self.get_members()[0]
|
||||
|
||||
def array_controller_by_location(self, location):
|
||||
"""Returns array controller instance by location
|
||||
|
@ -201,19 +156,3 @@ class HPEArrayControllerCollection(base.ResourceCollectionBase):
|
|||
for member in self.get_members():
|
||||
if member.model == model:
|
||||
return member
|
||||
|
||||
def _do_refresh(self, force):
|
||||
"""Do custom resource specific refresh activities
|
||||
|
||||
On refresh, all sub-resources are marked as stale, i.e.
|
||||
greedy-refresh not done for them unless forced by ``force``
|
||||
argument.
|
||||
"""
|
||||
self._logical_drives_maximum_size_mib = None
|
||||
self._physical_drives_maximum_size_mib = None
|
||||
self._has_ssd = None
|
||||
self._has_rotational = None
|
||||
self._logical_raid_levels = None
|
||||
self._drive_rotational_speed_rpm = None
|
||||
self._get_models = None
|
||||
self._get_default_controller = None
|
||||
|
|
|
@ -13,6 +13,7 @@
|
|||
# under the License.
|
||||
|
||||
from sushy.resources import base
|
||||
from sushy import utils as sushy_utils
|
||||
|
||||
from proliantutils.redfish import utils
|
||||
|
||||
|
@ -36,44 +37,28 @@ class HPELogicalDrive(base.ResourceBase):
|
|||
class HPELogicalDriveCollection(base.ResourceCollectionBase):
|
||||
"""This class represents the collection of LogicalDrives resource"""
|
||||
|
||||
_maximum_size_mib = None
|
||||
_logical_raid_levels = None
|
||||
|
||||
@property
|
||||
def _resource_type(self):
|
||||
return HPELogicalDrive
|
||||
|
||||
@property
|
||||
@sushy_utils.cache_it
|
||||
def maximum_size_mib(self):
|
||||
"""Gets the biggest logical drive
|
||||
|
||||
:returns size in MiB.
|
||||
"""
|
||||
if self._maximum_size_mib is None:
|
||||
self._maximum_size_mib = (
|
||||
utils.max_safe([member.capacity_mib
|
||||
for member in self.get_members()]))
|
||||
return self._maximum_size_mib
|
||||
return utils.max_safe([member.capacity_mib
|
||||
for member in self.get_members()])
|
||||
|
||||
@property
|
||||
@sushy_utils.cache_it
|
||||
def logical_raid_levels(self):
|
||||
"""Gets the raid level for each logical volume
|
||||
|
||||
:returns the set of list of raid levels configured.
|
||||
"""
|
||||
if self._logical_raid_levels is None:
|
||||
self._logical_raid_levels = set()
|
||||
lg_raid_lvls = set()
|
||||
for member in self.get_members():
|
||||
self._logical_raid_levels.add(
|
||||
mappings.RAID_LEVEL_MAP_REV.get(member.raid))
|
||||
return self._logical_raid_levels
|
||||
|
||||
def _do_refresh(self, force):
|
||||
"""Do custom resource specific refresh activities
|
||||
|
||||
On refresh, all sub-resources are marked as stale, i.e.
|
||||
greedy-refresh not done for them unless forced by ``force``
|
||||
argument.
|
||||
"""
|
||||
self._maximum_size_mib = None
|
||||
self._logical_raid_levels = None
|
||||
lg_raid_lvls.add(mappings.RAID_LEVEL_MAP_REV.get(member.raid))
|
||||
return lg_raid_lvls
|
||||
|
|
|
@ -13,6 +13,7 @@
|
|||
# under the License.
|
||||
|
||||
from sushy.resources import base
|
||||
from sushy import utils as sushy_utils
|
||||
|
||||
from proliantutils.redfish import utils
|
||||
|
||||
|
@ -39,71 +40,44 @@ class HPEPhysicalDrive(base.ResourceBase):
|
|||
class HPEPhysicalDriveCollection(base.ResourceCollectionBase):
|
||||
"""This class represents the collection of HPEPhysicalDrives resource"""
|
||||
|
||||
_maximum_size_mib = None
|
||||
_has_ssd = None
|
||||
_has_rotational = None
|
||||
_drive_rotational_speed_rpm = None
|
||||
|
||||
@property
|
||||
def _resource_type(self):
|
||||
return HPEPhysicalDrive
|
||||
|
||||
@property
|
||||
@sushy_utils.cache_it
|
||||
def maximum_size_mib(self):
|
||||
"""Gets the biggest physical drive
|
||||
|
||||
:returns size in MiB.
|
||||
"""
|
||||
if self._maximum_size_mib is None:
|
||||
self._maximum_size_mib = (
|
||||
utils.max_safe([member.capacity_mib
|
||||
for member in self.get_members()]))
|
||||
return self._maximum_size_mib
|
||||
return utils.max_safe([member.capacity_mib
|
||||
for member in self.get_members()])
|
||||
|
||||
@property
|
||||
@sushy_utils.cache_it
|
||||
def has_ssd(self):
|
||||
"""Return true if the drive is ssd"""
|
||||
|
||||
if self._has_ssd is None:
|
||||
self._has_ssd = False
|
||||
for member in self.get_members():
|
||||
if member.media_type == constants.MEDIA_TYPE_SSD:
|
||||
self._has_ssd = True
|
||||
break
|
||||
return self._has_ssd
|
||||
return True
|
||||
return False
|
||||
|
||||
@property
|
||||
@sushy_utils.cache_it
|
||||
def has_rotational(self):
|
||||
"""Return true if the drive is HDD"""
|
||||
|
||||
if self._has_rotational is None:
|
||||
self._has_rotational = False
|
||||
for member in self.get_members():
|
||||
if member.media_type == constants.MEDIA_TYPE_HDD:
|
||||
self._has_rotational = True
|
||||
break
|
||||
return self._has_rotational
|
||||
return True
|
||||
return False
|
||||
|
||||
@property
|
||||
@sushy_utils.cache_it
|
||||
def drive_rotational_speed_rpm(self):
|
||||
"""Gets the set of rotational speed of the HDD drives"""
|
||||
|
||||
if self._drive_rotational_speed_rpm is None:
|
||||
self._drive_rotational_speed_rpm = set()
|
||||
drv_rot_speed_rpm = set()
|
||||
for member in self.get_members():
|
||||
if member.rotational_speed_rpm is not None:
|
||||
self._drive_rotational_speed_rpm.add(
|
||||
member.rotational_speed_rpm)
|
||||
return self._drive_rotational_speed_rpm
|
||||
|
||||
def _do_refresh(self, force):
|
||||
"""Do custom resource specific refresh activities
|
||||
|
||||
On refresh, all sub-resources are marked as stale, i.e.
|
||||
greedy-refresh not done for them unless forced by ``force``
|
||||
argument.
|
||||
"""
|
||||
self._maximum_size_mib = None
|
||||
self._has_ssd = None
|
||||
self._has_rotational = None
|
||||
self._drive_rotational_speed_rpm = None
|
||||
drv_rot_speed_rpm.add(member.rotational_speed_rpm)
|
||||
return drv_rot_speed_rpm
|
||||
|
|
|
@ -14,6 +14,7 @@
|
|||
|
||||
|
||||
from sushy.resources import base
|
||||
from sushy import utils as sushy_utils
|
||||
|
||||
from proliantutils.redfish import utils
|
||||
|
||||
|
@ -33,29 +34,16 @@ class SimpleStorage(base.ResourceBase):
|
|||
devices = base.Field('Devices')
|
||||
"""The storage devices associated with this resource"""
|
||||
|
||||
_maximum_size_bytes = None
|
||||
|
||||
@property
|
||||
@sushy_utils.cache_it
|
||||
def maximum_size_bytes(self):
|
||||
"""Gets the biggest disk drive
|
||||
|
||||
:returns size in bytes.
|
||||
"""
|
||||
if self._maximum_size_bytes is None:
|
||||
self._maximum_size_bytes = (
|
||||
utils.max_safe([device.get('CapacityBytes')
|
||||
for device in self.devices
|
||||
if device.get('CapacityBytes') is not None]))
|
||||
return self._maximum_size_bytes
|
||||
|
||||
def _do_refresh(self, force):
|
||||
"""Do custom resource specific refresh activities
|
||||
|
||||
On refresh, all sub-resources are marked as stale, i.e.
|
||||
greedy-refresh not done for them unless forced by ``force``
|
||||
argument.
|
||||
"""
|
||||
self._maximum_size_bytes = None
|
||||
return utils.max_safe(
|
||||
[device.get('CapacityBytes') for device in self.devices
|
||||
if device.get('CapacityBytes') is not None])
|
||||
|
||||
|
||||
class SimpleStorageCollection(base.ResourceCollectionBase):
|
||||
|
@ -64,25 +52,12 @@ class SimpleStorageCollection(base.ResourceCollectionBase):
|
|||
def _resource_type(self):
|
||||
return SimpleStorage
|
||||
|
||||
_maximum_size_bytes = None
|
||||
|
||||
@property
|
||||
@sushy_utils.cache_it
|
||||
def maximum_size_bytes(self):
|
||||
"""Gets the biggest disk drive
|
||||
|
||||
:returns size in bytes.
|
||||
"""
|
||||
if self._maximum_size_bytes is None:
|
||||
self._maximum_size_bytes = (
|
||||
utils.max_safe([member.maximum_size_bytes
|
||||
for member in self.get_members()]))
|
||||
return self._maximum_size_bytes
|
||||
|
||||
def _do_refresh(self, force):
|
||||
"""Do custom resource specific refresh activities
|
||||
|
||||
On refresh, all sub-resources are marked as stale, i.e.
|
||||
greedy-refresh not done for them unless forced by ``force``
|
||||
argument.
|
||||
"""
|
||||
self._maximum_size_bytes = None
|
||||
return utils.max_safe([member.maximum_size_bytes
|
||||
for member in self.get_members()])
|
||||
|
|
|
@ -14,9 +14,11 @@
|
|||
|
||||
import logging
|
||||
|
||||
from sushy.resources import base
|
||||
from sushy import utils as sushy_utils
|
||||
|
||||
from proliantutils.redfish.resources.system.storage import array_controller
|
||||
from proliantutils.redfish import utils
|
||||
from sushy.resources import base
|
||||
|
||||
LOG = logging.getLogger(__name__)
|
||||
|
||||
|
@ -30,103 +32,60 @@ class HPESmartStorage(base.ResourceBase):
|
|||
description = base.Field('Description')
|
||||
"""Description"""
|
||||
|
||||
_array_controllers = None
|
||||
_logical_drives_maximum_size_mib = None
|
||||
_physical_drives_maximum_size_mib = None
|
||||
_has_ssd = None
|
||||
_has_rotational = None
|
||||
_logical_raid_levels = None
|
||||
_drive_rotational_speed_rpm = None
|
||||
|
||||
@property
|
||||
@sushy_utils.cache_it
|
||||
def array_controllers(self):
|
||||
"""This property gets the list of instances for array controllers
|
||||
|
||||
This property gets the list of instances for array controllers
|
||||
:returns: a list of instances of array controllers.
|
||||
"""
|
||||
if self._array_controllers is None:
|
||||
self._array_controllers = (
|
||||
array_controller.HPEArrayControllerCollection(
|
||||
return array_controller.HPEArrayControllerCollection(
|
||||
self._conn, utils.get_subresource_path_by(
|
||||
self, ['Links', 'ArrayControllers']),
|
||||
redfish_version=self.redfish_version))
|
||||
|
||||
self._array_controllers.refresh(force=False)
|
||||
return self._array_controllers
|
||||
redfish_version=self.redfish_version)
|
||||
|
||||
@property
|
||||
@sushy_utils.cache_it
|
||||
def logical_drives_maximum_size_mib(self):
|
||||
"""Gets the biggest logical drive
|
||||
|
||||
:Returns the size in MiB.
|
||||
"""
|
||||
if self._logical_drives_maximum_size_mib is None:
|
||||
self._logical_drives_maximum_size_mib = (
|
||||
self.array_controllers.logical_drives_maximum_size_mib)
|
||||
return self._logical_drives_maximum_size_mib
|
||||
return self.array_controllers.logical_drives_maximum_size_mib
|
||||
|
||||
@property
|
||||
@sushy_utils.cache_it
|
||||
def physical_drives_maximum_size_mib(self):
|
||||
"""Gets the biggest disk drive
|
||||
|
||||
:Returns the size in MiB.
|
||||
"""
|
||||
if self._physical_drives_maximum_size_mib is None:
|
||||
self._physical_drives_maximum_size_mib = (
|
||||
self.array_controllers.physical_drives_maximum_size_mib)
|
||||
return self._physical_drives_maximum_size_mib
|
||||
return self.array_controllers.physical_drives_maximum_size_mib
|
||||
|
||||
@property
|
||||
@sushy_utils.cache_it
|
||||
def has_ssd(self):
|
||||
"""Return true if any of the drive under ArrayControllers is ssd"""
|
||||
|
||||
if self._has_ssd is None:
|
||||
self._has_ssd = self.array_controllers.has_ssd
|
||||
return self._has_ssd
|
||||
return self.array_controllers.has_ssd
|
||||
|
||||
@property
|
||||
@sushy_utils.cache_it
|
||||
def has_rotational(self):
|
||||
"""Return true if any of the drive under ArrayControllers is HDD"""
|
||||
|
||||
if self._has_rotational is None:
|
||||
self._has_rotational = (
|
||||
self.array_controllers.has_rotational)
|
||||
return self._has_rotational
|
||||
return self.array_controllers.has_rotational
|
||||
|
||||
@property
|
||||
@sushy_utils.cache_it
|
||||
def logical_raid_levels(self):
|
||||
"""Gets the raid level for each logical volume
|
||||
|
||||
:returns the set of list of raid levels configured.
|
||||
"""
|
||||
if self._logical_raid_levels is None:
|
||||
self._logical_raid_levels = (
|
||||
self.array_controllers.logical_raid_levels)
|
||||
return self._logical_raid_levels
|
||||
return self.array_controllers.logical_raid_levels
|
||||
|
||||
@property
|
||||
@sushy_utils.cache_it
|
||||
def drive_rotational_speed_rpm(self):
|
||||
"""Gets the list of rotational speed of the HDD drives"""
|
||||
|
||||
if self._drive_rotational_speed_rpm is None:
|
||||
self._drive_rotational_speed_rpm = (
|
||||
self.array_controllers.drive_rotational_speed_rpm)
|
||||
return self._drive_rotational_speed_rpm
|
||||
|
||||
def _do_refresh(self, force):
|
||||
"""Do custom resource specific refresh activities
|
||||
|
||||
On refresh, all sub-resources are marked as stale, i.e.
|
||||
greedy-refresh not done for them unless forced by ``force``
|
||||
argument.
|
||||
"""
|
||||
if self._array_controllers is not None:
|
||||
self._array_controllers.invalidate(force)
|
||||
|
||||
self._logical_drives_maximum_size_mib = None
|
||||
self._physical_drives_maximum_size_mib = None
|
||||
self._has_ssd = None
|
||||
self._has_rotational = None
|
||||
self._logical_raid_levels = None
|
||||
self._drive_rotational_speed_rpm = None
|
||||
return self.array_controllers.drive_rotational_speed_rpm
|
||||
|
|
|
@ -14,12 +14,14 @@
|
|||
|
||||
import logging
|
||||
|
||||
from sushy.resources import base
|
||||
from sushy import utils as sushy_utils
|
||||
|
||||
from proliantutils.redfish.resources.system.storage import constants
|
||||
from proliantutils.redfish.resources.system.storage import drive as sys_drives
|
||||
from proliantutils.redfish.resources.system.storage \
|
||||
import volume as sys_volumes
|
||||
from proliantutils.redfish import utils
|
||||
from sushy.resources import base
|
||||
|
||||
LOG = logging.getLogger(__name__)
|
||||
|
||||
|
@ -39,27 +41,17 @@ class Storage(base.ResourceBase):
|
|||
drives = base.Field('Drives')
|
||||
"""The set of drives attached to the storage controllers"""
|
||||
|
||||
_volumes = None
|
||||
_drives_maximum_size_bytes = None
|
||||
_has_ssd = None
|
||||
_has_rotational = None
|
||||
_has_nvme_ssd = None
|
||||
_drive_rotational_speed_rpm = None
|
||||
|
||||
@property
|
||||
@sushy_utils.cache_it
|
||||
def volumes(self):
|
||||
"""This property prepares the list of volumes
|
||||
|
||||
:return a list of volumes.
|
||||
"""
|
||||
if self._volumes is None:
|
||||
self._volumes = sys_volumes.VolumeCollection(
|
||||
return sys_volumes.VolumeCollection(
|
||||
self._conn, utils.get_subresource_path_by(self, 'Volumes'),
|
||||
redfish_version=self.redfish_version)
|
||||
|
||||
self._volumes.refresh(force=False)
|
||||
return self._volumes
|
||||
|
||||
def _drives_list(self):
|
||||
"""Gets the list of drives
|
||||
|
||||
|
@ -72,177 +64,114 @@ class Storage(base.ResourceBase):
|
|||
return drives_list
|
||||
|
||||
@property
|
||||
@sushy_utils.cache_it
|
||||
def drives_maximum_size_bytes(self):
|
||||
"""Gets the biggest disk
|
||||
|
||||
:returns the size in MiB.
|
||||
"""
|
||||
if self._drives_maximum_size_bytes is None:
|
||||
self._drives_maximum_size_bytes = (
|
||||
utils.max_safe([member.capacity_bytes
|
||||
for member in self._drives_list()]))
|
||||
return self._drives_maximum_size_bytes
|
||||
return utils.max_safe([member.capacity_bytes
|
||||
for member in self._drives_list()])
|
||||
|
||||
@property
|
||||
@sushy_utils.cache_it
|
||||
def has_ssd(self):
|
||||
"""Return true if any of the drive is ssd"""
|
||||
|
||||
if self._has_ssd is None:
|
||||
self._has_ssd = False
|
||||
for member in self._drives_list():
|
||||
if member.media_type == constants.MEDIA_TYPE_SSD:
|
||||
self._has_ssd = True
|
||||
break
|
||||
return self._has_ssd
|
||||
return True
|
||||
return False
|
||||
|
||||
@property
|
||||
@sushy_utils.cache_it
|
||||
def has_rotational(self):
|
||||
"""Return true if any of the drive is HDD"""
|
||||
|
||||
if self._has_rotational is None:
|
||||
self._has_rotational = False
|
||||
for member in self._drives_list():
|
||||
if member.media_type == constants.MEDIA_TYPE_HDD:
|
||||
self._has_rotational = True
|
||||
break
|
||||
return self._has_rotational
|
||||
return True
|
||||
return False
|
||||
|
||||
@property
|
||||
@sushy_utils.cache_it
|
||||
def has_nvme_ssd(self):
|
||||
"""Return True if the drive is SSD and protocol is NVMe"""
|
||||
|
||||
if self._has_nvme_ssd is None:
|
||||
self._has_nvme_ssd = False
|
||||
for member in self._drives_list():
|
||||
if (member.media_type == constants.MEDIA_TYPE_SSD and
|
||||
member.protocol == constants.PROTOCOL_NVMe):
|
||||
self._has_nvme_ssd = True
|
||||
return self._has_nvme_ssd
|
||||
return True
|
||||
return False
|
||||
|
||||
@property
|
||||
@sushy_utils.cache_it
|
||||
def drive_rotational_speed_rpm(self):
|
||||
"""Gets set of rotational speed of the disks"""
|
||||
|
||||
if self._drive_rotational_speed_rpm is None:
|
||||
self._drive_rotational_speed_rpm = set()
|
||||
drv_rot_speed_rpm = set()
|
||||
for member in self._drives_list():
|
||||
if member.rotation_speed_rpm is not None:
|
||||
self._drive_rotational_speed_rpm.add(
|
||||
member.rotation_speed_rpm)
|
||||
return self._drive_rotational_speed_rpm
|
||||
|
||||
def _do_refresh(self, force):
|
||||
"""Do custom resource specific refresh activities
|
||||
|
||||
On refresh, all sub-resources are marked as stale, i.e.
|
||||
greedy-refresh not done for them unless forced by ``force``
|
||||
argument.
|
||||
"""
|
||||
if self._volumes is not None:
|
||||
self._volumes.invalidate(force)
|
||||
|
||||
self._drives_maximum_size_bytes = None
|
||||
self._has_ssd = None
|
||||
self._has_rotational = None
|
||||
self._has_nvme_ssd = None
|
||||
self._drive_rotational_speed_rpm = None
|
||||
drv_rot_speed_rpm.add(member.rotation_speed_rpm)
|
||||
return drv_rot_speed_rpm
|
||||
|
||||
|
||||
class StorageCollection(base.ResourceCollectionBase):
|
||||
"""This class represents the collection of Storage resource"""
|
||||
|
||||
_volumes_maximum_size_bytes = None
|
||||
_drives_maximum_size_bytes = None
|
||||
_has_ssd = None
|
||||
_has_rotational = None
|
||||
_has_nvme_ssd = None
|
||||
_drive_rotational_speed_rpm = None
|
||||
|
||||
@property
|
||||
def _resource_type(self):
|
||||
return Storage
|
||||
|
||||
@property
|
||||
@sushy_utils.cache_it
|
||||
def volumes_maximum_size_bytes(self):
|
||||
"""Gets the biggest logical drive
|
||||
|
||||
:returns the size in MiB.
|
||||
"""
|
||||
if self._volumes_maximum_size_bytes is None:
|
||||
self._volumes_maximum_size_bytes = (
|
||||
utils.max_safe([member.volumes.maximum_size_bytes
|
||||
for member in self.get_members()]))
|
||||
return self._volumes_maximum_size_bytes
|
||||
return utils.max_safe([member.volumes.maximum_size_bytes
|
||||
for member in self.get_members()])
|
||||
|
||||
@property
|
||||
@sushy_utils.cache_it
|
||||
def drives_maximum_size_bytes(self):
|
||||
"""Gets the biggest disk
|
||||
|
||||
:returns the size in MiB.
|
||||
"""
|
||||
if self._drives_maximum_size_bytes is None:
|
||||
self._drives_maximum_size_bytes = (
|
||||
utils.max_safe([member.drives_maximum_size_bytes
|
||||
for member in self.get_members()]))
|
||||
return self._drives_maximum_size_bytes
|
||||
return utils.max_safe([member.drives_maximum_size_bytes
|
||||
for member in self.get_members()])
|
||||
|
||||
@property
|
||||
@sushy_utils.cache_it
|
||||
def has_ssd(self):
|
||||
"""Return true if Storage has any drive as ssd"""
|
||||
|
||||
if self._has_ssd is None:
|
||||
self._has_ssd = False
|
||||
for member in self.get_members():
|
||||
if member.has_ssd:
|
||||
self._has_ssd = True
|
||||
break
|
||||
return self._has_ssd
|
||||
return True
|
||||
return False
|
||||
|
||||
@property
|
||||
@sushy_utils.cache_it
|
||||
def has_rotational(self):
|
||||
"""Return true if Storage has any drive as HDD"""
|
||||
|
||||
if self._has_rotational is None:
|
||||
self._has_rotational = False
|
||||
for member in self.get_members():
|
||||
if member.has_rotational:
|
||||
self._has_rotational = True
|
||||
break
|
||||
return self._has_rotational
|
||||
return True
|
||||
return False
|
||||
|
||||
@property
|
||||
@sushy_utils.cache_it
|
||||
def has_nvme_ssd(self):
|
||||
"""Return True if Storage has SSD drive and protocol is NVMe"""
|
||||
|
||||
if self._has_nvme_ssd is None:
|
||||
self._has_nvme_ssd = False
|
||||
for member in self.get_members():
|
||||
if member.has_nvme_ssd:
|
||||
self._has_nvme_ssd = True
|
||||
break
|
||||
return self._has_nvme_ssd
|
||||
return True
|
||||
return False
|
||||
|
||||
@property
|
||||
@sushy_utils.cache_it
|
||||
def drive_rotational_speed_rpm(self):
|
||||
"""Gets set of rotational speed of the disks"""
|
||||
|
||||
if self._drive_rotational_speed_rpm is None:
|
||||
self._drive_rotational_speed_rpm = set()
|
||||
drv_rot_speed_rpm = set()
|
||||
for member in self.get_members():
|
||||
self._drive_rotational_speed_rpm.update(
|
||||
member.drive_rotational_speed_rpm)
|
||||
return self._drive_rotational_speed_rpm
|
||||
|
||||
def _do_refresh(self, force):
|
||||
"""Do custom resource specific refresh activities
|
||||
|
||||
On refresh, all sub-resources are marked as stale, i.e.
|
||||
greedy-refresh not done for them unless forced by ``force``
|
||||
argument.
|
||||
"""
|
||||
self._volumes_maximum_size_bytes = None
|
||||
self._drives_maximum_size_bytes = None
|
||||
self._has_ssd = None
|
||||
self._has_rotational = None
|
||||
self._has_nvme_ssd = None
|
||||
self._drive_rotational_speed_rpm = None
|
||||
drv_rot_speed_rpm.update(member.drive_rotational_speed_rpm)
|
||||
return drv_rot_speed_rpm
|
||||
|
|
|
@ -13,6 +13,7 @@
|
|||
# under the License.
|
||||
|
||||
from sushy.resources import base
|
||||
from sushy import utils as sushy_utils
|
||||
|
||||
from proliantutils.redfish import utils
|
||||
|
||||
|
@ -30,29 +31,16 @@ class Volume(base.ResourceBase):
|
|||
class VolumeCollection(base.ResourceCollectionBase):
|
||||
"""This class represents the collection of Volume resource"""
|
||||
|
||||
_maximum_size_bytes = None
|
||||
|
||||
@property
|
||||
def _resource_type(self):
|
||||
return Volume
|
||||
|
||||
@property
|
||||
@sushy_utils.cache_it
|
||||
def maximum_size_bytes(self):
|
||||
"""Gets the biggest volume
|
||||
|
||||
:returns size in bytes.
|
||||
"""
|
||||
if self._maximum_size_bytes is None:
|
||||
self._maximum_size_bytes = (
|
||||
utils.max_safe([member.capacity_bytes
|
||||
for member in self.get_members()]))
|
||||
return self._maximum_size_bytes
|
||||
|
||||
def _do_refresh(self, force):
|
||||
"""Do custom resource specific refresh activities
|
||||
|
||||
On refresh, all sub-resources are marked as stale, i.e.
|
||||
greedy-refresh not done for them unless forced by ``force``
|
||||
argument.
|
||||
"""
|
||||
self._maximum_size_bytes = None
|
||||
return utils.max_safe([member.capacity_bytes
|
||||
for member in self.get_members()])
|
||||
|
|
|
@ -90,18 +90,6 @@ class HPESystem(system.System):
|
|||
_hpe_actions = HpeActionsField(['Oem', 'Hpe', 'Actions'], required=True)
|
||||
"""Oem specific system extensibility actions"""
|
||||
|
||||
_bios_settings = None # ref to BIOSSettings instance
|
||||
_secure_boot = None # ref to SecureBoot instance
|
||||
|
||||
_smart_storage = None # SmartStorage instance
|
||||
_simple_storages = None # SimpleStorage instance
|
||||
_storages = None # Storage instance
|
||||
_pci_devices = None # PCIDevice instance
|
||||
|
||||
_ethernet_interfaces = None # EthernetInterface instance
|
||||
|
||||
_memory = None # Memory instance
|
||||
|
||||
def _get_hpe_push_power_button_action_element(self):
|
||||
push_action = self._hpe_actions.computer_system_ext_powerbutton
|
||||
if not push_action:
|
||||
|
@ -134,20 +122,17 @@ class HPESystem(system.System):
|
|||
self._conn.post(target_uri, data={'PushType': value})
|
||||
|
||||
@property
|
||||
@sushy_utils.cache_it
|
||||
def bios_settings(self):
|
||||
"""Property to provide reference to `BIOSSettings` instance
|
||||
|
||||
It is calculated once when the first time it is queried. On refresh,
|
||||
this property gets reset.
|
||||
"""
|
||||
if self._bios_settings is None:
|
||||
self._bios_settings = bios.BIOSSettings(
|
||||
return bios.BIOSSettings(
|
||||
self._conn, utils.get_subresource_path_by(self, 'Bios'),
|
||||
redfish_version=self.redfish_version)
|
||||
|
||||
self._bios_settings.refresh(force=False)
|
||||
return self._bios_settings
|
||||
|
||||
def update_persistent_boot(self, devices=[], persistent=False):
|
||||
"""Changes the persistent boot device order in BIOS boot mode for host
|
||||
|
||||
|
@ -190,61 +175,29 @@ class HPESystem(system.System):
|
|||
self.set_system_boot_source(device, enabled=tenure)
|
||||
|
||||
@property
|
||||
@sushy_utils.cache_it
|
||||
def pci_devices(self):
|
||||
"""Provides the collection of PCI devices
|
||||
|
||||
It is calculated once when the first time it is queried. On refresh,
|
||||
this property gets reset.
|
||||
"""
|
||||
if self._pci_devices is None:
|
||||
self._pci_devices = pci_device.PCIDeviceCollection(
|
||||
return pci_device.PCIDeviceCollection(
|
||||
self._conn, utils.get_subresource_path_by(
|
||||
self, ['Oem', 'Hpe', 'Links', 'PCIDevices']))
|
||||
|
||||
self._pci_devices.refresh(force=False)
|
||||
return self._pci_devices
|
||||
|
||||
@property
|
||||
@sushy_utils.cache_it
|
||||
def secure_boot(self):
|
||||
"""Property to provide reference to `SecureBoot` instance
|
||||
|
||||
It is calculated once when the first time it is queried. On refresh,
|
||||
this property gets reset.
|
||||
"""
|
||||
if self._secure_boot is None:
|
||||
self._secure_boot = secure_boot.SecureBoot(
|
||||
return secure_boot.SecureBoot(
|
||||
self._conn, utils.get_subresource_path_by(self, 'SecureBoot'),
|
||||
redfish_version=self.redfish_version)
|
||||
|
||||
self._secure_boot.refresh(force=False)
|
||||
return self._secure_boot
|
||||
|
||||
def _do_refresh(self, force):
|
||||
"""Do custom resource specific refresh activities
|
||||
|
||||
On refresh, all sub-resources are marked as stale, i.e.
|
||||
greedy-refresh not done for them unless forced by ``force``
|
||||
argument.
|
||||
"""
|
||||
super(HPESystem, self)._do_refresh(force)
|
||||
|
||||
if self._bios_settings is not None:
|
||||
self._bios_settings.invalidate(force)
|
||||
if self._pci_devices is not None:
|
||||
self._pci_devices.invalidate(force)
|
||||
if self._secure_boot is not None:
|
||||
self._secure_boot.invalidate(force)
|
||||
if self._ethernet_interfaces is not None:
|
||||
self._ethernet_interfaces.invalidate(force)
|
||||
if self._smart_storage is not None:
|
||||
self._smart_storage.invalidate(force)
|
||||
if self._storages is not None:
|
||||
self._storages.invalidate(force)
|
||||
if self._simple_storages is not None:
|
||||
self._simple_storages.invalidate(force)
|
||||
if self._memory is not None:
|
||||
self._memory.invalidate(force)
|
||||
|
||||
def _get_hpe_sub_resource_collection_path(self, sub_res):
|
||||
path = None
|
||||
try:
|
||||
|
@ -255,20 +208,16 @@ class HPESystem(system.System):
|
|||
return path
|
||||
|
||||
@property
|
||||
@sushy_utils.cache_it
|
||||
def ethernet_interfaces(self):
|
||||
"""Provide reference to EthernetInterfacesCollection instance"""
|
||||
if self._ethernet_interfaces is None:
|
||||
sub_res = 'EthernetInterfaces'
|
||||
self._ethernet_interfaces = (
|
||||
ethernet_interface.EthernetInterfaceCollection(
|
||||
return ethernet_interface.EthernetInterfaceCollection(
|
||||
self._conn,
|
||||
self._get_hpe_sub_resource_collection_path(sub_res),
|
||||
redfish_version=self.redfish_version))
|
||||
|
||||
self._ethernet_interfaces.refresh(force=False)
|
||||
return self._ethernet_interfaces
|
||||
self._get_hpe_sub_resource_collection_path('EthernetInterfaces'),
|
||||
redfish_version=self.redfish_version)
|
||||
|
||||
@property
|
||||
@sushy_utils.cache_it
|
||||
def smart_storage(self):
|
||||
"""This property gets the object for smart storage.
|
||||
|
||||
|
@ -276,61 +225,46 @@ class HPESystem(system.System):
|
|||
There is no collection for smart storages.
|
||||
:returns: an instance of smart storage
|
||||
"""
|
||||
if self._smart_storage is None:
|
||||
self._smart_storage = hpe_smart_storage.HPESmartStorage(
|
||||
return hpe_smart_storage.HPESmartStorage(
|
||||
self._conn, utils.get_subresource_path_by(
|
||||
self, ['Oem', 'Hpe', 'Links', 'SmartStorage']),
|
||||
redfish_version=self.redfish_version)
|
||||
|
||||
self._smart_storage.refresh(force=False)
|
||||
return self._smart_storage
|
||||
|
||||
@property
|
||||
@sushy_utils.cache_it
|
||||
def storages(self):
|
||||
"""This property gets the list of instances for Storages
|
||||
|
||||
This property gets the list of instances for Storages
|
||||
:returns: a list of instances of Storages
|
||||
"""
|
||||
if self._storages is None:
|
||||
self._storages = storage.StorageCollection(
|
||||
return storage.StorageCollection(
|
||||
self._conn, utils.get_subresource_path_by(self, 'Storage'),
|
||||
redfish_version=self.redfish_version)
|
||||
|
||||
self._storages.refresh(force=False)
|
||||
return self._storages
|
||||
|
||||
@property
|
||||
@sushy_utils.cache_it
|
||||
def simple_storages(self):
|
||||
"""This property gets the list of instances for SimpleStorages
|
||||
|
||||
:returns: a list of instances of SimpleStorages
|
||||
"""
|
||||
if self._simple_storages is None:
|
||||
self._simple_storages = simple_storage.SimpleStorageCollection(
|
||||
self._conn, utils.get_subresource_path_by(
|
||||
self, 'SimpleStorage'),
|
||||
return simple_storage.SimpleStorageCollection(
|
||||
self._conn, utils.get_subresource_path_by(self, 'SimpleStorage'),
|
||||
redfish_version=self.redfish_version)
|
||||
|
||||
self._simple_storages.refresh(force=False)
|
||||
return self._simple_storages
|
||||
|
||||
@property
|
||||
@sushy_utils.cache_it
|
||||
def memory(self):
|
||||
"""Property to provide reference to `MemoryCollection` instance
|
||||
|
||||
It is calculated once when the first time it is queried. On refresh,
|
||||
this property gets reset.
|
||||
"""
|
||||
if self._memory is None:
|
||||
self._memory = memory.MemoryCollection(
|
||||
self._conn, utils.get_subresource_path_by(
|
||||
self, 'Memory'),
|
||||
return memory.MemoryCollection(
|
||||
self._conn, utils.get_subresource_path_by(self, 'Memory'),
|
||||
redfish_version=self.redfish_version)
|
||||
|
||||
self._memory.refresh(force=False)
|
||||
return self._memory
|
||||
|
||||
def get_smart_storage_config(self, smart_storage_config_url):
|
||||
"""Returns a SmartStorageConfig Instance for each controller."""
|
||||
return (smart_storage_config.
|
||||
|
|
|
@ -37,14 +37,12 @@ class HPEAccountServiceTestCase(testtools.TestCase):
|
|||
redfish_version='1.0.2')
|
||||
|
||||
def test_accounts(self):
|
||||
self.assertIsNone(self.acc_inst._accounts)
|
||||
|
||||
self.conn.get.return_value.json.reset_mock()
|
||||
with open('proliantutils/tests/redfish/'
|
||||
'json_samples/account_collection.json', 'r') as f:
|
||||
self.conn.get.return_value.json.return_value = json.loads(f.read())
|
||||
accounts = self.acc_inst.accounts
|
||||
self.assertIsInstance(accounts, account.HPEAccountCollection)
|
||||
self.assertIsInstance(self.acc_inst.accounts,
|
||||
account.HPEAccountCollection)
|
||||
|
||||
def test_accounts_on_refresh(self):
|
||||
with open('proliantutils/tests/redfish/'
|
||||
|
@ -60,8 +58,7 @@ class HPEAccountServiceTestCase(testtools.TestCase):
|
|||
self.acc_inst.invalidate()
|
||||
self.acc_inst.refresh(force=False)
|
||||
|
||||
self.assertIsNotNone(self.acc_inst._accounts)
|
||||
self.assertTrue(self.acc_inst._accounts._is_stale)
|
||||
self.assertTrue(accounts._is_stale)
|
||||
|
||||
with open('proliantutils/tests/redfish/'
|
||||
'json_samples/account_collection.json', 'r') as f:
|
||||
|
@ -69,4 +66,4 @@ class HPEAccountServiceTestCase(testtools.TestCase):
|
|||
|
||||
self.assertIsInstance(self.acc_inst.accounts,
|
||||
account.HPEAccountCollection)
|
||||
self.assertFalse(self.acc_inst._accounts._is_stale)
|
||||
self.assertFalse(accounts._is_stale)
|
||||
|
|
|
@ -41,8 +41,6 @@ class HPEManagerTestCase(testtools.TestCase):
|
|||
data={'LicenseKey': 'testkey'})
|
||||
|
||||
def test_virtual_media(self):
|
||||
self.assertIsNone(self.mgr_inst._virtual_media)
|
||||
|
||||
self.conn.get.return_value.json.reset_mock()
|
||||
|
||||
with open('proliantutils/tests/redfish/'
|
||||
|
@ -77,8 +75,7 @@ class HPEManagerTestCase(testtools.TestCase):
|
|||
self.mgr_inst.invalidate()
|
||||
self.mgr_inst.refresh(force=False)
|
||||
|
||||
self.assertIsNotNone(self.mgr_inst._virtual_media)
|
||||
self.assertTrue(self.mgr_inst._virtual_media._is_stale)
|
||||
self.assertTrue(actual_vmedia._is_stale)
|
||||
|
||||
with open('proliantutils/tests/redfish/'
|
||||
'json_samples/vmedia_collection.json', 'r') as f:
|
||||
|
@ -86,4 +83,4 @@ class HPEManagerTestCase(testtools.TestCase):
|
|||
|
||||
self.assertIsInstance(self.mgr_inst.virtual_media,
|
||||
virtual_media.VirtualMediaCollection)
|
||||
self.assertFalse(self.mgr_inst._virtual_media._is_stale)
|
||||
self.assertFalse(actual_vmedia._is_stale)
|
||||
|
|
|
@ -45,7 +45,6 @@ class HPEArrayControllerTestCase(testtools.TestCase):
|
|||
def test_logical_drives(self):
|
||||
log_coll = None
|
||||
log_dr = None
|
||||
self.assertIsNone(self.sys_stor._logical_drives)
|
||||
self.conn.get.return_value.json.reset_mock()
|
||||
with open('proliantutils/tests/redfish/'
|
||||
'json_samples/logical_drive_collection.json') as f:
|
||||
|
@ -65,7 +64,6 @@ class HPEArrayControllerTestCase(testtools.TestCase):
|
|||
def test_physical_drives(self):
|
||||
disk_coll = None
|
||||
disk_dr = None
|
||||
self.assertIsNone(self.sys_stor._physical_drives)
|
||||
self.conn.get.return_value.json.reset_mock()
|
||||
with open('proliantutils/tests/redfish/'
|
||||
'json_samples/disk_drive_collection.json') as f:
|
||||
|
@ -123,7 +121,6 @@ class HPEArrayControllerCollectionTestCase(testtools.TestCase):
|
|||
self.assertEqual(1, len(members))
|
||||
|
||||
def test_logical_drives_maximum_size_mib(self):
|
||||
self.assertIsNone(self.sys_stor_col._logical_drives_maximum_size_mib)
|
||||
self.conn.get.return_value.json.reset_mock()
|
||||
val = []
|
||||
path = ('proliantutils/tests/redfish/json_samples/'
|
||||
|
@ -146,7 +143,6 @@ class HPEArrayControllerCollectionTestCase(testtools.TestCase):
|
|||
self.assertEqual(expected, actual)
|
||||
|
||||
def test_logical_raid_levels(self):
|
||||
self.assertIsNone(self.sys_stor_col._logical_raid_levels)
|
||||
self.conn.get.return_value.json.reset_mock()
|
||||
val = []
|
||||
path = ('proliantutils/tests/redfish/json_samples/'
|
||||
|
@ -169,7 +165,6 @@ class HPEArrayControllerCollectionTestCase(testtools.TestCase):
|
|||
self.assertEqual(expected, actual)
|
||||
|
||||
def test_physical_drives_maximum_size_mib(self):
|
||||
self.assertIsNone(self.sys_stor_col._physical_drives_maximum_size_mib)
|
||||
self.conn.get.return_value.json.reset_mock()
|
||||
val = []
|
||||
path = ('proliantutils/tests/redfish/json_samples/'
|
||||
|
@ -192,7 +187,6 @@ class HPEArrayControllerCollectionTestCase(testtools.TestCase):
|
|||
self.assertEqual(expected, actual)
|
||||
|
||||
def test_has_ssd(self):
|
||||
self.assertIsNone(self.sys_stor_col._has_ssd)
|
||||
self.conn.get.return_value.json.reset_mock()
|
||||
val = []
|
||||
path = ('proliantutils/tests/redfish/json_samples/'
|
||||
|
@ -213,7 +207,6 @@ class HPEArrayControllerCollectionTestCase(testtools.TestCase):
|
|||
self.assertTrue(self.sys_stor_col.has_ssd)
|
||||
|
||||
def test_has_rotational(self):
|
||||
self.assertIsNone(self.sys_stor_col._has_rotational)
|
||||
self.conn.get.return_value.json.reset_mock()
|
||||
val = []
|
||||
path = ('proliantutils/tests/redfish/json_samples/'
|
||||
|
@ -234,7 +227,6 @@ class HPEArrayControllerCollectionTestCase(testtools.TestCase):
|
|||
self.assertTrue(self.sys_stor_col.has_rotational)
|
||||
|
||||
def test_drive_rotational_speed_rpm(self):
|
||||
self.assertIsNone(self.sys_stor_col._drive_rotational_speed_rpm)
|
||||
self.conn.get.return_value.json.reset_mock()
|
||||
val = []
|
||||
path = ('proliantutils/tests/redfish/json_samples/'
|
||||
|
@ -257,7 +249,6 @@ class HPEArrayControllerCollectionTestCase(testtools.TestCase):
|
|||
self.sys_stor_col.drive_rotational_speed_rpm)
|
||||
|
||||
def test_get_default_controller(self):
|
||||
self.assertIsNone(self.sys_stor_col._get_default_controller)
|
||||
self.conn.get.return_value.json.reset_mock()
|
||||
with open('proliantutils/tests/redfish/'
|
||||
'json_samples/array_controller.json', 'r') as f:
|
||||
|
|
|
@ -93,7 +93,6 @@ class HPELogicalDriveCollectionTestCase(testtools.TestCase):
|
|||
self.assertEqual(2, len(members))
|
||||
|
||||
def test_maximum_size_mib(self):
|
||||
self.assertIsNone(self.sys_stor_col._maximum_size_mib)
|
||||
self.conn.get.return_value.json.reset_mock()
|
||||
path = ('proliantutils/tests/redfish/json_samples/'
|
||||
'logical_drive.json')
|
||||
|
@ -106,7 +105,6 @@ class HPELogicalDriveCollectionTestCase(testtools.TestCase):
|
|||
self.assertEqual(expected, actual)
|
||||
|
||||
def test_logical_raid_levels(self):
|
||||
self.assertIsNone(self.sys_stor_col._logical_raid_levels)
|
||||
self.conn.get.return_value.json.reset_mock()
|
||||
path = ('proliantutils/tests/redfish/json_samples/'
|
||||
'logical_drive.json')
|
||||
|
|
|
@ -94,7 +94,6 @@ class HPEPhysicalDriveCollectionTestCase(testtools.TestCase):
|
|||
self.assertEqual(2, len(members))
|
||||
|
||||
def test_maximum_size_mib(self):
|
||||
self.assertIsNone(self.sys_stor_col._maximum_size_mib)
|
||||
self.conn.get.return_value.json.reset_mock()
|
||||
path = ('proliantutils/tests/redfish/json_samples/'
|
||||
'disk_drive.json')
|
||||
|
@ -107,7 +106,6 @@ class HPEPhysicalDriveCollectionTestCase(testtools.TestCase):
|
|||
self.assertEqual(expected, actual)
|
||||
|
||||
def test_has_ssd(self):
|
||||
self.assertIsNone(self.sys_stor_col._has_ssd)
|
||||
self.conn.get.return_value.json.reset_mock()
|
||||
path = ('proliantutils/tests/redfish/json_samples/'
|
||||
'disk_drive.json')
|
||||
|
@ -119,7 +117,6 @@ class HPEPhysicalDriveCollectionTestCase(testtools.TestCase):
|
|||
self.assertTrue(actual)
|
||||
|
||||
def test_has_rotational(self):
|
||||
self.assertIsNone(self.sys_stor_col._has_rotational)
|
||||
self.conn.get.return_value.json.reset_mock()
|
||||
path = ('proliantutils/tests/redfish/json_samples/'
|
||||
'disk_drive.json')
|
||||
|
@ -130,7 +127,6 @@ class HPEPhysicalDriveCollectionTestCase(testtools.TestCase):
|
|||
self.assertTrue(self.sys_stor_col.has_rotational)
|
||||
|
||||
def test_drive_rotational_speed_rpm(self):
|
||||
self.assertIsNone(self.sys_stor_col._drive_rotational_speed_rpm)
|
||||
self.conn.get.return_value.json.reset_mock()
|
||||
path = ('proliantutils/tests/redfish/json_samples/'
|
||||
'disk_drive.json')
|
||||
|
|
|
@ -45,7 +45,6 @@ class SimpleStorageTestCase(testtools.TestCase):
|
|||
self.sys_simple.devices)
|
||||
|
||||
def test_maximum_size_bytes(self):
|
||||
self.assertIsNone(self.sys_simple._maximum_size_bytes)
|
||||
self.conn.get.return_value.json.reset_mock()
|
||||
expected = 8000000000000
|
||||
actual = self.sys_simple.maximum_size_bytes
|
||||
|
@ -53,7 +52,6 @@ class SimpleStorageTestCase(testtools.TestCase):
|
|||
|
||||
def test_maximum_size_bytes_on_refresh(self):
|
||||
self.sys_simple.refresh()
|
||||
self.assertIsNone(self.sys_simple._maximum_size_bytes)
|
||||
|
||||
|
||||
class SimpleStorageCollectionTestCase(testtools.TestCase):
|
||||
|
@ -98,7 +96,6 @@ class SimpleStorageCollectionTestCase(testtools.TestCase):
|
|||
self.assertEqual(1, len(members))
|
||||
|
||||
def test_maximum_size_bytes(self):
|
||||
self.assertIsNone(self.sys_simple_col._maximum_size_bytes)
|
||||
self.conn.get.return_value.json.reset_mock()
|
||||
path = ('proliantutils/tests/redfish/json_samples/'
|
||||
'simple_storage.json')
|
||||
|
|
|
@ -51,13 +51,10 @@ class HPESmartStorageTestCase(testtools.TestCase):
|
|||
'array_controller.json', 'r') as f:
|
||||
value = (json.loads(f.read()))
|
||||
self.conn.get.return_value.json.side_effect = [coll, value]
|
||||
self.assertIsNone(self.sys_stor._array_controllers)
|
||||
self.sys_stor.array_controllers
|
||||
self.assertIsInstance(self.sys_stor._array_controllers,
|
||||
self.assertIsInstance(self.sys_stor.array_controllers,
|
||||
array_controller.HPEArrayControllerCollection)
|
||||
|
||||
def test_logical_drives_maximum_size_mib(self):
|
||||
self.assertIsNone(self.sys_stor._logical_drives_maximum_size_mib)
|
||||
self.conn.get.return_value.json.reset_mock()
|
||||
val = []
|
||||
path = ('proliantutils/tests/redfish/json_samples/'
|
||||
|
@ -84,7 +81,6 @@ class HPESmartStorageTestCase(testtools.TestCase):
|
|||
self.assertEqual(expected, actual)
|
||||
|
||||
def test_logical_raid_levels(self):
|
||||
self.assertIsNone(self.sys_stor._logical_raid_levels)
|
||||
self.conn.get.return_value.json.reset_mock()
|
||||
val = []
|
||||
path = ('proliantutils/tests/redfish/json_samples/'
|
||||
|
@ -111,7 +107,6 @@ class HPESmartStorageTestCase(testtools.TestCase):
|
|||
self.assertEqual(expected, actual)
|
||||
|
||||
def test_physical_drives_maximum_size_mib(self):
|
||||
self.assertIsNone(self.sys_stor._physical_drives_maximum_size_mib)
|
||||
self.conn.get.return_value.json.reset_mock()
|
||||
val = []
|
||||
path = ('proliantutils/tests/redfish/json_samples/'
|
||||
|
@ -138,7 +133,6 @@ class HPESmartStorageTestCase(testtools.TestCase):
|
|||
self.assertEqual(expected, actual)
|
||||
|
||||
def test_has_ssd(self):
|
||||
self.assertIsNone(self.sys_stor._has_ssd)
|
||||
self.conn.get.return_value.json.reset_mock()
|
||||
val = []
|
||||
path = ('proliantutils/tests/redfish/json_samples/'
|
||||
|
@ -163,7 +157,6 @@ class HPESmartStorageTestCase(testtools.TestCase):
|
|||
self.assertTrue(self.sys_stor.has_ssd)
|
||||
|
||||
def test_has_rotaional(self):
|
||||
self.assertIsNone(self.sys_stor._has_rotational)
|
||||
self.conn.get.return_value.json.reset_mock()
|
||||
val = []
|
||||
path = ('proliantutils/tests/redfish/json_samples/'
|
||||
|
@ -188,7 +181,6 @@ class HPESmartStorageTestCase(testtools.TestCase):
|
|||
self.assertTrue(self.sys_stor.has_rotational)
|
||||
|
||||
def test_drive_rotational_speed_rpm(self):
|
||||
self.assertIsNone(self.sys_stor._drive_rotational_speed_rpm)
|
||||
self.conn.get.return_value.json.reset_mock()
|
||||
val = []
|
||||
path = ('proliantutils/tests/redfish/json_samples/'
|
||||
|
|
|
@ -47,7 +47,6 @@ class StorageTestCase(testtools.TestCase):
|
|||
def test_volumes(self):
|
||||
log_coll = None
|
||||
log_dr = None
|
||||
self.assertIsNone(self.sys_stor._volumes)
|
||||
self.conn.get.return_value.json.reset_mock()
|
||||
with open('proliantutils/tests/redfish/'
|
||||
'json_samples/volume_collection.json') as f:
|
||||
|
@ -56,13 +55,12 @@ class StorageTestCase(testtools.TestCase):
|
|||
'json_samples/volume.json') as f:
|
||||
log_dr = json.loads(f.read())
|
||||
self.conn.get.return_value.json.side_effect = [log_coll, log_dr]
|
||||
actual_log_dr = self.sys_stor.volumes
|
||||
self.assertIs(actual_log_dr,
|
||||
actual_volumes = self.sys_stor.volumes
|
||||
self.assertIs(actual_volumes,
|
||||
self.sys_stor.volumes)
|
||||
self.sys_stor.invalidate()
|
||||
self.sys_stor.refresh(force=False)
|
||||
self.assertIsNotNone(self.sys_stor._volumes)
|
||||
self.assertTrue(self.sys_stor._volumes._is_stale)
|
||||
self.assertTrue(actual_volumes._is_stale)
|
||||
|
||||
def test__drives_list(self):
|
||||
self.conn.get.return_value.json.reset_mock()
|
||||
|
@ -76,7 +74,6 @@ class StorageTestCase(testtools.TestCase):
|
|||
self.assertIsInstance(actual_dr, list)
|
||||
|
||||
def test_drives_maximum_size_bytes(self):
|
||||
self.assertIsNone(self.sys_stor._drives_maximum_size_bytes)
|
||||
self.conn.get.return_value.json.reset_mock()
|
||||
val = []
|
||||
path = ('proliantutils/tests/redfish/json_samples/'
|
||||
|
@ -92,7 +89,6 @@ class StorageTestCase(testtools.TestCase):
|
|||
self.assertEqual(expected, actual)
|
||||
|
||||
def test_has_ssd_true(self):
|
||||
self.assertIsNone(self.sys_stor._has_ssd)
|
||||
self.conn.get.return_value.json.reset_mock()
|
||||
val = []
|
||||
path = ('proliantutils/tests/redfish/json_samples/'
|
||||
|
@ -106,7 +102,6 @@ class StorageTestCase(testtools.TestCase):
|
|||
self.assertTrue(self.sys_stor.has_ssd)
|
||||
|
||||
def test_has_rotational(self):
|
||||
self.assertIsNone(self.sys_stor._has_rotational)
|
||||
self.conn.get.return_value.json.reset_mock()
|
||||
val = []
|
||||
path = ('proliantutils/tests/redfish/json_samples/'
|
||||
|
@ -120,7 +115,6 @@ class StorageTestCase(testtools.TestCase):
|
|||
self.assertTrue(self.sys_stor.has_rotational)
|
||||
|
||||
def test_has_nvme_ssd(self):
|
||||
self.assertIsNone(self.sys_stor._has_nvme_ssd)
|
||||
self.conn.get.return_value.json.reset_mock()
|
||||
val = []
|
||||
path = ('proliantutils/tests/redfish/json_samples/'
|
||||
|
@ -134,7 +128,6 @@ class StorageTestCase(testtools.TestCase):
|
|||
self.assertTrue(self.sys_stor.has_nvme_ssd)
|
||||
|
||||
def test_drive_rotational_speed_rpm(self):
|
||||
self.assertIsNone(self.sys_stor._drive_rotational_speed_rpm)
|
||||
self.conn.get.return_value.json.reset_mock()
|
||||
val = []
|
||||
path = ('proliantutils/tests/redfish/json_samples/'
|
||||
|
@ -192,7 +185,6 @@ class StorageCollectionTestCase(testtools.TestCase):
|
|||
self.assertEqual(1, len(members))
|
||||
|
||||
def test_volumes_maximum_size_bytes(self):
|
||||
self.assertIsNone(self.sys_stor_col._volumes_maximum_size_bytes)
|
||||
self.conn.get.return_value.json.reset_mock()
|
||||
val = []
|
||||
path = ('proliantutils/tests/redfish/json_samples/'
|
||||
|
@ -213,7 +205,6 @@ class StorageCollectionTestCase(testtools.TestCase):
|
|||
self.assertEqual(expected, actual)
|
||||
|
||||
def test_drives_maximum_size_bytes(self):
|
||||
self.assertIsNone(self.sys_stor_col._drives_maximum_size_bytes)
|
||||
self.conn.get.return_value.json.reset_mock()
|
||||
val = []
|
||||
path = ('proliantutils/tests/redfish/json_samples/'
|
||||
|
@ -233,7 +224,6 @@ class StorageCollectionTestCase(testtools.TestCase):
|
|||
self.assertEqual(expected, actual)
|
||||
|
||||
def test_has_ssd_true(self):
|
||||
self.assertIsNone(self.sys_stor_col._has_ssd)
|
||||
self.conn.get.return_value.json.reset_mock()
|
||||
val = []
|
||||
path = ('proliantutils/tests/redfish/json_samples/'
|
||||
|
@ -251,7 +241,6 @@ class StorageCollectionTestCase(testtools.TestCase):
|
|||
self.assertTrue(self.sys_stor_col.has_ssd)
|
||||
|
||||
def test_has_rotational(self):
|
||||
self.assertIsNone(self.sys_stor_col._has_rotational)
|
||||
self.conn.get.return_value.json.reset_mock()
|
||||
val = []
|
||||
path = ('proliantutils/tests/redfish/json_samples/'
|
||||
|
@ -269,7 +258,6 @@ class StorageCollectionTestCase(testtools.TestCase):
|
|||
self.assertTrue(self.sys_stor_col.has_rotational)
|
||||
|
||||
def test_has_nvme_ssd(self):
|
||||
self.assertIsNone(self.sys_stor_col._has_nvme_ssd)
|
||||
self.conn.get.return_value.json.reset_mock()
|
||||
val = []
|
||||
path = ('proliantutils/tests/redfish/json_samples/'
|
||||
|
@ -287,7 +275,6 @@ class StorageCollectionTestCase(testtools.TestCase):
|
|||
self.assertTrue(self.sys_stor_col.has_nvme_ssd)
|
||||
|
||||
def test_drive_rotational_speed_rpm(self):
|
||||
self.assertIsNone(self.sys_stor_col._drive_rotational_speed_rpm)
|
||||
self.conn.get.return_value.json.reset_mock()
|
||||
val = []
|
||||
path = ('proliantutils/tests/redfish/json_samples/'
|
||||
|
|
|
@ -82,7 +82,6 @@ class VolumeCollectionTestCase(testtools.TestCase):
|
|||
self.assertEqual(1, len(members))
|
||||
|
||||
def test_maximum_size_bytes(self):
|
||||
self.assertIsNone(self.sys_vol_col._maximum_size_bytes)
|
||||
self.conn.get.return_value.json.reset_mock()
|
||||
path = ('proliantutils/tests/redfish/json_samples/'
|
||||
'volume.json')
|
||||
|
|
|
@ -48,8 +48,6 @@ class BIOSSettingsTestCase(testtools.TestCase):
|
|||
self.bios_inst.cpu_vt)
|
||||
|
||||
def test_pending_settings(self):
|
||||
self.assertIsNone(self.bios_inst._pending_settings)
|
||||
|
||||
self.conn.get.return_value.json.reset_mock()
|
||||
with open('proliantutils/tests/redfish/'
|
||||
'json_samples/bios.json', 'r') as f:
|
||||
|
@ -66,8 +64,6 @@ class BIOSSettingsTestCase(testtools.TestCase):
|
|||
self.conn.get.return_value.json.assert_not_called()
|
||||
|
||||
def test_boot_settings(self):
|
||||
self.assertIsNone(self.bios_inst._boot_settings)
|
||||
|
||||
self.conn.get.return_value.json.reset_mock()
|
||||
with open('proliantutils/tests/redfish/'
|
||||
'json_samples/bios_boot.json', 'r') as f:
|
||||
|
@ -84,8 +80,6 @@ class BIOSSettingsTestCase(testtools.TestCase):
|
|||
self.conn.get.return_value.json.assert_not_called()
|
||||
|
||||
def test_bios_mappings(self):
|
||||
self.assertIsNone(self.bios_inst._bios_mappings)
|
||||
|
||||
self.conn.get.return_value.json.reset_mock()
|
||||
with open('proliantutils/tests/redfish/'
|
||||
'json_samples/bios_mappings.json', 'r') as f:
|
||||
|
@ -102,8 +96,6 @@ class BIOSSettingsTestCase(testtools.TestCase):
|
|||
self.conn.get.return_value.json.assert_not_called()
|
||||
|
||||
def test_iscsi_resource(self):
|
||||
self.assertIsNone(self.bios_inst._iscsi_resource)
|
||||
|
||||
self.conn.get.return_value.json.reset_mock()
|
||||
with open('proliantutils/tests/redfish/'
|
||||
'json_samples/iscsi.json', 'r') as f:
|
||||
|
@ -120,7 +112,6 @@ class BIOSSettingsTestCase(testtools.TestCase):
|
|||
self.conn.get.return_value.json.assert_not_called()
|
||||
|
||||
def test__get_base_configs(self):
|
||||
self.assertIsNone(self.bios_inst._base_configs)
|
||||
with open('proliantutils/tests/redfish/'
|
||||
'json_samples/bios_base_configs.json', 'r') as f:
|
||||
self.conn.get.return_value.json.return_value = json.loads(f.read())
|
||||
|
@ -144,8 +135,7 @@ class BIOSSettingsTestCase(testtools.TestCase):
|
|||
self.bios_inst.invalidate()
|
||||
self.bios_inst.refresh(force=False)
|
||||
|
||||
self.assertIsNotNone(self.bios_inst._pending_settings)
|
||||
self.assertTrue(self.bios_inst._pending_settings._is_stale)
|
||||
self.assertTrue(actual_settings._is_stale)
|
||||
|
||||
with open('proliantutils/tests/redfish/'
|
||||
'json_samples/bios.json', 'r') as f:
|
||||
|
@ -154,7 +144,7 @@ class BIOSSettingsTestCase(testtools.TestCase):
|
|||
|
||||
self.assertIsInstance(self.bios_inst.pending_settings,
|
||||
bios.BIOSPendingSettings)
|
||||
self.assertFalse(self.bios_inst._pending_settings._is_stale)
|
||||
self.assertFalse(actual_settings._is_stale)
|
||||
|
||||
def test_boot_settings_on_refresh(self):
|
||||
with open('proliantutils/tests/redfish/'
|
||||
|
@ -173,8 +163,7 @@ class BIOSSettingsTestCase(testtools.TestCase):
|
|||
self.bios_inst.invalidate()
|
||||
self.bios_inst.refresh(force=False)
|
||||
|
||||
self.assertIsNotNone(self.bios_inst._boot_settings)
|
||||
self.assertTrue(self.bios_inst._boot_settings._is_stale)
|
||||
self.assertTrue(actual_settings._is_stale)
|
||||
|
||||
with open('proliantutils/tests/redfish/'
|
||||
'json_samples/bios_boot.json', 'r') as f:
|
||||
|
@ -183,7 +172,7 @@ class BIOSSettingsTestCase(testtools.TestCase):
|
|||
|
||||
self.assertIsInstance(self.bios_inst.boot_settings,
|
||||
bios.BIOSBootSettings)
|
||||
self.assertFalse(self.bios_inst._boot_settings._is_stale)
|
||||
self.assertFalse(actual_settings._is_stale)
|
||||
|
||||
def test_bios_mappings_on_refresh(self):
|
||||
with open('proliantutils/tests/redfish/'
|
||||
|
@ -202,8 +191,7 @@ class BIOSSettingsTestCase(testtools.TestCase):
|
|||
self.bios_inst.invalidate()
|
||||
self.bios_inst.refresh(force=False)
|
||||
|
||||
self.assertIsNotNone(self.bios_inst._bios_mappings)
|
||||
self.assertTrue(self.bios_inst._bios_mappings._is_stale)
|
||||
self.assertTrue(actual_settings._is_stale)
|
||||
|
||||
with open('proliantutils/tests/redfish/'
|
||||
'json_samples/bios_mappings.json', 'r') as f:
|
||||
|
@ -212,7 +200,7 @@ class BIOSSettingsTestCase(testtools.TestCase):
|
|||
|
||||
self.assertIsInstance(self.bios_inst.bios_mappings,
|
||||
bios.BIOSMappings)
|
||||
self.assertFalse(self.bios_inst._bios_mappings._is_stale)
|
||||
self.assertFalse(actual_settings._is_stale)
|
||||
|
||||
def test_iscsi_resource_on_refresh(self):
|
||||
with open('proliantutils/tests/redfish/'
|
||||
|
@ -231,8 +219,7 @@ class BIOSSettingsTestCase(testtools.TestCase):
|
|||
self.bios_inst.invalidate()
|
||||
self.bios_inst.refresh(force=False)
|
||||
|
||||
self.assertIsNotNone(self.bios_inst._iscsi_resource)
|
||||
self.assertTrue(self.bios_inst._iscsi_resource._is_stale)
|
||||
self.assertTrue(actual_settings._is_stale)
|
||||
|
||||
with open('proliantutils/tests/redfish/'
|
||||
'json_samples/iscsi.json', 'r') as f:
|
||||
|
@ -241,7 +228,7 @@ class BIOSSettingsTestCase(testtools.TestCase):
|
|||
|
||||
self.assertIsInstance(self.bios_inst.iscsi_resource,
|
||||
iscsi.ISCSIResource)
|
||||
self.assertFalse(self.bios_inst._iscsi_resource._is_stale)
|
||||
self.assertFalse(actual_settings._is_stale)
|
||||
|
||||
def test__get_base_configs_on_refresh(self):
|
||||
with open('proliantutils/tests/redfish/'
|
||||
|
@ -258,8 +245,7 @@ class BIOSSettingsTestCase(testtools.TestCase):
|
|||
self.bios_inst.invalidate()
|
||||
self.bios_inst.refresh(force=False)
|
||||
|
||||
self.assertIsNotNone(self.bios_inst._base_configs)
|
||||
self.assertTrue(self.bios_inst._base_configs._is_stale)
|
||||
self.assertTrue(default_settings._is_stale)
|
||||
|
||||
with open('proliantutils/tests/redfish/'
|
||||
'json_samples/bios_base_configs.json', 'r') as f:
|
||||
|
@ -267,7 +253,7 @@ class BIOSSettingsTestCase(testtools.TestCase):
|
|||
|
||||
self.assertIsInstance(self.bios_inst._get_base_configs(),
|
||||
bios.BIOSBaseConfigs)
|
||||
self.assertFalse(self.bios_inst._base_configs._is_stale)
|
||||
self.assertFalse(default_settings._is_stale)
|
||||
|
||||
|
||||
class BIOSBaseConfigsTestCase(testtools.TestCase):
|
||||
|
|
|
@ -98,7 +98,6 @@ class EthernetInterfaceCollectionTestCase(testtools.TestCase):
|
|||
self.assertEqual(1, len(members))
|
||||
|
||||
def test_summary(self):
|
||||
self.assertIsNone(self.sys_eth_col._summary)
|
||||
self.conn.get.return_value.json.reset_mock()
|
||||
path = ('proliantutils/tests/redfish/json_samples/'
|
||||
'ethernet_interface.json')
|
||||
|
|
|
@ -49,8 +49,6 @@ class ISCSIResourceTestCase(testtools.TestCase):
|
|||
self.assertEqual(ret_val, expected)
|
||||
|
||||
def test_iscsi_settings(self):
|
||||
self.assertIsNone(self.iscsi_inst._iscsi_settings)
|
||||
|
||||
self.conn.get.return_value.json.reset_mock()
|
||||
with open('proliantutils/tests/redfish/'
|
||||
'json_samples/iscsi_settings.json', 'r') as f:
|
||||
|
@ -83,8 +81,7 @@ class ISCSIResourceTestCase(testtools.TestCase):
|
|||
self.iscsi_inst.invalidate()
|
||||
self.iscsi_inst.refresh(force=False)
|
||||
|
||||
self.assertIsNotNone(self.iscsi_inst._iscsi_settings)
|
||||
self.assertTrue(self.iscsi_inst._iscsi_settings._is_stale)
|
||||
self.assertTrue(actual_settings._is_stale)
|
||||
|
||||
with open('proliantutils/tests/redfish/'
|
||||
'json_samples/iscsi_settings.json', 'r') as f:
|
||||
|
@ -92,7 +89,7 @@ class ISCSIResourceTestCase(testtools.TestCase):
|
|||
json.loads(f.read())['Default'])
|
||||
self.assertIsInstance(self.iscsi_inst.iscsi_settings,
|
||||
iscsi.ISCSISettings)
|
||||
self.assertFalse(self.iscsi_inst._iscsi_settings._is_stale)
|
||||
self.assertFalse(actual_settings._is_stale)
|
||||
|
||||
def test_attributes(self):
|
||||
with open('proliantutils/tests/redfish/'
|
||||
|
|
|
@ -87,7 +87,6 @@ class PCIDeviceCollectionTestCase(testtools.TestCase):
|
|||
self.assertEqual(2, len(members))
|
||||
|
||||
def test_gpu_devices(self):
|
||||
self.assertIsNone(self.sys_pci_col._gpu_devices)
|
||||
self.conn.get.return_value.json.reset_mock()
|
||||
val = []
|
||||
path = ('proliantutils/tests/redfish/json_samples/'
|
||||
|
@ -99,11 +98,9 @@ class PCIDeviceCollectionTestCase(testtools.TestCase):
|
|||
with open(path, 'r') as f:
|
||||
val.append(json.loads(f.read()))
|
||||
self.conn.get.return_value.json.side_effect = val
|
||||
self.sys_pci_col.gpu_devices
|
||||
self.assertEqual(1, len(self.sys_pci_col._gpu_devices))
|
||||
self.assertEqual(1, len(self.sys_pci_col.gpu_devices))
|
||||
|
||||
def test_max_nic_capacity(self):
|
||||
self.assertIsNone(self.sys_pci_col._max_nic_capacity)
|
||||
self.conn.get.return_value.json.reset_mock()
|
||||
val = []
|
||||
path = ('proliantutils/tests/redfish/json_samples/'
|
||||
|
|
|
@ -80,7 +80,6 @@ class HPESystemTestCase(testtools.TestCase):
|
|||
self.sys_inst.push_power_button, 'invalid-value')
|
||||
|
||||
def test_bios_settings(self):
|
||||
self.assertIsNone(self.sys_inst._bios_settings)
|
||||
self.conn.get.return_value.json.reset_mock()
|
||||
with open('proliantutils/tests/redfish/'
|
||||
'json_samples/bios.json', 'r') as f:
|
||||
|
@ -125,7 +124,8 @@ class HPESystemTestCase(testtools.TestCase):
|
|||
'r') as f:
|
||||
self.conn.get.return_value.json.return_value = json.loads(f.read())
|
||||
# | WHEN & THEN |
|
||||
self.assertIsInstance(self.sys_inst.bios_settings,
|
||||
actual_bios_settings = self.sys_inst.bios_settings
|
||||
self.assertIsInstance(actual_bios_settings,
|
||||
bios.BIOSSettings)
|
||||
|
||||
# On refreshing the system instance...
|
||||
|
@ -138,8 +138,7 @@ class HPESystemTestCase(testtools.TestCase):
|
|||
self.sys_inst.refresh(force=False)
|
||||
|
||||
# | WHEN & THEN |
|
||||
self.assertIsNotNone(self.sys_inst._bios_settings)
|
||||
self.assertTrue(self.sys_inst._bios_settings._is_stale)
|
||||
self.assertTrue(actual_bios_settings._is_stale)
|
||||
|
||||
# | GIVEN |
|
||||
with open('proliantutils/tests/redfish/json_samples/bios.json',
|
||||
|
@ -148,7 +147,7 @@ class HPESystemTestCase(testtools.TestCase):
|
|||
# | WHEN & THEN |
|
||||
self.assertIsInstance(self.sys_inst.bios_settings,
|
||||
bios.BIOSSettings)
|
||||
self.assertFalse(self.sys_inst._bios_settings._is_stale)
|
||||
self.assertFalse(actual_bios_settings._is_stale)
|
||||
|
||||
def test_update_persistent_boot_uefi_target(self):
|
||||
with open('proliantutils/tests/redfish/'
|
||||
|
@ -189,7 +188,6 @@ class HPESystemTestCase(testtools.TestCase):
|
|||
pci_dev_return_value = None
|
||||
pci_dev1_return_value = None
|
||||
pci_coll_return_value = None
|
||||
self.assertIsNone(self.sys_inst._pci_devices)
|
||||
self.conn.get.return_value.json.reset_mock()
|
||||
with open('proliantutils/tests/redfish/'
|
||||
'json_samples/pci_device_collection.json') as f:
|
||||
|
@ -220,8 +218,6 @@ class HPESystemTestCase(testtools.TestCase):
|
|||
_get_secure_boot)
|
||||
|
||||
def test_secure_boot(self):
|
||||
# check for the underneath variable value
|
||||
self.assertIsNone(self.sys_inst._secure_boot)
|
||||
# | GIVEN |
|
||||
self.conn.get.return_value.json.reset_mock()
|
||||
with open('proliantutils/tests/redfish/json_samples/secure_boot.json',
|
||||
|
@ -250,8 +246,8 @@ class HPESystemTestCase(testtools.TestCase):
|
|||
self.conn.get.return_value.json.return_value = (
|
||||
json.loads(f.read())['default'])
|
||||
# | WHEN & THEN |
|
||||
self.assertIsInstance(self.sys_inst.secure_boot,
|
||||
secure_boot.SecureBoot)
|
||||
actual_secure_boot = self.sys_inst.secure_boot
|
||||
self.assertIsInstance(actual_secure_boot, secure_boot.SecureBoot)
|
||||
|
||||
# On refreshing the system instance...
|
||||
with open('proliantutils/tests/redfish/'
|
||||
|
@ -263,8 +259,7 @@ class HPESystemTestCase(testtools.TestCase):
|
|||
self.sys_inst.refresh(force=False)
|
||||
|
||||
# | WHEN & THEN |
|
||||
self.assertIsNotNone(self.sys_inst._secure_boot)
|
||||
self.assertTrue(self.sys_inst._secure_boot._is_stale)
|
||||
self.assertTrue(actual_secure_boot._is_stale)
|
||||
|
||||
# | GIVEN |
|
||||
with open('proliantutils/tests/redfish/json_samples/secure_boot.json',
|
||||
|
@ -274,7 +269,7 @@ class HPESystemTestCase(testtools.TestCase):
|
|||
# | WHEN & THEN |
|
||||
self.assertIsInstance(self.sys_inst.secure_boot,
|
||||
secure_boot.SecureBoot)
|
||||
self.assertFalse(self.sys_inst._secure_boot._is_stale)
|
||||
self.assertFalse(actual_secure_boot._is_stale)
|
||||
|
||||
@mock.patch.object(utils, 'get_subresource_path_by')
|
||||
def test_get_hpe_sub_resource_collection_path(self, res_mock):
|
||||
|
@ -317,11 +312,10 @@ class HPESystemTestCase(testtools.TestCase):
|
|||
eth_value = (json.loads(f.read()))
|
||||
self.conn.get.return_value.json.side_effect = [eth_coll,
|
||||
eth_value]
|
||||
self.assertIsNone(self.sys_inst._ethernet_interfaces)
|
||||
actual_macs = self.sys_inst.ethernet_interfaces.summary
|
||||
self.assertEqual({'Port 1': '12:44:6A:3B:04:11'},
|
||||
actual_macs)
|
||||
self.assertIsInstance(self.sys_inst._ethernet_interfaces,
|
||||
self.assertIsInstance(self.sys_inst.ethernet_interfaces,
|
||||
ethernet_interface.EthernetInterfaceCollection)
|
||||
|
||||
def test_ethernet_interfaces_oem(self):
|
||||
|
@ -348,11 +342,10 @@ class HPESystemTestCase(testtools.TestCase):
|
|||
eth_value = (json.loads(f.read()))
|
||||
self.conn.get.return_value.json.side_effect = [eth_coll,
|
||||
eth_value]
|
||||
self.assertIsNone(self.sys_inst._ethernet_interfaces)
|
||||
actual_macs = self.sys_inst.ethernet_interfaces.summary
|
||||
self.assertEqual({'Port 1': '12:44:6A:3B:04:11'},
|
||||
actual_macs)
|
||||
self.assertIsInstance(self.sys_inst._ethernet_interfaces,
|
||||
self.assertIsInstance(self.sys_inst.ethernet_interfaces,
|
||||
ethernet_interface.EthernetInterfaceCollection)
|
||||
|
||||
def test_smart_storage(self):
|
||||
|
@ -362,7 +355,6 @@ class HPESystemTestCase(testtools.TestCase):
|
|||
'smart_storage.json', 'r') as f:
|
||||
value = (json.loads(f.read()))
|
||||
self.conn.get.return_value.json.return_value = value
|
||||
self.assertIsNone(self.sys_inst._smart_storage)
|
||||
value = self.sys_inst.smart_storage
|
||||
self.assertIsInstance(value, smart_storage.HPESmartStorage)
|
||||
|
||||
|
@ -378,9 +370,8 @@ class HPESystemTestCase(testtools.TestCase):
|
|||
'storage.json', 'r') as f:
|
||||
value = (json.loads(f.read()))
|
||||
self.conn.get.return_value.json.side_effect = [coll, value]
|
||||
self.assertIsNone(self.sys_inst._storages)
|
||||
value = self.sys_inst.storages
|
||||
self.assertIsInstance(value, storage.StorageCollection)
|
||||
self.assertIsInstance(self.sys_inst.storages,
|
||||
storage.StorageCollection)
|
||||
|
||||
def test_simple_storages(self):
|
||||
self.conn.get.return_value.json.reset_mock()
|
||||
|
@ -394,16 +385,16 @@ class HPESystemTestCase(testtools.TestCase):
|
|||
'simple_storage.json', 'r') as f:
|
||||
value = (json.loads(f.read()))
|
||||
self.conn.get.return_value.json.side_effect = [coll, value]
|
||||
self.assertIsNone(self.sys_inst._simple_storages)
|
||||
value = self.sys_inst.simple_storages
|
||||
self.assertIsInstance(value, simple_storage.SimpleStorageCollection)
|
||||
self.assertIsInstance(self.sys_inst.simple_storages,
|
||||
simple_storage.SimpleStorageCollection)
|
||||
|
||||
def test_simple_storage_on_refresh(self):
|
||||
with open('proliantutils/tests/redfish/json_samples/'
|
||||
'simple_storage_collection.json',
|
||||
'r') as f:
|
||||
self.conn.get.return_value.json.return_value = json.loads(f.read())
|
||||
self.assertIsInstance(self.sys_inst.simple_storages,
|
||||
actual_simple_storages = self.sys_inst.simple_storages
|
||||
self.assertIsInstance(actual_simple_storages,
|
||||
simple_storage.SimpleStorageCollection)
|
||||
with open('proliantutils/tests/redfish/'
|
||||
'json_samples/system.json', 'r') as f:
|
||||
|
@ -413,18 +404,16 @@ class HPESystemTestCase(testtools.TestCase):
|
|||
self.sys_inst.invalidate()
|
||||
self.sys_inst.refresh(force=False)
|
||||
|
||||
self.assertIsNotNone(self.sys_inst._simple_storages)
|
||||
self.assertTrue(self.sys_inst._simple_storages._is_stale)
|
||||
self.assertTrue(actual_simple_storages._is_stale)
|
||||
|
||||
with open('proliantutils/tests/redfish/json_samples/'
|
||||
'simple_storage_collection.json', 'r') as f:
|
||||
self.conn.get.return_value.json.return_value = json.loads(f.read())
|
||||
self.assertIsInstance(self.sys_inst.simple_storages,
|
||||
simple_storage.SimpleStorageCollection)
|
||||
self.assertFalse(self.sys_inst._simple_storages._is_stale)
|
||||
self.assertFalse(actual_simple_storages._is_stale)
|
||||
|
||||
def test_memory(self):
|
||||
self.assertIsNone(self.sys_inst._memory)
|
||||
self.conn.get.return_value.json.reset_mock()
|
||||
with open('proliantutils/tests/redfish/'
|
||||
'json_samples/memory_collection.json', 'r') as f:
|
||||
|
@ -445,8 +434,8 @@ class HPESystemTestCase(testtools.TestCase):
|
|||
'memory_collection.json', 'r') as f:
|
||||
self.conn.get.return_value.json.return_value = json.loads(f.read())
|
||||
# | WHEN & THEN |
|
||||
self.assertIsInstance(self.sys_inst.memory,
|
||||
memory.MemoryCollection)
|
||||
actual_memory = self.sys_inst.memory
|
||||
self.assertIsInstance(actual_memory, memory.MemoryCollection)
|
||||
|
||||
# On refreshing the system instance...
|
||||
with open('proliantutils/tests/redfish/'
|
||||
|
@ -458,8 +447,7 @@ class HPESystemTestCase(testtools.TestCase):
|
|||
self.sys_inst.refresh(force=False)
|
||||
|
||||
# | WHEN & THEN |
|
||||
self.assertIsNotNone(self.sys_inst._memory)
|
||||
self.assertTrue(self.sys_inst._memory._is_stale)
|
||||
self.assertTrue(actual_memory._is_stale)
|
||||
|
||||
# | GIVEN |
|
||||
with open('proliantutils/tests/redfish/json_samples/'
|
||||
|
@ -468,15 +456,15 @@ class HPESystemTestCase(testtools.TestCase):
|
|||
# | WHEN & THEN |
|
||||
self.assertIsInstance(self.sys_inst.memory,
|
||||
memory.MemoryCollection)
|
||||
self.assertFalse(self.sys_inst._memory._is_stale)
|
||||
self.assertFalse(actual_memory._is_stale)
|
||||
|
||||
def test_storage_on_refresh(self):
|
||||
with open('proliantutils/tests/redfish/json_samples/'
|
||||
'storage_collection.json',
|
||||
'r') as f:
|
||||
self.conn.get.return_value.json.return_value = json.loads(f.read())
|
||||
self.assertIsInstance(self.sys_inst.storages,
|
||||
storage.StorageCollection)
|
||||
actual_storages = self.sys_inst.storages
|
||||
self.assertIsInstance(actual_storages, storage.StorageCollection)
|
||||
# On refreshing the system instance...
|
||||
with open('proliantutils/tests/redfish/'
|
||||
'json_samples/system.json', 'r') as f:
|
||||
|
@ -486,15 +474,14 @@ class HPESystemTestCase(testtools.TestCase):
|
|||
self.sys_inst.invalidate()
|
||||
self.sys_inst.refresh(force=False)
|
||||
|
||||
self.assertIsNotNone(self.sys_inst._storages)
|
||||
self.assertTrue(self.sys_inst._storages._is_stale)
|
||||
self.assertTrue(actual_storages._is_stale)
|
||||
|
||||
with open('proliantutils/tests/redfish/json_samples/'
|
||||
'simple_storage_collection.json', 'r') as f:
|
||||
self.conn.get.return_value.json.return_value = json.loads(f.read())
|
||||
self.assertIsInstance(self.sys_inst.storages,
|
||||
storage.StorageCollection)
|
||||
self.assertFalse(self.sys_inst._storages._is_stale)
|
||||
self.assertFalse(actual_storages._is_stale)
|
||||
|
||||
def test_get_host_post_state(self):
|
||||
expected = sys_cons.POST_STATE_FINISHEDPOST
|
||||
|
|
|
@ -9,4 +9,4 @@ retrying!=1.3.0,>=1.2.3 # Apache-2.0
|
|||
pysnmp>=4.2.3,<5.0.0 # BSD
|
||||
|
||||
# Redfish communication uses the Sushy library
|
||||
sushy>=1.3.1
|
||||
sushy>=1.7.0
|
||||
|
|
Loading…
Reference in New Issue