Andreas Wrede
0543266c92
- Restructuring of the project directory into client and server components - Renaming of modules and classes to better reflect their purpose and functionality - Moving common utilities and configurations to a shared location - Updating import statements to reflect the new structure - Adding new documentation files for better clarity on various aspects of the project - Removing deprecated or unused code to streamline the codebase - Ensuring that all existing functionality is preserved and that the codebase remains functional after the refactoring.
451 lines
14 KiB
Python
451 lines
14 KiB
Python
"""
|
|
host and connection class shared between hbd and
|
|
the websit's heartbeat.py
|
|
|
|
"""
|
|
|
|
import time
|
|
import json
|
|
import copy
|
|
import queue
|
|
|
|
num = 0
|
|
|
|
MAXRTTS = 10
|
|
|
|
DEBUG = 2
|
|
|
|
|
|
def log(host, m):
|
|
if DEBUG:
|
|
print("class log: %s %s" % (host, m))
|
|
|
|
|
|
class Connection:
|
|
# map of addrs to names
|
|
|
|
htab = {}
|
|
UNKNOWN = "unknown"
|
|
UP = "up"
|
|
DOWN = "down"
|
|
OVERDUE = "overdue"
|
|
|
|
def __init__(self, host, cid, addr, afam):
|
|
self.host = host
|
|
self.cid = cid
|
|
if addr[0:7] == "::ffff:":
|
|
addr = addr[7:]
|
|
self.addr = addr
|
|
self.afam = afam
|
|
self.rtts = [0]
|
|
self.lastbeat = time.time()
|
|
self.statetime = self.lastbeat
|
|
self.deltastatetime = "computed"
|
|
self.state = Connection.UNKNOWN
|
|
|
|
if host:
|
|
Connection.htab[addr] = self.host.name
|
|
if self.host.isDynDns():
|
|
log(self.host.name, "dns update %s" % self.addr)
|
|
Host.dnsQ.put((self.host.name, self.addr))
|
|
|
|
def registerDns(self):
|
|
Host.dnsQ.put((self.host.name, self.addr))
|
|
|
|
def clearstate(self):
|
|
d = {}
|
|
d["addr"] = ""
|
|
d["rtt"] = ""
|
|
d["lastbeat"] = ""
|
|
d["state"] = ""
|
|
d["statetime"] = ""
|
|
d["deltastatetime"] = ""
|
|
d["rttstate"] = ""
|
|
return d
|
|
|
|
def statedict(self, Null=False):
|
|
d = self.clearstate()
|
|
now = time.time()
|
|
if not Null:
|
|
d["addr"] = self.addr
|
|
if self.rtts[-1]:
|
|
d["rtt"] = "%0.1f" % self.rtts[-1]
|
|
elif self.state == Connection.UNKNOWN:
|
|
d["rtt"] = ""
|
|
else:
|
|
d["rtt"] = "?"
|
|
d["lastbeat"] = self.lastbeat
|
|
if self.state == Connection.OVERDUE:
|
|
d["state"] = "<b>%s</b>" % self.state
|
|
else:
|
|
d["state"] = self.state
|
|
if self.state == Connection.UP:
|
|
d["rttstate"] = d["rtt"]
|
|
elif self.state == Connection.OVERDUE:
|
|
d["rttstate"] = ""
|
|
else:
|
|
d["rttstate"] = d["state"]
|
|
d["statetime"] = time.strftime(
|
|
"%Y-%m-%d %H:%M:%S", time.localtime(self.statetime)
|
|
)
|
|
delta = now - self.statetime
|
|
|
|
if self.state == Connection.UNKNOWN:
|
|
d["deltastatetime"] = ""
|
|
elif delta > 86400:
|
|
# d['deltastatetime'] = time.strftime("%d %H:%M:%S", time.gmtime(delta))
|
|
d["deltastatetime"] = "%0.1f days" % (delta / 86400.0)
|
|
elif delta > 3600:
|
|
# d['deltastatetime'] = time.strftime("%H:%M:%S", time.gmtime(delta))
|
|
d["deltastatetime"] = time.strftime("%k:%M hrs", time.gmtime(delta))
|
|
# d['deltastatetime'] = "%0.1f hrs" % (delta / 3600.)
|
|
elif delta > 60:
|
|
# d['deltastatetime'] = time.strftime("%M:%S", time.gmtime(delta))
|
|
d["deltastatetime"] = time.strftime("%M:%S mins", time.gmtime(delta))
|
|
# d['deltastatetime'] = "%0.1f mins" % (delta / 60.)
|
|
else:
|
|
# d['deltastatetime'] = time.strftime("%S", time.gmtime(delta))
|
|
d["deltastatetime"] = "%i secs" % (delta)
|
|
if self.state == Connection.UNKNOWN and now - self.lastbeat > 86400 * 10:
|
|
d = self.clearstate()
|
|
|
|
return d
|
|
|
|
def headerdict(self, afam):
|
|
d = {}
|
|
d["addr"] = "%s Addr" % afam
|
|
d["rtt"] = "Latencey"
|
|
d["lastbeat"] = "Last Contact"
|
|
d["state"] = "State"
|
|
d["statetime"] = "Last State"
|
|
d["rttstate"] = "Reach"
|
|
d["deltastatetime"] = "Last State"
|
|
return d
|
|
|
|
def jsons(self):
|
|
return json.dumps(self.__dict__)
|
|
|
|
# set new state, return number of secs in previous state
|
|
def newstate(self, state, now, when=0):
|
|
self.state = state
|
|
delta = now - when
|
|
s = delta - self.statetime
|
|
self.statetime = delta
|
|
return s
|
|
|
|
def getstate(self):
|
|
return self.state
|
|
|
|
def newaddr(self, addr, rtt, now):
|
|
self.lastbeat = now
|
|
self.rtts.append(rtt)
|
|
if len(self.rtts) > MAXRTTS:
|
|
del self.rtts[0]
|
|
|
|
if self.addr == addr:
|
|
r = None
|
|
else:
|
|
r = "changed from %s to %s" % (self.addr, addr)
|
|
try:
|
|
del Connection.htab[self.addr]
|
|
except Exception:
|
|
pass
|
|
self.addr = addr
|
|
Connection.htab[addr] = self.host.name
|
|
if self.host.isDynDns():
|
|
Host.dnsQ.put((self.host.name, self.addr))
|
|
return r
|
|
|
|
|
|
#
|
|
class Host:
|
|
# Table of Hosts
|
|
hosts = {}
|
|
dnsQ = queue.Queue()
|
|
|
|
def __init__(self, name):
|
|
global num
|
|
self.name = name
|
|
if name:
|
|
num += 1
|
|
Host.hosts[name] = self
|
|
self.num = num
|
|
self.dyn = False
|
|
self.watched = False
|
|
self.upcount = 0
|
|
self.interval = 0
|
|
self.doesack = -1
|
|
self.cmds = []
|
|
self.cver = 0
|
|
self.connections = {}
|
|
self.hdwcounts = [[0, 0], [0, 0], [0, 0]]
|
|
# Plugin data storage: {plugin_name: [(timestamp, data), ...]}
|
|
self.plugin_data = {}
|
|
self.plugin_retention = 100 # Keep last N samples per plugin
|
|
# Alert state tracking: {metric_path: AlertState}
|
|
self.alert_states = {}
|
|
|
|
def statedict(self):
|
|
d = {}
|
|
d["name"] = self.name
|
|
if self.dyn:
|
|
d["name"] += "*"
|
|
if self.watched:
|
|
d["name"] = "<b>%s</b>" % d["name"]
|
|
d["dyn"] = str(self.dyn)
|
|
d["ver"] = str(self.cver)
|
|
d["num"] = self.num
|
|
for c in ["IPv4", "IPv6"]:
|
|
if c in self.connections:
|
|
cs = self.connections[c].statedict()
|
|
else:
|
|
cs = ubConnection.statedict(True)
|
|
for csv in cs:
|
|
d["%s.%s" % (c, csv)] = cs[csv]
|
|
|
|
return d
|
|
|
|
def headerdict(self):
|
|
d = {}
|
|
d["name"] = "Name"
|
|
d["dyn"] = "Dyn"
|
|
d["ver"] = "Ver"
|
|
d["num"] = "??"
|
|
for c in ["IPv4", "IPv6"]:
|
|
cs = ubConnection.headerdict(c)
|
|
for csv in cs:
|
|
d["%s.%s" % (c, csv)] = cs[csv]
|
|
return d
|
|
|
|
def registerDns(self):
|
|
for af in self.connections:
|
|
self.connections[af].registerDns()
|
|
|
|
def stateinfo(self):
|
|
ddict = {}
|
|
for d in self.__dict__:
|
|
if d == "connections":
|
|
cl = []
|
|
for c in ["IPv4", "IPv6"]:
|
|
if c not in self.connections:
|
|
continue
|
|
# dirty ugly hack: fix conn to host backpointer
|
|
cld = copy.deepcopy(self.connections[c].__dict__)
|
|
cld["host"] = cld["host"].name
|
|
cl.append(cld)
|
|
ddict[d] = cl
|
|
else:
|
|
ddict[d] = self.__dict__[d]
|
|
return ddict
|
|
|
|
def jsons(self):
|
|
return json.dumps(self.stateinfo())
|
|
|
|
def setcver(self, cver):
|
|
self.cver = cver
|
|
|
|
def isDynDns(self):
|
|
return self.dyn
|
|
|
|
def isIPv4(self, addr):
|
|
if isinstance(addr, tuple):
|
|
return addr[0].find(".") > 0
|
|
else:
|
|
return addr.find(".") > 0
|
|
|
|
def conndata(self, cid, addr, rtt, now):
|
|
if addr[0:7] == "::ffff:":
|
|
addr = addr[7:]
|
|
if self.isIPv4(addr):
|
|
afam = "IPv4"
|
|
else:
|
|
afam = "IPv6"
|
|
|
|
if afam not in self.connections:
|
|
self.connections[afam] = Connection(self, cid, addr, afam)
|
|
|
|
conn = self.connections[afam]
|
|
res = conn.newaddr(addr, rtt, now)
|
|
return conn, res
|
|
|
|
# called when reloading class from pickle, add new fields here
|
|
def fixup(self):
|
|
for c in ["IPv4", "IPv6"]:
|
|
if c in self.connections:
|
|
addr = self.connections[c].addr
|
|
if addr[0:7] == "::ffff:":
|
|
addr = addr[7:]
|
|
self.connections[c].addr = addr
|
|
|
|
# Add plugin_data if missing (for backward compatibility)
|
|
if not hasattr(self, "plugin_data"):
|
|
self.plugin_data = {}
|
|
if not hasattr(self, "plugin_retention"):
|
|
self.plugin_retention = 100
|
|
if not hasattr(self, "alert_states"):
|
|
self.alert_states = {}
|
|
|
|
pass
|
|
|
|
def add_plugin_data(self, plugin_name, data, timestamp=None):
|
|
"""Store plugin data with timestamp.
|
|
|
|
Args:
|
|
plugin_name: Name of the plugin (e.g., "cpu_monitor")
|
|
data: Dict of plugin data
|
|
timestamp: Optional timestamp (default: current time)
|
|
"""
|
|
if timestamp is None:
|
|
timestamp = time.time()
|
|
|
|
if plugin_name not in self.plugin_data:
|
|
self.plugin_data[plugin_name] = []
|
|
|
|
# Add new data
|
|
self.plugin_data[plugin_name].append((timestamp, data))
|
|
|
|
# Enforce retention limit (keep last N samples)
|
|
if len(self.plugin_data[plugin_name]) > self.plugin_retention:
|
|
self.plugin_data[plugin_name] = self.plugin_data[plugin_name][-self.plugin_retention:]
|
|
|
|
def get_plugin_data(self, plugin_name, limit=None):
|
|
"""Retrieve plugin data for a specific plugin.
|
|
|
|
Args:
|
|
plugin_name: Name of the plugin
|
|
limit: Optional limit on number of recent samples to return
|
|
|
|
Returns:
|
|
List of (timestamp, data) tuples, most recent last
|
|
"""
|
|
data = self.plugin_data.get(plugin_name, [])
|
|
if limit and len(data) > limit:
|
|
return data[-limit:]
|
|
return data
|
|
|
|
def get_latest_plugin_data(self, plugin_name):
|
|
"""Get the most recent plugin data for a plugin.
|
|
|
|
Args:
|
|
plugin_name: Name of the plugin
|
|
|
|
Returns:
|
|
(timestamp, data) tuple or None if no data
|
|
"""
|
|
data = self.plugin_data.get(plugin_name, [])
|
|
return data[-1] if data else None
|
|
|
|
def get_all_plugin_data(self):
|
|
"""Get all plugin data for this host.
|
|
|
|
Returns:
|
|
Dict of {plugin_name: [(timestamp, data), ...]}
|
|
"""
|
|
return self.plugin_data
|
|
|
|
# def dispstate(self):
|
|
# if self.state in ["down", "overdue"]:
|
|
# state = "<b>%s</b>" % self.state
|
|
# elif self.state in ["up", "UP"]:
|
|
# state = ""
|
|
# for x in list(self.connections.keys()):
|
|
# try:
|
|
# state += " %5.1f" % (self.connections[x].rtts[-1])
|
|
# except:
|
|
# state += " %5s" % (self.connections[x].rtts[-1])
|
|
# elif self.state in ["unknown", "UNKNOWN"]:
|
|
# state = ""
|
|
# else:
|
|
# state = "%s" % self.state
|
|
# return state
|
|
|
|
def dispstats(self):
|
|
if self.doesack != -1:
|
|
if self.upcount > 0:
|
|
r = ""
|
|
for v in range(3):
|
|
a, u = self.hdwcounts[v]
|
|
if (self.upcount - u) != 0:
|
|
vs = "%0.0f" % (
|
|
100.0 - (((self.doesack - a) * 100.0) / (self.upcount - u))
|
|
)
|
|
if vs == "0":
|
|
vs = ""
|
|
else:
|
|
vs = "-"
|
|
r += '<td align="right">%s</td>' % vs
|
|
return r
|
|
else:
|
|
return "<td>(%s)</td><td></td><td></td>" % (self.doesack)
|
|
return '<td align="right">N/A</td><td></td<td></td>>'
|
|
|
|
hostfields_long = [
|
|
"name",
|
|
"IPv4.addr",
|
|
"IPv4.state",
|
|
("IPv4.rtt", 'style="text-align: right;"'),
|
|
("IPv4.statetime", 'style="text-align: right;"'),
|
|
"IPv6.addr",
|
|
"IPv6.state",
|
|
("IPv6.rtt", 'style="text-align: right;"'),
|
|
("IPv6.statetime", 'style="text-align: right;"'),
|
|
"ver",
|
|
]
|
|
|
|
hostfields_short = [
|
|
"name",
|
|
("IPv4.rttstate", 'style="text-align: right;"'),
|
|
("IPv4.deltastatetime", 'style="text-align: right;"'),
|
|
("IPv6.rttstate", 'style="text-align: right;"'),
|
|
("IPv6.deltastatetime", 'style="text-align: right;"'),
|
|
]
|
|
|
|
def gene(self, tag, v, attrib=None):
|
|
if attrib:
|
|
a = " %s" % attrib
|
|
else:
|
|
a = ""
|
|
return "<%s%s>%s</%s>" % (tag, a, v, tag)
|
|
|
|
def htmltable(self, tag, hd, short):
|
|
if short:
|
|
hostfields = Host.hostfields_short
|
|
else:
|
|
hostfields = Host.hostfields_long
|
|
h = []
|
|
for f in hostfields:
|
|
if isinstance(f, tuple):
|
|
h.append(self.gene(tag, hd[f[0]], f[1]))
|
|
else:
|
|
h.append(self.gene(tag, hd[f]))
|
|
return self.gene("tr", "\n".join(h))
|
|
|
|
def buildhosttable(self, short=False):
|
|
if DEBUG > 1:
|
|
print("DBG buildhosttable: start")
|
|
res = []
|
|
res.append('<table id="ntable" class="sortable">')
|
|
res.append(ubHost.htmltable("th", ubHost.headerdict(), short))
|
|
hosts_sorted = list(Host.hosts.keys())
|
|
if len(hosts_sorted):
|
|
hosts_sorted.sort()
|
|
for h in hosts_sorted:
|
|
res.append(ubHost.htmltable("td", Host.hosts[h].statedict(), short))
|
|
res.append("</table>")
|
|
if DEBUG > 1:
|
|
print("DBG buildhosttable: %s" % res)
|
|
return res
|
|
|
|
def buildmsgtable(self, msgs):
|
|
res = []
|
|
le = max(40 - len(Host.hosts), 3)
|
|
res.append("<h4>Log of Events</h4>")
|
|
for m in msgs[len(msgs) - le :]:
|
|
res.append("%s<BR>" % m)
|
|
return res
|
|
|
|
|
|
# create fake "unbound objects", remove in Python 3.0
|
|
ubHost = Host(None)
|
|
ubConnection = Connection(None, "", "", "")
|