def any_message_received(self):
act_time = time.time()
self.__num_write += 1
if not self.__last_stat_time or abs(
act_time - self.__last_stat_time
) > self.__stat_timer or self.__num_write % 10000 == 0:
last_stat_time = self.__last_stat_time
self.__last_stat_time = act_time
if self.__num_forward_ok or self.__num_forward_error:
fwd_str = ", {:d} fwd ({:d} error)".format(
self.__num_forward_ok,
self.__num_forward_error,
)
else:
fwd_str = ""
self.log(
"logstat (open/close/written): {:d} / {:d} / {:d} ({:.2f}/s), mem_used is {}{}"
.format(
self.__num_open,
self.__num_close,
self.__num_write,
(self.__num_write / max(1, (act_time - last_stat_time))),
process_tools.beautify_mem_info(),
fwd_str,
))
self.__num_open, self.__num_close, self.__num_write = (0, 0, 0)
self.__num_forward_ok, self.__num_forward_error = (0, 0)
def instance_to_form_list(self, opt_ns, res_xml):
prc_dict = {
SERVICE_OK: ("running", "ok"),
SERVICE_DEAD: ("error", "critical"),
SERVICE_INCOMPLETE: ("incomplete", "critical"),
SERVICE_NOT_INSTALLED: ("not installed", "warning"),
SERVICE_NOT_CONFIGURED: ("not configured", "warning"),
}
crc_dict = {
CONF_STATE_RUN: ("run", "ok"),
CONF_STATE_STOP: ("stop", "critical"),
CONF_STATE_IP_MISMATCH: ("ip mismatch", "critical"),
}
meta_dict = {
"t": {
TARGET_STATE_RUNNING: ("run", "ok"),
TARGET_STATE_STOPPED: ("stop", "critical"),
},
"i": {
0: ("monitor", "ok"),
1: ("ignore", "warning"),
}
}
if License is not None:
lic_dict = {
-1: ("-", ""),
LicenseState.none: ("no license", "critical"),
LicenseState.violated: ("parameter violated", "critical"),
LicenseState.valid: ("valid", "ok"),
LicenseState.grace: ("in grace", "warning"),
LicenseState.expired: ("expired", "critical"),
LicenseState.fp_mismatch: ("wrong fingerprint", "critical"),
# LicenseState.ip_mismatch: ("ip mismatch", "critical"),
}
else:
lic_dict = None
out_bl = logging_tools.new_form_list()
types = sorted(
list(
set(res_xml.xpath(".//instance/@runs_on",
start_strings=False))))
_list = sum([
res_xml.xpath("instance[result and @runs_on='{}']".format(_type))
for _type in types
], [])
for act_struct in _list:
_res = act_struct.find("result")
p_state = int(
act_struct.find(".//process_state_info").get(
"state", SERVICE_DEAD))
c_state = int(
act_struct.find(".//configured_state_info").get(
"state", CONF_STATE_STOP))
if not opt_ns.failed or (opt_ns.failed
and p_state not in [SERVICE_OK]):
cur_line = [
logging_tools.form_entry(act_struct.attrib["name"],
header="Name")
]
cur_line.append(
logging_tools.form_entry(act_struct.attrib["runs_on"],
header="runson"))
cur_line.append(
logging_tools.form_entry(
_res.find("process_state_info").get(
"check_source", "N/A"),
header="source"))
if opt_ns.process:
s_info = act_struct.find(".//process_state_info")
if "num_started" not in s_info.attrib:
cur_line.append(logging_tools.form_entry(s_info.text))
else:
num_diff, any_ok = (int(
s_info.get("num_diff")), True if int(
act_struct.attrib["any-processes-ok"]) else
False)
# print etree.tostring(act_struct, pretty_print=True)
num_pids = len(_res.findall(".//pids/pid"))
da_name = ""
if any_ok:
pass
else:
if num_diff < 0:
da_name = "critical"
elif num_diff > 0:
da_name = "warning"
cur_line.append(
logging_tools.form_entry(
s_info.attrib["proc_info_str"],
header="Process info",
display_attribute=da_name))
pid_dict = {}
for cur_pid in act_struct.findall(".//pids/pid"):
pid_dict[int(cur_pid.text)] = int(
cur_pid.get("count", "1"))
if pid_dict:
p_list = sorted(pid_dict.keys())
if max(pid_dict.values()) == 1:
cur_line.append(
logging_tools.form_entry(
logging_tools.compress_num_list(p_list),
header="pids"))
else:
cur_line.append(
logging_tools.form_entry(",".join([
"{:d}{}".format(
key, " ({:d})".format(pid_dict[key])
if pid_dict[key] > 1 else "")
for key in p_list
]),
header="pids"))
else:
cur_line.append(
logging_tools.form_entry("no PIDs", header="pids"))
if opt_ns.started:
start_time = int(
act_struct.find(".//process_state_info").get(
"start_time", "0"))
if start_time:
diff_time = max(
0,
time.mktime(time.localtime()) - start_time)
diff_days = int(diff_time / (3600 * 24))
diff_hours = int(
(diff_time - 3600 * 24 * diff_days) / 3600)
diff_mins = int((diff_time - 3600 *
(24 * diff_days + diff_hours)) / 60)
diff_secs = int(
diff_time - 60 *
(60 * (24 * diff_days + diff_hours) + diff_mins))
ret_str = "{}".format(
time.strftime("%a, %d. %b %Y, %H:%M:%S",
time.localtime(start_time)))
else:
ret_str = "no start info found"
cur_line.append(
logging_tools.form_entry(ret_str, header="started"))
if opt_ns.config:
cur_line.append(
logging_tools.form_entry(
act_struct.find(".//config_info").text,
header="config info"))
if opt_ns.memory:
cur_mem = act_struct.find(".//memory_info")
if cur_mem is not None:
mem_str = process_tools.beautify_mem_info(
int(cur_mem.text))
else:
# no pids hence no memory info
mem_str = ""
cur_line.append(
logging_tools.form_entry_right(mem_str,
header="Memory"))
if opt_ns.version:
if "version" in _res.attrib:
_version = _res.attrib["version"]
else:
_version = ""
cur_line.append(
logging_tools.form_entry_right(_version,
header="Version"))
_lic_info = _res.find("license_info")
_lic_state = int(_lic_info.attrib["state"])
if lic_dict is None:
cur_line.append(
logging_tools.form_entry(
"---",
header="License",
))
else:
cur_line.append(
logging_tools.form_entry(
lic_dict[_lic_state][0],
header="License",
display_attribute=lic_dict[_lic_state][1],
))
cur_line.append(
logging_tools.form_entry(
prc_dict[p_state][0],
header="PState",
display_attribute=prc_dict[p_state][1],
))
cur_line.append(
logging_tools.form_entry(
crc_dict[c_state][0],
header="CState",
display_attribute=crc_dict[c_state][1],
))
if opt_ns.meta:
_meta_res = act_struct.find(".//meta_result")
if _meta_res is not None:
t_state = int(_meta_res.get("target_state"))
ignore = int(_meta_res.get("ignore"))
cur_line.append(
logging_tools.form_entry(
meta_dict["t"][t_state][0],
header="TargetState",
display_attribute=meta_dict["t"][t_state][1],
))
cur_line.append(
logging_tools.form_entry(
meta_dict["i"][ignore][0],
header="Ignore",
display_attribute=meta_dict["i"][ignore][1],
))
else:
cur_line.append(
logging_tools.form_entry(
"N/A",
header="TargetState",
display_attribute="warning",
))
cur_line.append(
logging_tools.form_entry(
"N/A",
header="Ignore",
display_attribute="warning",
))
out_bl.append(cur_line)
return out_bl
def _show_meminfo(self, res_list):
act_time = time.time()
self.__act_meminfo_line += 1
valid_entries = [
entry for entry in res_list
if entry.entry.find(".//memory_info[@valid='1']") is not None
]
act_meminfo_keys = [entry.name for entry in valid_entries]
if act_meminfo_keys != self.__last_meminfo_keys or self.__act_meminfo_line > 100:
self.__act_meminfo_line = 0
self.__last_meminfo_keys = act_meminfo_keys
self.log("Memory info mapping: {}".format(", ".join([
"{:d}: {}".format(act_meminfo_keys.index(key) + 1, key)
for key in act_meminfo_keys
])))
if hm_classes and self.vector_socket:
drop_com = server_command.srv_command(command="set_vector")
mv_valid = act_time + 2 * global_config["MIN_MEMCHECK_TIME"]
my_vector = drop_com.builder("values")
# handle removal of old keys, track pids, TODO, FIXME
old_keys = set(self.mis_dict.keys())
new_keys = set()
for entry in valid_entries:
key = entry.name
tot_mem = 0
mem_el = entry.entry.find(".//memory_info")
tot_mem = int(mem_el.text.strip())
if mem_el.find("details") is not None:
for _detail in mem_el.findall("details/mem"):
proc_name = _detail.get("name")
f_key = (key, proc_name)
info_str = "memory usage of {} ({})".format(
key, proc_name)
if f_key not in self.mis_dict:
self.mis_dict[f_key] = hm_classes.mvect_entry(
"mem.icsw.{}.{}".format(key, proc_name),
info=info_str,
default=0,
unit="Byte",
base=1024)
self.mis_dict[f_key].update(int(_detail.text))
self.mis_dict[f_key].info = info_str
self.mis_dict[f_key].valid_until = mv_valid
new_keys.add(f_key)
my_vector.append(self.mis_dict[f_key].build_xml(
drop_com.builder))
if key not in self.mis_dict:
self.mis_dict[key] = hm_classes.mvect_entry(
"mem.icsw.{}.total".format(key),
info="memory usage of {}".format(key),
default=0,
unit="Byte",
base=1024)
self.mis_dict[key].update(tot_mem)
self.mis_dict[key].valid_until = mv_valid
new_keys.add(key)
my_vector.append(self.mis_dict[key].build_xml(
drop_com.builder))
drop_com["vector"] = my_vector
drop_com["vector"].attrib["type"] = "vector"
self.vector_socket.send_unicode(unicode(drop_com))
del_keys = old_keys - new_keys
if del_keys:
self.log("removing {} from mis_dict".format(
logging_tools.get_plural("key", len(del_keys))))
for del_key in del_keys:
del self.mis_dict[del_key]
self.log("Memory info: {}".format(" / ".join([
process_tools.beautify_mem_info(int(
_el.entry.find(".//memory_info").text),
short=True)
for _el in valid_entries
])))