def get_alert(cls, service, alert):
if service.state == "active":
description = alert.description.format(
service.name, service.state, service.active_threshold)
else:
description = alert.description.format(
service.name, service.state, service.nonactive_threshold)
return {
"sensor_request_type": {
"service_status_alert": {
"host_id": socket.getfqdn(),
"severity": SeverityReader().map_severity(
alert.alert_type),
"alert_id": 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 make_response(self, component_details, component, component_type,
resource_id):
resource_type = "enclosure:{}:{}".format(component, component_type)
epoch_time = str(int(time.time()))
alert_id = mon_utils.get_alert_id(epoch_time)
if component == "fru":
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": "GET",
"severity": "informational",
"host_id": socket.getfqdn(),
"alert_id": alert_id,
"info": {
"site_id": self.rssencl.site_id,
"rack_id": self.rssencl.rack_id,
"node_id": self.rssencl.node_id,
"cluster_id": self.rssencl.cluster_id,
"resource_type": resource_type,
"resource_id": resource_id,
"event_time": epoch_time
},
"specific_info": component_details
}
return response
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 = mon_utils.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):
super(IEMDataMsg, 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": info.get("event_time"),
"resource_id": "iem",
"site_id": info.get("site_id"),
"node_id": info.get("node_id"),
"cluster_id": info.get("cluster_id"),
"rack_id": info.get("rack_id"),
"resource_type": "iem",
"description": info.get("description"),
"impact": info.get("impact"),
"recommendation": info.get("recommendation")
},
"alert_type": info.get("alert_type"),
"severity": info.get("severity"),
"specific_info": {
"source": info.get("source_id"),
"component": info.get("component_id"),
"module": info.get("module_id"),
"event": info.get("event_id"),
"IEC": info.get("IEC")
},
"alert_id": mon_utils.get_alert_id(self._epoch_time),
"host_id": socket.getfqdn()
}
}
}
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'] = mon_utils.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 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 = mon_utils.get_alert_id(epoch_time)
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 == "fru":
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,
"resource_id": resource_id,
"event_time": epoch_time
},
"specific_info": component_details
}
return response
def __init__(self,
host_id,
local_time,
boot_time,
up_time,
uname,
units,
site_id,
rack_id,
node_id,
cluster_id,
total_memory,
logged_in_users,
process_count,
running_process_count,
alert_type,
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._site_id = site_id
self._rack_id = rack_id
self._node_id = node_id
self._cluster_id = cluster_id
self.alert_type = alert_type
epoch_time = str(int(time.time()))
alert_id = mon_utils.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": {
"site_id": self._site_id,
"rack_id": self._rack_id,
"node_id": self._node_id,
"cluster_id": self._cluster_id,
"resource_type": self.RESOURCE_TYPE,
"resource_id": self.RESOURCE_ID,
"event_time": epoch_time
},
"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
}
}
}
}
def __init__(self, host_id,
local_time,
free_space,
total_space,
disk_used_percentage,
units,
site_id, rack_id,
node_id, cluster_id,
alert_type,
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._site_id = site_id
self._rack_id = rack_id
self._node_id = node_id
self._cluster_id = cluster_id
self.alert_type = alert_type
epoch_time = str(calendar.timegm(time.gmtime()))
alert_id = mon_utils.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": {
"site_id": self._site_id,
"rack_id": self._rack_id,
"node_id": self._node_id,
"cluster_id": self._cluster_id,
"resource_type": self.RESOURCE_TYPE,
"resource_id": self.RESOURCE_ID,
"event_time": epoch_time
},
"specific_info": {
"freeSpace" : {
"value" : self._free_space,
"units" : self._units
},
"totalSpace" : {
"value" : self._total_space,
"units" : self._units
},
"diskUsedPercentage" : self._disk_used_percentage
}
}
}
}
def raise_alert(self, service, prev_state, state, prev_substate, substate,
prev_pid, pid, alert_info_index):
"""Send the alert to ServiceMsgHandler."""
# Each alert info contains 4 fields
# 1.Description | 2.Alert Type | 3.Impact | 4.Recommendation
alert_info = [
[
f"{service} in {state} state.", #index 0
"fault",
f"{service} service is unavailable.",
"Try to restart the service"
],
[
f"{service} in a {state} state for more than {self.max_wait_time} seconds.",
"fault", #index 1
f"{service} service is unavailable.",
"Try to restart the service"
],
[
f"{service} in {state} state.",
"fault_resolved", #index 2
f"{service} service is available now.",
""
],
]
description = alert_info[alert_info_index][0]
alert_type = alert_info[alert_info_index][1]
impact = alert_info[alert_info_index][2]
recommendation = alert_info[alert_info_index][3]
severity = SeverityReader().map_severity(alert_type)
epoch_time = str(self.current_time())
alert_id = get_alert_id(epoch_time)
host_name = socket.getfqdn()
self._site_id = Conf.get(GLOBAL_CONF, f"{CLUSTER}>{SRVNODE}>{SITE_ID}",
'DC01')
self._rack_id = Conf.get(GLOBAL_CONF, f"{CLUSTER}>{SRVNODE}>{RACK_ID}",
'RC01')
self._node_id = Conf.get(GLOBAL_CONF, f"{CLUSTER}>{SRVNODE}>{NODE_ID}",
'SN01')
self._cluster_id = Conf.get(GLOBAL_CONF, f'{CLUSTER}>{CLUSTER_ID}',
'CC01')
info = {
"site_id": self._site_id,
"cluster_id": self._cluster_id,
"rack_id": self._rack_id,
"node_id": self._node_id,
"resource_type": self.RESOURCE_TYPE,
"resource_id": service,
"event_time": epoch_time,
"description": description,
"impact": impact,
"recommendation": recommendation,
}
alert_msg = {
"sensor_request_type": {
"service_status_alert": {
"host_id": host_name,
"severity": severity,
"alert_id": alert_id,
"alert_type": alert_type,
"info": info,
"specific_info": {
"service_name": service,
"previous_state": prev_state,
"state": state,
"previous_substate": prev_substate,
"substate": substate,
"previous_pid": prev_pid,
"pid": pid,
}
}
}
}
self._write_internal_msgQ(ServiceMsgHandler.name(), alert_msg)
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,
site_id,
rack_id,
node_id,
cluster_id,
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._site_id = site_id
self._rack_id = rack_id
self._node_id = node_id
self._cluster_id = cluster_id
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 = mon_utils.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": {
"site_id": self._site_id,
"rack_id": self._rack_id,
"node_id": self._node_id,
"cluster_id": self._cluster_id,
"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
}
}
}
}
