def interpret_old(self, result, parsed_coms):
result = hm_classes.net_to_sys(result[3:])
shit_str = ""
_ret_str, ret_state = ("OK", limits.mon_STATE_CRITICAL)
_copy_struct = result.get("struct", None)
if parsed_coms.zombie:
result["num_ok"] += result["num_fail"]
result["num_fail"] = 0
if result["num_shit"] > 0:
shit_str = " (%s)" % (logging_tools.get_plural(
"dead cron", result["num_shit"]))
if result["num_fail"] > 0:
zomb_str = " and %s" % (logging_tools.get_plural(
"Zombie", result["num_fail"]))
else:
zomb_str = ""
ret_state = limits.check_floor(result["num_ok"], parsed_coms.warn,
parsed_coms.crit)
if result["command"] == "all":
rets = "{:d} processes running{}{}".format(result["num_ok"],
zomb_str, shit_str)
else:
rets = "proc {} has {} running{}{}".format(
result["name"],
logging_tools.get_plural("instance", result["num_ok"]),
zomb_str, shit_str)
return ret_state, rets
def client_call(self, result, parsed_coms):
u_dict = hm_classes.net_to_sys(result[3:])
# pprint.pprint(u_dict)
ret_state = limits.mon_STATE_OK
used = u_dict["total_size"]
if "max_size" in u_dict:
max_size = u_dict["max_size"]
perc_used = 100. * float(used) / float(max_size)
quota_perc = "%.2f %%" % (perc_used)
quota_info = "%s of %s" % (quota_perc,
logging_tools.get_size_str(
max_size,
long_version=True).strip())
if perc_used > 100:
ret_state = limits.mon_STATE_CRITICAL
used_info = "over quota (%s)" % (quota_info)
elif perc_used > 80:
ret_state = limits.mon_STATE_WARNING
used_info = "reaching quota (%s)" % (quota_info)
else:
used_info = "quota ok (%s)" % (quota_info)
else:
used_info = "no quota info"
account_stat = u_dict.get("mail_account", "unknown")
if account_stat.lower() != "unlocked":
ret_state = max(ret_state, limits.mon_STATE_WARNING)
return ret_state, "%s %s (%s), used size is %s, %s" % (
limits.get_state_str(ret_state),
(u_dict.get("user_name", "name not set").split("/")[0]).strip(),
account_stat, used and logging_tools.get_size_str(
used, long_version=True).strip() or "not known", used_info)
def client_call(self, result, parsed_coms):
lim = parsed_coms[0]
result = hm_classes.net_to_sys(result[3:])
return limits.mon_STATE_OK, "OK: %s: %s" % (logging_tools.get_plural(
"queue", len(result)), ", ".join([
"%s: %s" % (q_name, result[q_name])
for q_name in sorted(result.keys())
]))
def client_call(self, result, parsed_coms):
lim = parsed_coms[0]
# pprint.pprint(result)
j_dict = hm_classes.net_to_sys(result[3:])
ret_state = limits.mon_STATE_OK
if j_dict["status"] == 256:
ret_state = limits.mon_STATE_WARNING
if j_dict["status"] == 512:
ret_state = limits.mon_STATE_CRITICAL
return ret_state, "%s" % (j_dict["message"])
def client_call(self, result, parsed_coms):
lim = parsed_coms[0]
result = hm_classes.net_to_sys(result[3:])
raw_output = lim.get_add_flag("R")
ret_str, ret_state = ("OK", limits.mon_STATE_CRITICAL)
if not raw_output:
ret_state, ret_str = lim.check_ceiling(result["num_mails"])
result = "{}: {} in queue, format '{}' via '{}'".format(
ret_str, logging_tools.get_plural("mail", result["num_mails"]),
result["format"], result["command"])
return ret_state, result
def client_call(self, result, parsed_coms):
s_dict = hm_classes.net_to_sys(result[3:])
if s_dict:
ret_state = limits.mon_STATE_OK
if s_dict["act_state"].lower() not in ["enabled", "started"]:
ret_state = limits.mon_STATE_CRITICAL
ret_str = "%s: %s %s" % (limits.get_state_str(ret_state),
s_dict["name"], s_dict["act_state"])
else:
ret_state, ret_str = limits.mon_STATE_CRITICAL, "Error no info found"
return ret_state, ret_str
def client_call(self, result, parsed_coms):
if result.startswith("ok "):
l_dict = hm_classes.net_to_sys(result[3:])
feat_list = parse_features(l_dict["attributes"])
if "server_port" in l_dict and "server_name" in l_dict:
# old version
s_port, s_name = (l_dict["server_port"], l_dict["server_name"])
return limits.mon_STATE_OK, "ok %s (port %d); %s: %s" % (
s_name, s_port,
logging_tools.get_plural(
"feature", len(feat_list)), ", ".join(feat_list))
elif "servers" in l_dict and "server_status" in l_dict:
# num servers
num_servers = len(l_dict["servers"])
servers_up = sorted([
k for k, v in l_dict["server_status"].iteritems()
if v.lower().count("server up")
])
servers_down = sorted([
k for k, v in l_dict["server_status"].iteritems()
if k not in servers_up
])
if servers_down:
return limits.mon_STATE_CRITICAL, "error %s down: %s, %s up: %s; %s: %s" % (
logging_tools.get_plural("server", len(servers_down)),
", ".join(servers_down),
logging_tools.get_plural(
"server", len(servers_up)), ", ".join(servers_up),
logging_tools.get_plural(
"feature", len(feat_list)), ", ".join(feat_list))
else:
num_features = len(feat_list)
if num_features:
ret_state, ret_str = (limits.mon_STATE_OK, "ok")
else:
ret_state, ret_str = (limits.mon_STATE_CRITICAL,
"error")
return ret_state, "%s %s up: %s; %s%s" % (
ret_str,
logging_tools.get_plural(
"server", len(servers_up)), ", ".join(servers_up),
logging_tools.get_plural("feature", len(feat_list)),
feat_list and ": %s" % (", ".join(feat_list)) or "")
else:
return limits.mon_STATE_CRITICAL, "error no server_port or server_name key in response"
else:
return limits.mon_STATE_CRITICAL, "error %s" % (result)
def client_call(self, result, parsed_coms):
lim = parsed_coms[0]
result = hm_classes.net_to_sys(result[3:])
val = result["value"]
val_i = int(val)
if re.match("^.*emp.*$", result["sensor"]):
what = "C"
if val_i == -1:
ret_state = limits.mon_STATE_WARNING
state = "Can't read"
else:
ret_state, state = lim.check_ceiling(val)
else:
what = "RPM"
ret_state, state = lim.check_floor(val)
if (val_i == -1) or (val_i == 0):
ret_state = limits.mon_STATE_WARNING
state = "Can't read"
else:
ret_state, state = lim.check_floor(val)
return ret_state, "%s: %s has %s %s" % (state, result["sensor"], val, what)
def interpret_old(self, result, cur_ns):
ctrl_dict = hm_classes.net_to_sys(result[3:])
return self._interpret(ctrl_dict, cur_ns)
def interpret_old(self, result, parsed_coms):
tw_dict = hm_classes.net_to_sys(result[3:])
return self._interpret(tw_dict, parsed_coms)
def client_call(self, result, parsed_coms):
u_list = sorted(hm_classes.net_to_sys(result[3:]))
return limits.mon_STATE_OK, "OK: %s\n%s" % (logging_tools.get_plural(
"user", len(u_list)), "\n".join(u_list))
def interpret_old(self, result, parsed_coms):
return self._interpret(hm_classes.net_to_sys(result[3:]), parsed_coms)
def interpret_old(self, result, parsed_coms):
inst_dict = hm_classes.net_to_sys(result[3:])
return self._interpret(inst_dict, parsed_coms,
self.NOGOOD_srv_com["host"].text)
def interpret_old(self, result, cur_ns):
num_mails = hm_classes.net_to_sys(result[3:])["mails"]
return self.interpret(num_mails, cur_ns)
def interpret_old(self, result, cur_ns):
drbd_conf = hm_classes.net_to_sys(result[3:])
return self._interpret(drbd_conf, cur_ns)
def interpret_old(self, result, cur_ns):
return self._interpret(hm_classes.net_to_sys(result[3:]), cur_ns)
