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_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_alert(cls, service, alert): if service.state in ["active", "failed"]: description = alert.description.format( service.name, service.state, service.threshold_waiting_time) else: description = alert.description.format(service.name, service.state, service.nonactive_threshold) return { "sensor_request_type": { "service_status_alert": { "host_id": OSUtils.get_fqdn(), "severity": SeverityReader().map_severity(alert.alert_type), "alert_id": MonUtils.get_alert_id(str(int(time.time()))), "alert_type": alert.alert_type, "info": { "resource_type": cls.RESOURCE_TYPE, "resource_id": service.name, "event_time": str(int(time.time())), "description": description, "impact": alert.impact.format(service.name), "recommendation": alert.recommendation, }, "specific_info": { "service_name": service.name, "previous_state": service.previous_state, "state": service.state, "previous_substate": service.previous_substate, "substate": service.substate, "previous_pid": service.previous_pid, "pid": service.pid, } } } }
def __init__(self, host_id, local_time, interfaces, resource_id, resource_type, alert_type, severity, event, username="******", signature="N/A", in_time="N/A", expires=-1): super(IFdataMsg, self).__init__() self._username = username self._signature = signature self._time = in_time self._expires = expires self._host_id = host_id self._local_time = local_time self._interfaces = interfaces self._resource_id = resource_id self._resource_type = resource_type self.alert_type = alert_type self._severity = severity epoch_time = str(int(time.time())) alert_id = MonUtils.get_alert_id(epoch_time) self._json = { "username": self._username, "expires": self._expires, "description": self.DESCRIPTION, "title": self.TITLE, "signature": self._signature, "time": self._time, "message": { "sspl_ll_msg_header": { "msg_version": self.MESSAGE_VERSION, "schema_version": self.SCHEMA_VERSION, "sspl_version": self.SSPL_VERSION, }, "sensor_response_type": { "info": { "event_time": epoch_time, "resource_id": self._resource_id, "resource_type": self._resource_type, "description": event }, "specific_info": { "localtime": self._local_time, "interfaces": self._interfaces }, "host_id": self._host_id, "alert_type": self.alert_type, "severity": self._severity, "alert_id": alert_id } } }
def __init__(self, info, username="******", signature="N/A", expires=-1): """Initialize thread monitoring message.""" super(ThreadMonitorMsg, self).__init__() self._epoch_time = str(int(time.time())) self._json = { "username": username, "description": self.DESCRIPTION, "title": self.TITLE, "expires": expires, "signature": signature, "time": self._epoch_time, "message": { "sspl_ll_msg_header": { "schema_version": self.SCHEMA_VERSION, "sspl_version": self.SSPL_VERSION, "msg_version": self.MESSAGE_VERSION, }, "sensor_response_type": { "info": { "event_time": self._epoch_time, "resource_id": info.get("module_name"), "resource_type": self.RESOURCE_TYPE, "description": info.get("description"), "impact": info.get("impact"), "recommendation": info.get("recommendation") }, "alert_type": info.get("alert_type"), "severity": info.get("severity"), "specific_info": info.get("specific_info"), "alert_id": MonUtils.get_alert_id(self._epoch_time), "host_id": socket.getfqdn() } } }
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_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_data(self, rpath): """Fetch Manifest information for given rpath.""" logger.info(self.log.svc_log(f"Get Manifest data for rpath:{rpath}")) info = {} resource_found = False nodes = rpath.strip().split(">") leaf_node, _ = StorageResourceMap.get_node_info(nodes[-1]) # Fetch health information for all sub nodes if leaf_node == "storage": # Example rpath: 'node>storage[0]' resource_found = True info = self.get_storage_manifest_info() elif leaf_node in self.storage_resources: # Example rpath: 'node>storage[0]>hw' resource_found = True for resource, method in self.storage_resources[leaf_node].items(): try: info.update({resource: method()}) resource_found = True except Exception as err: logger.error( self.log.svc_log(f"{err.__class__.__name__}:{err}")) info = None else: # Example rpath: 'node>storage[0]>hw>disk' for node in nodes: resource, _ = StorageResourceMap.get_node_info(node) for res_type in self.storage_resources: method = self.storage_resources[res_type].get(resource) if not method: logger.error( self.log.svc_log( f"No mapping function found for {res_type}")) continue try: resource_found = True info = method() break except Exception as err: logger.error( self.log.svc_log( f"{err.__class__.__name__}: {err}")) info = None if resource_found: break if not resource_found: msg = f"Invalid rpath or manifest provider doesn't have support for'{rpath}'." logger.error(self.log.svc_log(f"{msg}")) raise ResourceMapError(errno.EINVAL, msg) info = MonUtils.normalize_kv(info, HEALTH_UNDESIRED_VALS, "Not Available") return info
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 _build_generic_info(self, response): """ Build json with generic information :param response: :return: """ epoch_time = str(int(time.time())) response['instance_id'] = self._resource_id response['alert_type'] = AlertTypes.GET.value response['severity'] = SeverityTypes.INFORMATIONAL.value response['alert_id'] = MonUtils.get_alert_id(epoch_time) response['info'] = { "resource_type": f"enclosure:{self._enclosure_type.lower()}:{self._enclosure_resource_type.lower()}", "resource_id": self._resource_id, "event_time": epoch_time, } # fetch host details response["host_id"] = socket.getfqdn()
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 make_response(self, component_details, component, component_type, resource_id, ctrl_action = None): resource_type = "enclosure:{}:{}".format(component, component_type) epoch_time = str(int(time.time())) alert_id = MonUtils.get_alert_id(epoch_time) fru = self.rssencl.is_storage_fru(component_type) if ctrl_action in self.CTRL_ACTION_LST: resource_type = component_details['resource_type'] del component_details['resource_type'] self.ALERT_TYPE = component_details['alert_type'] del component_details['alert_type'] self.SEVERITY = component_details['severity'] del component_details['severity'] if self.SEVERITY == "warning": del component_details['description'] elif component == "hw": if resource_id == self.RESOURCE_ALL: for comp in component_details: comp['resource_id'] = self.fru_response_manipulators[ component_type](comp if component_type!=self.FRU_DISK else [comp]) else: resource_id = self.fru_response_manipulators[component_type](component_details) response = { "alert_type": self.ALERT_TYPE, "severity": self.SEVERITY, "host_id": socket.getfqdn(), "alert_id": alert_id, "info": { "resource_type": resource_type, "fru": fru, "resource_id": resource_id, "event_time": epoch_time }, "specific_info": component_details } return response
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.""" 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
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 __init__(self, host_id, local_time, free_space, total_space, disk_used_percentage, units, alert_type, event, username = "******", signature = "N/A", in_time = "N/A", expires = -1 ): super(DiskSpaceAlertMsg, self).__init__() self._username = username self._signature = signature self._time = in_time self._expires = expires self._host_id = host_id # No need for local time self._free_space = free_space self._total_space = total_space self._disk_used_percentage = disk_used_percentage self._units = units self.alert_type = alert_type self.event = event if self.alert_type == "fault_resolved": self.SEVERITY = "informational" epoch_time = str(calendar.timegm(time.gmtime())) alert_id = MonUtils.get_alert_id(epoch_time) self._json = { "username" : self._username, "description" : self.DESCRIPTION, "title" : self.TITLE, "expires" : self._expires, "signature" : self._signature, "time" : epoch_time, "message" : { "sspl_ll_msg_header": { "msg_version" : self.MESSAGE_VERSION, "schema_version" : self.SCHEMA_VERSION, "sspl_version" : self.SSPL_VERSION, }, "sensor_response_type": { "alert_type": self.alert_type, "severity": self.SEVERITY, "alert_id": alert_id, "host_id": self._host_id, "info": { "resource_type": self.RESOURCE_TYPE, "resource_id": self.RESOURCE_ID, "event_time": epoch_time, "description": self.event }, "specific_info": { "freeSpace" : { "value" : self._free_space, "units" : self._units }, "totalSpace" : { "value" : self._total_space, "units" : self._units }, "diskUsedPercentage" : self._disk_used_percentage } } } }
def __init__(self, host_id, local_time, csps, idle_time, interrupt_time, iowait_time, nice_time, softirq_time, steal_time, system_time, user_time, core_data, cpu_usage, alert_type, event, username = "******", signature = "N/A", in_time = "N/A", expires = -1): super(CPUdataMsg, self).__init__() self._username = username self._signature = signature self._time = in_time self._expires = expires self._host_id = host_id self._local_time = local_time self._csps = csps self._idle_time = idle_time self._interrupt_time = interrupt_time self._iowait_time = iowait_time self._nice_time = nice_time self._softirq_time = softirq_time self._steal_time = steal_time self._system_time = system_time self._user_time = user_time self._core_data = core_data self._cpu_usage = cpu_usage self.alert_type = alert_type self.event = event if self.alert_type == "fault_resolved": self.SEVERITY = "informational" epoch_time = str(int(time.time())) alert_id = MonUtils.get_alert_id(epoch_time) self._json = { "username" : self._username, "description" : self.DESCRIPTION, "title" : self.TITLE, "expires" : self._expires, "signature" : self._signature, "time" : epoch_time, "message" : { "sspl_ll_msg_header": { "schema_version" : self.SCHEMA_VERSION, "sspl_version" : self.SSPL_VERSION, "msg_version" : self.MESSAGE_VERSION, }, "sensor_response_type": { "alert_type": self.alert_type, "severity": self.SEVERITY, "alert_id": alert_id, "host_id": self._host_id, "info": { "resource_type": self.RESOURCE_TYPE, "resource_id": self.RESOURCE_ID, "event_time": epoch_time, "description": self.event }, "specific_info": { "localtime" : self._local_time, "csps" : self._csps, "idleTime" : self._idle_time, "interruptTime" : self._interrupt_time, "iowaitTime" : self._iowait_time, "niceTime" : self._nice_time, "softirqTime" : self._softirq_time, "stealTime" : self._steal_time, "systemTime" : self._system_time, "userTime" : self._user_time, "coreData" : self._core_data, "cpu_usage" : self._cpu_usage } } } }
def __init__(self, host_id, local_time, boot_time, up_time, uname, units, total_memory, logged_in_users, process_count, running_process_count, alert_type, event, username = "******", signature = "N/A", in_time = "N/A", expires = -1): super(HostUpdateMsg, self).__init__() self._username = username self._signature = signature self._time = in_time self._expires = expires self._host_id = host_id self._local_time = local_time self._boot_time = boot_time self._up_time = up_time self._uname = uname self._total_memory = total_memory self._units = units self._logged_in_users = logged_in_users self._process_count = process_count self._running_process_count = running_process_count self.alert_type = alert_type self.event = event if self.alert_type == "fault_resolved": self.SEVERITY = "informational" epoch_time = str(int(time.time())) alert_id = MonUtils.get_alert_id(epoch_time) self._json = { "username" : self._username, "description" : self.DESCRIPTION, "title" : self.TITLE, "expires" : self._expires, "signature" : self._signature, "time" : epoch_time, "message" : { "sspl_ll_msg_header": { "schema_version" : self.SCHEMA_VERSION, "sspl_version" : self.SSPL_VERSION, "msg_version" : self.MESSAGE_VERSION, }, "sensor_response_type": { "alert_type": self.alert_type, "severity": self.SEVERITY, "alert_id": alert_id, "host_id": self._host_id, "info": { "resource_type": self.RESOURCE_TYPE, "resource_id": self.RESOURCE_ID, "event_time": epoch_time, "description": self.event }, "specific_info": { "localtime" : self._local_time, "bootTime" : self._boot_time, "upTime" : self._up_time, "uname" : self._uname, "totalMemory" : self._total_memory, "loggedInUsers" : self._logged_in_users, "processCount" : self._process_count, "runningProcessCount" : self._running_process_count } } } }