def get_enclosures_info(self):
"""Update and return enclosure information in specific format."""
data = []
chassis_serial_no = "NA"
enclosure = ENCL.get_realstor_encl_data("enclosures")
frus = ENCL.get_realstor_encl_data("frus")
if frus:
for fru in frus:
if fru["name"] == "CHASSIS_MIDPLANE":
chassis_serial_no = fru.get("serial-number", "NA")
break
for encl in enclosure:
encl_dict = {
"uid":
encl.get("durable-id", "NA"),
"type":
encl.get("type", "NA"),
"description":
encl.get("description", "NA"),
"product":
encl.get("object-name", "NA"),
"manufacturer":
encl.get("vendor", "NA"),
"serial_number":
chassis_serial_no,
"version":
"NA",
"part_number":
encl.get("part-number", "NA"),
"last_updated":
int(time.time()),
"specifics": [{
"enclosure_wwn":
encl.get("enclosure-wwn", "NA"),
"platform":
encl.get("platform-type", "NA"),
"board_model":
encl.get("board-model", "NA"),
"mfg_date":
encl.get("mfg-date", "NA"),
"number_of_disks":
encl.get("number-of-disks", "NA"),
"number_of_power_supplies":
encl.get("number-of-power-supplies", "NA"),
"model":
encl.get("model", "NA"),
"columns":
encl.get("columns", "NA"),
"slots":
encl.get("slots", "NA"),
"midplane_type":
encl.get("midplane-type", "NA"),
"enclosure_power":
encl.get("enclosure-power", "NA"),
}]
}
data.append(encl_dict)
logger.debug(self.log.svc_log(f"Enclosure Manifest Data:{data}"))
return data
def get_enclosures_info(self):
"""Update and return enclosure information in specific format."""
data = []
enclosures = enclosure.get_realstor_encl_data("enclosures")
for encl in enclosures:
uid = encl.get("durable-id")
status = encl.get("health", "NA")
description = encl.get("description", "NA")
recommendation = encl.get("health-recommendation", "NA")
specifics = [{
"vendor": encl.get("vendor", "NA"),
"model": encl.get("model", "NA"),
"platform-type": encl.get("platform-type", "NA"),
"board-model": encl.get("board-model", "NA"),
"fru-location": encl.get("fru-location", "NA"),
"rack-number": encl.get("rack-number", "NA"),
"rack-position": encl.get("rack-position", "NA"),
"midplane-type": encl.get("midplane-type", "NA"),
"locator-led": encl.get("locator-led", "NA"),
"part-number": encl.get("part-number", "NA")
}]
encl_dict = self.get_health_template(uid, is_fru=True)
self.set_health_data(encl_dict, status, description,
recommendation, specifics)
data.append(encl_dict)
return data
def get_fan_modules_info(self):
"""Update and return fan modules information in specific format."""
data = []
fanmoduels_data = ENCL.get_realstor_encl_data("fan-modules")
if fanmoduels_data:
for fan_module in fanmoduels_data:
specifics = [self.get_fan_specifics(fan) for fan in \
fan_module['fan']]
sort_key_path = self.resource_indexing_map["hw"]["fan"]
specifics = MonUtils.sort_by_specific_kv(
specifics, sort_key_path, self.log)
fan_module_resp = {
"uid": fan_module.get("durable-id", "NA"),
"type": fan_module.get("type", "NA"),
"description": fan_module.get("description", "NA"),
"product": fan_module.get("object-name", "NA"),
"manufacturer": fan_module.get("vendor", "NA"),
"serial_number": fan_module.get("serial-number", "NA"),
"version": fan_module.get("hardware-version", "NA"),
"part_number": fan_module.get("part-number", "NA"),
"last_updated": int(time.time()),
"specifics": specifics
}
data.append(fan_module_resp)
logger.debug(self.log.svc_log(f"Fan Manifest Data:{data}"))
sort_key_path = self.resource_indexing_map["hw"]["fan"]
data = MonUtils.sort_by_specific_kv(data, sort_key_path, self.log)
return data
def get_logical_volumes_info(self):
"""Update and return logical volume information in specific format."""
logvol_data = []
logicalvolumes = enclosure.get_realstor_encl_data("volumes")
if logicalvolumes:
for logicalvolume in logicalvolumes:
uid = logicalvolume.get("volume-name", "NA")
health = logicalvolume.get("health", "NA")
if health in const.HEALTH_UNDESIRED_VALS:
health = "NA"
description = logicalvolume.get("volume-description", "NA")
recommendation = logicalvolume.get("health-recommendation",
"NA")
specifics = [{
"disk_group": {
"disk_group_name":
logicalvolume.get("container-name", "NA"),
"pool_serial_number":
logicalvolume.get("container-serial", "NA")
}
}]
logvol_data_dict = self.get_health_template(uid, is_fru=False)
self.set_health_data(logvol_data_dict, health, description,
recommendation, specifics)
logvol_data.append(logvol_data_dict)
logger.debug(
self.log.svc_log(f"Logical Volume Health Data:{logvol_data}"))
return logvol_data
def get_psu_info(self):
"""Update and return PSUs information in specific format."""
data = []
psus = enclosure.get_realstor_encl_data("power-supplies")
for psu in psus:
uid = psu.get("durable-id")
status = psu.get("health", "NA")
description = psu.get("description")
recommendation = psu.get("health-recommendation")
specifics = [{
"location": psu.get("location", "NA"),
"dc12v": psu.get("dc12v", "NA"),
"dc5v": psu.get("dc5v", "NA"),
"dc33v": psu.get("dc33v", "NA"),
"dc12i": psu.get("dc12i", "NA"),
"dc5i": psu.get("dc5i", "NA"),
"dctemp": psu.get("dctemp", "NA"),
"serial-number": psu.get("serial-number", "NA")
}]
psu_dict = self.get_health_template(uid, is_fru=True)
self.set_health_data(psu_dict, status, description, recommendation,
specifics)
data.append(psu_dict)
logger.debug(self.log.svc_log(f"PSU Health Data:{data}"))
sort_key_path = self.resource_indexing_map["hw"]["psu"]
data = MonUtils.sort_by_specific_kv(data, sort_key_path, self.log)
return data
def get_controllers_info(self):
"""Update and return controller information in specific format."""
data = []
controllers = enclosure.get_realstor_encl_data("controllers")
for controller in controllers:
uid = controller.get("durable-id")
status = controller.get("health", "NA")
description = controller.get("description")
recommendation = controller.get("health-recommendation")
specifics = [{
"serial-number": controller.get("serial-number", "NA"),
"disks": controller.get("disks", "NA"),
"virtual-disks": controller.get("virtual-disks", "NA"),
"model": controller.get("model", "NA"),
"part-number": controller.get("part-number", "NA"),
"fw": controller.get("sc-fw", "NA"),
"location": controller.get("position", "NA")
}]
controller_dict = self.get_health_template(uid, is_fru=True)
self.set_health_data(controller_dict, status, description,
recommendation, specifics)
data.append(controller_dict)
logger.debug(self.log.svc_log(f"Contollers Health Data:{data}"))
sort_key_path = self.resource_indexing_map["hw"]["controller"]
data = MonUtils.sort_by_specific_kv(data, sort_key_path, self.log)
return data
def get_fanmodules_info(self):
"""Returns fan modules health data."""
response = []
fanmodules_data = enclosure.get_realstor_encl_data("fan-modules")
if fanmodules_data:
for fan_module in fanmodules_data:
uid = fan_module.get('durable-id', 'NA')
health = fan_module.get('health')
fan_module_resp = self.get_health_template(uid, is_fru=True)
specifics = [
self.get_fan_specfics(fan) for fan in fan_module['fan']
]
fan_key_path = self.resource_indexing_map["hw"]["fan"]
specifics = MonUtils.sort_by_specific_kv(
specifics, fan_key_path, self.log)
self.set_health_data(fan_module_resp,
health,
specifics=specifics)
response.append(fan_module_resp)
logger.debug(
self.log.svc_log(f"Fan modules health Data:{response}"))
else:
logger.error(
self.log.svc_log("No response received from fan modules"))
sort_key_path = self.resource_indexing_map["hw"]["fan"]
response = MonUtils.sort_by_specific_kv(response, sort_key_path,
self.log)
return response
def get_controllers_info(self):
"""Update and return controller information in specific format."""
data = []
controllers = ENCL.get_realstor_encl_data("controllers")
for controller in controllers:
controller_dict = {
"uid":
controller.get("durable-id", "NA"),
"type":
controller.get("type", "NA"),
"description":
controller.get("description", "NA"),
"product":
controller.get("object-name", "NA"),
"manufacturer":
controller.get("vendor", "NA"),
"serial_number":
controller.get("serial-number", "NA"),
"version":
controller.get("hardware-version", "NA"),
"part_number":
controller.get("part-number", "NA"),
"last_updated":
int(time.time()),
"specifics": [{
"disks":
controller.get("disks", "NA"),
"virtual_disks":
controller.get("virtual-disks", "NA"),
"host_ports":
controller.get("host-ports", "NA"),
"drive_channels":
controller.get("drive-channels", "NA"),
"drive_bus_type":
controller.get("drive-bus-type", "NA"),
"fw":
controller.get("sc-fw", "NA"),
"model":
controller.get("model", "NA"),
"mfg_date":
controller.get("mfg-date", "NA"),
"status":
controller.get("status", "NA")
}]
}
data.append(controller_dict)
logger.debug(self.log.svc_log(f"Controller Manifest Data:{data}"))
sort_key_path = self.resource_indexing_map["hw"]["controller"]
data = MonUtils.sort_by_specific_kv(data, sort_key_path, self.log)
return data
def get_sideplane_expander_info(self):
"""Update and return sideplane information in specific format."""
sideplane_expander_list = []
data = []
enclosures = ENCL.get_realstor_encl_data("enclosures")
#TODO : Handle CORVAULT sideplane expander data without expecting drawers
encl_drawers = enclosures[0].get("drawers") if enclosures else []
if encl_drawers:
for drawer in encl_drawers:
sideplanes = drawer.get("sideplanes")
sideplane_expander_list.extend(sideplanes)
for sideplane in sideplane_expander_list:
expanders = [self.get_expander_data(expander) for expander in \
sideplane['expanders']]
key_path = self.resource_indexing_map["hw"]["sideplane_expander"]
expanders = MonUtils.sort_by_specific_kv(expanders, key_path,
self.log)
sideplane_dict = {
"uid":
sideplane.get("durable-id", "NA"),
"type":
sideplane.get("type", "NA"),
"description":
sideplane.get("description", "NA"),
"product":
sideplane.get("object-name", "NA"),
"manufacturer":
sideplane.get("vendor", "NA"),
"serial_number":
sideplane.get("serial-number", "NA"),
"version":
sideplane.get("hardware-version", "NA"),
"part_number":
sideplane.get("part-number", "NA"),
"last_updated":
int(time.time()),
"specifics": [{
"name": sideplane.get("name", "NA"),
"location": sideplane.get("location", "NA"),
"drawer_id": sideplane.get("drawer-id", "NA"),
"status": sideplane.get("status", "NA"),
"expanders": expanders
}]
}
data.append(sideplane_dict)
logger.debug(self.log.svc_log(f"Sideplane Manifest Data:{data}"))
sort_key_path = self.resource_indexing_map["hw"]["sideplane_expander"]
data = MonUtils.sort_by_specific_kv(data, sort_key_path, self.log)
return data
def build_encl_platform_sensors_data(self, platform_sensors):
"""
Builds and returns platform sensors data (Temperature, Voltage and Current)
It calls enclosure API to fetch the sensor data.
Args:
platform_sensors - list of sensors to fetch the data.
Returns:
dict with three keys for respective sensors.
"""
sensors_data = {}
sensors_resp = enclosure.get_realstor_encl_data('sensors')
if sensors_resp:
for platform_sensor in platform_sensors:
for sensor in sensors_resp:
if sensor['sensor-type'].lower() == platform_sensor:
status = sensor.get('status')
description = sensor.get("description", "NA")
recommendation = sensor.get("recommendation", "NA")
specifics = [{
'sensor-name':
sensor.get('sensor-name'),
'value':
sensor.get('value'),
'controller-id':
sensor.get('controller-id'),
'container':
sensor.get('container'),
}]
single_sensor_data = self.get_health_template(
sensor.get('durable-id'), is_fru=False)
self.set_health_data(single_sensor_data, status,
description, recommendation,
specifics)
if platform_sensor in sensors_data:
sensors_data[platform_sensor].append(
single_sensor_data)
else:
sensors_data[platform_sensor] = [
single_sensor_data
]
else:
logger.error(
self.log.svc_log("No response received for platform sensors"))
return sensors_data
def get_sas_ports_info(self):
"""Return SAS ports current health."""
data = []
sas_ports = enclosure.get_realstor_encl_data("expander-ports")
for sas_port in sas_ports:
port_data = self.get_health_template(sas_port.get("durable-id"),
False)
specifics = [{
"sas-port-type": sas_port.get("sas-port-type"),
"controller": sas_port.get("controller"),
"status": sas_port.get("status")
}]
self.set_health_data(port_data, sas_port.get("health"),
sas_port.get("health-reason"),
sas_port.get("health-recommendation"),
specifics)
data.append(port_data)
return data
def get_nw_ports_info(self):
"""Return the current network health."""
nw_data = []
nw_interfaces = enclosure.get_realstor_encl_data("network-parameters")
for nw_inf in nw_interfaces:
nw_inf_data = self.get_health_template(nw_inf.get('durable-id'),
False)
specifics = {
"ip-address": nw_inf.get('ip-address'),
"link-speed": nw_inf.get('link-speed'),
"controller": nw_inf.get('object-name'),
}
self.set_health_data(nw_inf_data, nw_inf.get('health'),
nw_inf.get('health-reason'),
nw_inf.get('health-recommendation'),
[specifics])
nw_data.append(nw_inf_data)
logger.debug(self.log.svc_log(f"Network ports Health data:{nw_data}"))
return nw_data
def get_sideplane_expanders_info(self):
"""Update and return sideplane_expanders information."""
sideplane_expander_list = []
sideplane_expander_data = []
enclosures = enclosure.get_realstor_encl_data("enclosures")
#TODO : Handle CORVAULT sideplane expander data without expecting drawers
encl_drawers = enclosures[0].get("drawers")
if encl_drawers:
for drawer in encl_drawers:
sideplanes = drawer.get("sideplanes")
sideplane_expander_list.extend(sideplanes)
for sideplane in sideplane_expander_list:
uid = sideplane.get("durable-id", "NA")
expanders = sideplane.get("expanders")
expander_data = self.get_expander_data(expanders)
sort_key_path = self.resource_indexing_map["hw"][
"sideplane_expander"]
expander_data = MonUtils.sort_by_specific_kv(
expander_data, sort_key_path, self.log)
health = sideplane.get("health", "NA")
recommendation = sideplane.get("health-recommendation", "NA")
specifics = [{
"name": sideplane.get("name", "NA"),
"location": sideplane.get("location", "NA"),
"drawer-id": sideplane.get("drawer-id", "NA"),
"expanders": expander_data
}]
sideplane_dict = self.get_health_template(uid, is_fru=True)
self.set_health_data(sideplane_dict,
status=health,
recommendation=recommendation,
specifics=specifics)
sideplane_expander_data.append(sideplane_dict)
sort_key_path = self.resource_indexing_map["hw"]["sideplane_expander"]
sideplane_expander_data = MonUtils.sort_by_specific_kv(
sideplane_expander_data, sort_key_path, self.log)
logger.debug(
self.log.svc_log(
f"Sideplane Expander Health Data:{sideplane_expander_data}"))
return sideplane_expander_data
def get_psu_info(self):
"""Update and return power supplies information in specific format."""
data = []
psus = ENCL.get_realstor_encl_data("power-supplies")
for psu in psus:
psu_dict = {
"uid":
psu.get("durable-id", "NA"),
"type":
psu.get("type", "NA"),
"description":
psu.get("description", "NA"),
"product":
psu.get("object-name", "NA"),
"manufacturer":
psu.get("vendor", "NA"),
"serial_number":
psu.get("serial-number", "NA"),
"version":
psu.get("hardware-version", "NA"),
"part_number":
psu.get("part-number", "NA"),
"last_updated":
int(time.time()),
"specifics": [{
"location": psu.get("location", "NA"),
"dc12v": psu.get("dc12v", "NA"),
"dc5v": psu.get("dc5v", "NA"),
"dc33v": psu.get("dc33v", "NA"),
"dc12i": psu.get("dc12i", "NA"),
"dc5i": psu.get("dc5i", "NA"),
"model": psu.get("model", "NA"),
"status": psu.get("status", "NA"),
"mfg_date": psu.get("mfg-date", "NA")
}]
}
data.append(psu_dict)
logger.debug(self.log.svc_log(f"PSU Manifest Data:{data}"))
sort_key_path = self.resource_indexing_map["hw"]["psu"]
data = MonUtils.sort_by_specific_kv(data, sort_key_path, self.log)
return data
def get_versions_info(self):
"""Update and return versions information in specific format."""
data = []
versions = ENCL.get_realstor_encl_data("versions")
for version in versions:
version_dict = {
"uid":
version.get("object-name", "NA"),
"type":
version.get("sc-cpu-type", "NA"),
"description":
version.get("description", "NA"),
"product":
version.get("object-name", "NA"),
"manufacturer":
version.get("vendor", "NA"),
"serial_number":
version.get("serial-number", "NA"),
"version":
version.get("bundle-version", "NA"),
"part_number":
version.get("part-number", "NA"),
"last_updated":
int(time.time()),
"specifics": [{
"sc_cpu_type":
version.get("sc-cpu-type", "NA"),
"bundle_version":
version.get("bundle-version", "NA"),
"bundle_base_version":
version.get("bundle-base-version", "NA"),
"build_date":
version.get("build-date", "NA"),
"sc_fw":
version.get("sc-fw", "NA"),
"sc_baselevel":
version.get("sc-baselevel", "NA"),
"sc_memory":
version.get("sc-memory", "NA"),
"sc_fu_version":
version.get("sc-fu-version", "NA"),
"sc_loader":
version.get("sc-loader", "NA"),
"capi_version":
version.get("capi-version", "NA"),
"mc_fw":
version.get("mc-fw", "NA"),
"mc_loader":
version.get("mc-loader", "NA"),
"mc_base_fw":
version.get("mc-base-fw", "NA"),
"fw_default_platform_brand":
version.get("fw-default-platform-brand", "NA"),
"ec_fw":
version.get("ec-fw", "NA"),
"pld_rev":
version.get("pld-rev", "NA"),
"prm_version":
version.get("prm-version", "NA"),
"hw_rev":
version.get("hw-rev", "NA"),
"him_rev":
version.get("him-rev", "NA"),
"him_model":
version.get("him-model", "NA"),
"backplane_type":
version.get("backplane-type", "NA"),
"host_channel_revision":
version.get("host-channel_revision", "NA"),
"disk_channel_revision":
version.get("disk-channel_revision", "NA"),
"mrc_version":
version.get("mrc-version", "NA"),
"ctk_version":
version.get("ctk-version", "NA")
}]
}
data.append(version_dict)
logger.debug(
self.log.svc_log(f"Controller firmware Manifest Data:{data}"))
return data
def get_disk_groups_info(self):
"""Update and return disk-group information in specific format."""
dg_data = []
dg_vol_map = {}
diskgroups = enclosure.get_realstor_encl_data("disk-groups")
# Mapping logical volumes with disk group.
logicalvolumes = enclosure.get_realstor_encl_data("volumes")
cvg_info = Conf.get(GLOBAL_CONF, CVG_INFO_KEY)
cvg_dict = {}
if cvg_info:
cvg_dict = {cvg['name']: idx for idx, cvg in enumerate(cvg_info) \
if 'name' in cvg}
if logicalvolumes:
for logicalvolume in logicalvolumes:
volume_pool_sr_no = logicalvolume.get("container-serial", "NA")
volume_uid = logicalvolume.get("volume-name", "NA")
if volume_pool_sr_no in dg_vol_map:
dg_vol_map[volume_pool_sr_no].append(
{"volume_uid": volume_uid})
else:
dg_vol_map.update(
{volume_pool_sr_no: [{
"volume_uid": volume_uid
}]})
if diskgroups:
for diskgroup in diskgroups:
uid = diskgroup.get("name", "NA")
health = diskgroup.get("health", "NA")
pool_sr_no = diskgroup.get("pool-serial-number", "NA")
if pool_sr_no in dg_vol_map:
volumes = dg_vol_map[pool_sr_no]
else:
volumes = None
recommendation = diskgroup.get("health-recommendation", "NA")
specifics = [{
"cvg_name":
uid if uid in cvg_dict else "NA",
"cvg_id":
cvg_dict.get(uid, "NA"),
"class":
diskgroup.get("storage-type", "NA"),
"disks":
diskgroup.get("diskcount", "NA"),
"size":
diskgroup.get("size", "NA"),
"free":
diskgroup.get("freespace", "NA"),
"status":
diskgroup.get("status", "NA"),
"current_job":
diskgroup.get("current-job", "NA"),
"current_job_completion":
diskgroup.get("current-job-completion", "NA"),
"tier":
diskgroup.get("storage-tier", "NA"),
"pool":
diskgroup.get("pool", "NA"),
"blocksize":
diskgroup.get("blocksize", "NA"),
"chunksize":
diskgroup.get("chunksize", "NA"),
"volumes":
volumes
}]
dg_data_dict = self.get_health_template(uid, is_fru=False)
self.set_health_data(dg_data_dict,
health,
recommendation=recommendation,
specifics=specifics)
dg_data.append(dg_data_dict)
logger.debug(self.log.svc_log(f"disk-group Health Data:{dg_data}"))
return dg_data
def get_drives_info(self):
"""Update and return drives information in specific format."""
data = []
drives = ENCL.get_realstor_encl_data("drives")
for drive in drives:
slot = drive.get("slot", -1)
if slot == -1:
continue
drive_dict = {
"uid":
drive.get("durable-id", "NA"),
"type":
drive.get("type", "NA"),
"description":
drive.get("description", "NA"),
"product":
drive.get("object-name", "NA"),
"manufacturer":
drive.get("vendor", "NA"),
"serial_number":
drive.get("serial-number", "NA"),
"version":
drive.get("hardware-version", "NA"),
"part_number":
drive.get("part-number", "NA"),
"last_updated":
int(time.time()),
"specifics": [{
"drive-serial-number":
drive.get("serial-number")[:8],
"model":
drive.get("model", "NA"),
"slot":
slot,
"architecture":
drive.get("architecture", "NA"),
"interface":
drive.get("interface", "NA"),
"usage":
drive.get("usage", "NA"),
"current_job_completion":
drive.get("current-job-completion", "NA"),
"speed":
drive.get("speed", "NA"),
"size":
drive.get("size", "NA"),
"enclosure_wwn":
drive.get("enclosure-wwn", "NA"),
"status":
drive.get("status", "NA"),
"ssd_life_left":
drive.get("ssd-life-left", "NA"),
"led_status":
drive.get("led-status", "NA"),
"temperature":
drive.get("temperature", "NA"),
"location":
drive.get("location", "NA")
}]
}
data.append(drive_dict)
logger.debug(self.log.svc_log(f"Drive Manifest Data:{data}"))
sort_key_path = self.resource_indexing_map["hw"]["disk"]
data = MonUtils.sort_by_specific_kv(data, sort_key_path, self.log)
return data
def get_drives_info(self):
"""Update and return drives information in specific format."""
drive_data = []
drives = enclosure.get_realstor_encl_data("drives")
for drive in drives:
slot = drive.get("slot", -1)
if slot == -1:
continue
uid = drive.get("durable-id")
status = drive.get("health", "NA")
description = drive.get("description", "NA")
recommendation = drive.get("health-recommendation", "NA")
specifics = [{
"serial-number":
drive.get("serial-number", "NA"),
"model":
drive.get("model", "NA"),
"size":
drive.get("size", "NA"),
"temperature":
drive.get("temperature", "NA"),
"disk-group":
drive.get("disk-group", "NA"),
"storage-pool-name":
drive.get("storage-pool-name", "NA"),
"location":
drive.get("location", "NA"),
"enclosure-id":
drive.get("enclosure-id", "NA"),
"drawer-id":
drive.get("drawer-id", "NA"),
"slot":
drive.get("slot", "NA"),
"port":
drive.get("port", "NA"),
"scsi-id":
drive.get("scsi-id", "NA"),
"blocksize":
drive.get("blocksize", "NA"),
"blocks":
drive.get("blocks", "NA"),
"vendor":
drive.get("vendor", "NA"),
"revision":
drive.get("revision", "NA"),
"architecture":
drive.get("architecture", "NA"),
"interface":
drive.get("interface", "NA"),
"type":
drive.get("type", "NA"),
"blink":
drive.get("blink", "NA"),
"locator-led":
drive.get("locator-led", "NA"),
"enclosure-wwn":
drive.get("enclosure-wwn", "NA"),
"virtual-disk-serial":
drive.get("virtual-disk-serial", "NA"),
"led-status":
drive.get("led-status", "NA"),
"power-on-hours":
drive.get("power-on-hours", "NA")
}]
drives_dict = self.get_health_template(uid, is_fru=True)
self.set_health_data(drives_dict, status, description,
recommendation, specifics)
drive_data.append(drives_dict)
sort_key_path = self.resource_indexing_map["hw"]["disk"]
drive_data = MonUtils.sort_by_specific_kv(drive_data, sort_key_path,
self.log)
logger.debug(self.log.svc_log(f"disk Health data:{drive_data}"))
return drive_data
