def _render_manpage_list(titles, manpage_list, path_comp, heading):
def translate(t):
return titles.get(t, t)
html.h3(heading)
with table_element(searchable=False, sortable=False,
css="check_catalog") as table:
for entry in sorted(manpage_list, key=lambda x: x["title"]):
if not isinstance(entry, dict):
continue
table.row()
url = makeuri(
request,
[
("mode", "check_manpage"),
("check_type", entry["name"]),
("back", makeuri(request, [])),
],
)
table.cell(_("Type of Check"),
HTMLWriter.render_a(entry["title"], href=url),
css=["title"])
table.cell(_("Plugin Name"),
HTMLWriter.render_tt(entry["name"]),
css=["name"])
table.cell(_("Agents"),
", ".join(map(translate, sorted(entry["agents"]))),
css=["agents"])
def value_to_html(self, value: Optional[str]) -> ValueSpecText:
return HTMLWriter.render_tt(value)
def _show_patterns(self):
import cmk.gui.logwatch as logwatch
collection = SingleRulesetRecursively("logwatch_rules")
collection.load()
ruleset = collection.get("logwatch_rules")
html.h3(_("Logfile patterns"))
if ruleset.is_empty():
html.open_div(class_="info")
html.write_text(
"There are no logfile patterns defined. You may create "
'logfile patterns using the <a href="%s">Rule Editor</a>.' %
folder_preserving_link([
("mode", "edit_ruleset"),
("varname", "logwatch_rules"),
]))
html.close_div()
# Loop all rules for this ruleset
already_matched = False
abs_rulenr = 0
for folder, rulenr, rule in ruleset.get_rules():
# Check if this rule applies to the given host/service
if self._hostname:
service_desc = self._get_service_description(
self._hostname, "logwatch", self._item)
# If hostname (and maybe filename) try match it
rule_matches = rule.matches_host_and_item(
Folder.current(), self._hostname, self._item, service_desc)
else:
# If no host/file given match all rules
rule_matches = True
with foldable_container(
treename="rule",
id_=str(abs_rulenr),
isopen=True,
title=HTML("<b>Rule #%d</b>" % (abs_rulenr + 1)),
indent=False,
), table_element("pattern_editor_rule_%d" % abs_rulenr,
sortable=False,
css="logwatch") as table:
abs_rulenr += 1
# TODO: What's this?
pattern_list = rule.value
if isinstance(pattern_list, dict):
pattern_list = pattern_list["reclassify_patterns"]
# Each rule can hold no, one or several patterns. Loop them all here
for state, pattern, comment in pattern_list:
match_class = ""
disp_match_txt = HTML("")
match_img = ""
if rule_matches:
# Applies to the given host/service
matched = re.search(pattern, self._match_txt)
if matched:
# Prepare highlighted search txt
match_start = matched.start()
match_end = matched.end()
disp_match_txt = (
escape_to_html(self._match_txt[:match_start]) +
HTMLWriter.render_span(
self._match_txt[match_start:match_end],
class_="match") +
escape_to_html(self._match_txt[match_end:]))
if not already_matched:
# First match
match_class = "match first"
match_img = "match"
match_title = _(
"This logfile pattern matches first and will be used for "
"defining the state of the given line.")
already_matched = True
else:
# subsequent match
match_class = "match"
match_img = "imatch"
match_title = _(
"This logfile pattern matches but another matched first."
)
else:
match_img = "nmatch"
match_title = _(
"This logfile pattern does not match the given string."
)
else:
# rule does not match
match_img = "nmatch"
match_title = _("The rule conditions do not match.")
table.row()
table.cell(_("Match"))
html.icon("rule%s" % match_img, match_title)
cls = ([
"state%d" %
logwatch.level_state(state), "fillbackground"
] if match_class == "match first" else [])
table.cell(_("State"),
HTMLWriter.render_span(
logwatch.level_name(state)),
css=cls)
table.cell(_("Pattern"), HTMLWriter.render_tt(pattern))
table.cell(_("Comment"), comment)
table.cell(_("Matched line"), disp_match_txt)
table.row(fixed=True)
table.cell(colspan=5)
edit_url = folder_preserving_link([
("mode", "edit_rule"),
("varname", "logwatch_rules"),
("rulenr", rulenr),
("item", mk_repr(self._item).decode()),
("rule_folder", folder.path()),
("rule_id", rule.id),
])
html.icon_button(edit_url, _("Edit this rule"), "edit")
