def render(self):
for analyzerid in self.parameters["analyzerid"]:
if self.parameters.has_key("alerts"):
criteria = "alert.analyzer.analyzerid == '%s'" % utils.escape_criteria(analyzerid)
self.env.idmef_db.deleteAlert(self.env.idmef_db.getAlertIdents(criteria))
if self.parameters.has_key("heartbeats"):
criteria = "heartbeat.analyzer(-1).analyzerid == '%s'" % utils.escape_criteria(analyzerid)
self.env.idmef_db.deleteHeartbeat(self.env.idmef_db.getHeartbeatIdents(criteria))
SensorListing.render(self)
def getUriCriteria(parameters):
if not parameters.has_key("messageid"):
return None
if parameters.has_key("analyzerid"):
criteria = "alert.analyzer(-1).analyzerid = '%s' &&" % utils.escape_criteria(parameters["analyzerid"])
else:
criteria = ""
criteria += "alert.messageid = '%s'" % utils.escape_criteria(parameters["messageid"])
return criteria
def _addTimelineChart(self, title, value_name, width, height, path, criteria, limit=-1, names_and_colors={}, allow_stacked=False, value_callback=None, zoom_type=None):
self._path = path
self._limit = limit
self._value_callback = value_callback
self._criteria = criteria
self._zoom_type = zoom_type
self._names_and_colors = names_and_colors
base_url = self._getBaseURL()
chart = { "title": title, "value_name": value_name }
if limit > 0:
res = self.env.idmef_db.getValues(self._getSelection(), criteria = criteria, limit=self._limit)
c = u""
for name, count in res:
if c:
c += " || "
if name:
c += "%s = '%s'" % (self._path, utils.escape_criteria(name))
else:
c += "! %s" % (self._path)
if c:
criteria.append(c)
timeline = self._generateTimeline(self.user, width, height)
timeline.render(title)
chart["chart"] = timeline
self.dataset["charts"].append(chart)
self.dataset["zoom"] = self.parameters.get("zoom", None)
def _applyInlineFilters(self, criteria):
filter_found = False
for column, path in (("name", "heartbeat.analyzer(-1).name"),
("model", "heartbeat.analyzer(-1).model"),
("address", "heartbeat.analyzer(-1).node.address.address"),
("node_name", "heartbeat.analyzer(-1).node.name")):
self.dataset[column + "_filtered"] = False
if not filter_found:
if self.parameters.has_key(path):
criteria.append("%s == '%s'" % (path, utils.escape_criteria(self.parameters[path])))
self.dataset[column + "_filtered"] = True
filter_found = True
def _replace(self, element):
element = element.group(1)
if element in ("and", "AND", "&&"):
return "&&"
if element in ("or", "OR", "||"):
return "||"
if not self.elements.has_key(element):
raise Error(_("Invalid filter element '%s' referenced from filter formula") % element)
criteria, operator, value = self.elements[element]
return "%s %s '%s'" % (criteria, operator, utils.escape_criteria(value))
def render(self):
analyzers = { }
criteria = None
if self.parameters.has_key("filter_path"):
criteria = "%s == '%s'" % (self.parameters["filter_path"],
utils.escape_criteria(self.parameters["filter_value"]))
locations = { }
nodes = { }
for analyzerid in self.env.idmef_db.getAnalyzerids():
analyzer = self.env.idmef_db.getAnalyzer(analyzerid)
parameters = { "analyzerid": analyzer["analyzerid"] }
analyzer["alert_listing"] = utils.create_link("sensor_alert_listing", parameters)
analyzer["heartbeat_listing"] = utils.create_link("sensor_heartbeat_listing", parameters)
analyzer["heartbeat_analyze"] = utils.create_link("heartbeat_analyze", parameters)
if analyzer["node_name"]:
analyzer["node_name_link"] = utils.create_link(self.view_name,
{ "filter_path": "heartbeat.analyzer(-1).node.name",
"filter_value": analyzer["node_name"] })
if analyzer["node_location"]:
analyzer["node_location_link"] = utils.create_link(self.view_name,
{ "filter_path": "heartbeat.analyzer(-1).node.location",
"filter_value": analyzer["node_location"] })
node_key = ""
for i in range(len(analyzer["node_addresses"])):
addr = analyzer["node_addresses"][i]
node_key += addr
analyzer["node_addresses"][i] = {}
analyzer["node_addresses"][i]["value"] = addr
analyzer["node_addresses"][i]["inline_filter"] = utils.create_link(self.view_name,
{ "filter_path": "heartbeat.analyzer(-1).node.address.address",
"filter_value": addr })
analyzer["node_addresses"][i]["host_commands"] = []
for command in self.env.host_commands.keys():
analyzer["node_addresses"][i]["host_commands"].append((command.capitalize(),
utils.create_link("Command",
{ "origin": self.view_name,
"command": command, "host": addr })))
analyzer["status"], analyzer["status_meaning"] = \
get_analyzer_status_from_latest_heartbeat(analyzer["last_heartbeat_status"],
analyzer["last_heartbeat_time"],
analyzer["last_heartbeat_interval"],
self._heartbeat_error_margin)
analyzer["last_heartbeat_time"] = utils.time_to_ymdhms(time.localtime(int(analyzer["last_heartbeat_time"]))) + \
" %+.2d:%.2d" % utils.get_gmt_offset()
node_location = analyzer["node_location"] or _("Node location n/a")
node_name = analyzer.get("node_name") or _("Node name n/a")
osversion = analyzer["osversion"] or _("OS version n/a")
ostype = analyzer["ostype"] or _("OS type n/a")
addresses = analyzer["node_addresses"]
node_key = node_name + osversion + ostype
if not locations.has_key(node_location):
locations[node_location] = { "total": 1, "missing": 0, "unknown": 0, "offline": 0, "online": 0, "nodes": { } }
else:
locations[node_location]["total"] += 1
if not locations[node_location]["nodes"].has_key(node_key):
locations[node_location]["nodes"][node_key] = { "total": 1, "missing": 0, "unknown": 0, "offline": 0, "online": 0,
"analyzers": [ ],
"node_name": node_name, "node_location": node_location,
"ostype": ostype, "osversion": osversion,
"node_addresses": addresses, "node_key": node_key }
else:
locations[node_location]["nodes"][node_key]["total"] += 1
status = analyzer["status"]
locations[node_location][status] += 1
locations[node_location]["nodes"][node_key][status] += 1
if status == "missing" or status == "unknown":
locations[node_location]["nodes"][node_key]["analyzers"].insert(0, analyzer)
else:
locations[node_location]["nodes"][node_key]["analyzers"].append(analyzer)
self.dataset["locations"] = locations
