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_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_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 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_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_cortx_service_info(self):
"""Get cortx service info in required format."""
cortx_services = self.service.get_cortx_service_list()
cortx_service_info = self.get_service_info(cortx_services)
sort_key_path = self.resource_indexing_map["sw"]["cortx_sw_services"]
cortx_service_info = MonUtils.sort_by_specific_kv(
cortx_service_info, sort_key_path, self.log)
return cortx_service_info
def get_external_service_info(self):
"""Get external service info in required format."""
external_services = self.service.get_external_service_list()
external_service_info = self.get_service_info(external_services)
sort_key_path = self.resource_indexing_map["sw"][
"external_sw_services"]
external_service_info = MonUtils.sort_by_specific_kv(
external_service_info, sort_key_path, self.log)
return external_service_info
def get_nw_ports_info(self):
"""Return the Network ports information."""
network_cable_data = []
loopback_interface = {}
sort_key_path = None
io_counters = psutil.net_io_counters(pernic=True)
nw_instance = Network()
for interface, addrs in psutil.net_if_addrs().items():
nic_info = self.get_health_template(interface, False)
specifics = {}
for addr in addrs:
if addr.family == socket.AF_INET:
specifics["ipV4"] = addr.address
if interface in io_counters:
io_info = io_counters[interface]
specifics = {
"networkErrors": io_info.errin + io_info.errout,
"droppedPacketsIn": io_info.dropin,
"droppedPacketsOut": io_info.dropout,
"packetsIn": io_info.packets_recv,
"packetsOut": io_info.packets_sent,
"trafficIn": io_info.bytes_recv,
"trafficOut": io_info.bytes_sent
}
# Get the interface health status.
nw_status, nw_cable_conn_status = \
self.get_nw_status(nw_instance, interface)
specifics["nwStatus"] = nw_status
specifics["nwCableConnStatus"] = nw_cable_conn_status
specifics["logical_name"] = interface
# Map and set the interface health status and description.
map_status = {
"CONNECTED": "OK",
"DISCONNECTED": "Disabled/Failed",
"UNKNOWN": "NA"
}
health_status = map_status[nw_cable_conn_status]
desc = "Network Interface '%s' is %sin good health." % (
interface, '' if health_status == "OK" else 'not ')
self.set_health_data(nic_info,
health_status,
description=desc,
specifics=[specifics])
# Separating out loopback interface and ethernet interface
# data to make correct sorting/mapping with manifest data.
if interface == 'lo':
loopback_interface = nic_info
else:
network_cable_data.append(nic_info)
sort_key_path = self.resource_indexing_map["hw"]["nw_port"]
network_cable_data = MonUtils.sort_by_specific_kv(
network_cable_data, sort_key_path, self.log)
if loopback_interface:
network_cable_data.append(loopback_interface)
return network_cable_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_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_psu_info(self):
"""Update and return PSU information in specific format."""
psus_data = []
sort_key_path = None
for psu in self.get_psus():
psu = {k.lower().replace(" ", "_"): v for k, v in psu.items()}
data = self.get_health_template(f'{psu["location"]}', True)
health = "OK" if (psu["status"] == "Present, OK") else "Fault"
self.set_health_data(data, health, specifics=psu)
psus_data.append(data)
# Sort disk list by serial_number
sort_key_path = self.resource_indexing_map["hw"]["psu"]
psus_data = MonUtils.sort_by_specific_kv(psus_data, sort_key_path,
self.log)
logger.debug(self.log.svc_log(f"PSU Health Data:{psus_data}"))
return psus_data
def get_server_hw_info(self):
"""Get server hw information."""
cls_res_cnt = {}
lshw_data = {}
data, output_file = self.set_lshw_input_data()
for kv_key in data.get_keys():
if kv_key.endswith('class'):
r_spec = data.get(kv_key)
if r_spec in cls_res_cnt:
cls_res_cnt[r_spec] += 1
else:
cls_res_cnt[r_spec] = 0
if r_spec in self.class_mapping.keys():
for field in self.field_mapping.keys():
manifest_key = self.class_mapping[r_spec] % (
cls_res_cnt[r_spec], self.field_mapping[field])
self.map_manifest_server_data(field, manifest_key,
data, kv_key)
# Adding data to kv
output_file.set(self.kv_dict.keys(), self.kv_dict.values())
lshw_data = self.get_manifest_output_data()
# Removing out storage enclosure (RBOD/JBOD) drives from disk server data
# as they are coming from lshw , as those need to be represented
# separately & uniquely
if "disk" in lshw_data["hw"]:
lshw_data["hw"]["disk"] = self.get_local_disk(
lshw_data["hw"]["disk"])
# Sort list by serial_number
eth_ctrl = []
for resource, sort_key_path in self.resource_indexing_map["hw"].items(
):
if resource in lshw_data["hw"]:
if resource == "nw_port":
# Separating out ethernet controller and ethernet interface
# data for sorting.
eth_ctrl = [eth_ctr for eth_ctr in lshw_data["hw"][resource] \
if eth_ctr['logical_name']=='NA']
lshw_data["hw"][resource] = [eth_interface for eth_interface \
in lshw_data["hw"][resource] if eth_interface[
'logical_name']!='NA']
sorted_data = MonUtils.sort_by_specific_kv(
lshw_data["hw"][resource], sort_key_path, self.log)
lshw_data["hw"][resource] = sorted_data
if resource == "nw_port" and eth_ctrl:
lshw_data["hw"][resource] += eth_ctrl
return lshw_data
def get_cpu_info(self, add_overall_usage=False):
"""Update and return CPU information in specific format."""
per_cpu_data = []
cpu_present = self.get_cpu_list("present")
cpu_online = self.get_cpu_list("online")
cpu_usage = self.get_cpu_usage(percpu=True)
cpu_usage_dict = dict(zip(cpu_online, cpu_usage))
overall_cpu_usage = list(psutil.getloadavg())
cpu_count = len(cpu_present)
overall_usage = {
"current": self.get_cpu_usage(percpu=False),
"1_min_avg": overall_cpu_usage[0],
"5_min_avg": overall_cpu_usage[1],
"15_min_avg": overall_cpu_usage[2]
}
for cpu_id in range(0, cpu_count):
uid = f"CPU-{cpu_id}"
cpu_dict = self.get_health_template(uid, is_fru=False)
online_status = "Online" if cpu_id in cpu_online else "Offline"
health_status = "OK" if online_status == "Online" else "NA"
usage = "NA" if health_status == "NA" \
else cpu_usage_dict[cpu_id]
specifics = [{"cpu_usage": usage, "state": online_status}]
self.set_health_data(cpu_dict,
status=health_status,
specifics=specifics)
per_cpu_data.append(cpu_dict)
cpu_data = [{
"overall_usage": overall_usage,
"cpu_count": cpu_count,
"last_updated": int(time.time()),
"cpus": per_cpu_data
}]
if not add_overall_usage:
cpu_data = per_cpu_data
sort_key_path = self.resource_indexing_map["hw"]["cpu"]
cpu_data = MonUtils.sort_by_specific_kv(cpu_data, sort_key_path,
self.log)
logger.debug(self.log.svc_log(f"CPU Health Data:{cpu_data}"))
return cpu_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_disks_info(self):
"""Update and return server drive information in specific format."""
disks = []
sort_key_path = None
for disk in Disk.get_disks():
uid = disk.path if disk.path else disk.id
disk_health = self.get_health_template(uid, True)
health_data = disk.get_health()
health = "OK" if (health_data['SMART_health']
== "PASSED") else "Fault"
serial_number = disk.id.split("-")[-1] if disk.id else "NA"
health_data.update({"serial_number": serial_number})
self.set_health_data(disk_health,
health,
specifics=[{
"SMART": health_data
}])
disks.append(disk_health)
# Sort disk list by serial_number
sort_key_path = self.resource_indexing_map["hw"]["disk"]
disks = MonUtils.sort_by_specific_kv(disks, sort_key_path, self.log)
logger.debug(self.log.svc_log(f"Disk Health Data:{disks}"))
return disks
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
