def show(self, **opions):
present_perms = self._get_perms()
out_list = logging_tools.new_form_list()
for perm in present_perms:
out_list.append([
logging_tools.form_entry(perm.content_type.app_label,
header="App Label"),
logging_tools.form_entry(perm.content_type.model,
header="Model"),
logging_tools.form_entry(perm.codename, header="Code"),
logging_tools.form_entry(perm.name, header="Info"),
logging_tools.form_entry_center(
"G/O" if perm.valid_for_object_level else "G",
header="Scope"),
logging_tools.form_entry(
perm.created.strftime("%Y-%m-%d %H:%M:%S"),
header="Created"),
logging_tools.form_entry_right(
perm.rolepermission_set.all().count(), header="RolePerms"),
logging_tools.form_entry_right(
perm.csw_object_permission_set.all().count(),
header="RoleObjPerms"),
])
print("{} defined:".format(
logging_tools.get_plural("Permission", len(out_list)), ))
print unicode(out_list)
def ova_show(opts):
print("Recalc ova info")
_sys_c = icswEggCradle.objects.get_system_cradle()
_sys_c.calc()
print("System cradle info: {}".format(unicode(_sys_c)))
_out_list = logging_tools.new_form_list()
for _cons in _sys_c.icsweggconsumer_set.all():
_out_list.append(_cons.get_info_line())
print(unicode(_out_list))
def raw_license_info(opts):
if opts.delete:
print("Deleting LicenseFile Entry from database with idx {:d}".format(
opts.delete))
try:
License.objects.get(Q(idx=opts.delete)).delete()
except License.DoesNotExist:
# ignore
pass
out_list = logging_tools.new_form_list()
_to_save = []
_query = License.objects.all()
if opts.only_valid:
_query = _query.filter(Q(valid=True))
for lic in _query:
try:
_info = License.objects.get_license_info(lic)
except:
_info = process_tools.get_except_info()
_raw_info = None
_error = True
else:
_raw_info = License.objects.get_raw_license_info(lic)
_error = False
if _error:
if opts.mark_error:
_valid = False
elif opts.unmark_all:
_valid = True
else:
_valid = lic.valid
else:
_valid = True
if lic.valid != _valid:
lic.valid = _valid
_to_save.append(lic)
# todo, extract fingerprint info from raw_license_info
# import pprint
# pprint.pprint(_raw_info)
out_list.append([
logging_tools.form_entry(lic.file_name, header="Filename"),
logging_tools.form_entry(lic.date.isoformat(), header="created"),
logging_tools.form_entry_right(lic.idx, header="idx"),
logging_tools.form_entry_center(
"valid" if lic.valid else "invalid", header="validity"),
logging_tools.form_entry_center("error" if _error else "ok",
header="error"),
logging_tools.form_entry(_info, header="Info"),
])
print(str(out_list))
if len(_to_save):
print("")
print("Updating LicenseFile states ({:d})".format(len(_to_save)))
for lic_to_save in _to_save:
lic_to_save.save(update_fields=["valid"])
print("...done")
def get_info(self, short=True):
vg_names = sorted(self.lv_dict.get("vg", {}).keys())
vg_info = {}
for vg_name in vg_names:
vg_stuff = self.lv_dict.get("vg", {})[vg_name]
_vg_extent_size = vg_stuff["extent_size"]
_vg_extent_count = vg_stuff["extent_count"]
vg_info[vg_name] = (self._get_size_str(vg_stuff["size"]),
self._get_size_str(vg_stuff["free"]))
lv_names = sorted(self.lv_dict.get("lv", {}).keys())
lv_info = {}
for lv_name in lv_names:
lv_stuff = self.lv_dict.get("lv", {})[lv_name]
vg_name = lv_stuff["vg_name"]
lv_size = lv_stuff["size"]
lv_info.setdefault(vg_name, []).append("{}{} ({})".format(
lv_name, lv_stuff["attr"][5] == "o" and "[open]" or "",
self._get_size_str(lv_size)))
# print "*", lv_name, vg_stuff["name"], vg_extent_size, vg_extent_count, vg_size, lv_extents
if short:
ret_info = []
for vg_name in vg_names:
ret_info.append("{} ({}, {} free, {}: {})".format(
vg_name, vg_info[vg_name][0], vg_info[vg_name][1],
logging_tools.get_plural("LV",
len(lv_info.get(vg_name, []))),
", ".join(lv_info.get(vg_name, [])) or "NONE"))
return "{}: {}".format(
logging_tools.get_plural("VG", len(ret_info)),
"; ".join(ret_info))
else:
ret_info = logging_tools.new_form_list()
for vg_name in vg_names:
ret_info.append([
logging_tools.form_entry("VG", header="type"),
logging_tools.form_entry(vg_name, header="name"),
logging_tools.form_entry_right(vg_info[vg_name][0],
header="size"),
logging_tools.form_entry_right(vg_info[vg_name][1],
header="free"),
logging_tools.form_entry("", header="options"),
])
for lv_name in lv_names:
lv_stuff = self.lv_dict.get("lv", {})[lv_name]
if lv_stuff["vg_name"] == vg_name:
ret_info.append([
logging_tools.form_entry(" LV", header="type"),
logging_tools.form_entry(lv_name, header="name"),
logging_tools.form_entry_right(self._get_size_str(
lv_stuff["size"]),
header="size"),
logging_tools.form_entry(""),
logging_tools.form_entry(lv_stuff["attr"]),
])
return unicode(ret_info)
def main(opts):
ret_code = -1
if opts.mode == "list":
def_query = Q()
if opts.level:
def_query &= Q(level__identifier=opts.level)
if opts.source:
def_query &= Q(source__identifier=opts.source)
if opts.device:
def_query &= Q(device__name=opts.device)
# print def_query
all_logs = DeviceLogEntry.objects.filter(def_query).select_related(
"source", "source__device", "level", "user",
"device").order_by("-date")
print("{} found:".format(
logging_tools.get_plural("Log entry", all_logs.count())))
new_entry = logging_tools.new_form_list()
for cur_dl in all_logs:
new_entry.append([
logging_tools.form_entry(unicode(cur_dl.date), header="date"),
logging_tools.form_entry(unicode(cur_dl.device),
header="device"),
logging_tools.form_entry(unicode(cur_dl.source),
header="source"),
logging_tools.form_entry(unicode(cur_dl.source.device
or "---"),
header="sdevice"),
logging_tools.form_entry(unicode(cur_dl.level),
header="level"),
logging_tools.form_entry(unicode(cur_dl.user or "---"),
header="user"),
logging_tools.form_entry(unicode(cur_dl.text), header="text"),
])
print(unicode(new_entry))
ret_code = 0
elif opts.mode == "create":
if not opts.text:
print("no text entered")
else:
log_dev = device.objects.get(Q(name=opts.device))
new_log_entry = DeviceLogEntry.new(
device=log_dev,
# todo, fixme
# source=def_source,
level=LogLevel.objects.get(Q(identifier=opts.level)),
text=" ".join(opts.text),
)
ret_code = 0
print("created '{}'".format(unicode(new_log_entry)))
else:
print("Uknown mode '{}'".format(opts.mode))
sys.exit(ret_code)
def main():
parser = argparse.ArgumentParser()
parser.add_argument("--port", type=int, default=1055, help="license server [%(default)d]")
parser.add_argument("--server", type=str, default="localhost", help="license port [%(default)s]")
parser.add_argument("--mode", type=str, default="xml", choices=["xml", "check", "csv", "list"], help="output mode [%(default)s]")
parser.add_argument("--check-eval", type=str, default="true", help="check string, should return true or false")
opts = parser.parse_args()
my_lc = sge_license_tools.license_check(
server=opts.server,
port=opts.port,
)
xml_res = my_lc.check()
ret_code = 0
if opts.mode == "xml":
print(etree.tostring(xml_res, pretty_print=True)) # @UndefinedVariable
elif opts.mode == "check":
glob_dict = {}
for cur_lic in xml_res.findall(".//license"):
lic_name = cur_lic.attrib["name"]
for attr_name in ["issued", "used", "free", "reserved"]:
glob_dict["{}_{}".format(lic_name, attr_name)] = int(cur_lic.attrib[attr_name])
ret_val = eval(opts.check_eval, glob_dict)
if not ret_val:
ret_code = 1
elif opts.mode == "csv":
print(",".join(["name", "issued", "used", "free", "reserved"]))
for cur_lic in xml_res.findall(".//license"):
print(
",".join(
[
cur_lic.attrib["name"],
cur_lic.attrib["issued"],
cur_lic.attrib["used"],
cur_lic.attrib["free"],
cur_lic.attrib["reserved"],
]
)
)
elif opts.mode == "list":
out_form = logging_tools.new_form_list()
for cur_lic in xml_res.findall(".//license"):
out_form.append(
[
logging_tools.form_entry(cur_lic.attrib["name"], header="name"),
logging_tools.form_entry_right(cur_lic.attrib["issued"], header="issued"),
logging_tools.form_entry_right(cur_lic.attrib["used"], header="used"),
logging_tools.form_entry_right(cur_lic.attrib["free"], header="free"),
logging_tools.form_entry_right(cur_lic.attrib["reserved"], header="reserved"),
]
)
print(unicode(out_form))
sys.exit(ret_code)
def list_images(opt_ns):
images = image.objects.all().order_by("name")
print("{} defined:".format(logging_tools.get_plural("image", len(images))))
_list = logging_tools.new_form_list()
for _image in images:
_list.append(
[
logging_tools.form_entry(unicode(_image), header="info"),
logging_tools.form_entry(_image.version, header="version"),
logging_tools.form_entry(_image.release, header="release"),
logging_tools.form_entry("yes" if _image.build_lock else "--", header="locked"),
]
)
print(unicode(_list))
def interpret(self, srv_com, cur_ns):
if cur_ns.arguments:
re_list = [re.compile(_arg) for _arg in cur_ns.arguments]
else:
re_list = []
cur_vector = srv_com["data:machine_vector"]
if cur_ns.raw:
return limits.mon_STATE_OK, etree.tostring(
cur_vector) # @UndefinedVariable
else:
vector_keys = sorted(
srv_com.xpath(".//ns:mve/@name",
start_el=cur_vector,
smart_strings=False))
used_keys = [
key for key in vector_keys
if any([cur_re.search(key)
for cur_re in re_list]) or not re_list
]
ret_array = [
"Machinevector id {}, {}, {} shown:".format(
cur_vector.attrib["version"],
logging_tools.get_plural("key", len(vector_keys)),
logging_tools.get_plural("key", len(used_keys)),
)
]
out_list = logging_tools.new_form_list()
max_num_keys = 0
_list = []
for mv_num, mv_key in enumerate(vector_keys):
if mv_key in used_keys:
cur_xml = srv_com.xpath(
"//ns:mve[@name='{}']".format(mv_key),
start_el=cur_vector,
smart_strings=False)[0]
_mv = hm_classes.mvect_entry(cur_xml.attrib.pop("name"),
**cur_xml.attrib)
_list.append((mv_num, _mv))
max_num_keys = max(max_num_keys, _mv.num_keys)
for mv_num, entry in _list:
out_list.append(entry.get_form_entry(mv_num, max_num_keys))
ret_array.extend(unicode(out_list).split("\n"))
return limits.mon_STATE_OK, "\n".join(ret_array)
def _log_limits(self):
# read limits
r_dict = {}
try:
import resource
except ImportError:
self.log("cannot import resource",
logging_tools.LOG_LEVEL_CRITICAL)
else:
available_resources = [
key for key in dir(resource) if key.startswith("RLIMIT")
]
for av_r in available_resources:
try:
r_dict[av_r] = resource.getrlimit(getattr(resource, av_r))
except ValueError:
r_dict[av_r] = "invalid resource"
except:
r_dict[av_r] = None
if r_dict:
res_keys = sorted(r_dict.keys())
self.log("{} defined".format(
logging_tools.get_plural("limit", len(res_keys))))
res_list = logging_tools.new_form_list()
for key in res_keys:
val = r_dict[key]
if isinstance(val, basestring):
info_str = val
elif type(val) is tuple:
info_str = "{:8d} (hard), {:8d} (soft)".format(*val)
else:
info_str = "None (error?)"
res_list.append([
logging_tools.form_entry(key, header="key"),
logging_tools.form_entry(info_str, header="value")
])
for line in str(res_list).split("\n"):
self.log(line)
else:
self.log("no limits found, strange ...",
logging_tools.LOG_LEVEL_WARN)
def get_config_info(self):
gk = sorted(self.keys())
if gk:
f_obj = logging_tools.new_form_list()
for key in gk:
if self.get_type(key) in ["a", "d"]:
pv = self.pretty_print(key)
f_obj.append(
[
logging_tools.form_entry(key),
logging_tools.form_entry("list with {}:".format(logging_tools.get_plural("entry", len(pv)))),
logging_tools.form_entry(self.get_type(key)),
logging_tools.form_entry(self.get_source(key)),
]
)
for idx, entry in enumerate(pv):
f_obj.append(
[
logging_tools.form_entry(""),
logging_tools.form_entry(""),
logging_tools.form_entry(entry),
logging_tools.form_entry(str(idx)),
logging_tools.form_entry("---"),
]
)
else:
f_obj.append(
[
logging_tools.form_entry(key, header="key"),
logging_tools.form_entry(self.is_global(key) and "global" or "local", post_str=" : ", header="global"),
logging_tools.form_entry(self.pretty_print(key), header="value"),
logging_tools.form_entry(self.get_type(key), pre_str=", (", post_str=" from ", header="type"),
logging_tools.form_entry(self.get_source(key), post_str=")", header="source"),
]
)
ret_str = unicode(f_obj).split("\n")
else:
ret_str = []
return ret_str
def enum_show_command(options):
from initat.cluster.backbone.server_enums import icswServiceEnum
from initat.cluster.backbone.models import ConfigServiceEnum, config, config_catalog
from initat.cluster.backbone import factories
from django.core.exceptions import ValidationError
from django.db.models import Q
_c_dict = {
entry.enum_name: entry
for entry in ConfigServiceEnum.objects.all()
}
print("ServiceEnums defined: {:d}".format(len(icswServiceEnum)))
_list = logging_tools.new_form_list()
for entry in icswServiceEnum:
if entry.name not in _c_dict:
if options.sync and (entry.value.server_service
or entry.value.relayer_service):
new_entry = ConfigServiceEnum.create_db_entry(entry)
_c_dict[new_entry.enum_name] = new_entry
else:
_db_str = "no"
if entry.name in _c_dict:
if options.sync:
_c_dict[entry.name].update_values(entry)
_db_str = "yes ({:d})".format(_c_dict[entry.name].pk)
if entry.value.server_service:
_egg_action = ", ".join(
[unicode(_action)
for _action in entry.value.egg_actions]) or "none"
else:
_egg_action = "---"
_list.append([
logging_tools.form_entry(entry.name, header="EnumName"),
logging_tools.form_entry(entry.value.name, header="Name"),
logging_tools.form_entry_center(
"yes" if entry.value.root_service else "no",
header="Root Service"),
logging_tools.form_entry_center(
"yes" if entry.value.server_service else "no",
header="Server"),
logging_tools.form_entry_center(
"yes" if entry.value.relayer_service else "no",
header="Relayer"),
logging_tools.form_entry(entry.value.info, header="Info"),
logging_tools.form_entry_center(_db_str, header="DB info"),
logging_tools.form_entry(_egg_action, header="Egg actions"),
])
print(unicode(_list))
if options.sync:
_change_list = []
# compat dict
comp_dict = {
"rrd_grapher": icswServiceEnum.grapher_server.name,
"rrd_server": icswServiceEnum.collectd_server.name,
"rrd_collector": icswServiceEnum.collectd_server.name,
"server": icswServiceEnum.cluster_server.name,
"ldap_server": icswServiceEnum.ldap_server.name,
}
for c_con in config.objects.all():
if not c_con.config_service_enum_id:
_check_names = [c_con.name]
if c_con.name in comp_dict:
_check_names.append(comp_dict[c_con.name])
for _check_name in _check_names:
if _check_name in _c_dict:
c_con.config_service_enum = _c_dict[_check_name]
try:
c_con.save(update_fields=["config_service_enum"])
except ValidationError:
print("cannot save {}: {}".format(
unicode(c_con),
process_tools.get_except_info()))
else:
_change_list.append(c_con)
break
_create_list = []
sys_cc = config_catalog.objects.get(Q(system_catalog=True))
for db_enum in _c_dict.itervalues():
if not db_enum.config_set.all().count():
_create_list.append(
factories.Config(
name=db_enum.name,
description=db_enum.info,
config_service_enum=db_enum,
config_catalog=sys_cc,
server_config=True,
# system_config=True,
))
if len(_change_list):
print("")
print("{} moved to ConfigServiceEnum:".format(
logging_tools.get_plural("Config", len(_change_list))))
for entry in _change_list:
print(" {} ({})".format(entry.name,
unicode(entry.config_service_enum)))
if len(_create_list):
print("")
print("{} created:".format(
logging_tools.get_plural("Config", len(_create_list))))
for entry in _create_list:
print(" {} ({})".format(entry.name,
unicode(entry.config_service_enum)))
def _recv_command(self, zmq_sock):
body = zmq_sock.recv()
if zmq_sock.getsockopt(zmq.RCVMORE): # @UndefinedVariable
_src_id = body
body = zmq_sock.recv()
parameter_ok = False
xml_input = body.startswith("<")
if self.__verbose > 3:
self.log("received {:d} bytes, xml_input is {}".format(len(body), str(xml_input)))
if xml_input:
srv_com = server_command.srv_command(source=body)
srv_com.set_result("no reply set", server_command.SRV_REPLY_STATE_UNSET)
try:
host = srv_com.xpath(".//ns:host", smart_strings=False)[0].text
snmp_version = int(srv_com.xpath(".//ns:snmp_version", smart_strings=False)[0].text)
snmp_community = srv_com.xpath(".//ns:snmp_community", smart_strings=False)[0].text
comline = srv_com.xpath(".//ns:command", smart_strings=False)[0].text
timeout = int(srv_com.get(".//ns:timeout", "10"))
except:
self._send_return(body, limits.mon_STATE_CRITICAL, "message format error: {}".format(process_tools.get_except_info()))
else:
envelope = srv_com["identity"].text
parameter_ok = True
if len(srv_com.xpath(".//ns:arg_list/text()", smart_strings=False)):
comline = " ".join([comline] + srv_com.xpath(".//ns:arg_list/text()", smart_strings=False)[0].strip().split())
else:
srv_com = None
if body.count(";") >= 3:
if body.startswith(";"):
# new format
proto_version, body = body[1:].split(";", 1)
else:
proto_version, body = ("0", body)
proto_version = int(proto_version)
if proto_version == 0:
parts = body.split(";", 4)
parts.insert(4, "10")
else:
parts = body.split(";", 5)
envelope = parts.pop(0)
# parse new format
if parts[4].endswith(";"):
com_part = parts[4][:-1]
else:
com_part = parts[4].split(";")
# iterative parser
try:
arg_list = []
while com_part.count(";"):
cur_size, cur_str = com_part.split(";", 1)
cur_size = int(cur_size)
com_part = cur_str[cur_size + 1:]
arg_list.append(cur_str[:cur_size].decode("utf-8"))
if com_part:
raise ValueError("not fully parsed ({})".format(com_part))
except:
self.log("error parsing %s" % (body), logging_tools.LOG_LEVEL_ERROR)
arg_list = []
host, snmp_version, snmp_community, timeout = parts[0:4]
timeout = int(timeout)
comline = " ".join(arg_list)
# print host, snmp_version, snmp_community, timeout, arg_list
parameter_ok = True
# envelope, host, snmp_version, snmp_community, comline = body.split(";", 4)
if parameter_ok:
try:
snmp_version = int(snmp_version)
comline_split = comline.split()
scheme = comline_split.pop(0)
except:
self._send_return(envelope, limits.mon_STATE_CRITICAL, "message format error: {}".format(process_tools.get_except_info()))
else:
self.__ret_dict[envelope] = time.time()
if scheme in self.__local_schemes:
act_scheme, s_type = (self.__local_schemes[scheme], "L")
elif scheme in self.__gen_schemes:
act_handler, s_type = (self.__gen_schemes[scheme], "G")
elif scheme == "list_schemes":
_out_list = logging_tools.new_form_list()
for _s_name in sorted(self.__local_schemes):
try:
_scheme = self.__local_schemes[_s_name](dummy_init=True, options="")
except:
pass
else:
_out_list.append(
[
logging_tools.form_entry("local", header="type"),
logging_tools.form_entry(_s_name, header="name"),
logging_tools.form_entry(len(_scheme.requests), header="#reqs"),
logging_tools.form_entry(", ".join(sorted([repr(_req) for _req in _scheme.requests])), header="requests"),
]
)
for _s_name in sorted(self.__gen_schemes):
_scheme = self.__gen_schemes[_s_name]
_out_list.append(
[
logging_tools.form_entry("generic", header="type"),
logging_tools.form_entry(_s_name, header="name"),
]
)
self._send_return(envelope, limits.mon_STATE_OK, unicode(_out_list))
s_type = None
else:
guess_list = ", ".join(difflib.get_close_matches(scheme, self.__local_schemes.keys() + self.__gen_schemes.keys()))
err_str = "got unknown scheme '{}'{}".format(
scheme,
", maybe one of {}".format(guess_list) if guess_list else ", no similar scheme found"
)
self._send_return(envelope, limits.mon_STATE_CRITICAL, err_str)
s_type = None
if s_type:
host = self._resolve_address(host)
host_obj = self._get_host_object(host, snmp_community, snmp_version)
if self.__verbose:
self.log(
"got request for scheme {} (host {}, community {}, version {:d}, envelope {}, timeout {:d})".format(
scheme,
host,
snmp_community,
snmp_version,
envelope,
timeout,
)
)
try:
if s_type == "L":
act_scheme = act_scheme(
net_obj=host_obj,
envelope=envelope,
options=comline_split,
xml_input=xml_input,
srv_com=srv_com,
init_time=time.time(),
timeout=timeout,
)
else:
act_scheme = SNMPGeneralScheme(
net_obj=host_obj,
envelope=envelope,
options=comline_split,
xml_input=xml_input,
srv_com=srv_com,
init_time=time.time(),
timeout=timeout,
handler=act_handler,
)
except IOError:
err_str = "error while creating scheme {}: {}".format(
scheme,
process_tools.get_except_info()
)
self._send_return(envelope, limits.mon_STATE_CRITICAL, err_str)
else:
if act_scheme.get_errors():
err_str = "problem in creating scheme {}: {}".format(
scheme,
", ".join(act_scheme.get_errors())
)
self._send_return(envelope, limits.mon_STATE_CRITICAL, err_str)
else:
self._start_snmp_fetch(act_scheme)
elif not xml_input:
self._send_return(envelope, limits.mon_STATE_CRITICAL, "message format error")
self.__num_messages += 1
if self.__verbose > 3:
self.log("recv() done")
if not self.__num_messages % 100:
cur_mem = process_tools.get_mem_info(self.CC.msi_block.get_unique_pids() if self.CC.msi_block else 0)
self.log(
"memory usage is {} after {}".format(
logging_tools.get_size_str(cur_mem),
logging_tools.get_plural("message", self.__num_messages)
)
)
if not self.__num_messages % 50:
# log process usage
self.log(self.spc.get_usage())
def interpret(self, srv_com, cur_ns):
_fe = logging_tools.form_entry
def proc_line(_ps, **kwargs):
nest = kwargs.get("nest", 0)
if _psutil:
_affinity = _ps["cpu_affinity"]
if len(_affinity) == num_cores:
_affinity = "-"
else:
_affinity = ",".join(
["{:d}".format(_core) for _core in _affinity])
pass
else:
_affinity = _ps.get("affinity", "-")
return [
_fe("{}{:d}".format(" " * nest, _ps["pid"]), header="pid"),
_fe(_ps["ppid"], header="ppid"),
_fe(_ps["uids"][0] if _psutil else proc_stuff["uid"],
header="uid"),
_fe(_ps["gids"][0] if _psutil else proc_stuff["gid"],
header="gid"),
_fe(_ps["state"], header="state"),
_fe(_ps.get("last_cpu", -1), header="cpu"),
_fe(_affinity, header="aff"),
_fe(_ps["out_name"], header="process"),
]
def draw_tree(m_pid, nest=0):
proc_stuff = result[m_pid]
r_list = [proc_line(proc_stuff, nest=nest)]
# _fe("%s%s" % (" " * nest, m_pid), header="pid"),
for dt_entry in [
draw_tree(y, nest + 2) for y in result[m_pid]["childs"]
]:
r_list.extend([z for z in dt_entry])
return r_list
tree_view = cur_ns.tree
comline_view = cur_ns.comline
if cur_ns.filter:
name_re = re.compile("^.*%s.*$" % ("|".join(cur_ns.filter)),
re.IGNORECASE)
tree_view = False
else:
name_re = re.compile(".*")
result = srv_com["process_tree"]
_psutil = "psutil" in srv_com
if _psutil:
num_cores = srv_com["*num_cores"]
# unpack and cast pid to integer
result = {
int(key): value
for key, value in process_tools.decompress_struct(
result.text).iteritems()
}
for _val in result.itervalues():
_val["state"] = process_tools.PROC_STATUSES_REV[_val["status"]]
# print etree.tostring(srv_com.tree, pretty_print=True)
ret_state = limits.mon_STATE_CRITICAL
pids = sorted([
key for key, value in result.iteritems()
if name_re.match(value["name"])
])
for act_pid in pids:
proc_stuff = result[act_pid]
proc_name = proc_stuff["name"] if proc_stuff["exe"] else "[%s]" % (
proc_stuff["name"])
if comline_view:
proc_name = " ".join(proc_stuff.get("cmdline")) or proc_name
proc_stuff["out_name"] = proc_name
ret_a = [
"found {} matching {}".format(
logging_tools.get_plural("process", len(pids)),
name_re.pattern)
]
form_list = logging_tools.new_form_list()
if tree_view:
for act_pid in pids:
result[act_pid]["childs"] = [
pid for pid in pids if result[pid]["ppid"] == int(act_pid)
]
for init_pid in [pid for pid in pids if not result[pid]["ppid"]]:
form_list.extend(
[add_line for add_line in draw_tree(init_pid)])
else:
form_list.extend([proc_line(result[_pid]) for _pid in pids])
if form_list:
ret_a.extend(str(form_list).split("\n"))
return ret_state, "\n".join(ret_a)
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 interpret(self, srv_com, cur_ns):
l_dict = {}
for key in IPMI_LONG_LIMITS:
try:
l_dict[key] = float(getattr(cur_ns, key))
except:
l_dict[key] = None
s_list = srv_com.xpath(".//ns:sensor_list", smart_strings=False)
if s_list:
s_list = s_list[0]
if cur_ns.arguments:
el = s_list[0]
cur_value = float(el.attrib["value"])
ret_state = limits.mon_STATE_OK
for t_name, log, t_state in [
("lowern", False, limits.mon_STATE_CRITICAL),
("lowerc", False, limits.mon_STATE_CRITICAL),
("lowerw", False, limits.mon_STATE_WARNING),
("upperw", True, limits.mon_STATE_WARNING),
("upperc", True, limits.mon_STATE_CRITICAL),
("uppern", True, limits.mon_STATE_CRITICAL),
]:
if l_dict[t_name] is not None:
if (log and cur_value >= l_dict[t_name]) or (
not log and cur_value <= l_dict[t_name]):
ret_state = max(ret_state, t_state)
return ret_state, "{}: {} is {:.2f} {}".format(
el.attrib["key"],
el.attrib["info"],
cur_value,
el.attrib["unit"],
)
else:
# list mode
keys = s_list.xpath(".//@key", smart_strings=False)
out_list = logging_tools.new_form_list()
for key in keys:
el = s_list.xpath("*[@key='{}']".format(key),
smart_strings=False)[0]
v_list = [
logging_tools.form_entry(key, header="key"),
logging_tools.form_entry_right(el.attrib["value"],
header="value"),
logging_tools.form_entry_right(el.attrib["base"],
header="base"),
logging_tools.form_entry(el.attrib["unit"],
header="unit"),
logging_tools.form_entry(el.attrib["info"],
header="info"),
]
for l_key in IPMI_LIMITS:
x_key = "limit_{}".format(l_key)
v_list.append(
logging_tools.form_entry(el.attrib.get(x_key, "-"),
header=x_key))
out_list.append(v_list)
return limits.mon_STATE_OK, "found {}:\n{}".format(
logging_tools.get_plural("IPMI sensor", len(keys)),
unicode(out_list))
else:
return limits.mon_STATE_WARNING, "no IPMI sensors found"
def main(options):
options.overview = True if (not options.stat and not options.index
and not options.num) else False
options.index = [int(cur_idx) for cur_idx in options.index]
err_file_name = os.path.join(LOG_ROOT, "logging-server", "err_py")
if not os.path.isfile(err_file_name):
print("{} does not exist".format(err_file_name))
sys.exit(1)
if options.clear:
new_file_name = "{}_{}.tar".format(
err_file_name, time.strftime("%Y-%m-%d_%H:%M:%S",
time.localtime()))
if process_tools.find_file("xz"):
_pf = ".xz"
_compr = "J"
c_stat, out = commands.getstatusoutput("tar cpJf {}{} {}".format(
new_file_name, _pf, err_file_name))
elif process_tools.find_file("bzip2"):
_pf = ".bz2"
_compr = "j"
c_stat, out = commands.getstatusoutput("tar cpjf {}{} {}".format(
new_file_name, _pf, err_file_name))
else:
_pf = ""
_compr = ""
print("taring {} to {}{} ...".format(err_file_name, new_file_name,
_pf))
c_stat, out = commands.getstatusoutput("tar cp{}f {}{} {}".format(
_compr, new_file_name, _pf, err_file_name))
if c_stat:
print("*** error (%d): %s" % (c_stat, out))
else:
os.unlink(err_file_name)
sys.exit(c_stat)
try:
err_lines = [
line.strip()
for line in file(err_file_name, "r").read().split("\n")
if line.count("from pid")
]
except IOError:
print("Cannot read '{}': {}".format(err_file_name,
process_tools.get_except_info()))
sys.exit(1)
print("Found error_file {} with {}".format(
err_file_name, logging_tools.get_plural("line", len(err_lines))))
errs_found, act_err = ([], None)
act_idx, idx_dict, prev_dt = (0, {}, None)
for line in err_lines:
line_parts = line.split(":")
# date is always the first 4 parts
line_date = ":".join(line_parts[0:3]).strip()
info_part = line_parts[3].strip()
err_line = ":".join(line_parts[4:])
# parse info_part
try:
if info_part.startswith("("):
line_state = ""
else:
line_state = info_part.split()[0]
info_part = info_part[len(line_state):].strip()
info_parts = info_part.split()
# skip error-thread name and "from pid" string
info_parts.pop(0)
info_parts.pop(0)
info_parts.pop(0)
except:
print("Error pre-parsing line '{}': {}".format(
line, process_tools.get_except_info()))
else:
try:
# get pid
line_pid = int(info_parts.pop(0))
# unknown or full source
if len(info_parts) == 7:
# full source
line_s_name = info_parts[0][1:]
line_uid = int(info_parts[2])
line_uname = info_parts[3][1:-2]
line_gid = int(info_parts[5])
line_gname = info_parts[6][1:-3]
else:
line_s_name = info_parts[0][1:-1]
line_uid, line_gid = (-1, -1)
line_uname, line_gname = ("unknown", "unknown")
cur_dt = datetime.datetime.strptime(line_date,
"%a %b %d %H:%M:%S %Y")
if prev_dt:
dt_change = abs(cur_dt - prev_dt).seconds > 5
else:
dt_change = False
prev_dt = cur_dt
if not act_err or act_err.pid != line_pid or dt_change or line.count(
"<type"):
act_idx += 1
act_err = ErrorRecord(
line_pid,
line_s_name,
line_uid,
line_uname,
line_gid,
line_gname,
)
act_err.set_idx(act_idx)
idx_dict[act_idx] = act_err
errs_found.append(act_err)
if err_line.strip() or not options.noempty:
act_err.add_line(line_date, line_state, err_line)
except:
print("Error parsing line '%s': %s" %
(line, process_tools.get_except_info()))
print("Found {}".format(
logging_tools.get_plural("error record", len(errs_found))))
if options.overview:
if errs_found:
out_list = logging_tools.new_form_list()
for err in errs_found:
out_list.append(err.get_form_parts())
print(unicode(out_list))
elif options.stat:
uid_dict = {}
for err in errs_found:
uid_dict.setdefault(err.uid, []).append(err)
all_uids = uid_dict.keys()
all_uids.sort()
out_list = logging_tools.new_form_list()
for uid in all_uids:
uid_stuff = uid_dict[uid]
diff_sources = []
for err in uid_stuff:
if err.source_name not in diff_sources:
diff_sources.append(err.source_name)
diff_sources.sort()
out_list.append((
logging_tools.form_entry(uid, header="uid"),
logging_tools.form_entry(uid_stuff[0].uname, header="uname"),
logging_tools.form_entry(len(uid_stuff), header="# err"),
logging_tools.form_entry(len(diff_sources),
header="# sources"),
logging_tools.form_entry(", ".join(diff_sources),
header="sources"),
))
print(unicode(out_list))
elif options.num:
idx_l = idx_dict.keys()
idx_l.sort()
idx_show = []
while options.num and idx_l:
options.num -= 1
idx_show.append(idx_l.pop(-1))
idx_show.reverse()
options.index = idx_show
if options.index:
for idx in options.index:
if idx in idx_dict:
act_err = idx_dict[idx]
print(act_err.get_header())
print(act_err.show_lines())
else:
print("Index {:d} not in index_list {}".format(
idx, logging_tools.compress_num_list(idx_dict.keys())))
def _call(self, cur_inst):
file_list = []
server_idxs = [self.server_idx]
# get additional idx if host is virtual server
print("*** IS_SERVER FIXME TODO")
is_server, serv_idx, _server_type, _server_str, _config_idx, _real_server_name = cluster_location.is_server(
"server", True, False)
if is_server and serv_idx != self.server_idx:
server_idxs.append(serv_idx)
# recognize for which devices i am responsible
dev_r = cluster_location.DeviceRecognition()
server_idxs = list(set(server_idxs) | set(dev_r.device_dict.keys()))
# get all peers to local machine and local netdevices
my_idxs = netdevice.objects.exclude(Q(enabled=False)).filter(
Q(device__in=server_idxs) & Q(device__enabled=True)
& Q(device__device_group__enabled=True)).values_list("pk",
flat=True)
# ref_table
route_obj = RouterObject(cur_inst.log)
all_paths = []
for s_ndev in my_idxs:
all_paths.extend(
networkx.shortest_path(route_obj.nx, s_ndev,
weight="weight").values())
# pprint.pprint(all_paths)
nd_lut = {
cur_nd.pk: cur_nd
for cur_nd in netdevice.objects.all().select_related(
"device").prefetch_related("net_ip_set", "net_ip_set__network",
"net_ip_set__domain_tree_node")
}
# fetch key-information
ssh_vars = device_variable.objects.filter(
Q(name="ssh_host_rsa_key_pub")).select_related("device")
rsa_key_dict = {}
for _db_rec in ssh_vars:
pass
# read pre/post lines from /etc/hosts
pre_host_lines, post_host_lines = ([], [])
# parse pre/post host_lines
try:
host_lines = [
line.strip() for line in codecs.open(
ETC_HOSTS_FILENAME, "r", "utf-8").read().split("\n")
]
except:
self.log(
"error reading / parsing {}: {}".format(
ETC_HOSTS_FILENAME, process_tools.get_except_info()),
logging_tools.LOG_LEVEL_ERROR)
else:
mode, any_modes_found = (0, False)
for line in host_lines:
if line.lower().startswith("### aeh-start-pre"):
mode, any_modes_found = (1, True)
elif line.lower().startswith("### aeh-start-post"):
mode, any_modes_found = (2, True)
elif line.lower().startswith("### aeh-end"):
mode, any_modes_found = (0, True)
else:
if mode == 1:
pre_host_lines.append(line)
elif mode == 2:
post_host_lines.append(line)
if not any_modes_found:
self.log("no ### aeh-.* stuff found in {}, copying to {}.orig".
format(ETC_HOSTS_FILENAME, ETC_HOSTS_FILENAME))
try:
pass
except:
self.log("error writing {}.orig: {}".format(
ETC_HOSTS_FILENAME, process_tools.get_except_info()))
# mapping from device_name to all names for ssh_host_keys
name_dict = {}
# ip dictionary
ip_dict = {}
# min_target_dict
min_target_dict = {}
for cur_path in all_paths:
min_value = route_obj.get_penalty(cur_path)
target_nd = nd_lut[cur_path[-1]]
min_target_dict[target_nd] = min(
min_target_dict.get(target_nd, 999999999), min_value)
tl_dtn = domain_tree_node.objects.get(Q(depth=0))
for cur_path in all_paths:
target_nd = nd_lut[cur_path[-1]]
min_value = min_target_dict[target_nd]
for cur_ip in nd_lut[cur_path[-1]].net_ip_set.all():
# get names
host_names = []
cur_dtn = cur_ip.domain_tree_node or tl_dtn
if not (cur_ip.alias.strip() and cur_ip.alias_excl):
host_names.append("{}{}".format(target_nd.device.name,
cur_dtn.node_postfix))
host_names.extend([
"{}".format(cur_entry)
for cur_entry in cur_ip.alias.strip().split()
])
if "localhost" in [x.split(".")[0] for x in host_names]:
host_names = [
host_name for host_name in host_names
if host_name.split(".")[0] == "localhost"
]
if cur_dtn.full_name:
if cur_dtn.create_short_names:
# also create short_names
out_names = (" ".join([
"{}.{} {}".format(host_name, cur_dtn.full_name,
host_name)
for host_name in host_names
if not host_name.count(".")
])).split()
else:
# only print the long names
out_names = [
"{}.{}".format(host_name, cur_dtn.full_name)
for host_name in host_names
if not host_name.count(".")
]
else:
if cur_dtn.create_short_names:
# also create short_names
out_names = (" ".join([
"{}".format(host_name) for host_name in host_names
if not host_name.count(".")
])).split()
else:
# only print the long names
out_names = [
"{}".format(host_name) for host_name in host_names
if not host_name.count(".")
]
# add names with dot
out_names.extend([
host_name for host_name in host_names
if host_name.count(".")
])
# name_dict without localhost
name_dict.setdefault(target_nd.device.name, []).extend([
out_name for out_name in out_names
if out_name not in name_dict[target_nd.device.name]
and not out_name.startswith("localhost")
])
ip_dict.setdefault(cur_ip.ip, [])
if out_names not in [entry[1] for entry in ip_dict[cur_ip.ip]]:
if cur_ip.ip != "0.0.0.0":
ip_dict[cur_ip.ip].append((min_value, out_names))
# out_list
loc_dict = {}
for ip, h_list in ip_dict.iteritems():
all_values = sorted([entry[0] for entry in h_list])
if all_values:
min_value = all_values[0]
out_names = []
for val in all_values:
for _act_val, act_list in [(x_value, x_list)
for x_value, x_list in h_list
if x_value == val]:
out_names.extend([
value for value in act_list
if value not in out_names
])
# print min_value, ip, out_names
loc_dict.setdefault(
min_value, []).append([ipvx_tools.ipv4(ip)] + out_names)
pen_list = sorted(loc_dict.keys())
out_file = []
for pen_value in pen_list:
act_out_list = logging_tools.new_form_list()
for entry in sorted(loc_dict[pen_value]):
act_out_list.append(
[logging_tools.form_entry(entry[0])] +
[logging_tools.form_entry(cur_e) for cur_e in entry[1:]])
host_lines = str(act_out_list).split("\n")
out_file.extend([
"# penalty {:d}, {}".format(
pen_value,
logging_tools.get_plural("host entry", len(host_lines))),
""
] + host_lines + [""])
if not os.path.isdir(GROUP_DIR):
try:
os.makedirs(GROUP_DIR)
except:
pass
if os.path.isdir(GROUP_DIR):
# remove old files
for file_name in os.listdir(GROUP_DIR):
try:
os.unlink(os.path.join(GROUP_DIR, file_name))
except:
pass
# get all devices with netips
all_devs = device.objects.filter(
Q(enabled=True) & Q(device_group__enabled=True)
& Q(netdevice__net_ip__ip__contains=".")).values_list(
"name",
"device_group__name").order_by("device_group__name",
"name")
dg_dict = {}
for dev_name, dg_name in all_devs:
dg_dict.setdefault(dg_name, []).append(dev_name)
for file_name, content in dg_dict.iteritems():
codecs.open(os.path.join(GROUP_DIR, file_name), "w",
"utf-8").write(
"\n".join(sorted(set(content)) + [""]))
file_list.append(ETC_HOSTS_FILENAME)
codecs.open(ETC_HOSTS_FILENAME, "w+", "utf-8").write(
"\n".join(["### AEH-START-PRE insert pre-host lines below"] +
pre_host_lines +
["### AEH-END-PRE insert pre-host lines above", ""] +
out_file +
["", "### AEH-START-POST insert post-host lines below"] +
post_host_lines +
["### AEH-END-POST insert post-host lines above", ""]))
# write known_hosts_file
if os.path.isdir(os.path.dirname(SSH_KNOWN_HOSTS_FILENAME)):
skh_f = file(SSH_KNOWN_HOSTS_FILENAME, "w")
for ssh_key_node in sorted(rsa_key_dict.keys()):
skh_f.write("{} {}\n".format(
",".join(name_dict.get(ssh_key_node, [ssh_key_node])),
rsa_key_dict[ssh_key_node]))
skh_f.close()
file_list.append(SSH_KNOWN_HOSTS_FILENAME)
cur_inst.srv_com.set_result("wrote {}".format(", ".join(
sorted(file_list))))
def device_syslog(opt_ns, cur_dev, j_logs):
print(
u"Information about device '{}' (full name {}, devicegroup {})".format(
unicode(cur_dev), unicode(cur_dev.full_name),
unicode(cur_dev.device_group)))
print("UUID is '{}', database-ID is {:d}".format(cur_dev.uuid, cur_dev.pk))
_cr = routing.SrvTypeRouting(force=True, ignore_errors=True)
_ST = "logcheck-server"
if _ST in _cr.service_types:
_inst_xml = InstanceXML(quiet=True)
# get logcheck-server IP
_ls_ip = _cr[_ST][0][1]
# get logcheck-server Port
_ls_port = _inst_xml.get_port_dict(_ST, ptype="command")
_sc = server_command.srv_command(command="get_syslog", )
_sc["devices"] = _sc.builder(
"devices", *[
_sc.builder(
"device",
pk="{:d}".format(cur_dev.pk),
lines="{:d}".format(opt_ns.loglines),
minutes="{:d}".format(opt_ns.minutes),
)
])
_conn_str = "tcp://{}:{:d}".format(_ls_ip, _ls_port)
_result = net_tools.ZMQConnection("icsw_state_{:d}".format(
os.getpid())).add_connection(
_conn_str,
_sc,
)
if _result is not None:
_dev = _result.xpath(".//ns:devices/ns:device[@pk]")[0]
_lines = _result.xpath("ns:lines", start_el=_dev)[0]
_rates = _result.xpath("ns:rates", start_el=_dev)
if _rates:
_rates = {
int(_el.get("timeframe")): float(_el.get("rate"))
for _el in _rates[0]
}
print("rate info: {}".format(", ".join([
"{:.2f} lines/sec in {}".format(
_rates[_seconds],
logging_tools.get_diff_time_str(_seconds))
for _seconds in sorted(_rates)
])))
else:
print("no rate info found")
print(_rates)
_out_lines = logging_tools.new_form_list()
for _entry in process_tools.decompress_struct(_lines.text):
_out_lines.append([
logging_tools.form_entry(_entry["line_id"], header="idx"),
logging_tools.form_entry(
"{:04d}-{:02d}-{:02d} {:02d}:{:02d}:{:02d}".format(
*_entry["line_datetime_parsed"]),
header="Timestamp",
),
] + [
logging_tools.form_entry(_entry[_key], header=_key)
for _key in ["hostname", "priority", "facility", "tag"]
] + [
logging_tools.form_entry(_entry["text"], header="text"),
])
print(unicode(_out_lines))
else:
print("got no result from {} ({})".format(_conn_str, _ST))
else:
print("No logcheck-server found, skipping syslog display")
def interpret(self, srv_com, cur_ns):
r_dict = server_command.decompress(srv_com["pkg_list"].text,
pickle=True)
root_dir = srv_com["root_dir"].text
in_format = srv_com["format"].text
out_f = logging_tools.new_form_list()
keys = sorted(r_dict.keys())
header_line = "{} found, system is {} (root is {})".format(
logging_tools.get_plural("package", len(keys)),
in_format,
root_dir,
)
if keys:
if in_format == "rpm":
for key in keys:
for value in r_dict[key]:
if type(value) is tuple:
if len(value) == 4:
ver, rel, arch, summary = value
size = 0
else:
ver, rel, arch, size, summary = value
else:
ver, rel, arch, size, summary = (value["version"],
value["release"],
value["arch"],
value["size"],
value["summary"])
out_f.append([
logging_tools.form_entry(key, header="name"),
logging_tools.form_entry_right(ver,
header="version"),
logging_tools.form_entry(rel, header="release"),
logging_tools.form_entry(arch, header="arch"),
logging_tools.form_entry_right(size,
header="size"),
logging_tools.form_entry(summary,
header="summary"),
])
elif in_format == "debian":
for key in keys:
for value in r_dict[key]:
d_flag, s_flag, e_flag = value["flags"]
ver, rel = (value["version"], value["release"])
summary = value["summary"]
out_f.append([
logging_tools.form_entry(key, header="name"),
logging_tools.form_entry_right(d_flag,
header="d_flag"),
logging_tools.form_entry_right(s_flag,
header="s_flag"),
logging_tools.form_entry_right(e_flag,
header="e_flag"),
logging_tools.form_entry_right(ver,
header="version"),
logging_tools.form_entry(rel, header="release"),
logging_tools.form_entry(summary,
header="summary"),
])
out_f.add_line(
(key, d_flag, s_flag, e_flag, ver, rel, summary))
return limits.mon_STATE_OK, "{}\n{}".format(
header_line, str(out_f))
else:
return limits.mon_STATE_CRITICAL, "{}, nothing found".format(
header_line)
