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", watolib.mk_repr(self._item)),
("rule_folder", folder.path()),
])
html.icon_button(edit_url, _("Edit this rule"), "edit")
html.end_foldable_container()
def _activation_status(self):
with table_element("site-status", searchable=False, sortable=False,
css="activation") as table:
for site_id, site in sort_sites(config.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
nr_changes = len(self._changes_of_site(site_id))
# Activation checkbox
table.cell("", css="buttons")
if can_activate_all and nr_changes:
html.checkbox("site_%s" % site_id, need_action, cssclass="site_checkbox")
# Iconbuttons
table.cell(_("Actions"), css="buttons")
if config.user.may("wato.sites"):
edit_url = watolib.folder_preserving_link([("mode", "edit_site"),
("site", 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("siteuptodate", _("This site is up-to-date."))
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.cell(_("Site"), site.get("alias", site_id), css="narrow nobr")
# Livestatus
table.cell(_("Status"), css="narrow nobr")
html.status_label(content=status,
status=status,
title=_("This site is %s") % status)
# Livestatus-/Checkmk-Version
table.cell(_("Version"),
site_status.get("livestatus_version", ""),
css="narrow nobr")
table.cell(_("Changes"), "%d" % nr_changes, 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()
table.cell(_("Details"), css="details")
html.open_div(id_="site_%s_details" % site_id)
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"))
elif (need_action and
last_state["_state"] == cmk.gui.watolib.activate_changes.STATE_SUCCESS):
html.write_text(_("Activation needed"))
else:
html.javascript("cmk.activation.update_site_activation_state(%s);" %
json.dumps(last_state))
html.close_div()
def _show_user_list(self):
visible_custom_attrs = [(name, attr)
for name, attr in userdb.get_user_attributes()
if attr.show_in_table()]
users = userdb.load_users()
entries = users.items()
entries.sort(cmp=lambda a, b: cmp(a[1].get("alias", a[0]).lower(), b[1]
.get("alias", b[0]).lower()))
html.begin_form("bulk_delete_form", method="POST")
roles = userdb.load_roles()
timeperiods = watolib.timeperiods.load_timeperiods()
contact_groups = load_contact_group_information()
with table_element("users",
None,
empty_text=_("No users are defined yet.")) as table:
online_threshold = time.time() - config.user_online_maxage
for uid, user in entries:
table.row()
# Checkboxes
table.cell(html.render_input(
"_toggle_group",
type_="button",
class_="checkgroup",
onclick="cmk.selection.toggle_all_rows();",
value='X'),
sortable=False,
css="checkbox")
if uid != config.user.id:
html.checkbox("_c_user_%s" %
base64.b64encode(uid.encode("utf-8")))
user_connection_id = userdb.cleanup_connection_id(
user.get('connector'))
connection = userdb.get_connection(user_connection_id)
# Buttons
table.cell(_("Actions"), css="buttons")
if connection: # only show edit buttons when the connector is available and enabled
edit_url = watolib.folder_preserving_link([("mode",
"edit_user"),
("edit", uid)])
html.icon_button(edit_url, _("Properties"), "edit")
clone_url = watolib.folder_preserving_link([
("mode", "edit_user"), ("clone", uid)
])
html.icon_button(clone_url,
_("Create a copy of this user"), "clone")
delete_url = make_action_link([("mode", "users"),
("_delete", uid)])
html.icon_button(delete_url, _("Delete"), "delete")
notifications_url = watolib.folder_preserving_link([
("mode", "user_notifications"), ("user", uid)
])
if watolib.load_configuration_settings().get(
"enable_rulebased_notifications"):
html.icon_button(
notifications_url,
_("Custom notification table of this user"),
"notifications")
# ID
table.cell(_("ID"), uid)
# Online/Offline
if config.save_user_access_times:
last_seen = user.get('last_seen', 0)
if last_seen >= online_threshold:
title = _('Online')
img_txt = 'online'
elif last_seen != 0:
title = _('Offline')
img_txt = 'offline'
elif last_seen == 0:
title = _('Never logged in')
img_txt = 'inactive'
title += ' (%s %s)' % (render.date(last_seen),
render.time_of_day(last_seen))
table.cell(_("Act."))
html.icon(title, img_txt)
table.cell(_("Last seen"))
if last_seen != 0:
html.write_text("%s %s" %
(render.date(last_seen),
render.time_of_day(last_seen)))
else:
html.write_text(_("Never logged in"))
if cmk.is_managed_edition():
table.cell(_("Customer"), managed.get_customer_name(user))
# Connection
if connection:
table.cell(
_("Connection"), '%s (%s)' %
(connection.short_title(), user_connection_id))
locked_attributes = userdb.locked_attributes(
user_connection_id)
else:
table.cell(
_("Connection"),
"%s (%s) (%s)" %
(_("UNKNOWN"), user_connection_id, _("disabled")),
css="error")
locked_attributes = []
# Authentication
if "automation_secret" in user:
auth_method = _("Automation")
elif user.get("password") or 'password' in locked_attributes:
auth_method = _("Password")
else:
auth_method = "<i>%s</i>" % _("none")
table.cell(_("Authentication"), auth_method)
table.cell(_("State"))
if user.get("locked", False):
html.icon(_('The login is currently locked'),
'user_locked')
if "disable_notifications" in user and isinstance(
user["disable_notifications"], bool):
disable_notifications_opts = {
"disable": user["disable_notifications"]
}
else:
disable_notifications_opts = user.get(
"disable_notifications", {})
if disable_notifications_opts.get("disable", False):
html.icon(_('Notifications are disabled'),
'notif_disabled')
# Full name / Alias
table.text_cell(_("Alias"), user.get("alias", ""))
# Email
table.text_cell(_("Email"), user.get("email", ""))
# Roles
table.cell(_("Roles"))
if user.get("roles", []):
role_links = [(watolib.folder_preserving_link([
("mode", "edit_role"), ("edit", role)
]), roles[role].get("alias")) for role in user["roles"]]
html.write_html(
HTML(", ").join(
html.render_a(alias, href=link)
for (link, alias) in role_links))
# contact groups
table.cell(_("Contact groups"))
cgs = user.get("contactgroups", [])
if cgs:
cg_aliases = [
contact_groups[c]['alias']
if c in contact_groups else c for c in cgs
]
cg_urls = [
watolib.folder_preserving_link([("mode",
"edit_contact_group"),
("edit", c)])
for c in cgs
]
html.write_html(
HTML(", ").join(
html.render_a(content, href=url)
for (content, url) in zip(cg_aliases, cg_urls)))
else:
html.i(_("none"))
#table.cell(_("Sites"))
#html.write(vs_authorized_sites().value_to_text(user.get("authorized_sites",
# vs_authorized_sites().default_value())))
# notifications
if not watolib.load_configuration_settings().get(
"enable_rulebased_notifications"):
table.cell(_("Notifications"))
if not cgs:
html.i(_("not a contact"))
elif not user.get("notifications_enabled", True):
html.write_text(_("disabled"))
elif user.get("host_notification_options", "") == "" and \
user.get("service_notification_options", "") == "":
html.write_text(_("all events disabled"))
else:
tp = user.get("notification_period", "24X7")
if tp not in timeperiods:
tp = tp + _(" (invalid)")
elif tp not in watolib.timeperiods.builtin_timeperiods(
):
url = watolib.folder_preserving_link([
("mode", "edit_timeperiod"), ("edit", tp)
])
tp = html.render_a(timeperiods[tp].get(
"alias", tp),
href=url)
else:
tp = timeperiods[tp].get("alias", tp)
html.write(tp)
# the visible custom attributes
for name, attr in visible_custom_attrs:
vs = attr.valuespec()
table.cell(html.attrencode(_u(vs.title())))
html.write(
vs.value_to_text(user.get(name, vs.default_value())))
html.button("_bulk_delete_users",
_("Bulk Delete"),
"submit",
style="margin-top:10px")
html.hidden_fields()
html.end_form()
if not load_contact_group_information():
url = "wato.py?mode=contact_groups"
html.open_div(class_="info")
html.write(
_("Note: you haven't defined any contact groups yet. If you <a href='%s'>"
"create some contact groups</a> you can assign users to them und thus "
"make them monitoring contacts. Only monitoring contacts can receive "
"notifications.") % url)
html.write(
" you can assign users to them und thus "
"make them monitoring contacts. Only monitoring contacts can receive "
"notifications.")
html.close_div()
def page(self):
# Show outcome of host validation. Do not validate new hosts
errors = None
if self._mode == "edit":
errors = watolib.validate_all_hosts([self._host.name()]).get(
self._host.name(), []) + self._host.validation_errors()
if errors:
html.open_div(class_="info")
html.open_table(class_="validationerror", boder="0", cellspacing="0", cellpadding="0")
html.open_tr()
html.open_td(class_="img")
html.icon("validation_error")
html.close_td()
html.open_td()
html.open_p()
html.h3(_("Warning: This host has an invalid configuration!"))
html.open_ul()
for error in errors:
html.li(error)
html.close_ul()
html.close_p()
if html.form_submitted():
html.br()
html.b(_("Your changes have been saved nevertheless."))
html.close_td()
html.close_tr()
html.close_table()
html.close_div()
lock_message = u""
locked_hosts = watolib.Folder.current().locked_hosts()
if locked_hosts:
if locked_hosts is True:
lock_message = _("Host attributes locked (You cannot edit this host)")
elif isinstance(locked_hosts, str):
lock_message = locked_hosts
if lock_message:
html.div(lock_message, class_="info")
html.begin_form("edit_host", method="POST")
html.prevent_password_auto_completion()
basic_attributes = [
# attribute name, valuepec, default value
("host", self._vs_host_name(), self._host.name()),
]
if self._is_cluster():
basic_attributes += [
# attribute name, valuepec, default value
("nodes", self._vs_cluster_nodes(),
self._host.cluster_nodes() if self._host else []),
]
configure_attributes(
new=self._mode != "edit",
hosts={self._host.name(): self._host} if self._mode != "new" else {},
for_what="host" if not self._is_cluster() else "cluster",
parent=watolib.Folder.current(),
basic_attributes=basic_attributes,
)
if self._mode != "edit":
html.set_focus("host")
forms.end()
html.hidden_fields()
html.end_form()
def iconlink(text, url, icon):
html.open_a(class_=["iconlink", "link"], target="main", href=url)
html.icon(icon, cssclass="inline")
html.write_text(text)
html.close_a()
html.br()
def _show_node(self, tree, show_host, mousecode=None, img_class=None):
# Check if we have an assumed state: comparing assumed state (tree[1]) with state (tree[0])
if tree[1] and tree[0] != tree[1]:
addclass: Optional[str] = "assumed"
effective_state = tree[1]
else:
addclass = None
effective_state = tree[0]
class_: List[Optional[str]] = [
"content", #
"state",
"state%d" % (effective_state["state"] if effective_state["state"] is not None else -1),
addclass
]
html.open_span(class_=class_)
html.write_text(self._render_bi_state(effective_state["state"]))
html.close_span()
if mousecode:
if img_class:
html.img(src=html.theme_url("images/tree_closed.png"),
class_=["treeangle", img_class],
onclick=mousecode)
html.open_span(class_=["content", "name"])
icon_name, icon_title = None, None
if tree[0]["in_downtime"] == 2:
icon_name = "downtime"
icon_title = _("This element is currently in a scheduled downtime.")
elif tree[0]["in_downtime"] == 1:
# only display host downtime if the service has no own downtime
icon_name = "derived_downtime"
icon_title = _("One of the subelements is in a scheduled downtime.")
if tree[0]["acknowledged"]:
icon_name = "ack"
icon_title = _("This problem has been acknowledged.")
if not tree[0]["in_service_period"]:
icon_name = "outof_serviceperiod"
icon_title = _("This element is currently not in its service period.")
if icon_name and icon_title:
html.icon(icon_name, title=icon_title, class_=["icon", "bi"])
yield
if mousecode:
if str(effective_state["state"]) in tree[2].get("state_messages", {}):
html.b(HTML("♦"), class_="bullet")
html.write_text(tree[2]["state_messages"][str(effective_state["state"])])
html.close_span()
output: HTMLContent = cmk.gui.view_utils.format_plugin_output(
effective_state["output"], shall_escape=config.escape_plugin_output)
if output:
output = html.render_b(HTML("♦"), class_="bullet") + output
else:
output = ""
html.span(output, class_=["content", "output"])
def page(self):
# Show outcome of host validation. Do not validate new hosts
errors = None
if self._mode != "edit":
watolib.Folder.current().show_breadcrump()
else:
errors = watolib.validate_all_hosts([self._host.name()]).get(
self._host.name(), []) + self._host.validation_errors()
if errors:
html.open_div(class_="info")
html.open_table(class_="validationerror",
boder=0,
cellspacing=0,
cellpadding=0)
html.open_tr()
html.open_td(class_="img")
html.icon(title=None, icon="validation_error")
html.close_td()
html.open_td()
html.open_p()
html.h3(_("Warning: This host has an invalid configuration!"))
html.open_ul()
for error in errors:
html.li(error)
html.close_ul()
html.close_p()
if html.form_submitted():
html.br()
html.b(_("Your changes have been saved nevertheless."))
html.close_td()
html.close_tr()
html.close_table()
html.close_div()
lock_message = ""
if watolib.Folder.current().locked_hosts():
if watolib.Folder.current().locked_hosts() is True:
lock_message = _(
"Host attributes locked (You cannot edit this host)")
else:
lock_message = watolib.Folder.current().locked_hosts()
if len(lock_message) > 0:
html.div(lock_message, class_="info")
html.begin_form("edit_host", method="POST")
html.prevent_password_auto_completion()
forms.header(_("General Properties"))
self._show_host_name()
# Cluster: nodes
if self._is_cluster():
forms.section(_("Nodes"))
self._vs_cluster_nodes().render_input(
"nodes",
self._host.cluster_nodes() if self._host else [])
html.help(
_('Enter the host names of the cluster nodes. These '
'hosts must be present in WATO. '))
configure_attributes(
new=self._mode != "edit",
hosts={self._host.name(): self._host}
if self._mode != "new" else {},
for_what="host" if not self._is_cluster() else "cluster",
parent=watolib.Folder.current())
forms.end()
if not watolib.Folder.current().locked_hosts():
html.button("services", _("Save & go to Services"), "submit")
html.button("save", _("Save & Finish"), "submit")
if not self._is_cluster():
html.button("diag_host", _("Save & Test"), "submit")
html.hidden_fields()
html.end_form()
def _show_host_row(self, rendered_hosts, table, hostname, search_text,
show_checkboxes, colspan, host_errors,
contact_group_names):
if search_text and (search_text.lower() not in hostname.lower()):
return
host = self._folder.host(hostname)
rendered_hosts.append(hostname)
effective = host.effective_attributes()
table.row()
# Column with actions (buttons)
if show_checkboxes:
table.cell(html.render_input(
"_toggle_group",
type_="button",
class_="checkgroup",
onclick="cmk.selection.toggle_all_rows();",
value='X'),
sortable=False,
css="checkbox")
# Use CSS class "failed" in order to provide information about
# selective toggling inventory-failed hosts for Javascript
html.input(name="_c_%s" % hostname,
type_="checkbox",
value=colspan,
class_="failed" if host.discovery_failed() else None)
html.label("", "_c_%s" % hostname)
table.cell(_("Actions"), css="buttons", sortable=False)
self._show_host_actions(host)
# Hostname with link to details page (edit host)
table.cell(_("Hostname"))
errors = host_errors.get(hostname, []) + host.validation_errors()
if errors:
msg = _("Warning: This host has an invalid configuration: ")
msg += ", ".join(errors)
html.icon(msg, "validation_error")
html.nbsp()
if host.is_offline():
html.icon(_("This host is disabled"), "disabled")
html.nbsp()
if host.is_cluster():
html.icon(
_("This host is a cluster of %s") %
", ".join(host.cluster_nodes()), "cluster")
html.nbsp()
html.a(hostname, href=host.edit_url())
# Show attributes
for attr in host_attribute_registry.attributes():
if attr.show_in_table():
attrname = attr.name()
if attrname in host.attributes():
tdclass, tdcontent = attr.paint(
host.attributes()[attrname], hostname)
else:
tdclass, tdcontent = attr.paint(effective.get(attrname),
hostname)
tdclass += " inherited"
table.cell(attr.title(),
escaping.escape_attribute(tdcontent),
css=tdclass)
# Am I authorized?
reason = host.reason_why_may_not("read")
if not reason:
icon = "authok"
title = _("You have permission to this host.")
else:
icon = "autherr"
title = escaping.strip_tags(reason)
table.cell(_('Auth'),
html.render_icon(icon, title),
css="buttons",
sortable=False)
# Permissions and Contact groups - through complete recursion and inhertance
permitted_groups, host_contact_groups, _use_for_services = host.groups(
)
table.cell(
_("Permissions"),
HTML(", ").join([
self._render_contact_group(contact_group_names, g)
for g in permitted_groups
]))
table.cell(
_("Contact Groups"),
HTML(", ").join([
self._render_contact_group(contact_group_names, g)
for g in host_contact_groups
]))
if not config.wato_hide_hosttags:
table.cell(_("Tags"), css="tag-ellipsis")
tag_groups, show_all_code = self._limit_labels(host.tag_groups())
html.write(
cmk.gui.view_utils.render_tag_groups(tag_groups,
"host",
with_links=False))
html.write(show_all_code)
table.cell(_("Explicit labels"), css="tag-ellipsis")
labels, show_all_code = self._limit_labels(host.labels())
html.write(
cmk.gui.view_utils.render_labels(
labels,
"host",
with_links=False,
label_sources={k: "explicit"
for k in labels.keys()}))
html.write(show_all_code)
# Located in folder
if self._folder.is_search_folder():
table.cell(_("Folder"))
html.a(host.folder().alias_path(), href=host.folder().url())
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', 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 ''),
])
varname = rulespec.name
valuespec = rulespec.valuespec
url = watolib.folder_preserving_link([
('mode', 'edit_ruleset'),
('varname', varname),
('host', self._hostname),
('item', ensure_str(watolib.mk_repr(svc_desc_or_item))),
('service', ensure_str(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(s) for s 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_link(self, url: str, onclick: Optional[str], target: Optional[str], icon: Icon,
title: str) -> None:
html.open_a(href=url, onclick=onclick, target=target)
html.icon(icon or "trans")
html.span(title)
html.close_a()
def show_annotations(annotations, av_rawdata, what, avoptions, omit_service):
annos_to_render = get_relevant_annotations(annotations, av_rawdata, what,
avoptions)
render_date = get_annotation_date_render_function(annos_to_render,
avoptions)
with table_element(title=_("Annotations"), omit_if_empty=True) as table:
for (site_id, host, service), annotation in annos_to_render:
table.row()
table.cell("", css="buttons")
anno_vars = [
("anno_site", site_id),
("anno_host", host),
("anno_service", service or ""),
("anno_from", int(annotation["from"])),
("anno_until", int(annotation["until"])),
]
edit_url = html.makeuri(anno_vars)
html.icon_button(edit_url, _("Edit this annotation"), "edit")
delete_url = html.makeactionuri([("_delete_annotation", "1")] +
anno_vars)
html.icon_button(delete_url, _("Delete this annotation"), "delete")
if not omit_service:
if not "omit_host" in avoptions["labelling"]:
host_url = "view.py?" + html.urlencode_vars(
[("view_name", "hoststatus"), ("site", site_id),
("host", host)])
table.cell(_("Host"), html.render_a(host, host_url))
if what == "service":
if service:
service_url = "view.py?" + html.urlencode_vars(
[("view_name", "service"), ("site", site_id),
("host", host), ("service", service)])
# TODO: honor use_display_name. But we have no display names here...
service_name = service
table.cell(_("Service"),
html.render_a(service_name, service_url))
else:
table.cell(_("Service"),
"") # Host annotation in service table
table.cell(_("From"),
render_date(annotation["from"]),
css="nobr narrow")
table.cell(_("Until"),
render_date(annotation["until"]),
css="nobr narrow")
table.cell("", css="buttons")
if annotation.get("downtime") is True:
html.icon(
_("This period has been reclassified as a scheduled downtime"
), "downtime")
elif annotation.get("downtime") is False:
html.icon(
_("This period has been reclassified as a not being a scheduled downtime"
), "nodowntime")
table.cell(_("Annotation"), html.render_text(annotation["text"]))
table.cell(_("Author"), annotation["author"])
table.cell(_("Entry"),
render_date(annotation["date"]),
css="nobr narrow")
if not cmk.is_raw_edition():
table.cell(
_("Hide in report"),
_("Yes")
if annotation.get("hide_from_report") else _("No"))
def _iconlink(self, text, url, icon):
html.open_a(class_=["iconlink", "link"], target="main", href=url)
html.icon("/webconf/images/icon_%s.png" % icon, cssclass="inline")
html.write_text(text)
html.close_a()
html.br()
def _show_link_item(self, entry: PageMenuEntry,
item: PageMenuLink) -> None:
html.open_a(href=item.link.url, onclick=item.link.onclick)
html.icon(title=None, icon=entry.icon_name or "trans")
html.write_text(entry.shortcut_title or entry.title)
html.close_a()
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_html_permissive(
self._match_txt[:match_start]) +
html.render_span(
self._match_txt[match_start:match_end],
class_="match") + escape_html_permissive(
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")
