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
}
}
}
}
