def _show_aux_tag_used_by_tags(tags: Set[cmk.utils.tags.GroupedTag]) -> None:
if not tags:
return
html.open_ul()
html.open_li()
builtin_config = cmk.utils.tags.BuiltinTagConfig()
for index, tag in enumerate(sorted(tags, key=lambda t: t.choice_title)):
if index > 0:
html.write_text(", ")
# Builtin tag groups can not be edited
if builtin_config.tag_group_exists(tag.group.id):
html.write_text(_u(tag.choice_title))
else:
edit_url = watolib.folder_preserving_link([("mode", "edit_tag"),
("edit", tag.group.id)])
html.a(_u(tag.choice_title), href=edit_url)
html.close_li()
html.close_ul()
def _find_usages_in_notification_rule(self,
tpname: str,
index: int,
rule: EventRule,
user_id: _Optional[UserId] = None
) -> List[TimeperiodUsage]:
used_in: List[TimeperiodUsage] = []
if self._used_in_tp_condition(rule, tpname) or self._used_in_bulking(rule, tpname):
url = watolib.folder_preserving_link([
("mode", "notification_rule"),
("edit", index),
("user", user_id),
])
if user_id:
title = _("Notification rule of user '%s'") % user_id
else:
title = _("Notification rule")
used_in.append((title, url))
return used_in
def buttons(self):
global_buttons()
if self._host:
if self._item:
title = _("Show Logfile")
else:
title = _("Host Logfiles")
html.context_button(
title,
html.makeuri_contextless([("host", self._hostname),
("file", self._item)],
filename="logwatch.py"), 'logwatch')
html.context_button(
_('Edit Logfile Rules'),
watolib.folder_preserving_link([
('mode', 'edit_ruleset'),
('varname', 'logwatch_rules'),
]), 'edit')
def _find_usages_in_host_and_service_rules(self, tpname: str) -> List[TimeperiodUsage]:
used_in: List[TimeperiodUsage] = []
rulesets = watolib.AllRulesets()
rulesets.load()
for varname, ruleset in rulesets.get_rulesets().items():
if not isinstance(ruleset.valuespec(), watolib.timeperiods.TimeperiodSelection):
continue
for _folder, _rulenr, rule in ruleset.get_rules():
if rule.value == tpname:
used_in.append(
(
"%s: %s" % (_("Ruleset"), ruleset.title()),
watolib.folder_preserving_link(
[("mode", "edit_ruleset"), ("varname", varname)]
),
)
)
break
return used_in
def page_menu(self, breadcrumb: Breadcrumb) -> PageMenu:
page_menu: PageMenu = PageMenu(
dropdowns=[
PageMenuDropdown(
name="connections",
title=_("Connections"),
topics=[
PageMenuTopic(
title=_("Add connection"),
entries=[
PageMenuEntry(
title=_("Add connection"),
icon_name="new",
item=make_simple_link(
watolib.folder_preserving_link(
[("mode", "edit_ldap_connection")]
)
),
is_shortcut=True,
is_suggested=True,
),
],
),
],
),
PageMenuDropdown(
name="related",
title=_("Related"),
topics=[
PageMenuTopic(
title=_("Setup"),
entries=list(self._page_menu_entries_related()),
),
],
),
],
breadcrumb=breadcrumb,
inpage_search=PageMenuSearch(),
)
page_menu.add_doc_reference(title=self.title(), doc_ref=DocReference.LDAP)
return page_menu
def _page_menu_entries_synchronized_users(self) -> Iterator[PageMenuEntry]:
if userdb.sync_possible():
if not self._job_snapshot.is_active():
yield PageMenuEntry(
title=_("Start user synchronization"),
icon_name="replicate",
item=make_simple_link(html.makeactionuri([("_sync", 1)])),
)
yield PageMenuEntry(
title=_("Last synchronization result"),
icon_name="background_job_details",
item=make_simple_link(self._job.detail_url()),
)
yield PageMenuEntry(
title=_("LDAP & Active Directory"),
icon_name="ldap",
item=make_simple_link(
watolib.folder_preserving_link([("mode", "ldap_config")])),
)
def _show_tag_icons(self, tag_group, nr):
# Tag groups were made builtin with ~1.4. Previously users could modify
# these groups. These users now have the modified tag groups in their
# user configuration and should be able to cleanup this using the GUI
# for the moment. Make the buttons available to the users.
if self._builtin_config.tag_group_exists(
tag_group.id
) and not self._tag_config.tag_group_exists(tag_group.id):
html.i("(%s)" % _("builtin"))
return
edit_url = watolib.folder_preserving_link([("mode", "edit_tag"), ("edit", tag_group.id)])
html.icon_button(edit_url, _("Edit this tag group"), "edit")
html.element_dragger_url("tr", base_url=make_action_link([("mode", "tags"), ("_move", nr)]))
delete_url = make_confirm_link(
url=make_action_link([("mode", "tags"), ("_delete", tag_group.id)]),
message=_("Do you really want to delete the tag group '%s'?") % tag_group.id,
)
html.icon_button(delete_url, _("Delete this tag group"), "delete")
def action(self) -> ActionResult:
if not html.transaction_valid():
return redirect(mode_url("folder"))
attributes = watolib.collect_attributes(self._host_type_name(), new=True)
cluster_nodes = self._get_cluster_nodes()
hostname = html.request.get_ascii_input_mandatory("host")
Hostname().validate_value(hostname, "host")
folder = watolib.Folder.current()
if html.check_transaction():
folder.create_hosts([(hostname, attributes, cluster_nodes)])
self._host = folder.host(hostname)
inventory_url = watolib.folder_preserving_link([
("mode", "inventory"),
("host", self._host.name()),
("_scan", "1"),
])
create_msg = None if self._host.is_ping_host() else (
_('Successfully created the host. Now you should do a '
'<a href="%s">service discovery</a> in order to auto-configure '
'all services to be checked on this host.') % inventory_url)
if html.request.var("services"):
raise redirect(inventory_url)
if html.request.var("diag_host"):
if create_msg:
flash(create_msg)
return redirect(
mode_url("diag_host", folder=folder.path(), host=self._host.name(), _try="1"))
if create_msg:
flash(create_msg)
return redirect(mode_url("folder", folder=folder.path()))
def _page_menu_entries_this_folder(self) -> Iterator[PageMenuEntry]:
if self._folder.may("read"):
yield PageMenuEntry(
title=_("Properties"),
icon_name="edit",
item=make_simple_link(self._folder.edit_url(backfolder=self._folder)),
)
if not self._folder.locked_subfolders() and not self._folder.locked():
if self._folder.may("write") and config.user.may("wato.manage_folders"):
yield PageMenuEntry(
title=_("Add subfolder"),
icon_name="newfolder",
item=make_simple_link(self._folder.url([("mode", "newfolder")])),
is_shortcut=True,
is_suggested=True,
)
yield make_folder_status_link(watolib.Folder.current(), view_name="allhosts")
if config.user.may("wato.rulesets") or config.user.may("wato.seeall"):
yield PageMenuEntry(
title=_("Rules"),
icon_name="rulesets",
item=make_simple_link(
watolib.folder_preserving_link([
("mode", "rule_search"),
("filled_in", "rule_search"),
("folder", watolib.Folder.current().path()),
("search_p_ruleset_used", DropdownChoice.option_id(True)),
("search_p_ruleset_used_USE", "on"),
])),
)
if config.user.may("wato.auditlog"):
yield PageMenuEntry(
title=_("Audit log"),
icon_name="auditlog",
item=make_simple_link(make_object_audit_log_url(self._folder.object_ref())),
)
def _find_usages_in_notification_rule(self,
tpname,
index,
rule,
user_id=None):
used_in = []
if self._used_in_tp_condition(rule, tpname) or self._used_in_bulking(
rule, tpname):
url = watolib.folder_preserving_link([
("mode", "notification_rule"),
("edit", index),
("user", user_id),
])
if user_id:
title = _("Notification rule of user '%s'") % user_id
else:
title = _("Notification rule")
used_in.append((title, url))
return used_in
def action(self):
if not html.transaction_valid():
return "folder"
attributes = watolib.collect_attributes(self._host_type_name(),
new=True)
cluster_nodes = self._get_cluster_nodes()
hostname = html.request.get_ascii_input_mandatory("host")
Hostname().validate_value(hostname, "host")
if html.check_transaction():
watolib.Folder.current().create_hosts([(hostname, attributes,
cluster_nodes)])
self._host = watolib.Folder.current().host(hostname)
inventory_url = watolib.folder_preserving_link([
("mode", "inventory"),
("host", self._host.name()),
("_scan", "1"),
])
if not self._host.is_ping_host():
create_msg = _(
'Successfully created the host. Now you should do a '
'<a href="%s">service discovery</a> in order to auto-configure '
'all services to be checked on this host.') % inventory_url
else:
create_msg = None
if html.request.var("services"):
raise HTTPRedirect(inventory_url)
if html.request.var("diag_host"):
html.request.set_var("_try", "1")
return "diag_host", create_msg
return "folder", create_msg
def page_menu(self, breadcrumb: Breadcrumb) -> PageMenu:
return PageMenu(
dropdowns=[
PageMenuDropdown(
name="attributes",
title=_("Attributes"),
topics=[
PageMenuTopic(
title=_("Create"),
entries=[
PageMenuEntry(
title=_("Add attribute"),
icon_name="new",
item=make_simple_link(
watolib.folder_preserving_link([
("mode",
"edit_%s_attr" % self._type)
])),
is_shortcut=True,
is_suggested=True,
),
],
),
],
),
PageMenuDropdown(
name="related",
title=_("Related"),
topics=[
PageMenuTopic(
title=_("Setup"),
entries=list(self._page_menu_entries_related()),
),
],
),
],
breadcrumb=breadcrumb,
inpage_search=PageMenuSearch(),
)
def page(self):
if not self._attrs:
html.div(_("No custom attributes are defined yet."), class_="info")
return
with table_element(self._type + "attrs") as table:
for custom_attr in sorted(self._attrs, key=lambda x: x['title']):
table.row()
table.cell(_("Actions"), css="buttons")
edit_url = watolib.folder_preserving_link([
("mode", "edit_%s_attr" % self._type),
("edit", custom_attr['name'])
])
delete_url = html.makeactionuri([("_delete",
custom_attr['name'])])
html.icon_button(edit_url, _("Properties"), "edit")
html.icon_button(delete_url, _("Delete"), "delete")
table.text_cell(_("Name"), custom_attr['name'])
table.text_cell(_("Title"), custom_attr['title'])
table.cell(_("Type"),
dict(custom_attr_types())[custom_attr['type']])
def buttons(self) -> None:
global_buttons()
if self.name() != "download_agents_windows":
html.context_button(
_("Windows files"),
folder_preserving_link([("mode", "download_agents_windows")]),
"download_agents")
if self.name() != "download_agents_linux":
html.context_button(
_("Linux files"),
folder_preserving_link([("mode", "download_agents_linux")]),
"download_agents")
if self.name() != "download_agents":
html.context_button(
_("Other files"),
folder_preserving_link([("mode", "download_agents")]),
"download_agents")
if watolib.has_agent_bakery():
html.context_button(
_("Baked agents"),
watolib.folder_preserving_link([("mode", "agents")]), "agents")
def _find_usages_in_time_specific_parameters(self, tpname: str) -> List[TimeperiodUsage]:
used_in: List[TimeperiodUsage] = []
rulesets = watolib.AllRulesets()
rulesets.load()
for ruleset in rulesets.get_rulesets().values():
vs = ruleset.valuespec()
if not isinstance(vs, cmk.gui.plugins.wato.utils.TimeperiodValuespec):
continue
for rule_folder, rule_index, rule in ruleset.get_rules():
if not vs.is_active(rule.value):
continue
for index, (rule_tp_name, _value) in enumerate(rule.value["tp_values"]):
if rule_tp_name != tpname:
continue
edit_url = watolib.folder_preserving_link([
("mode", "edit_rule"),
("back_mode", "timeperiods"),
("varname", ruleset.name),
("rulenr", rule_index),
("rule_folder", rule_folder.path()),
])
used_in.append((_("Time specific check parameter #%d") % (index + 1), edit_url))
return used_in
def page_menu(self, breadcrumb: Breadcrumb) -> PageMenu:
return PageMenu(
dropdowns=[
PageMenuDropdown(
name="connections",
title=_("Connections"),
topics=[
PageMenuTopic(
title=_("Add connection"),
entries=[
PageMenuEntry(
title=_("Add connection"),
icon_name="new",
item=make_simple_link(
watolib.folder_preserving_link([
("mode", "edit_ldap_connection")
])),
is_shortcut=True,
is_suggested=True,
),
],
),
],
),
PageMenuDropdown(
name="related",
title=_("Related"),
topics=[
PageMenuTopic(
title=_("Setup"),
entries=list(self._page_menu_entries_related()),
),
],
),
],
breadcrumb=breadcrumb,
)
def page_menu(self, breadcrumb: Breadcrumb) -> PageMenu:
menu = PageMenu(
dropdowns=[
PageMenuDropdown(
name="roles",
title=_("Roles"),
topics=[
PageMenuTopic(
title=_("Overview"),
entries=[
PageMenuEntry(
title=_("Permission matrix"),
icon_name="matrix",
item=make_simple_link(
watolib.folder_preserving_link([("mode", "role_matrix")])),
),
],
),
],
),
],
breadcrumb=breadcrumb,
)
return menu
def buttons(self):
super(ModeEditHost, self).buttons()
host_status_button(self._host.name(), "hoststatus")
html.context_button(
_("Services"),
watolib.folder_preserving_link([("mode", "inventory"), ("host", self._host.name())]),
"services")
if watolib.has_agent_bakery() and config.user.may('wato.download_agents'):
html.context_button(
_("Monitoring Agent"),
watolib.folder_preserving_link([("mode", "agent_of_host"),
("host", self._host.name())]), "agents")
if config.user.may('wato.rulesets'):
html.context_button(
_("Parameters"),
watolib.folder_preserving_link([("mode", "object_parameters"),
("host", self._host.name())]), "rulesets")
if self._is_cluster():
html.context_button(
_("Clustered Services"),
watolib.folder_preserving_link([("mode", "edit_ruleset"),
("varname", "clustered_services")]), "rulesets")
if not watolib.Folder.current().locked_hosts():
if config.user.may("wato.rename_hosts"):
html.context_button(
self._is_cluster() and _("Rename cluster") or _("Rename host"),
watolib.folder_preserving_link([("mode", "rename_host"),
("host", self._host.name())]), "rename_host")
html.context_button(self._is_cluster() and _("Delete cluster") or _("Delete host"),
html.makeactionuri([("delete", "1")]), "delete")
if not self._is_cluster():
html.context_button(
_("Diagnostic"),
watolib.folder_preserving_link([("mode", "diag_host"),
("host", self._host.name())]), "diagnose")
html.context_button(_("Update DNS Cache"), html.makeactionuri([("_update_dns_cache", "1")]),
"update")
def _rules_url(self) -> str:
return watolib.folder_preserving_link([("mode", "rule_search"),
("filled_in", "search"),
("search", "contactgroups")])
def _rules_url(self) -> str:
return watolib.folder_preserving_link([("mode", "edit_ruleset"),
("varname", "service_groups")])
def page_menu_host_entries(mode_name: str,
host: CREHost) -> Iterator[PageMenuEntry]:
if mode_name != "edit_host":
yield PageMenuEntry(
title=_("Properties"),
icon_name="edit",
item=make_simple_link(
watolib.folder_preserving_link([("mode", "edit_host"),
("host", host.name())])),
)
if mode_name != "inventory":
yield PageMenuEntry(
title=_("Service configuration"),
icon_name="services",
item=make_simple_link(
watolib.folder_preserving_link([("mode", "inventory"),
("host", host.name())])),
)
if mode_name != "diag_host" and not host.is_cluster():
yield PageMenuEntry(
title=_("Connection tests"),
icon_name="diagnose",
item=make_simple_link(
watolib.folder_preserving_link([("mode", "diag_host"),
("host", host.name())])),
)
if mode_name != "object_parameters" and user.may("wato.rulesets"):
yield PageMenuEntry(
title=_("Effective parameters"),
icon_name="rulesets",
item=make_simple_link(
watolib.folder_preserving_link([("mode", "object_parameters"),
("host", host.name())])),
)
if mode_name == "object_parameters" or mode_name == "edit_host" and user.may(
"wato.rulesets"):
yield PageMenuEntry(
title=_("Rules"),
icon_name="rulesets",
item=make_simple_link(
makeuri_contextless(
request,
[
("mode", "rule_search"),
("filled_in", "search"),
("search_p_ruleset_deprecated", "OFF"),
("search_p_rule_host_list_USE", "ON"),
("search_p_rule_host_list", host.name()),
],
filename="wato.py",
)),
)
yield make_host_status_link(host_name=host.name(), view_name="hoststatus")
if user.may("wato.rulesets") and host.is_cluster():
yield PageMenuEntry(
title=_("Clustered services"),
icon_name="rulesets",
item=make_simple_link(
watolib.folder_preserving_link([("mode", "edit_ruleset"),
("varname",
"clustered_services")])),
)
if watolib.has_agent_bakery() and user.may("wato.download_agents"):
yield PageMenuEntry(
title=_("Monitoring agent"),
icon_name="agents",
item=make_simple_link(
watolib.folder_preserving_link([("mode", "agent_of_host"),
("host", host.name())])),
)
if mode_name == "edit_host" and not host.locked():
if user.may("wato.rename_hosts"):
yield PageMenuEntry(
title=_("Rename"),
icon_name="rename_host",
item=make_simple_link(
watolib.folder_preserving_link([("mode", "rename_host"),
("host", host.name())])),
)
if user.may("wato.manage_hosts") and user.may("wato.clone_hosts"):
yield PageMenuEntry(
title=_("Clone"),
icon_name="insert",
item=make_simple_link(host.clone_url()),
)
yield PageMenuEntry(
title=_("Delete"),
icon_name="delete",
item=make_simple_link(
make_confirm_link(
url=makeactionuri(request, transactions,
[("delete", "1")]),
message=_(
"Do you really want to delete the host <tt>%s</tt>?") %
host.name(),
)),
)
if user.may("wato.auditlog"):
yield PageMenuEntry(
title=_("Audit log"),
icon_name="auditlog",
item=make_simple_link(
make_object_audit_log_url(host.object_ref())),
)
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_service_info(self, all_rulesets):
serviceinfo = watolib.check_mk_automation(
self._host.site_id(), "analyse-service",
[self._hostname, self._service])
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:
rulespec = None
if rulespec:
url = watolib.folder_preserving_link([
('mode', 'edit_ruleset'),
('varname', "static_checks:" + checkgroup),
('host', self._hostname)
])
self._render_rule_reason(
_("Parameters"), url, _("Determined by discovery"),
None, False,
rulespec.valuespec._elements[2].value_to_text(
serviceinfo["parameters"]))
else:
self._render_rule_reason(
_("Parameters"), None, "", "", True,
_("This check is not configurable via WATO"))
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_text(serviceinfo["item"])
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)
html.write(rulespec.valuespec._elements[2].value_to_text(
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 = watolib.folder_preserving_link([('mode', 'edit_ruleset'),
('varname', "custom_checks"),
('host', self._hostname)])
forms.section(html.render_a(_("Command Line"), href=url))
url = watolib.folder_preserving_link([('mode', 'edit_rule'),
('varname', "custom_checks"),
('rule_folder',
rule_folder.path()),
('rulenr', rule_index),
('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 _vs_rules(self):
if config.user.may('wato.add_or_modify_executables'):
ds_option = [(
'datasource_program',
TextAscii(
title=_("Datasource Program (<a href=\"%s\">Rules</a>)") %
watolib.folder_preserving_link(
[('mode', 'edit_ruleset'),
('varname', 'datasource_programs')]),
help=
_("For agent based checks Check_MK allows you to specify an alternative "
"program that should be called by Check_MK instead of connecting the agent "
"via TCP. That program must output the agent's data on standard output in "
"the same format the agent would do. This is for example useful for monitoring "
"via SSH.") + monitoring_macro_help() + " " +
_("This option can only be used with the permission \"Can add or modify executables\"."
),
))] # type: List[DictionaryEntry]
else:
ds_option = []
return Dictionary(
optional_keys = False,
elements = [
('agent_port', Integer(
minvalue = 1,
maxvalue = 65535,
default_value = 6556,
title = _("Check_MK Agent Port (<a href=\"%s\">Rules</a>)") %
watolib.folder_preserving_link([('mode', 'edit_ruleset'), ('varname', 'agent_ports')]),
help = _("This variable allows to specify the TCP port to "
"be used to connect to the agent on a per-host-basis.")
)),
('tcp_connect_timeout', Float(
minvalue = 1.0,
default_value = 5.0,
unit = _("sec"),
display_format = "%.0f", # show values consistent to
size = 2, # SNMP-Timeout
title = _("TCP Connection Timeout (<a href=\"%s\">Rules</a>)") % \
watolib.folder_preserving_link([('mode', 'edit_ruleset'), ('varname', 'tcp_connect_timeouts')]),
help = _("This variable allows to specify a timeout for the "
"TCP connection to the Check_MK agent on a per-host-basis."
"If the agent does not respond within this time, it is considered to be unreachable.")
)),
('snmp_timeout', Integer(
title = _("SNMP-Timeout (<a href=\"%s\">Rules</a>)") % \
watolib.folder_preserving_link([('mode', 'edit_ruleset'), ('varname', 'snmp_timing')]),
help = _("After a request is sent to the remote SNMP agent we will wait up to this "
"number of seconds until assuming the answer get lost and retrying."),
default_value = 1,
minvalue = 1,
maxvalue = 60,
unit = _("sec"),
)),
('snmp_retries', Integer(
title = _("SNMP-Retries (<a href=\"%s\">Rules</a>)") % \
watolib.folder_preserving_link([('mode', 'edit_ruleset'), ('varname', 'snmp_timing')]),
default_value = 5,
minvalue = 0,
maxvalue = 50,
)),
] + ds_option,
)
def buttons(self) -> None:
html.context_button(
_("All groups"),
watolib.folder_preserving_link([
("mode", "%s_groups" % self.type_name)
]), "back")
def home_button():
html.context_button(_("Main Menu"),
watolib.folder_preserving_link([("mode", "main")]),
"home")
def _activation_status(self):
with table_element("site-status",
searchable=False,
sortable=False,
css="activation") as table:
for site_id, site in sort_sites(
cmk.gui.watolib.changes.activation_sites()):
table.row()
site_status, status = self._get_site_status(site_id, site)
is_online = self._site_is_online(status)
is_logged_in = self._site_is_logged_in(site_id, site)
has_foreign = self._site_has_foreign_changes(site_id)
can_activate_all = not has_foreign or config.user.may(
"wato.activateforeign")
# Disable actions for offline sites and not logged in sites
if not is_online or not is_logged_in:
can_activate_all = False
need_restart = self._is_activate_needed(site_id)
need_sync = self.is_sync_needed(site_id)
need_action = need_restart or need_sync
# Activation checkbox
table.cell("", css="buttons")
if can_activate_all and need_action:
html.checkbox("site_%s" % site_id,
cssclass="site_checkbox")
# Iconbuttons
table.cell(_("Actions"), css="buttons")
if config.user.may("wato.sites"):
edit_url = watolib.folder_preserving_link([
("mode", "edit_site"), ("edit", site_id)
])
html.icon_button(edit_url,
_("Edit the properties of this site"),
"edit")
# State
if can_activate_all and need_sync:
html.icon_button(
url="javascript:void(0)",
id_="activate_%s" % site_id,
cssclass="activate_site",
title=
_("This site is not update and needs a replication. Start it now."
),
icon="need_replicate",
onclick=
"cmk.activation.activate_changes(\"site\", \"%s\")" %
site_id)
if can_activate_all and need_restart:
html.icon_button(
url="javascript:void(0)",
id_="activate_%s" % site_id,
cssclass="activate_site",
title=
_("This site needs a restart for activating the changes. Start it now."
),
icon="need_restart",
onclick=
"cmk.activation.activate_changes(\"site\", \"%s\")" %
site_id)
if can_activate_all and not need_action:
html.icon(_("This site is up-to-date."), "siteuptodate")
site_url = site.get("multisiteurl")
if site_url:
html.icon_button(
site_url,
_("Open this site's local web user interface"),
"url",
target="_blank")
table.text_cell(_("Site"), site.get("alias", site_id))
# Livestatus
table.cell(_("Status"), css="narrow nobr")
html.status_label(content=status,
status=status,
title=_("This site is %s") % status)
# Livestatus-/Check_MK-Version
table.cell(_("Version"),
site_status.get("livestatus_version", ""),
css="narrow nobr")
table.cell(_("Changes"),
"%d" % len(self._changes_of_site(site_id)),
css="number narrow nobr")
table.cell(_("Progress"), css="repprogress")
html.open_div(id_="site_%s_status" % site_id, class_=["msg"])
html.close_div()
html.open_div(id_="site_%s_progress" % site_id,
class_=["progress"])
html.close_div()
# Hidden on initial rendering and shown on activation start
table.cell(_("Details"), css="details")
html.open_div(id_="site_%s_details" % site_id)
# Shown on initial rendering and hidden on activation start
table.cell(_("Last result"), css="last_result")
last_state = self._last_activation_state(site_id)
if not is_logged_in:
html.write_text(_("Is not logged in.") + " ")
if not last_state:
html.write_text(_("Has never been activated"))
else:
html.write_text("%s: %s. " %
(_("State"), last_state["_status_text"]))
if last_state["_status_details"]:
html.write(last_state["_status_details"])
def buttons(self):
html.context_button(
_("Folder"), watolib.folder_preserving_link([("mode", "folder")]),
"back")
def _vs_rules(self):
return Dictionary(
optional_keys=False,
elements=[
(
"agent_port",
Integer(
minvalue=1,
maxvalue=65535,
default_value=6556,
title=_('Checkmk Agent Port (<a href="%s">Rules</a>)')
% watolib.folder_preserving_link(
[("mode", "edit_ruleset"), ("varname", "agent_ports")]
),
help=_(
"This variable allows to specify the TCP port to "
"be used to connect to the agent on a per-host-basis."
),
),
),
(
"tcp_connect_timeout",
Float(
minvalue=1.0,
default_value=5.0,
unit=_("sec"),
display_format="%.0f", # show values consistent to
size=2, # SNMP-Timeout
title=_('TCP Connection Timeout (<a href="%s">Rules</a>)')
% watolib.folder_preserving_link(
[("mode", "edit_ruleset"), ("varname", "tcp_connect_timeouts")]
),
help=_(
"This variable allows to specify a timeout for the "
"TCP connection to the Check_MK agent on a per-host-basis."
"If the agent does not respond within this time, it is considered to be unreachable."
),
),
),
(
"snmp_timeout",
Integer(
title=_('SNMP-Timeout (<a href="%s">Rules</a>)')
% watolib.folder_preserving_link(
[("mode", "edit_ruleset"), ("varname", "snmp_timing")]
),
help=_(
"After a request is sent to the remote SNMP agent we will wait up to this "
"number of seconds until assuming the answer get lost and retrying."
),
default_value=1,
minvalue=1,
maxvalue=60,
unit=_("sec"),
),
),
(
"snmp_retries",
Integer(
title=_('SNMP-Retries (<a href="%s">Rules</a>)')
% watolib.folder_preserving_link(
[("mode", "edit_ruleset"), ("varname", "snmp_timing")]
),
default_value=5,
minvalue=0,
maxvalue=50,
),
),
],
)
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 = watolib.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"),
html.render_span(
str(len(role["permissions"])),
title=
_("That many permissions do not use the factory defaults."
),
),
)
# Users
table.cell(
_("Users"),
HTML(", ").join([
html.render_a(
user.get("alias", user_id),
watolib.folder_preserving_link([
("mode", "edit_user"), ("edit", user_id)
]),
) for (user_id, user) in users.items()
if rid in user["roles"]
]),
)
