def rule_url(rule):
return watolib.folder_preserving_link([
('mode', 'edit_rule'),
('varname', varname),
('rule_folder', rule.folder.path()),
('rulenr', rule.index()),
('host', self._hostname),
('item', ensure_str(watolib.mk_repr(svc_desc_or_item)) if svc_desc_or_item else ''),
('service', ensure_str(watolib.mk_repr(svc_desc)) if svc_desc else ''),
])
def rule_url(rule: Rule) -> str:
return watolib.folder_preserving_link([
('mode', 'edit_rule'),
('varname', varname),
('rule_folder', rule.folder.path()),
('rule_id', rule.id),
('host', self._hostname),
('item', watolib.mk_repr(svc_desc_or_item).decode()
if svc_desc_or_item else ''),
('service',
watolib.mk_repr(svc_desc).decode() if svc_desc else ''),
])
def rule_url(rule: Rule) -> str:
return watolib.folder_preserving_link(
[
("mode", "edit_rule"),
("varname", varname),
("rule_folder", rule.folder.path()),
("rule_id", rule.id),
("host", self._hostname),
(
"item",
watolib.mk_repr(svc_desc_or_item).decode() if svc_desc_or_item else "",
),
("service", watolib.mk_repr(svc_desc).decode() if svc_desc else ""),
]
)
def _execute_push_profile(self):
try:
response.set_data(str(watolib.mk_repr(self._automation_push_profile())))
except Exception as e:
logger.exception("error pushing profile")
if config.debug:
raise
response.set_data(_("Internal automation error: %s\n%s") % (e, traceback.format_exc()))
def _execute_push_profile(self):
try:
# Don't use write_text() here (not needed, because no HTML document is rendered)
html.write(watolib.mk_repr(self._automation_push_profile()))
except Exception as e:
logger.exception("error pushing profile")
if config.debug:
raise
html.write_text(_("Internal automation error: %s\n%s") % (e, traceback.format_exc()))
def rule_url(rule):
return watolib.folder_preserving_link([
('mode', 'edit_rule'),
('varname', varname),
('rule_folder', rule.folder.path()),
('rulenr', rule.index()),
('host', self._hostname),
('item', watolib.mk_repr(service) if service else ''),
])
def _output_analysed_ruleset(self,
all_rulesets,
rulespec,
svc_desc_or_item,
svc_desc,
known_settings=None):
if known_settings is None:
known_settings = self._PARAMETERS_UNKNOWN
def rule_url(rule):
return watolib.folder_preserving_link([
('mode', 'edit_rule'),
('varname', varname),
('rule_folder', rule.folder.path()),
('rulenr', rule.index()),
('host', self._hostname),
('item', watolib.mk_repr(svc_desc_or_item)
if svc_desc_or_item else ''),
('service', watolib.mk_repr(svc_desc) if svc_desc else ''),
])
varname = rulespec.name
valuespec = rulespec.valuespec
url = watolib.folder_preserving_link([
('mode', 'edit_ruleset'),
('varname', varname),
('host', self._hostname),
('item', watolib.mk_repr(svc_desc_or_item)),
('service', watolib.mk_repr(svc_desc)),
])
forms.section(html.render_a(rulespec.title, url))
ruleset = all_rulesets.get(varname)
setting, rules = ruleset.analyse_ruleset(self._hostname,
svc_desc_or_item, svc_desc)
html.open_table(class_="setting")
html.open_tr()
html.open_td(class_="reason")
# Show reason for the determined value
if len(rules) == 1:
rule_folder, rule_index, rule = rules[0]
url = rule_url(rule)
html.a(_("Rule %d in %s") % (rule_index + 1, rule_folder.title()),
href=rule_url(rule))
elif len(rules) > 1:
html.a("%d %s" % (len(rules), _("Rules")), href=url)
else:
html.i(_("Default Value"))
html.close_td()
# Show the resulting value or factory setting
html.open_td(
class_=["settingvalue", "used" if len(rules) > 0 else "unused"])
if isinstance(known_settings,
dict) and "tp_computed_params" in known_settings:
computed_at = known_settings["tp_computed_params"]["computed_at"]
html.write_text(
_("Timespecific parameters computed at %s") %
cmk.utils.render.date_and_time(computed_at))
html.br()
known_settings = known_settings["tp_computed_params"]["params"]
# In some cases we now the settings from a check_mk automation
if known_settings is self._PARAMETERS_OMIT:
return
# Special handling for logwatch: The check parameter is always None. The actual
# patterns are configured in logwatch_rules. We do not have access to the actual
# patterns here but just to the useless "None". In order not to complicate things
# we simply display nothing here.
if varname == "logwatch_rules":
pass
elif known_settings is not self._PARAMETERS_UNKNOWN:
try:
html.write(valuespec.value_to_text(known_settings))
except Exception as e:
if config.debug:
raise
html.write_text(
_("Invalid parameter %r: %s") % (known_settings, e))
else:
# For match type "dict" it can be the case the rule define some of the keys
# while other keys are taken from the factory defaults. We need to show the
# complete outcoming value here.
if rules and ruleset.match_type() == "dict":
if rulespec.factory_default is not watolib.Rulespec.NO_FACTORY_DEFAULT \
and rulespec.factory_default is not watolib.Rulespec.FACTORY_DEFAULT_UNUSED:
fd = rulespec.factory_default.copy()
fd.update(setting)
setting = fd
if valuespec and not rules: # show the default value
if rulespec.factory_default is watolib.Rulespec.FACTORY_DEFAULT_UNUSED:
# Some rulesets are ineffective if they are empty
html.write_text(_("(unused)"))
elif rulespec.factory_default is not watolib.Rulespec.NO_FACTORY_DEFAULT:
# If there is a factory default then show that one
setting = rulespec.factory_default
html.write(valuespec.value_to_text(setting))
elif ruleset.match_type() in ("all", "list"):
# Rulesets that build lists are empty if no rule matches
html.write_text(_("(no entry)"))
else:
# Else we use the default value of the valuespec
html.write(
valuespec.value_to_text(valuespec.default_value()))
# We have a setting
elif valuespec:
if ruleset.match_type() == "all":
html.write(", ".join(
[valuespec.value_to_text(e) for e in setting]))
else:
html.write(valuespec.value_to_text(setting))
# Binary rule, no valuespec, outcome is True or False
else:
icon_name = "rule_%s%s" % ("yes" if setting else "no",
"_off" if not rules else '')
html.icon(title=_("yes") if setting else _("no"),
icon=icon_name)
html.close_td()
html.close_tr()
html.close_table()
def _show_patterns(self):
import cmk.gui.logwatch as logwatch
collection = watolib.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>.' %
watolib.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(watolib.Folder.current(), self._hostname,
self._item, service_desc)
else:
# If no host/file given match all rules
rule_matches = True
html.begin_foldable_container("rule",
"%s" % abs_rulenr,
True,
HTML("<b>Rule #%d</b>" % (abs_rulenr + 1)),
indent=False)
with table_element("pattern_editor_rule_%d" % abs_rulenr, sortable=False) 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
reason_class = 'reason'
matched = re.search(pattern, self._match_txt)
if matched:
# Prepare highlighted search txt
match_start = matched.start()
match_end = matched.end()
disp_match_txt = html.render_text(self._match_txt[:match_start]) \
+ html.render_span(self._match_txt[match_start:match_end], class_="match")\
+ html.render_text(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
reason_class = 'noreason'
match_img = 'nmatch'
match_title = _('The rule conditions do not match.')
table.row(css=reason_class)
table.cell(_('Match'))
html.icon(match_title, "rule%s" % match_img)
cls = ''
if match_class == 'match first':
cls = 'svcstate state%d' % logwatch.level_state(state)
table.cell(_('State'), logwatch.level_name(state), css=cls)
table.cell(_('Pattern'), html.render_tt(pattern))
table.cell(_('Comment'), html.render_text(comment))
table.cell(_('Matched line'), disp_match_txt)
table.row(fixed=True)
table.cell(colspan=5)
edit_url = watolib.folder_preserving_link([
("mode", "edit_rule"),
("varname", "logwatch_rules"),
("rulenr", rulenr),
("host", self._hostname),
("item", ensure_str(watolib.mk_repr(self._item))),
("rule_folder", folder.path()),
])
html.icon_button(edit_url, _("Edit this rule"), "edit")
html.end_foldable_container()
def _show_patterns(self):
import cmk.gui.logwatch as logwatch
collection = watolib.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>.'
% watolib.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(
watolib.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])
+ html.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: List[str] = []
if match_class == "match first":
cls = ["state%d" % logwatch.level_state(state), "fillbackground"]
table.cell(_("State"), html.render_span(logwatch.level_name(state)), css=cls)
table.cell(_("Pattern"), html.render_tt(pattern))
table.cell(_("Comment"), comment)
table.cell(_("Matched line"), disp_match_txt)
table.row(fixed=True)
table.cell(colspan=5)
edit_url = watolib.folder_preserving_link(
[
("mode", "edit_rule"),
("varname", "logwatch_rules"),
("rulenr", rulenr),
("item", watolib.mk_repr(self._item).decode()),
("rule_folder", folder.path()),
("rule_id", rule.id),
]
)
html.icon_button(edit_url, _("Edit this rule"), "edit")
