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 ])))