def _submit_via_command_pipe(host, service, state, output): # type: (HostName, ServiceName, ServiceState, ServiceDetails) -> None output = output.replace("\n", "\\n") _open_command_pipe() if _nagios_command_pipe is not None and not isinstance(_nagios_command_pipe, bool): # [<timestamp>] PROCESS_SERVICE_CHECK_RESULT;<host_name>;<svc_description>;<return_code>;<plugin_output> _nagios_command_pipe.write( "[%d] PROCESS_SERVICE_CHECK_RESULT;%s;%s;%d;%s\n" % (int(time.time()), host, make_utf8(service), state, make_utf8(output))) # Important: Nagios needs the complete command in one single write() block! # Python buffers and sends chunks of 4096 bytes, if we do not flush. _nagios_command_pipe.flush()
def _output_check_result(servicedesc, state, infotext, perftexts): if _show_perfdata: infotext_fmt = "%-56s" p = ' (%s)' % (" ".join(perftexts)) else: p = '' infotext_fmt = "%s" console.verbose("%-20s %s%s" + infotext_fmt + "%s%s\n", servicedesc.encode('utf-8'), tty.bold, tty.states[state], make_utf8(infotext.split('\n')[0]), tty.normal, make_utf8(p))
def export_rule_pack(rule_pack, pretty_print=False, dir_=None): # type: (Dict[str, Any], bool, Optional[Path]) -> None """ Export the representation of a rule pack (i.e. a dict) to a .mk file accessible by the WATO module Extension Packages. In case of a MkpRulePackProxy the representation of the underlying rule pack is used. The name of the .mk file is determined by the ID of the rule pack, i.e. the rule pack 'test' will be saved as 'test.mk' By default the rule pack is saved to the default directory for mkp rule packs. If dir_ is given the default is replaced by the directory dir_. """ if isinstance(rule_pack, MkpRulePackProxy): rule_pack = rule_pack.rule_pack repr_ = (pprint.pformat(rule_pack) if pretty_print else repr(rule_pack)) output = ("# Written by WATO\n" "# encoding: utf-8\n" "\n" "mkp_rule_packs['%s'] = \\\n" "%s\n") % (rule_pack['id'], repr_) if not dir_: dir_ = mkp_rule_pack_dir() dir_.mkdir(parents=True, exist_ok=True) store.save_file(str(dir_ / ("%s.mk" % rule_pack['id'])), make_utf8(output))
def check_mk_local_automation(command, args=None, indata="", stdin_data=None, timeout=None): if args is None: args = [] auto_logger = logger.getChild("automations") if timeout: args = ["--timeout", "%d" % timeout] + args cmd = ['check_mk', '--automation', command, '--'] + args if command in ['restart', 'reload']: call_hook_pre_activate_changes() cmd = [make_utf8(a) for a in cmd] try: # This debug output makes problems when doing bulk inventory, because # it garbles the non-HTML response output # if config.debug: # html.write("<div class=message>Running <tt>%s</tt></div>\n" % subprocess.list2cmdline(cmd)) auto_logger.info("RUN: %s" % subprocess.list2cmdline(cmd)) p = subprocess.Popen(cmd, stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.PIPE, close_fds=True) except Exception as e: raise _local_automation_failure(command=command, cmdline=cmd, exc=e) if stdin_data is not None: auto_logger.info("STDIN: %r" % stdin_data) p.stdin.write(stdin_data) else: auto_logger.info("STDIN: %r" % indata) p.stdin.write(repr(indata)) p.stdin.close() outdata = p.stdout.read() exitcode = p.wait() auto_logger.info("FINISHED: %d" % exitcode) auto_logger.debug("OUTPUT: %r" % outdata) errdata = p.stderr.read() if errdata: auto_logger.warning("'%s' returned '%s'" % (" ".join(cmd), errdata)) if exitcode != 0: auto_logger.error("Error running %r (exit code %d)" % (subprocess.list2cmdline(cmd), exitcode)) raise _local_automation_failure(command=command, cmdline=cmd, code=exitcode, out=outdata, err=errdata) # On successful "restart" command execute the activate changes hook if command in ['restart', 'reload']: call_hook_activate_changes() try: return ast.literal_eval(outdata) except SyntaxError as e: raise _local_automation_failure(command=command, cmdline=cmd, out=outdata, exc=e)
def print_table(headers, colors, rows, indent=""): num_columns = len(headers) lengths = _column_lengths(headers, rows, num_columns) fmt = _row_template(lengths, colors, indent) for index, row in enumerate([headers] + rows): sys.stdout.write(fmt % tuple(make_utf8(c) for c in row[:num_columns])) if index == 0: sys.stdout.write(fmt % tuple("-" * l for l in lengths))
def _submit_via_check_result_file(host, service, state, output): output = output.replace("\n", "\\n") _open_checkresult_file() if _checkresult_file_fd: now = time.time() os.write( _checkresult_file_fd, """host_name=%s service_description=%s check_type=1 check_options=0 reschedule_check latency=0.0 start_time=%.1f finish_time=%.1f return_code=%d output=%s """ % (host, make_utf8(service), now, now, state, make_utf8(output)))
def _column_lengths(headers, rows, num_columns): lengths = [len(h) for h in headers] for row in rows: for index, column in enumerate(row[:num_columns]): # FIXME alignment by reference to lengths of utf-8 strings? # column can be None, str, data structures, ... if not isinstance(column, six.string_types): column = six.binary_type(column) lengths[index] = max(len(make_utf8(column)), lengths[index]) return lengths
def execute(self, cmd, args): # type: (str, List[str]) -> Any self._handle_generic_arguments(args) try: try: automation = self._automations[cmd] except KeyError: raise MKAutomationError( "Automation command '%s' is not implemented." % cmd) if automation.needs_checks: config.load_all_checks(check_api.get_check_api_context) if automation.needs_config: config.load(validate_hosts=False) result = automation.execute(args) except (MKAutomationError, MKTimeout) as e: console.error("%s\n" % make_utf8("%s" % e)) if cmk.utils.debug.enabled(): raise return 1 except Exception as e: if cmk.utils.debug.enabled(): raise console.error("%s\n" % make_utf8("%s" % e)) return 2 finally: profiling.output_profile() if cmk.utils.debug.enabled(): console.output(pprint.pformat(result) + "\n") else: console.output("%r\n" % (result, )) return 0
def save_rule_packs(rule_packs, pretty_print=False, dir_=None): # type: (List[Dict[str, Any]], bool, Optional[Path]) -> None """Saves the given rule packs to rules.mk. By default they are saved to the default directory for rule packs. If dir_ is given it is used instead of the default.""" output = "# Written by WATO\n# encoding: utf-8\n\n" if pretty_print: rule_packs_text = pprint.pformat(rule_packs) else: rule_packs_text = repr(rule_packs) output += "rule_packs += \\\n%s\n" % rule_packs_text if not dir_: dir_ = rule_pack_dir() dir_.mkdir(parents=True, exist_ok=True) store.save_file(str(dir_ / "rules.mk"), make_utf8(output))
def dump_host(hostname): # type: (HostName) -> None config_cache = config.get_config_cache() host_config = config_cache.get_host_config(hostname) console.output("\n") if host_config.is_cluster: nodes = host_config.nodes if nodes is None: raise RuntimeError() color = tty.bgmagenta add_txt = " (cluster of " + (", ".join(nodes)) + ")" else: color = tty.bgblue add_txt = "" console.output( "%s%s%s%-78s %s\n" % (color, tty.bold, tty.white, hostname + add_txt, tty.normal)) ipaddress = _ip_address_for_dump_host(host_config) addresses = "" # type: Optional[str] if not host_config.is_ipv4v6_host: addresses = ipaddress else: try: if host_config.is_ipv6_primary: secondary = _ip_address_for_dump_host(host_config, 4) else: secondary = _ip_address_for_dump_host(host_config, 6) except Exception: secondary = "X.X.X.X" addresses = "%s, %s" % (ipaddress, secondary) if host_config.is_ipv6_primary: addresses += " (Primary: IPv6)" else: addresses += " (Primary: IPv4)" console.output(tty.yellow + "Addresses: " + tty.normal + (addresses if addresses is not None else "No IP") + "\n") tag_template = tty.bold + "[" + tty.normal + "%s" + tty.bold + "]" + tty.normal tags = [(tag_template % ":".join(t)) for t in sorted(host_config.tag_groups.iteritems())] console.output(tty.yellow + "Tags: " + tty.normal + ", ".join(tags) + "\n") labels = [(tag_template % ":".join(l)).encode("utf-8") for l in sorted(host_config.labels.iteritems())] console.output(tty.yellow + "Labels: " + tty.normal + ", ".join(labels) + "\n") # TODO: Clean this up once cluster parent handling has been moved to HostConfig if host_config.is_cluster: parents_list = host_config.nodes if parents_list is None: raise RuntimeError() else: parents_list = host_config.parents if len(parents_list) > 0: console.output(tty.yellow + "Parents: " + tty.normal + ", ".join(parents_list) + "\n") console.output(tty.yellow + "Host groups: " + tty.normal + make_utf8(", ".join(host_config.hostgroups)) + "\n") console.output(tty.yellow + "Contact groups: " + tty.normal + make_utf8(", ".join(host_config.contactgroups)) + "\n") agenttypes = [] sources = data_sources.DataSources(hostname, ipaddress) for source in sources.get_data_sources(): agenttypes.append(source.describe()) if host_config.is_ping_host: agenttypes.append('PING only') console.output(tty.yellow + "Agent mode: " + tty.normal) console.output(sources.describe_data_sources() + "\n") console.output(tty.yellow + "Type of agent: " + tty.normal) if len(agenttypes) == 1: console.output(agenttypes[0] + "\n") else: console.output("\n ") console.output("\n ".join(agenttypes) + "\n") console.output(tty.yellow + "Services:" + tty.normal + "\n") headers = ["checktype", "item", "params", "description", "groups"] colors = [tty.normal, tty.blue, tty.normal, tty.green, tty.normal] table_data = [] # type: tty.TableRows for service in sorted(check_table.get_check_table(hostname).values(), key=lambda s: s.description): table_data.append( (service.check_plugin_name, make_utf8("%s" % service.item), _evaluate_params(service.parameters), make_utf8(service.description), make_utf8(",".join( config_cache.servicegroups_of_service(hostname, service.description))))) tty.print_table(headers, colors, table_data, " ")