def page(self) -> cmk.gui.pages.PageResult:
breadcrumb = make_simple_page_breadcrumb(
mega_menu_registry["help_links"], _("Info"))
make_header(
html,
self._title(),
breadcrumb=breadcrumb,
)
html.open_div(id_="info_title")
html.h1(_("Your monitoring machine"))
html.a(
HTMLWriter.render_img(theme.url("images/tribe29.svg")),
"https://tribe29.com",
target="_blank",
)
html.close_div()
html.div(None, id_="info_underline")
html.open_div(id_="info_intro_text")
html.span(_("Open. Effective. Awesome."))
html.span(
_("May we present? Monitoring as it's supposed to be: "
"incredibly quick to install, infinetely scalable, highly customizable and "
"designed for admins."))
html.span(
_("Visit our %s to learn more about Checkmk and about the %s.") % (
HTMLWriter.render_a(
_("website"), "https://checkmk.com", target="_blank"),
HTMLWriter.render_a(
_("latest version"),
"https://checkmk.com/product/latest-version",
target="_blank",
),
))
html.close_div()
version_major_minor = re.sub(r".\d+$", "",
Version(__version__).version_base)
if version_major_minor:
current_version_link = "https://checkmk.com/product/checkmk-%s" % version_major_minor
else:
current_version_link = "https://checkmk.com/product/latest-version"
html.open_div(id="info_image")
html.open_a(href=current_version_link, target="_blank")
html.img(theme.url("images/monitoring-machine.png"))
html.close_a()
html.close_div()
html.close_div()
html.open_div(id_="info_footer")
html.span(
_("© %s tribe29 GmbH. All Rights Reserved.") % time.strftime("%Y"))
html.a(_("License agreement"),
href="https://checkmk.com/legal.html",
target="_blank")
html.close_div()
def query_limit_exceeded_warn(limit: Optional[int], user_config: LoggedInUser) -> None:
"""Compare query reply against limits, warn in the GUI about incompleteness"""
text = HTML(_("Your query produced more than %d results. ") % limit)
if request.get_ascii_input("limit", "soft") == "soft" and user_config.may(
"general.ignore_soft_limit"
):
text += HTMLWriter.render_a(
_("Repeat query and allow more results."),
target="_self",
href=makeuri(request, [("limit", "hard")]),
)
elif request.get_ascii_input("limit") == "hard" and user_config.may(
"general.ignore_hard_limit"
):
text += HTMLWriter.render_a(
_("Repeat query without limit."),
target="_self",
href=makeuri(request, [("limit", "none")]),
)
text += escaping.escape_to_html_permissive(
" " + _("<b>Note:</b> the shown results are incomplete and do not reflect the sort order.")
)
html.show_warning(text)
def test_render_a(request_context):
a = HTMLWriter.render_a("bla", href="blu", class_=["eee"], target="_blank")
assert compare_html(a, '<a href="blu" target="_blank" class="eee">bla</a>')
a = HTMLWriter.render_a(
"b<script>alert(1)</script>la",
href="b<script>alert(1)</script>lu",
class_=["eee"],
target="_blank",
)
assert compare_html(
a,
'<a href="b<script>alert(1)</script>lu" target="_blank" '
'class="eee">b<script>alert(1)</script>la</a>',
)
def paint(self, value, hostname):
value = convert_cgroups_from_tuple(value)
texts: List[HTML] = []
self.load_data()
if self._contactgroups is None: # conditional caused by horrible API
raise Exception("invalid contact groups")
items = self._contactgroups.items()
for name, cgroup in sorted(items, key=lambda x: x[1]["alias"]):
if name in value["groups"]:
display_name = cgroup.get("alias", name)
texts.append(
HTMLWriter.render_a(
display_name,
href=makeuri_contextless(
request,
[("mode", "edit_contact_group"), ("edit", name)],
filename="wato.py",
),
))
result: HTML = HTML(", ").join(texts)
if texts and value["use"]:
result += HTMLWriter.render_span(
HTMLWriter.render_b("*"),
title=
_("These contact groups are also used in the monitoring configuration."
),
)
return "", result
def render_object_ref_as_icon(
object_ref: Optional[ObjectRef]) -> Optional[HTML]:
if object_ref is None:
return None
url, title = _get_object_reference(object_ref)
if not url:
return None
icons = {
ObjectRefType.Host: "host",
ObjectRefType.Folder: "folder",
ObjectRefType.User: "******",
ObjectRefType.Rule: "rule",
ObjectRefType.Ruleset: "rulesets",
}
return HTMLWriter.render_a(
content=html.render_icon(
icons.get(object_ref.object_type, "link"),
title="%s: %s" %
(object_ref.object_type.name, title) if title else None,
),
href=url,
)
def render_tree_folder(tree_id, folder, js_func):
subfolders = folder.get(".folders", {}).values()
is_leaf = len(subfolders) == 0
# Suppress indentation for non-emtpy root folder
if folder[".path"] == "" and is_leaf:
html.open_ul() # empty root folder
elif folder and folder[".path"] != "":
html.open_ul(style="padding-left:0px;")
title = HTMLWriter.render_a(
"%s (%d)" % (folder["title"], folder[".num_hosts"]),
href="#",
class_="link",
onclick="%s(this, '%s');" % (js_func, folder[".path"]),
)
if not is_leaf:
with foldable_container(
treename=tree_id,
id_="/" + folder[".path"],
isopen=False,
title=HTML(title),
icon="foldable_sidebar",
padding=6,
):
for subfolder in sorted(subfolders, key=lambda x: x["title"].lower()):
render_tree_folder(tree_id, subfolder, js_func)
else:
html.li(title)
html.close_ul()
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 show_log_list():
title = _("All problematic logfiles")
breadcrumb = make_simple_page_breadcrumb(
mega_menu_registry.menu_monitoring(), title)
make_header(html, title, breadcrumb, _log_list_page_menu(breadcrumb))
if request.has_var("_ack") and not request.var("_do_actions") == _("No"):
do_log_ack(site=None, host_name=None, file_name=None)
return
for site, host_name, logs in all_logs():
if not logs:
continue
all_logs_empty = not any(
parse_file(site, host_name, file_name) for file_name in logs)
if all_logs_empty:
continue # Logfile vanished
html.h3(
HTMLWriter.render_a(
host_name,
href=makeuri(
request,
[("site", site), ("host", host_name)],
),
),
class_="table",
)
list_logs(site, host_name, logs)
html.footer()
def list_logs(site, host_name, logfile_names):
with table_element(empty_text=_("No logs found for this host.")) as table:
for file_name in logfile_names:
table.row()
file_display = form_file_to_ext(file_name)
uri = makeuri(request, [("site", site), ("host", host_name),
("file", file_display)])
logfile_link = HTMLWriter.render_a(file_display, href=uri)
try:
log_chunks = parse_file(site, host_name, file_name)
if not log_chunks:
continue # Logfile vanished
worst_log = get_worst_chunk(log_chunks)
last_log = get_last_chunk(log_chunks)
state = worst_log["level"]
state_name = form_level(state)
table.cell(_("Level"), state_name, css=["state%d" % state])
table.cell(_("Logfile"), logfile_link)
table.cell(_("Last Entry"),
form_datetime(last_log["datetime"]))
table.cell(_("Entries"), len(log_chunks), css=["number"])
except Exception:
if active_config.debug:
raise
table.cell(_("Level"), "")
table.cell(_("Logfile"), logfile_link)
table.cell(_("Last Entry"), "")
table.cell(_("Entries"), _("Corrupted"))
def _render_tree(self, tree):
for group, attrs in tree.items():
aggr_group_tree = "/".join(attrs["__path__"])
fetch_url = makeuri_contextless(
request,
[
("view_name", "aggr_all"),
("aggr_group_tree", aggr_group_tree),
],
filename="view.py",
)
if attrs.get("__children__"):
with foldable_container(
treename="bi_aggregation_group_trees",
id_=aggr_group_tree,
isopen=False,
title=HTML(
HTMLWriter.render_a(
group,
href=fetch_url,
target="main",
)),
icon="foldable_sidebar",
):
self._render_tree(attrs["__children__"])
else:
html.open_ul()
bulletlink(group, fetch_url)
html.close_ul()
def render(self, row: Row, cell: Cell) -> CellSpec:
classes = ["perfometer"]
if is_stale(row):
classes.append("stale")
try:
title, h = Perfometer(row).render()
if title is None and h is None:
return "", ""
except Exception as e:
logger.exception("error rendering performeter")
if active_config.debug:
raise
return " ".join(classes), _("Exception: %s") % e
assert h is not None
content = (HTMLWriter.render_div(HTML(h), class_=["content"]) +
HTMLWriter.render_div(title, class_=["title"]) +
HTMLWriter.render_div("", class_=["glass"]))
# pnpgraph_present: -1 means unknown (path not configured), 0: no, 1: yes
if display_options.enabled(
display_options.X) and row["service_pnpgraph_present"] != 0:
url = cmk_graph_url(row, "service")
disabled = False
else:
url = "javascript:void(0)"
disabled = True
return " ".join(classes), HTMLWriter.render_a(
content=content,
href=url,
title=escaping.strip_tags(title),
class_=["disabled"] if disabled else [],
)
def render_object_ref(
object_ref: Optional[ObjectRef]) -> Union[str, HTML, None]:
url, title = _get_object_reference(object_ref)
if title and not url:
return title
if not title:
return None
return HTMLWriter.render_a(title, href=url)
def paint(self, value, hostname):
parts = [
HTMLWriter.render_a(
hn, "wato.py?" + urlencode_vars([("mode", "edit_host"),
("host", hn)]))
for hn in value
]
return "", HTML(", ").join(parts)
def text_with_links_to_user_translated_html(
elements: Iterable[Tuple[str, Optional[str]]],
separator: str = "",
) -> HTML:
return HTML(separator).join(
HTMLWriter.render_a(user_translation, href=url, title=user_translation
) if url else escape_to_html_permissive(
user_translation, escape_links=False)
for txt, url in elements for user_translation in [_u(txt)] if txt)
def render(self, row, cell):
url = makeuri_contextless(
request,
[
("crash_id", row["crash_id"]),
("site", row["site"]),
],
filename="crash.py",
)
return (None, HTMLWriter.render_a(row["crash_id"], href=url))
def _render_rule_reason(self, title, title_url, reason, reason_url,
is_default, setting: Union[str, HTML]) -> None:
if title_url:
title = HTMLWriter.render_a(title, href=title_url)
forms.section(title)
if reason:
reason = HTMLWriter.render_a(reason, href=reason_url)
html.open_table(class_="setting")
html.open_tr()
if is_default:
html.td(HTMLWriter.render_i(reason), class_="reason")
html.td(setting, class_=["settingvalue", "unused"])
else:
html.td(reason, class_="reason")
html.td(setting, class_=["settingvalue", "used"])
html.close_tr()
html.close_table()
def _show_row_cells(self, table: Table, name: GroupName,
group: GroupSpec) -> None:
super()._show_row_cells(table, name, group)
table.cell(_("Members"))
html.write_html(
HTML(", ").join([
HTMLWriter.render_a(
alias,
href=folder_preserving_link([("mode", "edit_user"),
("edit", userid)]),
) for userid, alias in self._members.get(name, [])
]))
def test_HTMLWriter(request_context):
with output_funnel.plugged():
with output_funnel.plugged():
html.open_div()
text = output_funnel.drain()
assert text.rstrip("\n").rstrip(" ") == "<div>"
with output_funnel.plugged():
# html.open_div().write("test").close_div()
html.open_div()
html.write_text("test")
html.close_div()
assert compare_html(output_funnel.drain(), "<div>test</div>")
with output_funnel.plugged():
# html.open_table().open_tr().td("1").td("2").close_tr().close_table()
html.open_table()
html.open_tr()
html.td("1")
html.td("2")
html.close_tr()
html.close_table()
assert compare_html(
output_funnel.drain(),
"<table><tr><td>1</td><td>2</td></tr></table>")
with output_funnel.plugged():
html.div("test", **{"</div>malicious_code<div>": "trends"})
assert compare_html(
output_funnel.drain(),
"<div </div>malicious_code<div>=trends>test</div>",
)
a = "\u2665"
with output_funnel.plugged():
assert HTMLWriter.render_a("test", href="www.test.case")
HTMLWriter.render_a("test", href="www.test.case")
HTMLWriter.render_a("test", href="www.test.case")
HTMLWriter.render_a("test", href="www.test.case")
try:
assert HTMLWriter.render_a(
"test",
href=str("www.test.case"),
id_=str("something"),
class_=str("test_%s") % a,
)
except Exception as e:
traceback.print_exc()
print(e)
def page(self):
with table_element("roles") as table:
users = userdb.load_users()
for rid, role in sorted(self._roles.items(), key=lambda a: (a[1]["alias"], a[0])):
table.row()
# Actions
table.cell(_("Actions"), css=["buttons"])
edit_url = folder_preserving_link([("mode", "edit_role"), ("edit", rid)])
clone_url = make_action_link([("mode", "roles"), ("_clone", rid)])
delete_url = make_confirm_link(
url=make_action_link([("mode", "roles"), ("_delete", rid)]),
message=_("Do you really want to delete the role %s?") % rid,
)
html.icon_button(edit_url, _("Properties"), "edit")
html.icon_button(clone_url, _("Clone"), "clone")
if not role.get("builtin"):
html.icon_button(delete_url, _("Delete this role"), "delete")
# ID
table.cell(_("Name"), rid)
# Alias
table.cell(_("Alias"), role["alias"])
# Type
table.cell(_("Type"), _("builtin") if role.get("builtin") else _("custom"))
# Modifications
table.cell(
_("Modifications"),
HTMLWriter.render_span(
str(len(role["permissions"])),
title=_("That many permissions do not use the factory defaults."),
),
)
# Users
table.cell(
_("Users"),
HTML(", ").join(
[
HTMLWriter.render_a(
user.get("alias", user_id),
folder_preserving_link([("mode", "edit_user"), ("edit", user_id)]),
)
for (user_id, user) in users.items()
if rid in user["roles"]
]
),
)
def _render_tag_group(
tag_group_id_or_label_key: Union[TaggroupID, str],
tag_id_or_label_value: Union[TagID, str],
object_type: str,
with_link: bool,
label_type: str,
label_source: str,
) -> HTML:
span = HTMLWriter.render_tag(
HTMLWriter.render_div(
HTMLWriter.render_span(
"%s:%s"
% (
tag_group_id_or_label_key,
tag_id_or_label_value,
),
class_=["tagify__tag-text"],
)
),
class_=["tagify--noAnim", label_source],
)
if not with_link:
return span
if label_type == "tag_group":
type_filter_vars: HTTPVariables = [
("%s_tag_0_grp" % object_type, tag_group_id_or_label_key),
("%s_tag_0_op" % object_type, "is"),
("%s_tag_0_val" % object_type, tag_id_or_label_value),
]
elif label_type == "label":
type_filter_vars = [
(
"%s_label" % object_type,
json.dumps(
[{"value": "%s:%s" % (tag_group_id_or_label_key, tag_id_or_label_value)}]
),
),
]
else:
raise NotImplementedError()
url_vars: HTTPVariables = [
("filled_in", "filter"),
("search", "Search"),
("view_name", "searchhost" if object_type == "host" else "searchsvc"),
]
url = makeuri_contextless(request, url_vars + type_filter_vars, filename="view.py")
return HTMLWriter.render_a(span, href=url)
def _tag_tree_bullet(self, state, path, leaf) -> HTML:
code = HTMLWriter.render_div(
" ",
class_=["tagtree"] + (["leaf"] if leaf else []) +
["statebullet", "state%d" % state],
)
if not leaf:
code = HTMLWriter.render_a(
code,
href="javascript:virtual_host_tree_enter('%s');" %
"|".join(path),
title=_("Display the tree only below this node"),
)
return code + " "
def get_host_list_links(site: SiteId, hosts: List[Union[str]]) -> List[str]:
entries = []
for host in hosts:
args: HTTPVariables = [
("view_name", "hoststatus"),
("site", site),
("host", host),
]
if request.var("display_options"):
args.append(("display_options", request.var("display_options")))
url = makeuri_contextless(request, args, filename="view.py")
link = str(HTMLWriter.render_a(host, href=url))
entries.append(link)
return entries
def insert_manpage_links(text: str) -> HTML:
parts = text.replace(",", " ").split()
new_parts: List[HTML] = []
check_regex = re.compile(r"[-_\.a-z0-9]")
for part in parts:
if check_regex.match(part) and os.path.exists(
cmk.utils.paths.check_manpages_dir + "/" + part):
url = makeuri_contextless(
request,
[
("mode", "check_manpage"),
("check_type", part),
],
filename="wato.py",
)
new_parts.append(HTMLWriter.render_a(content=part, href=url))
else:
new_parts.append(escape_to_html(part))
return HTML(" ").join(new_parts)
def render_link(text: Union[str, HTML],
url: str,
target: str = "main",
onclick: Optional[str] = None) -> HTML:
# Convert relative links into absolute links. We have three kinds
# of possible links and we change only [3]
# [1] protocol://hostname/url/link.py
# [2] /absolute/link.py
# [3] relative.py
if not (":" in url[:10]
) and not url.startswith("javascript") and url[0] != "/":
url = url_prefix() + "check_mk/" + url
return HTMLWriter.render_a(
text,
href=url,
class_="link",
target=target or "",
onfocus="if (this.blur) this.blur();",
onclick=onclick or None,
)
def paint_aggr_hosts(row, link_to_view):
h = []
for site, host in row["aggr_hosts"]:
url = makeuri(request, [("view_name", link_to_view), ("site", site), ("host", host)])
h.append(HTMLWriter.render_a(host, url))
return "", HTML(" ").join(h)
def _render_tag_tree_level(self, tree_spec, path, cwd, title,
tree) -> None:
if not self._is_tag_subdir(
path=path, cwd=cwd) and not self._is_tag_subdir(path=cwd,
cwd=path):
return
container: ContextManager[bool] = nullcontext(False)
if path != cwd and self._is_tag_subdir(path, cwd):
bullet = self._tag_tree_bullet(self._tag_tree_worst_state(tree),
path, False)
if self._tag_tree_has_svc_problems(tree):
bullet += html.render_icon_button(
self._tag_tree_url(tree_spec, path, "svcproblems"),
_("Show the service problems contained in this branch"),
"svc_problems",
target="main",
)
if path:
container = foldable_container(
treename="tag-tree",
id_=".".join(map(str, path)),
isopen=False,
title=bullet + title,
icon="foldable_sidebar",
)
with container:
for (node_title, node_value), subtree in sorted(
tree.get("_children", {}).items()):
subpath = path + [node_value or ""]
url = self._tag_tree_url(tree_spec, subpath, "allhosts")
if "_num_hosts" in subtree:
node_title += " (%d)" % subtree["_num_hosts"]
node_title = HTMLWriter.render_a(node_title,
href=url,
target="main")
if "_children" not in subtree:
if self._is_tag_subdir(path, cwd):
html.write_html(
self._tag_tree_bullet(subtree.get("_state", 0),
subpath, True))
if subtree.get("_svc_problems"):
url = self._tag_tree_url(tree_spec, subpath,
"svcproblems")
html.icon_button(
url,
_("Show the service problems contained in this branch"
),
"svc_problems",
target="main",
)
html.write_html(node_title)
html.br()
else:
self._render_tag_tree_level(tree_spec, subpath, cwd,
node_title, subtree)
def _show_configuration_variables(self) -> None:
search = self._search
at_least_one_painted = False
html.open_div(class_="globalvars")
for group, config_variables in self.iter_all_configuration_variables():
header_is_painted = False # needed for omitting empty groups
for config_variable in config_variables:
varname = config_variable.ident()
valuespec = config_variable.valuespec()
if self._show_only_modified and varname not in self._current_settings:
continue
help_text = valuespec.help() or ""
title_text = valuespec.title() or ""
if (search and search not in group.title().lower() and search
not in config_variable.domain().ident().lower()
and search not in varname
and search not in help_text.lower()
and search not in title_text.lower()):
continue # skip variable when search is performed and nothing matches
at_least_one_painted = True
if not header_is_painted:
# always open headers when searching
forms.header(group.title(),
isopen=search or self._show_only_modified)
header_is_painted = True
default_value = self._default_values[varname]
edit_url = folder_preserving_link([
("mode", self.edit_mode_name),
("varname", varname),
("site", request.var("site", "")),
])
title = HTMLWriter.render_a(
title_text,
href=edit_url,
class_="modified"
if varname in self._current_settings else None,
title=escaping.strip_tags(help_text),
)
if varname in self._current_settings:
value = self._current_settings[varname]
elif varname in self._global_settings:
value = self._global_settings[varname]
else:
value = default_value
try:
to_text = valuespec.value_to_html(value)
except Exception:
logger.exception("error converting %r to text", value)
to_text = html.render_error(
_("Failed to render value: %r") % value)
# Is this a simple (single) value or not? change styling in these cases...
simple = True
if "\n" in to_text or "<td>" in to_text:
simple = False
forms.section(title, simple=simple)
if varname in self._current_settings:
modified_cls = ["modified"]
value_title: Optional[str] = _(
"This option has been modified.")
elif varname in self._global_settings:
modified_cls = ["modified globally"]
value_title = _(
"This option has been modified in global settings.")
else:
modified_cls = []
value_title = None
if is_a_checkbox(valuespec):
html.open_div(class_=["toggle_switch_container"] +
modified_cls + (["on"] if value else []))
html.toggle_switch(
enabled=value,
help_txt=_("Immediately toggle this setting"),
href=makeactionuri(request, transactions,
[("_action", "toggle"),
("_varname", varname)]),
class_=modified_cls,
title=value_title,
)
html.close_div()
else:
html.a(to_text,
href=edit_url,
class_=modified_cls,
title=value_title)
if header_is_painted:
forms.end()
if not at_least_one_painted and search:
html.show_message(
_("Did not find any global setting matching your search."))
html.close_div()
def _show_service_info(self, all_rulesets):
assert self._service is not None
serviceinfo = analyse_service(
self._host.site_id(),
self._hostname,
self._service,
).service_info
if not serviceinfo:
return
forms.header(_("Check origin and parameters"),
isopen=True,
narrow=True,
css="rulesettings")
origin = serviceinfo["origin"]
origin_txt = {
"active": _("Active check"),
"static": _("Manual check"),
"auto": _("Inventorized check"),
"classic": _("Classical check"),
}[origin]
self._render_rule_reason(_("Type of check"), None, "", "", False,
origin_txt)
# First case: discovered checks. They come from var/check_mk/autochecks/HOST.
if origin == "auto":
checkgroup = serviceinfo["checkgroup"]
checktype = serviceinfo["checktype"]
if not checkgroup:
self._render_rule_reason(
_("Parameters"),
None,
"",
"",
True,
_("This check is not configurable via WATO"),
)
# Logwatch needs a special handling, since it is not configured
# via checkgroup_parameters but via "logwatch_rules" in a special
# WATO module.
elif checkgroup == "logwatch":
rulespec = rulespec_registry["logwatch_rules"]
self._output_analysed_ruleset(
all_rulesets,
rulespec,
svc_desc_or_item=serviceinfo["item"],
svc_desc=self._service,
known_settings=serviceinfo["parameters"],
)
else:
# Note: some discovered checks have a check group but
# *no* ruleset for discovered checks. One example is "ps".
# That can be configured as a manual check or created by
# inventory. But in the later case all parameters are set
# by the inventory. This will be changed in a later version,
# but we need to address it anyway.
grouprule = "checkgroup_parameters:" + checkgroup
if grouprule not in rulespec_registry:
try:
rulespec = rulespec_registry["static_checks:" +
checkgroup]
except KeyError:
self._render_rule_reason(
_("Parameters"),
None,
"",
"",
True,
_("This check is not configurable via WATO"),
)
return
url = folder_preserving_link([
("mode", "edit_ruleset"),
("varname", "static_checks:" + checkgroup),
("host", self._hostname),
])
assert isinstance(rulespec.valuespec, Tuple)
self._render_rule_reason(
_("Parameters"),
url,
_("Determined by discovery"),
None,
False,
rulespec.valuespec._elements[2].value_to_html(
serviceinfo["parameters"]),
)
else:
rulespec = rulespec_registry[grouprule]
self._output_analysed_ruleset(
all_rulesets,
rulespec,
svc_desc_or_item=serviceinfo["item"],
svc_desc=self._service,
known_settings=serviceinfo["parameters"],
)
elif origin == "static":
checkgroup = serviceinfo["checkgroup"]
checktype = serviceinfo["checktype"]
if not checkgroup:
html.write_text(_("This check is not configurable via WATO"))
else:
rulespec = rulespec_registry["static_checks:" + checkgroup]
itemspec = rulespec.item_spec
if itemspec:
item_text = itemspec.value_to_html(serviceinfo["item"])
assert rulespec.item_spec is not None
title = rulespec.item_spec.title()
else:
item_text = serviceinfo["item"]
title = _("Item")
self._render_rule_reason(title, None, "", "", False, item_text)
self._output_analysed_ruleset(
all_rulesets,
rulespec,
svc_desc_or_item=serviceinfo["item"],
svc_desc=self._service,
known_settings=self._PARAMETERS_OMIT,
)
assert isinstance(rulespec.valuespec, Tuple)
html.write_text(rulespec.valuespec._elements[2].value_to_html(
serviceinfo["parameters"]))
html.close_td()
html.close_tr()
html.close_table()
elif origin == "active":
checktype = serviceinfo["checktype"]
rulespec = rulespec_registry["active_checks:" + checktype]
self._output_analysed_ruleset(
all_rulesets,
rulespec,
svc_desc_or_item=None,
svc_desc=None,
known_settings=serviceinfo["parameters"],
)
elif origin == "classic":
ruleset = all_rulesets.get("custom_checks")
origin_rule_result = self._get_custom_check_origin_rule(
ruleset, self._hostname, self._service)
if origin_rule_result is None:
raise MKUserError(
None,
_("Failed to determine origin rule of %s / %s") %
(self._hostname, self._service),
)
rule_folder, rule_index, rule = origin_rule_result
url = folder_preserving_link([("mode", "edit_ruleset"),
("varname", "custom_checks"),
("host", self._hostname)])
forms.section(HTMLWriter.render_a(_("Command Line"), href=url))
url = folder_preserving_link([
("mode", "edit_rule"),
("varname", "custom_checks"),
("rule_folder", rule_folder.path()),
("rule_id", rule.id),
("host", self._hostname),
])
html.open_table(class_="setting")
html.open_tr()
html.open_td(class_="reason")
html.a("%s %d %s %s" %
(_("Rule"), rule_index + 1, _("in"), rule_folder.title()),
href=url)
html.close_td()
html.open_td(class_=["settingvalue", "used"])
if "command_line" in serviceinfo:
html.tt(serviceinfo["command_line"])
else:
html.write_text(_("(no command line, passive check)"))
html.close_td()
html.close_tr()
html.close_table()
self._show_labels(serviceinfo.get("labels", {}), "service",
serviceinfo.get("label_sources", {}))
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: Rule) -> str:
return folder_preserving_link([
("mode", "edit_rule"),
("varname", varname),
("rule_folder", rule.folder.path()),
("rule_id", rule.id),
("host", self._hostname),
(
"item",
mk_repr(svc_desc_or_item).decode()
if svc_desc_or_item else "",
),
("service", mk_repr(svc_desc).decode() if svc_desc else ""),
])
varname = rulespec.name
valuespec = rulespec.valuespec
url = folder_preserving_link([
("mode", "edit_ruleset"),
("varname", varname),
("host", self._hostname),
("item", mk_repr(svc_desc_or_item).decode()),
("service", mk_repr(svc_desc).decode()),
])
forms.section(HTMLWriter.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.span(_("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_text(valuespec.value_to_html(known_settings))
except Exception as e:
if active_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 Rulespec.NO_FACTORY_DEFAULT
and rulespec.factory_default
is not 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 Rulespec.FACTORY_DEFAULT_UNUSED:
# Some rulesets are ineffective if they are empty
html.write_text(_("(unused)"))
elif rulespec.factory_default is not Rulespec.NO_FACTORY_DEFAULT:
# If there is a factory default then show that one
setting = rulespec.factory_default
html.write_text(valuespec.value_to_html(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_text(
valuespec.value_to_html(valuespec.default_value()))
# We have a setting
elif valuespec:
if ruleset.match_type() == "all":
for s in setting:
html.write_text(valuespec.value_to_html(s))
else:
html.write_text(valuespec.value_to_html(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(icon_name, title=_("yes") if setting else _("no"))
html.close_td()
html.close_tr()
html.close_table()
def render_werk_id(werk, with_link) -> Union[HTML, str]:
if with_link:
url = makeuri_contextless(request, [("werk", werk["id"])],
filename="werk.py")
return HTMLWriter.render_a("#%04d" % werk["id"], href=url)
return "#%04d" % werk["id"]