def _action_buttons(self, name):
edit_url = watolib.folder_preserving_link([
("mode", "edit_timeperiod"),
("edit", name),
])
clone_url = watolib.folder_preserving_link([
("mode", "edit_timeperiod"),
("clone", name),
])
delete_url = make_action_link([
("mode", "timeperiods"),
("_delete", name),
])
html.icon_button(edit_url, _("Properties"), "edit")
html.icon_button(clone_url, _("Create a copy"), "clone")
html.icon_button(delete_url, _("Delete"), "delete")
def _sidebar_foot(self, user_config):
html.open_div(id_="side_footer")
if config.user.may("general.configure_sidebar"):
html.icon_button("sidebar_add_snapin.py",
_("Add snapin to the sidebar"),
"sidebar_addsnapin",
target="main")
# editing the profile is not possible on remote sites which are sync targets
# of a central WATO system
if config.wato_enabled and \
(config.user.may("general.edit_profile") or config.user.may("general.change_password")):
html.icon_button("user_profile.py",
_("Edit your personal settings, change your password"),
"sidebar_settings",
target="main")
if config.user.may("general.logout") and not config.auth_by_http_header:
html.icon_button("logout.py", _("Log out"), "sidebar_logout", target="_top")
html.icon_button("return void();",
_("You have pending messages."),
"sidebar_messages",
onclick='cmk.sidebar.read_message()',
id_='msg_button',
style='display:none')
html.open_div(style="display:none;", id_="messages")
self.render_messages()
html.close_div()
html.open_div(class_=["copyright"])
html.write("© " +
html.render_a("tribe29 GmbH", target="_blank", href="https://checkmk.com"))
html.close_div()
html.close_div()
if user_config.folded:
html.final_javascript("cmk.sidebar.fold_sidebar();")
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.text_cell(_("Name"), rid)
# Alias
table.text_cell(_("Alias"), role["alias"])
# Type
table.cell(_("Type"), _("builtin") if role.get("builtin") else _("custom"))
# Modifications
table.cell(
_("Modifications"), "<span title='%s'>%s</span>" %
(_("That many permissions do not use the factory defaults."),
len(role["permissions"])))
# 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"]
]))
def _show_row_cells(self, table, name, group):
table.cell(_("Actions"), css="buttons")
edit_url = watolib.folder_preserving_link([
("mode", "edit_%s_group" % self.type_name), ("edit", name)
])
delete_url = make_confirm_link(
url=html.makeactionuri([("_delete", name)]),
message=_('Do you really want to delete the %s group "%s"?') %
(self.type_name, name))
clone_url = watolib.folder_preserving_link([
("mode", "edit_%s_group" % self.type_name), ("clone", name)
])
html.icon_button(edit_url, _("Properties"), "edit")
html.icon_button(clone_url, _("Create a copy of this group"), "clone")
html.icon_button(delete_url, _("Delete"), "delete")
table.cell(_("Name"), escaping.escape_attribute(name))
table.cell(_("Alias"), escaping.escape_attribute(group['alias']))
def _show_row_cells(self, table: Table, name: GroupName, group: GroupSpec) -> None:
table.cell(_("Actions"), css="buttons")
edit_url = watolib.folder_preserving_link(
[("mode", "edit_%s_group" % self.type_name), ("edit", name)]
)
delete_url = make_confirm_link(
url=makeactionuri(request, transactions, [("_delete", name)]),
message=_('Do you really want to delete the %s group "%s"?') % (self.type_name, name),
)
clone_url = watolib.folder_preserving_link(
[("mode", "edit_%s_group" % self.type_name), ("clone", name)]
)
html.icon_button(edit_url, _("Properties"), "edit")
html.icon_button(clone_url, _("Create a copy of this group"), "clone")
html.icon_button(delete_url, _("Delete"), "delete")
table.cell(_("Name"), name)
table.cell(_("Alias"), group["alias"])
def _display_page_controls(self, start_time, end_time, previous_log_time, next_log_time):
html.open_div(class_="paged_controls")
def time_url_args(t):
return [
("options_start_1_day", time.strftime("%d", time.localtime(t))),
("options_start_1_month", time.strftime("%m", time.localtime(t))),
("options_start_1_year", time.strftime("%Y", time.localtime(t))),
("options_start_sel", "1"),
]
if next_log_time is not None:
html.icon_button(
makeactionuri(
request,
transactions,
[
("options_start_sel", "0"),
],
),
_("Most recent events"),
"start",
)
html.icon_button(
makeactionuri(request, transactions, time_url_args(next_log_time)),
"%s: %s" % (_("Newer events"), render.date(next_log_time)),
"back",
)
else:
html.empty_icon_button()
html.empty_icon_button()
if previous_log_time is not None:
html.icon_button(
makeactionuri(request, transactions, time_url_args(previous_log_time)),
"%s: %s" % (_("Older events"), render.date(previous_log_time)),
"forth",
)
else:
html.empty_icon_button()
html.close_div()
def _action_buttons(self, name):
edit_url = watolib.folder_preserving_link([
("mode", "edit_timeperiod"),
("edit", name),
])
clone_url = watolib.folder_preserving_link([
("mode", "edit_timeperiod"),
("clone", name),
])
delete_url = make_confirm_link(
url=make_action_link([
("mode", "timeperiods"),
("_delete", name),
]),
message=_("Do you really want to delete the time period '%s'?" % name))
html.icon_button(edit_url, _("Properties"), "edit")
html.icon_button(clone_url, _("Create a copy"), "clone")
html.icon_button(delete_url, _("Delete"), "delete")
def _show_action_cell(self, table, ident):
table.cell(_("Actions"), css="buttons")
edit_url = html.makeuri_contextless([
("mode", self._mode_type.edit_mode_name()),
("ident", ident),
])
html.icon_button(edit_url, _("Edit this %s") % self._mode_type.name_singular(), "edit")
clone_url = html.makeuri_contextless([
("mode", self._mode_type.edit_mode_name()),
("clone", ident),
])
html.icon_button(clone_url, _("Clone this %s") % self._mode_type.name_singular(), "clone")
delete_url = watolib.make_action_link([
("mode", self._mode_type.list_mode_name()),
("_action", "delete"),
("_delete", ident),
])
html.icon_button(delete_url,
_("Delete this %s") % self._mode_type.name_singular(), "delete")
def render(self, row: Row, cell: Cell) -> CellSpec:
single_url = "view.py?" + urlencode_vars(
[("view_name", "aggr_single"), ("aggr_name", row["aggr_name"])]
)
avail_url = single_url + "&mode=availability"
bi_map_url = "bi_map.py?" + urlencode_vars(
[
("aggr_name", row["aggr_name"]),
]
)
with output_funnel.plugged():
html.icon_button(bi_map_url, _("Visualize this aggregation"), "aggr")
html.icon_button(single_url, _("Show only this aggregation"), "showbi")
html.icon_button(
avail_url, _("Analyse availability of this aggregation"), "availability"
)
if row["aggr_effective_state"]["in_downtime"] != 0:
html.icon(
"derived_downtime", _("A service or host in this aggregation is in downtime.")
)
if row["aggr_effective_state"]["acknowledged"]:
html.icon(
"ack",
_(
"The critical problems that make this aggregation non-OK have been acknowledged."
),
)
if not row["aggr_effective_state"]["in_service_period"]:
html.icon(
"outof_serviceperiod",
_("This aggregation is currently out of its service period."),
)
code = HTML(output_funnel.drain())
return "buttons", code
def _show_action_cell(self, table: Table, ident: str) -> None:
table.cell(_("Actions"), css="buttons")
edit_url = makeuri_contextless(
request,
[
("mode", self._mode_type.edit_mode_name()),
("ident", ident),
],
)
html.icon_button(edit_url,
_("Edit this %s") % self._mode_type.name_singular(),
"edit")
clone_url = makeuri_contextless(
request,
[
("mode", self._mode_type.edit_mode_name()),
("clone", ident),
],
)
html.icon_button(clone_url,
_("Clone this %s") % self._mode_type.name_singular(),
"clone")
delete_url = make_confirm_link(
url=watolib.make_action_link([
("mode", self._mode_type.list_mode_name()),
("_action", "delete"),
("_delete", ident),
]),
message=self._delete_confirm_message(),
)
html.icon_button(delete_url,
_("Delete this %s") % self._mode_type.name_singular(),
"delete")
def _render_headers(self, actions_enabled: bool, actions_visible: bool,
empty_columns: List[bool]) -> None:
if self.options["omit_headers"]:
return
table_id = self.id
html.open_tr()
first_col = True
for nr, header in enumerate(self.headers):
if self.options["omit_empty_columns"] and empty_columns[nr]:
continue
if header.help_txt:
header_title: Union[int, HTML, str] = html.render_span(
header.title, title=header.help_txt)
else:
header_title = header.title
if not isinstance(header.css, list):
css_class: CSSSpec = [header.css]
else:
css_class = header.css
assert isinstance(css_class, list)
css_class = [("header_%s" % c) for c in css_class if c is not None]
if not self.options["sortable"] or not header.sortable:
html.open_th(class_=css_class)
else:
css_class.insert(0, "sort")
reverse = 0
sort = html.request.get_ascii_input('_%s_sort' % table_id)
if sort:
sort_col, sort_reverse = map(int, sort.split(',', 1))
if sort_col == nr:
reverse = 1 if sort_reverse == 0 else 0
action_uri = html.makeactionuri([('_%s_sort' % table_id,
'%d,%d' % (nr, reverse))])
html.open_th(class_=css_class,
title=_("Sort by %s") % header.title,
onclick="location.href='%s'" % action_uri)
# Add the table action link
if first_col:
first_col = False
if actions_enabled:
if not header_title:
header_title = " " # Fixes layout problem with white triangle
if actions_visible:
state = '0'
help_txt = _('Hide table actions')
img = 'table_actions_on'
else:
state = '1'
help_txt = _('Display table actions')
img = 'table_actions_off'
html.open_div(class_=["toggle_actions"])
html.icon_button(html.makeuri([('_%s_actions' % table_id,
state)]),
help_txt,
img,
cssclass='toggle_actions')
html.open_span()
html.write(header_title)
html.close_span()
html.close_div()
else:
html.write(header_title)
else:
html.write(header_title)
html.close_th()
html.close_tr()
def render_bi_availability(title, aggr_rows):
# type: (Text, Rows) -> None
config.user.need_permission("general.see_availability")
av_mode = html.request.get_ascii_input_mandatory("av_mode", "availability")
avoptions = get_availability_options_from_url("bi")
if av_mode == "timeline":
title = _("Timeline of") + " " + title
else:
title = _("Availability of") + " " + title
if html.output_format != "csv_export":
html.body_start(title)
html.top_heading(title)
html.begin_context_buttons()
html.toggle_button("avoptions", False, "painteroptions",
_("Configure details of the report"))
html.context_button(_("Status View"),
html.makeuri([("mode", "status")]), "status")
if config.reporting_available() and config.user.may(
"general.reporting"):
html.context_button(_("Export as PDF"),
html.makeuri([], filename="report_instant.py"),
"report")
if config.user.may("general.csv_export"):
html.context_button(
_("Export as CSV"),
html.makeuri([("output_format", "csv_export")]),
"download_csv")
if av_mode == "timeline":
html.context_button(_("Availability"),
html.makeuri([("av_mode", "availability")]),
"availability")
elif len(aggr_rows) == 1:
aggr_name = aggr_rows[0]["aggr_name"]
aggr_group = aggr_rows[0]["aggr_group"]
timeline_url = html.makeuri([("av_mode", "timeline"),
("av_aggr_name", aggr_name),
("av_aggr_group", aggr_group)])
html.context_button(_("Timeline"), timeline_url, "timeline")
html.end_context_buttons()
avoptions = render_availability_options("bi")
if not html.has_user_errors():
logrow_limit = avoptions["logrow_limit"]
if logrow_limit == 0:
livestatus_limit = None
else:
livestatus_limit = (len(aggr_rows) * logrow_limit)
spans = [] # type: List[AVSpan]
# iterate all aggregation rows
timewarpcode = HTML()
timewarp = html.request.get_integer_input("timewarp")
has_reached_logrow_limit = False
timeline_containers, fetched_rows = availability.get_timeline_containers(
aggr_rows, avoptions, timewarp,
livestatus_limit + 1 if livestatus_limit is not None else None)
if livestatus_limit and fetched_rows > livestatus_limit:
has_reached_logrow_limit = True
for timeline_container in timeline_containers:
tree = timeline_container.aggr_tree
these_spans = timeline_container.timeline
timewarp_tree_state = timeline_container.timewarp_state
spans += these_spans
# render selected time warp for the corresponding aggregation row (should be matched by only one)
if timewarp and timewarp_tree_state:
state, assumed_state, node, _subtrees = timewarp_tree_state
eff_state = state
if assumed_state is not None:
eff_state = assumed_state
row = {
"aggr_tree": tree,
"aggr_treestate": timewarp_tree_state,
"aggr_state": state, # state disregarding assumptions
"aggr_assumed_state":
assumed_state, # is None, if there are no assumptions
"aggr_effective_state":
eff_state, # is assumed_state, if there are assumptions, else real state
"aggr_name": node["title"],
"aggr_output": eff_state["output"],
"aggr_hosts": node["reqhosts"],
"aggr_function": node["func"],
"aggr_group": html.request.var("aggr_group"),
}
renderer = bi.FoldableTreeRendererTree(
row,
omit_root=False,
expansion_level=config.user.bi_expansion_level,
only_problems=False,
lazy=False)
tdclass, htmlcode = renderer.css_class(), renderer.render()
with html.plugged():
# TODO: SOMETHING IS WRONG IN HERE (used to be the same situation in original code!)
# FIXME: WHAT is wrong in here??
html.open_h3()
# render icons for back and forth
button_back_shown = False
button_forth_shown = False
if int(these_spans[0]["from"]) == timewarp:
html.disabled_icon_button("back_off")
button_back_shown = True
previous_span = None
for span in these_spans:
if not button_back_shown and int(
span["from"]
) == timewarp and previous_span is not None:
html.icon_button(
html.makeuri([("timewarp",
str(int(previous_span["from"])))
]), _("Jump one phase back"),
"back")
button_back_shown = True
# Multiple followup spans can have the same "from" time
# We only show one forth-arrow with an actual time difference
elif not button_forth_shown and previous_span and int(
previous_span["from"]) == timewarp and int(
span["from"]) != timewarp:
html.icon_button(
html.makeuri([("timewarp",
str(int(span["from"])))]),
_("Jump one phase forth"), "forth")
button_forth_shown = True
previous_span = span
if not button_forth_shown:
html.disabled_icon_button("forth_off")
html.write_text(" ")
html.icon_button(html.makeuri([("timewarp", "")]),
_("Close Timewarp"), "closetimewarp")
html.write_text("%s %s" %
(_("Timewarp to "),
time.strftime("%Y-%m-%d %H:%M:%S",
time.localtime(timewarp))))
html.close_h3()
html.open_table(class_=["data", "table", "timewarp"])
html.open_tr(class_=["data", "odd0"])
html.open_td(class_=tdclass)
html.write_html(htmlcode)
html.close_td()
html.close_tr()
html.close_table()
timewarpcode += html.drain()
# Note: 'spans_by_object' returns two arguments which are used by
# all availability views but not by BI. There we have to take
# only complete aggregations
av_rawdata = availability.spans_by_object(spans, None)[0]
av_data = availability.compute_availability("bi", av_rawdata,
avoptions)
# If we abolish the limit we have to fetch the data again
# with changed logrow_limit = 0, which means no limit
if has_reached_logrow_limit:
text = _(
"Your query matched more than %d log entries. "
"<b>Note:</b> The shown data does not necessarily reflect the "
"matched entries and the result might be incomplete. "
) % avoptions["logrow_limit"]
text += html.render_a(_('Repeat query without limit.'),
html.makeuri([("_unset_logrow_limit", "1")]))
html.show_warning(text)
if html.output_format == "csv_export" and config.user.may(
"general.csv_export"):
_output_csv("bi", av_mode, av_data, avoptions)
return
html.write(timewarpcode)
do_render_availability("bi", av_rawdata, av_data, av_mode, None,
avoptions)
html.bottom_footer()
html.body_end()
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")
del_anno = [("_delete_annotation", "1")] # type: HTTPVariables
delete_url = html.makeactionuri(del_anno + anno_vars)
html.icon_button(delete_url, _("Delete this annotation"), "delete")
if not omit_service:
if "omit_host" not 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_version.is_raw_edition():
table.cell(
_("Hide in report"),
_("Yes")
if annotation.get("hide_from_report") else _("No"))
def _render_availability_timeline(what, av_entry, avoptions, timeline_nr):
# type: (AVObjectType, AVEntry, AVOptions, int) -> None
html.open_h3()
html.write("%s %s" %
(_("Timeline of"), availability.object_title(what, av_entry)))
html.close_h3()
timeline_rows = av_entry["timeline"]
if not timeline_rows:
html.div(_("No information available"), class_="info")
return
timeline_layout = availability.layout_timeline(
what,
timeline_rows,
av_entry["considered_duration"],
avoptions,
"standalone",
)
render_timeline_bar(timeline_layout, "standalone", timeline_nr)
# Table with detailed events
with table_element("av_timeline",
"",
css="timelineevents",
sortable=False,
searchable=False) as table:
for row_nr, row in enumerate(timeline_layout["table"]):
table.row(
id_="timetable_%d_entry_%d" % (timeline_nr, row_nr),
onmouseover="cmk.availability.timetable_hover(%d, %d, 1);" %
(timeline_nr, row_nr),
onmouseout="cmk.availability.timetable_hover(%d, %d, 0);" %
(timeline_nr, row_nr))
table.cell(_("Links"), css="buttons")
if what == "bi":
url = html.makeuri([("timewarp", str(int(row["from"])))])
if html.request.var(
"timewarp"
) and html.request.get_integer_input_mandatory(
"timewarp") == int(row["from"]):
html.disabled_icon_button("timewarp_off")
else:
html.icon_button(
url,
_("Time warp - show BI aggregate during this time period"
), "timewarp")
else:
url = html.makeuri([("anno_site", av_entry["site"]),
("anno_host", av_entry["host"]),
("anno_service", av_entry["service"]),
("anno_from", str(row["from"])),
("anno_until", str(row["until"]))])
html.icon_button(url,
_("Create an annotation for this period"),
"annotation")
table.cell(_("From"), row["from_text"], css="nobr narrow")
table.cell(_("Until"), row["until_text"], css="nobr narrow")
table.cell(_("Duration"),
row["duration_text"],
css="narrow number")
table.cell(_("State"),
row["state_name"],
css=row["css"] + " state narrow")
if "omit_timeline_plugin_output" not in avoptions["labelling"]:
table.cell(
_("Last Known Plugin Output"),
format_plugin_output(row.get("log_output", ""), row))
if "timeline_long_output" in avoptions["labelling"]:
table.cell(
_("Last Known Long Output"),
format_plugin_output(row.get("long_log_output", ""), row))
# Legend for timeline
if "display_timeline_legend" in avoptions["labelling"]:
render_timeline_legend(what)
def render_availability_table(group_title, availability_table, what,
avoptions):
av_table = availability.layout_availability_table(what, group_title,
availability_table,
avoptions)
# TODO: If summary line is activated, then sorting should now move that line to the
# top. It should also stay at the bottom. This would require an extension to the
# table.py module.
with table_element("av_items",
av_table["title"],
css="availability",
searchable=False,
limit=None,
omit_headers="omit_headers"
in avoptions["labelling"]) as table:
show_urls, show_timeline = False, False
for row in av_table["rows"]:
table.row()
# Column with icons
timeline_url = None
if row["urls"]:
show_urls = True
table.cell("", css="buttons")
for image, tooltip, url in row["urls"]:
html.icon_button(url, tooltip, image)
if image == "timeline":
timeline_url = url
# Column with host/service or aggregate name
for title, (name, url) in zip(av_table["object_titles"],
row["object"]):
table.cell(title, html.render_a(name, url))
if "timeline" in row:
show_timeline = True
table.cell(_("Timeline"), css="timeline")
html.open_a(href=timeline_url)
render_timeline_bar(row["timeline"], "inline")
html.close_a()
# Columns with the actual availability data
for (title, help_txt), (text, css) in zip(av_table["cell_titles"],
row["cells"]):
table.cell(title, text, css=css, help_txt=help_txt)
if "summary" in av_table:
table.row(css="summary", fixed=True)
if show_urls:
table.cell("", "") # Empty cell in URLs column
table.cell("", _("Summary"), css="heading")
for _x in range(1, len(av_table["object_titles"])):
table.cell("",
"") # empty cells, of more object titles than one
if show_timeline:
table.cell("", "")
for (title, help_txt), (text, css) in zip(av_table["cell_titles"],
av_table["summary"]):
table.cell(title,
text,
css="heading " + css,
help_txt=help_txt)
def show_file(site, host_name, file_name):
int_filename = form_file_to_int(file_name)
title = _("Logfiles of Host %s: %s") % (host_name, int_filename)
breadcrumb = _show_file_breadcrumb(host_name, title)
html.header(
title, breadcrumb,
_show_file_page_menu(breadcrumb, site, host_name, int_filename))
if request.has_var("_ack") and not request.var("_do_actions") == _("No"):
do_log_ack(site, host_name, file_name)
return
try:
log_chunks = parse_file(site,
host_name,
int_filename,
hidecontext=request.var("_hidecontext",
"no") == "yes")
except Exception as e:
if config.debug:
raise
html.show_error(_("Unable to show logfile: <b>%s</b>") % e)
html.footer()
return
if log_chunks is None:
html.show_error(_("The logfile does not exist on site."))
html.footer()
return
if log_chunks == []:
html.show_message(
_("This logfile contains no unacknowledged messages."))
html.footer()
return
html.open_div(id_="logwatch")
for log in log_chunks:
html.open_table(class_="groupheader")
html.open_tr()
html.td(form_level(log["level"]), class_=form_level(log["level"]))
html.td(form_datetime(log["datetime"]), class_="date")
html.close_tr()
html.close_table()
html.open_table(class_=["section"])
for line in log["lines"]:
html.open_tr(class_=line["class"])
html.open_td(class_="lines")
html.icon_button(
analyse_url(site, host_name, int_filename, line["line"]),
_("Analyze this line"),
"analyze",
)
html.write_text(line["line"].replace(" ", " ").replace(
"\1", "<br>"))
html.close_td()
html.close_tr()
html.close_table()
html.close_div()
html.footer()
def _show_patterns(self):
import cmk.gui.logwatch as logwatch
collection = watolib.SingleRulesetRecursively("logwatch_rules")
collection.load()
ruleset = collection.get("logwatch_rules")
html.h3(_("Logfile patterns"))
if ruleset.is_empty():
html.open_div(class_="info")
html.write_text(
"There are no logfile patterns defined. You may create "
'logfile patterns using the <a href="%s">Rule Editor</a>.'
% watolib.folder_preserving_link(
[
("mode", "edit_ruleset"),
("varname", "logwatch_rules"),
]
)
)
html.close_div()
# Loop all rules for this ruleset
already_matched = False
abs_rulenr = 0
for folder, rulenr, rule in ruleset.get_rules():
# Check if this rule applies to the given host/service
if self._hostname:
service_desc = self._get_service_description(self._hostname, "logwatch", self._item)
# If hostname (and maybe filename) try match it
rule_matches = rule.matches_host_and_item(
watolib.Folder.current(), self._hostname, self._item, service_desc
)
else:
# If no host/file given match all rules
rule_matches = True
with foldable_container(
treename="rule",
id_=str(abs_rulenr),
isopen=True,
title=HTML("<b>Rule #%d</b>" % (abs_rulenr + 1)),
indent=False,
), table_element(
"pattern_editor_rule_%d" % abs_rulenr, sortable=False, css="logwatch"
) as table:
abs_rulenr += 1
# TODO: What's this?
pattern_list = rule.value
if isinstance(pattern_list, dict):
pattern_list = pattern_list["reclassify_patterns"]
# Each rule can hold no, one or several patterns. Loop them all here
for state, pattern, comment in pattern_list:
match_class = ""
disp_match_txt = HTML("")
match_img = ""
if rule_matches:
# Applies to the given host/service
matched = re.search(pattern, self._match_txt)
if matched:
# Prepare highlighted search txt
match_start = matched.start()
match_end = matched.end()
disp_match_txt = (
escape_to_html(self._match_txt[:match_start])
+ html.render_span(
self._match_txt[match_start:match_end], class_="match"
)
+ escape_to_html(self._match_txt[match_end:])
)
if not already_matched:
# First match
match_class = "match first"
match_img = "match"
match_title = _(
"This logfile pattern matches first and will be used for "
"defining the state of the given line."
)
already_matched = True
else:
# subsequent match
match_class = "match"
match_img = "imatch"
match_title = _(
"This logfile pattern matches but another matched first."
)
else:
match_img = "nmatch"
match_title = _("This logfile pattern does not match the given string.")
else:
# rule does not match
match_img = "nmatch"
match_title = _("The rule conditions do not match.")
table.row()
table.cell(_("Match"))
html.icon("rule%s" % match_img, match_title)
cls: List[str] = []
if match_class == "match first":
cls = ["state%d" % logwatch.level_state(state), "fillbackground"]
table.cell(_("State"), html.render_span(logwatch.level_name(state)), css=cls)
table.cell(_("Pattern"), html.render_tt(pattern))
table.cell(_("Comment"), comment)
table.cell(_("Matched line"), disp_match_txt)
table.row(fixed=True)
table.cell(colspan=5)
edit_url = watolib.folder_preserving_link(
[
("mode", "edit_rule"),
("varname", "logwatch_rules"),
("rulenr", rulenr),
("item", watolib.mk_repr(self._item).decode()),
("rule_folder", folder.path()),
("rule_id", rule.id),
]
)
html.icon_button(edit_url, _("Edit this rule"), "edit")
def _show_pending_changes_icon(self) -> None:
html.open_td(class_="icon_container")
html.icon_button("wato.py?mode=changelog", _("View pending changes"),
"activate_changes")
html.close_td()
def _render_headers(self, actions_enabled: bool, actions_visible: bool,
empty_columns: List[bool]) -> None:
if self.options["omit_headers"]:
return
table_id = self.id
html.open_tr()
first_col = True
for nr, header in enumerate(self.headers):
if self.options["omit_empty_columns"] and empty_columns[nr]:
continue
if header.help_txt:
header_title: HTML = html.render_span(header.title,
title=header.help_txt)
else:
header_title = header.title
if not isinstance(header.css, list):
css_class: "CSSSpec" = [header.css]
else:
css_class = header.css
assert isinstance(css_class, list)
css_class = [("header_%s" % c) for c in css_class if c is not None]
if not self.options["sortable"] or not header.sortable:
html.open_th(class_=css_class)
else:
css_class.insert(0, "sort")
reverse = 0
sort = request.get_ascii_input("_%s_sort" % table_id)
if sort:
sort_col, sort_reverse = map(int, sort.split(",", 1))
if sort_col == nr:
reverse = 1 if sort_reverse == 0 else 0
action_uri = makeactionuri(request, transactions,
[("_%s_sort" % table_id, "%d,%d" %
(nr, reverse))])
html.open_th(
class_=css_class,
title=_("Sort by %s") % header.title,
onclick="location.href='%s'" % action_uri,
)
# Add the table action link
if first_col:
first_col = False
if actions_enabled:
if not header_title:
header_title = HTML(
" "
) # Fixes layout problem with white triangle
if actions_visible:
state = "0"
help_txt = _("Hide table actions")
img = "table_actions_on"
else:
state = "1"
help_txt = _("Display table actions")
img = "table_actions_off"
html.open_div(class_=["toggle_actions"])
html.icon_button(
makeuri(request, [("_%s_actions" % table_id, state)]),
help_txt,
img,
cssclass="toggle_actions",
)
html.span(header_title)
html.close_div()
else:
html.write_text(header_title)
else:
html.write_text(header_title)
html.close_th()
html.close_tr()
def page_list(cls):
cls.load()
# custom_columns = []
# render_custom_buttons = None
# render_custom_columns = None
# render_custom_context_buttons = None
# check_deletable_handler = None
cls.need_overriding_permission("edit")
html.header(cls.phrase("title_plural"))
html.begin_context_buttons()
html.context_button(cls.phrase("new"), cls.create_url(), "new_" + cls.type_name())
# TODO: Remove this legacy code as soon as views, dashboards and reports have been
# moved to pagetypes.py
html.context_button(_("Views"), "edit_views.py", "view")
html.context_button(_("Dashboards"), "edit_dashboards.py", "dashboard")
def has_reporting():
try:
# The suppression below is OK, we just want to check if the module is there.
import cmk.gui.cee.reporting # noqa: F401 # pylint: disable=unused-variable,redefined-outer-name
return True
except ImportError:
return False
if has_reporting():
html.context_button(_("Reports"), "edit_reports.py", "report")
# ## if render_custom_context_buttons:
# ## render_custom_context_buttons()
for other_type_name, other_pagetype in page_types.items():
if cls.type_name() != other_type_name:
html.context_button(
other_pagetype.phrase("title_plural").title(), '%ss.py' % other_type_name,
other_type_name)
html.end_context_buttons()
# Deletion
delname = html.request.var("_delete")
if delname and html.transaction_valid():
owner = UserId(html.request.get_unicode_input_mandatory('_owner', config.user.id))
try:
instance = cls.instance((owner, delname))
except KeyError:
raise MKUserError(
"_delete",
_("The %s you are trying to delete "
"does not exist.") % cls.phrase("title"))
if not instance.may_delete():
raise MKUserError("_delete", _("You are not permitted to perform this action."))
try:
if owner != config.user.id:
owned_by = _(" (owned by %s)") % owner
else:
owned_by = ""
c = html.confirm(
_("Please confirm the deletion of \"%s\"%s.") % (instance.title(), owned_by))
if c:
cls.remove_instance((owner, delname))
cls.save_user_instances(owner)
html.reload_sidebar()
elif c is False:
html.footer()
return
except MKUserError as e:
html.user_error(e)
# Bulk delete
if html.request.var("_bulk_delete_my") and html.transaction_valid():
if cls._bulk_delete_after_confirm("my") is False:
html.footer()
return
elif html.request.var("_bulk_delete_foreign") and html.transaction_valid():
if cls._bulk_delete_after_confirm("foreign") is False:
html.footer()
return
my_instances, foreign_instances, builtin_instances = cls.get_instances()
for what, title, instances in [
("my", _('Customized'), my_instances),
("foreign", _('Owned by other users'), foreign_instances),
("builtin", _('Builtin'), builtin_instances),
]:
if not instances:
continue
html.open_h3()
html.write(title)
html.close_h3()
if what != "builtin":
html.begin_form("bulk_delete_%s" % what, method="POST")
with table_element(limit=None) as table:
for instance in instances:
table.row()
if what != "builtin" and instance.may_delete():
table.cell(html.render_input(
"_toggle_group",
type_="button",
class_="checkgroup",
onclick="cmk.selection.toggle_all_rows(this.form);",
value='X'),
sortable=False,
css="checkbox")
html.checkbox("_c_%s+%s+%s" % (what, instance.owner(), instance.name()))
# Actions
table.cell(_('Actions'), css='buttons visuals')
# View
if isinstance(instance, PageRenderer):
html.icon_button(instance.page_url(), _("View"), "new_" + cls.type_name())
# Clone / Customize
html.icon_button(instance.clone_url(), _("Create a customized copy of this"),
"clone")
# Delete
if instance.may_delete():
html.icon_button(instance.delete_url(), _("Delete!"), "delete")
# Edit
if instance.may_edit():
html.icon_button(instance.edit_url(), _("Edit"), "edit")
cls.custom_list_buttons(instance)
# Internal ID of instance (we call that 'name')
table.cell(_('ID'), instance.name(), css="narrow")
# Title
table.cell(_('Title'))
html.write_text(instance.render_title())
html.help(_u(instance.description()))
# Custom columns specific to that page type
instance.render_extra_columns(table)
# ## for title, renderer in custom_columns:
# ## table.cell(title, renderer(visual))
# Owner
if instance.is_builtin():
ownertxt = html.render_i(_("builtin"))
else:
ownertxt = instance.owner()
table.cell(_('Owner'), ownertxt)
table.cell(_('Public'), _("yes") if instance.is_public() else _("no"))
table.cell(_('Hidden'), _("yes") if instance.is_hidden() else _("no"))
# FIXME: WTF?!?
# TODO: Haeeh? Another custom columns
# ## if render_custom_columns:
# ## render_custom_columns(visual_name, visual)
if what != "builtin":
html.button("_bulk_delete_%s" % what,
_("Bulk delete"),
"submit",
style="margin-top:10px")
html.hidden_fields()
html.end_form()
html.footer()
return
def show_file(site, host_name, file_name):
int_filename = form_file_to_int(file_name)
title = _("Logfiles of Host %s: %s") % (host_name, file_name)
html.header(title, make_host_breadcrumb(host_name))
html.begin_context_buttons()
html.context_button(_("Services"), services_url(site, host_name),
'services')
html.context_button(_("All Logfiles of Host"),
html.makeuri([('file', '')]))
button_all_logfiles()
html.context_button(_("Analyze patterns"),
analyse_url(site, host_name, file_name), 'analyze')
if html.request.var('_hidecontext', 'no') == 'yes':
hide_context_label = _('Show Context')
hide_context_param = 'no'
hide = True
else:
hide_context_label = _('Hide Context')
hide_context_param = 'yes'
hide = False
try:
log_chunks = parse_file(site, host_name, int_filename, hide)
except Exception as e:
if config.debug:
raise
html.end_context_buttons()
html.show_error(_("Unable to show logfile: <b>%s</b>") % e)
html.footer()
return
if log_chunks is None:
html.end_context_buttons()
html.show_error(_("The logfile does not exist."))
html.footer()
return
if log_chunks == []:
html.end_context_buttons()
html.show_message(
_("This logfile contains no unacknowledged messages."))
html.footer()
return
ack_button(site, host_name, int_filename)
html.context_button(hide_context_label,
html.makeuri([('_hidecontext', hide_context_param)]))
html.end_context_buttons()
html.open_div(id_="logwatch")
for log in log_chunks:
html.open_div(class_=["chunk"])
html.open_table(class_=["section"])
html.open_tr()
html.td(form_level(log['level']), class_=form_level(log['level']))
html.td(form_datetime(log['datetime']), class_="date")
html.close_tr()
html.close_table()
for line in log['lines']:
html.open_p(class_=line['class'])
html.icon_button(
analyse_url(site, host_name, file_name, line['line']),
_("Analyze this line"), "analyze")
html.write_text(line['line'].replace(" ", " ").replace(
"\1", "<br>"))
html.close_p()
html.close_div()
html.close_div()
html.footer()
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 _show_patterns(self):
import cmk.gui.logwatch as logwatch
collection = watolib.SingleRulesetRecursively("logwatch_rules")
collection.load()
ruleset = collection.get("logwatch_rules")
html.h3(_('Logfile patterns'))
if ruleset.is_empty():
html.open_div(class_="info")
html.write_text('There are no logfile patterns defined. You may create '
'logfile patterns using the <a href="%s">Rule Editor</a>.' %
watolib.folder_preserving_link([
('mode', 'edit_ruleset'),
('varname', 'logwatch_rules'),
]))
html.close_div()
# Loop all rules for this ruleset
already_matched = False
abs_rulenr = 0
for folder, rulenr, rule in ruleset.get_rules():
# Check if this rule applies to the given host/service
if self._hostname:
service_desc = self._get_service_description(self._hostname, "logwatch", self._item)
# If hostname (and maybe filename) try match it
rule_matches = rule.matches_host_and_item(watolib.Folder.current(), self._hostname,
self._item, service_desc)
else:
# If no host/file given match all rules
rule_matches = True
html.begin_foldable_container("rule",
"%s" % abs_rulenr,
True,
HTML("<b>Rule #%d</b>" % (abs_rulenr + 1)),
indent=False)
with table_element("pattern_editor_rule_%d" % abs_rulenr, sortable=False) as table:
abs_rulenr += 1
# TODO: What's this?
pattern_list = rule.value
if isinstance(pattern_list, dict):
pattern_list = pattern_list["reclassify_patterns"]
# Each rule can hold no, one or several patterns. Loop them all here
for state, pattern, comment in pattern_list:
match_class = ''
disp_match_txt = HTML('')
match_img = ''
if rule_matches:
# Applies to the given host/service
reason_class = 'reason'
matched = re.search(pattern, self._match_txt)
if matched:
# Prepare highlighted search txt
match_start = matched.start()
match_end = matched.end()
disp_match_txt = html.render_text(self._match_txt[:match_start]) \
+ html.render_span(self._match_txt[match_start:match_end], class_="match")\
+ html.render_text(self._match_txt[match_end:])
if not already_matched:
# First match
match_class = 'match first'
match_img = 'match'
match_title = _(
'This logfile pattern matches first and will be used for '
'defining the state of the given line.')
already_matched = True
else:
# subsequent match
match_class = 'match'
match_img = 'imatch'
match_title = _(
'This logfile pattern matches but another matched first.')
else:
match_img = 'nmatch'
match_title = _('This logfile pattern does not match the given string.')
else:
# rule does not match
reason_class = 'noreason'
match_img = 'nmatch'
match_title = _('The rule conditions do not match.')
table.row(css=reason_class)
table.cell(_('Match'))
html.icon(match_title, "rule%s" % match_img)
cls = ''
if match_class == 'match first':
cls = 'svcstate state%d' % logwatch.level_state(state)
table.cell(_('State'), logwatch.level_name(state), css=cls)
table.cell(_('Pattern'), html.render_tt(pattern))
table.cell(_('Comment'), html.render_text(comment))
table.cell(_('Matched line'), disp_match_txt)
table.row(fixed=True)
table.cell(colspan=5)
edit_url = watolib.folder_preserving_link([
("mode", "edit_rule"),
("varname", "logwatch_rules"),
("rulenr", rulenr),
("host", self._hostname),
("item", ensure_str(watolib.mk_repr(self._item))),
("rule_folder", folder.path()),
])
html.icon_button(edit_url, _("Edit this rule"), "edit")
html.end_foldable_container()
def _show_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()
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 sorted(entries, key=lambda x: x[1].get("alias", x[0]).lower()):
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 show_job_details(cls, job_id, job_status):
"""Renders the complete job details in a single table with left headers"""
html.open_table(class_=["data", "headerleft", "job_details"])
# Static info
for left, right in [
(_("ID"), job_id),
(_("Title"), job_status.get("title", "")),
(_("Started"),
cmk.utils.render.date_and_time(job_status["started"])),
(_("Owner"), job_status.get("user", "")),
]:
html.open_tr()
html.th(left)
html.td(right)
html.close_tr()
# Actions
html.open_tr()
html.th(_("Actions"))
html.open_td()
if job_status.get("may_stop"):
html.icon_button(
html.makeactionuri([(ActionHandler.stop_job_var, job_id)]),
_("Stop this job"),
"disable_test",
)
if job_status.get("may_delete"):
html.icon_button(
html.makeactionuri([(ActionHandler.delete_job_var, job_id)]),
_("Delete this job"),
"delete",
)
html.close_td()
html.close_tr()
# Job state
html.open_tr()
html.th(_("State"))
html.td(job_status["state"],
css=cls.get_css_for_jobstate(job_status["state"]))
html.close_tr()
if job_status["state"] == background_job.JobStatusStates.EXCEPTION:
html.open_tr()
html.th(_("Acknowledged by"))
html.td(job_status.get("acknowledged_by", ""))
html.close_tr()
# Dynamic data
loginfo = job_status.get("loginfo")
runtime_info = ensure_str(
cmk.utils.render.timespan(job_status.get("duration", 0)))
if job_status["state"] == background_job.JobStatusStates.RUNNING \
and job_status.get("estimated_duration") is not None:
runtime_info += u" (%s: %s)" % (
_("estimated duration"),
ensure_str(
cmk.utils.render.timespan(
job_status["estimated_duration"])))
for left, right in [
(_("Runtime"), runtime_info),
(_("PID"), job_status["pid"] or ""),
(_("Result"), "<br>".join(loginfo["JobResult"])),
]:
if right is None:
continue
html.open_tr()
html.th(left)
html.td(HTML(right))
html.close_tr()
# Exceptions
exceptions = loginfo["JobException"]
if exceptions:
html.open_tr()
html.th(_("Exceptions"))
html.open_td()
if exceptions and "logfile_path" in job_status:
exceptions.append(
_("More information can be found in %s") %
job_status["logfile_path"])
html.open_div(class_="log_output", id_="exception_log")
html.pre("\n".join(exceptions))
html.close_div()
html.close_td()
html.close_tr()
# Progress Update
html.open_tr()
html.th(_("Progress Info"))
html.open_td()
html.open_div(class_="log_output",
style="height: 400px;",
id_="progress_log")
html.pre(HTML("\n").join(loginfo["JobProgressUpdate"]))
html.close_div()
html.close_td()
html.close_tr()
html.close_table()
html.javascript(
"var log = document.getElementById('progress_log'); log.scrollTop = log.scrollHeight;"
)
def render_snapin(self, snapin: UserSidebarSnapin) -> str:
snapin_class = snapin.snapin_type
name = snapin_class.type_name()
snapin_instance = snapin_class()
html.open_div(id_="snapin_container_%s" % name, class_="snapin")
self._render_snapin_styles(snapin_instance)
# When not permitted to open/close snapins, the snapins are always opened
if snapin.visible == SnapinVisibility.OPEN or not config.user.may(
"general.configure_sidebar"):
style = None
else:
style = "display:none"
toggle_url = "sidebar_openclose.py?name=%s&state=" % name
# If the user may modify the sidebar then add code for dragging the snapin
head_actions: Dict[str, str] = {}
if config.user.may("general.configure_sidebar"):
head_actions = {
"onmouseover": "document.body.style.cursor='move';",
"onmouseout ": "document.body.style.cursor='';",
"onmousedown": "cmk.sidebar.snapin_start_drag(event)",
"onmouseup": "cmk.sidebar.snapin_stop_drag(event)"
}
html.open_div(class_=["head", snapin.visible.value], **head_actions)
if config.user.may("general.configure_sidebar"):
# Icon for mini/maximizing
html.div("",
class_="minisnapin",
title=_("Toggle this snapin"),
onclick="cmk.sidebar.toggle_sidebar_snapin(this, '%s')" %
toggle_url)
# Button for closing (removing) a snapin
html.open_div(class_="closesnapin")
close_url = "sidebar_openclose.py?name=%s&state=off" % name
html.icon_button(
url=None,
title=_("Remove this snapin"),
icon="closesnapin",
onclick="cmk.sidebar.remove_sidebar_snapin(this, '%s')" %
close_url)
html.close_div()
# The heading. A click on the heading mini/maximizes the snapin
toggle_actions: Dict[str, str] = {}
if config.user.may("general.configure_sidebar"):
toggle_actions = {
"onclick":
"cmk.sidebar.toggle_sidebar_snapin(this,'%s')" % toggle_url,
"onmouseover": "this.style.cursor='pointer'",
"onmouseout": "this.style.cursor='auto'"
}
html.b(snapin_class.title(), class_=["heading"], **toggle_actions)
# End of header
html.close_div()
# Now comes the content
html.open_div(class_="content", id_="snapin_%s" % name, style=style)
refresh_url = ''
try:
# TODO: Refactor this confusing special case. Add deddicated method or something
# to let the snapins make the sidebar know that there is a URL to fetch.
url = snapin_instance.show()
if url is not None:
# Fetch the contents from an external URL. Don't render it on our own.
refresh_url = url
html.javascript(
"cmk.ajax.get_url(\"%s\", cmk.utils.update_contents, \"snapin_%s\")"
% (refresh_url, name))
except Exception as e:
logger.exception("error rendering snapin %s", name)
write_snapin_exception(e)
html.close_div()
html.close_div()
return refresh_url
def render_job_row(cls,
job_id,
job_status,
odd,
job_details_back_url=None):
html.open_tr(css="data %s0" % odd)
# Actions
html.open_td(css="job_actions")
if job_status.get("may_stop"):
html.icon_button(
html.makeactionuri([(ActionHandler.stop_job_var, job_id)]),
_("Stop this job"), "disable_test")
if job_status.get("may_delete"):
html.icon_button(
html.makeactionuri([(ActionHandler.delete_job_var, job_id)]),
_("Delete this job"), "delete")
html.close_td()
# Job ID
html.open_td(css="job_id")
uri = makeuri_contextless(
request,
[
("mode", "background_job_details"),
("back_url", job_details_back_url),
("job_id", job_id),
],
filename="wato.py",
)
html.a(job_id, href=uri)
html.close_td()
# Title
html.td(job_status.get("title", _("Background Job")), css="job_title")
# State
html.td(job_status["state"],
css=cls.get_css_for_jobstate(job_status["state"]))
# Started
html.td(cmk.utils.render.date_and_time(job_status["started"]),
css="job_started")
# Owner
html.td(job_status.get("user", _("Unknown user")), css="job_owner")
# PID
html.td(job_status["pid"] or "", css="job_pid")
# Druation
html.td(cmk.utils.render.timespan(job_status.get("duration", 0)),
css="job_runtime")
# Progress info
loginfo = job_status.get("loginfo")
if loginfo:
if job_status.get(
"state") == background_job.JobStatusStates.EXCEPTION:
html.td(HTML("<br>".join(loginfo["JobException"])),
css="job_last_progress")
else:
progress_text = ""
if loginfo["JobProgressUpdate"]:
progress_text += "%s" % loginfo["JobProgressUpdate"][-1]
html.td(HTML(progress_text), css="job_last_progress")
html.td(HTML("<br>".join(loginfo["JobResult"])), css="job_result")
else:
html.td("", css="job_last_progress")
html.td("", css="job_result")
def page(self):
# Let exceptions from loading notification scripts happen now
watolib.load_notification_scripts()
html.begin_form("user", method="POST")
html.prevent_password_auto_completion()
forms.header(_("Identity"))
# ID
forms.section(_("Username"), simple=not self._is_new_user)
if self._is_new_user:
vs_user_id = UserID(allow_empty=False)
else:
vs_user_id = FixedValue(self._user_id)
vs_user_id.render_input("user_id", self._user_id)
def lockable_input(name, dflt):
if not self._is_locked(name):
html.text_input(name, self._user.get(name, dflt), size=50)
else:
html.write_text(self._user.get(name, dflt))
html.hidden_field(name, self._user.get(name, dflt))
# Full name
forms.section(_("Full name"))
lockable_input('alias', self._user_id)
html.help(_("Full name or alias of the user"))
# Email address
forms.section(_("Email address"))
email = self._user.get("email", "")
if not self._is_locked("email"):
EmailAddressUnicode().render_input("email", email)
else:
html.write_text(email)
html.hidden_field("email", email)
html.help(
_("The email address is optional and is needed "
"if the user is a monitoring contact and receives notifications "
"via Email."))
forms.section(_("Pager address"))
lockable_input('pager', '')
html.help(_("The pager address is optional "))
if cmk.is_managed_edition():
forms.section(self._vs_customer.title())
self._vs_customer.render_input("customer", managed.get_customer_id(self._user))
html.help(self._vs_customer.help())
vs_sites = self._vs_sites()
forms.section(vs_sites.title())
authorized_sites = self._user.get("authorized_sites", vs_sites.default_value())
if not self._is_locked("authorized_sites"):
vs_sites.render_input("authorized_sites", authorized_sites)
else:
html.write_html(vs_sites.value_to_text(authorized_sites))
html.help(vs_sites.help())
self._show_custom_user_attributes('ident')
forms.header(_("Security"))
forms.section(_("Authentication"))
is_automation = self._user.get("automation_secret", None) is not None
html.radiobutton("authmethod", "password", not is_automation,
_("Normal user login with password"))
html.open_ul()
html.open_table()
html.open_tr()
html.td(_("password:"******"_password_" + self._pw_suffix(), autocomplete="new-password")
html.close_td()
html.close_tr()
html.open_tr()
html.td(_("repeat:"))
html.open_td()
html.password_input("_password2_" + self._pw_suffix(), autocomplete="new-password")
html.write_text(" (%s)" % _("optional"))
html.close_td()
html.close_tr()
html.open_tr()
html.td("%s:" % _("Enforce change"))
html.open_td()
# Only make password enforcement selection possible when user is allowed to change the PW
if self._is_new_user or config.user_may(self._user_id,
'general.edit_profile') and config.user_may(
self._user_id, 'general.change_password'):
html.checkbox("enforce_pw_change",
self._user.get("enforce_pw_change", False),
label=_("Change password at next login or access"))
else:
html.write_text(
_("Not permitted to change the password. Change can not be enforced."))
else:
html.i(_('The password can not be changed (It is locked by the user connector).'))
html.hidden_field('_password', '')
html.hidden_field('_password2', '')
html.close_td()
html.close_tr()
html.close_table()
html.close_ul()
html.radiobutton("authmethod", "secret", is_automation,
_("Automation secret for machine accounts"))
html.open_ul()
html.text_input("_auth_secret",
self._user.get("automation_secret", ""),
size=30,
id_="automation_secret")
html.write_text(" ")
html.open_b(style=["position: relative", "top: 4px;"])
html.write(" ")
html.icon_button("javascript:cmk.wato.randomize_secret('automation_secret', 20);",
_("Create random secret"), "random")
html.close_b()
html.close_ul()
html.help(
_("If you want the user to be able to login "
"then specify a password here. Users without a login make sense "
"if they are monitoring contacts that are just used for "
"notifications. The repetition of the password is optional. "
"<br>For accounts used by automation processes (such as fetching "
"data from views for further procession), set the method to "
"<u>secret</u>. The secret will be stored in a local file. Processes "
"with read access to that file will be able to use Multisite as "
"a webservice without any further configuration."))
# Locking
forms.section(_("Disable password"), simple=True)
if not self._is_locked('locked'):
html.checkbox("locked",
self._user.get("locked", False),
label=_("disable the login to this account"))
else:
html.write_text(
_('Login disabled') if self._user.get("locked", False) else _('Login possible'))
html.hidden_field('locked', '1' if self._user.get("locked", False) else '')
html.help(
_("Disabling the password will prevent a user from logging in while "
"retaining the original password. Notifications are not affected "
"by this setting."))
forms.section(_("Idle timeout"))
idle_timeout = self._user.get("idle_timeout")
if not self._is_locked("idle_timeout"):
watolib.get_vs_user_idle_timeout().render_input("idle_timeout", idle_timeout)
else:
html.write_text(idle_timeout)
html.hidden_field("idle_timeout", idle_timeout)
# Roles
forms.section(_("Roles"))
entries = self._roles.items()
entries.sort(key=lambda x: (x[1]["alias"], x[0]))
is_member_of_at_least_one = False
for role_id, role in entries:
if not self._is_locked("roles"):
html.checkbox("role_" + role_id, role_id in self._user.get("roles", []))
url = watolib.folder_preserving_link([("mode", "edit_role"), ("edit", role_id)])
html.a(role["alias"], href=url)
html.br()
else:
is_member = role_id in self._user.get("roles", [])
if is_member:
is_member_of_at_least_one = True
url = watolib.folder_preserving_link([("mode", "edit_role"), ("edit", role_id)])
html.a(role["alias"], href=url)
html.br()
html.hidden_field("role_" + role_id, '1' if is_member else '')
if self._is_locked('roles') and not is_member_of_at_least_one:
html.i(_('No roles assigned.'))
self._show_custom_user_attributes('security')
# Contact groups
forms.header(_("Contact Groups"), isopen=False)
forms.section()
groups_page_url = watolib.folder_preserving_link([("mode", "contact_groups")])
group_assign_url = watolib.folder_preserving_link([("mode", "rulesets"),
("group", "grouping")])
if not self._contact_groups:
html.write(
_("Please first create some <a href='%s'>contact groups</a>") % groups_page_url)
else:
entries = sorted([(group['alias'] or c, c) for c, group in self._contact_groups.items()
])
is_member_of_at_least_one = False
for alias, gid in entries:
is_member = gid in self._user.get("contactgroups", [])
if not self._is_locked('contactgroups'):
html.checkbox("cg_" + gid, gid in self._user.get("contactgroups", []))
else:
if is_member:
is_member_of_at_least_one = True
html.hidden_field("cg_" + gid, '1' if is_member else '')
if not self._is_locked('contactgroups') or is_member:
url = watolib.folder_preserving_link([("mode", "edit_contact_group"),
("edit", gid)])
html.a(alias, href=url)
html.br()
if self._is_locked('contactgroups') and not is_member_of_at_least_one:
html.i(_('No contact groups assigned.'))
html.help(
_("Contact groups are used to assign monitoring "
"objects to users. If you haven't defined any contact groups yet, "
"then first <a href='%s'>do so</a>. Hosts and services can be "
"assigned to contact groups using <a href='%s'>rules</a>.<br><br>"
"If you do not put the user into any contact group "
"then no monitoring contact will be created for the user.") %
(groups_page_url, group_assign_url))
forms.header(_("Notifications"), isopen=False)
if not self._rbn_enabled():
forms.section(_("Enabling"), simple=True)
html.checkbox("notifications_enabled",
self._user.get("notifications_enabled", False),
label=_("enable notifications"))
html.help(
_("Notifications are sent out "
"when the status of a host or service changes."))
# Notification period
forms.section(_("Notification time period"))
choices = [(id_, "%s" % (tp["alias"])) for (id_, tp) in self._timeperiods.items()]
html.dropdown("notification_period",
choices,
deflt=self._user.get("notification_period"),
ordered=True)
html.help(
_("Only during this time period the "
"user will get notifications about host or service alerts."))
# Notification options
notification_option_names = { # defined here: _() must be executed always!
"host": {
"d": _("Host goes down"),
"u": _("Host gets unreachble"),
"r": _("Host goes up again"),
},
"service": {
"w": _("Service goes into warning state"),
"u": _("Service goes into unknown state"),
"c": _("Service goes into critical state"),
"r": _("Service recovers to OK"),
},
"both": {
"f": _("Start or end of flapping state"),
"s": _("Start or end of a scheduled downtime"),
}
}
forms.section(_("Notification Options"))
for title, what, opts in [(_("Host events"), "host", "durfs"),
(_("Service events"), "service", "wucrfs")]:
html.write_text("%s:" % title)
html.open_ul()
user_opts = self._user.get(what + "_notification_options", opts)
for opt in opts:
opt_name = notification_option_names[what].get(
opt, notification_option_names["both"].get(opt))
html.checkbox(what + "_" + opt, opt in user_opts, label=opt_name)
html.br()
html.close_ul()
html.help(
_("Here you specify which types of alerts "
"will be notified to this contact. Note: these settings will only be saved "
"and used if the user is member of a contact group."))
forms.section(_("Notification Method"))
watolib.get_vs_flexible_notifications().render_input(
"notification_method", self._user.get("notification_method"))
else:
forms.section(_("Fallback notifications"), simple=True)
html.checkbox("fallback_contact",
self._user.get("fallback_contact", False),
label=_("Receive fallback notifications"))
html.help(
_("In case none of your notification rules handles a certain event a notification "
"will be sent to this contact. This makes sure that in that case at least <i>someone</i> "
"gets notified. Furthermore this contact will be used for notifications to any host or service "
"that is not known to the monitoring. This can happen when you forward notifications "
"from the Event Console.<br><br>Notification fallback can also configured in the global "
"setting <a href=\"wato.py?mode=edit_configvar&varname=notification_fallback_email\">"
"Fallback email address for notifications</a>."))
self._show_custom_user_attributes('notify')
forms.header(_("Personal Settings"), isopen=False)
select_language(self._user)
self._show_custom_user_attributes('personal')
# Later we could add custom macros here, which then could be used
# for notifications. On the other hand, if we implement some check_mk
# --notify, we could directly access the data in the account with the need
# to store values in the monitoring core. We'll see what future brings.
forms.end()
html.button("save", _("Save"))
if self._is_new_user:
html.set_focus("user_id")
else:
html.set_focus("alias")
html.hidden_fields()
html.end_form()
def _show_test_row(self, table, test_id, test_results_by_site, site_ids):
table.row()
table.cell(_("Actions"), css="buttons", sortable=False)
html.icon_button(
None,
_("Toggle result details"),
"toggle_details",
onclick="cmk.wato.toggle_container('test_result_details_%s')" %
test_id)
worst_result = sorted(test_results_by_site["site_results"].values(),
key=lambda result: result.status)[0]
# Disabling of test in total
is_test_disabled = self._is_test_disabled(test_id)
if is_test_disabled:
html.icon_button(
html.makeactionuri([
("_do", "enable"),
("_test_id", worst_result.test_id),
]),
_("Reenable this test"),
"enable_test",
)
else:
html.icon_button(
html.makeactionuri([
("_do", "disable"),
("_test_id", worst_result.test_id),
]),
_("Disable this test"),
"disable_test",
)
# assume all have the same test meta information (title, help, ...)
table.cell(_("Title"),
css="title " + "stale" if is_test_disabled else "")
html.write_text(test_results_by_site["test"]["title"])
# Now loop all sites to display their results
for site_id in site_ids:
if is_test_disabled:
table.cell(site_id, "")
table.cell("", "")
continue
result = test_results_by_site["site_results"].get(site_id)
if result is None:
table.cell(site_id, css="state state-1")
table.cell("", css="buttons")
continue
is_acknowledged = self._is_acknowledged(result)
if is_acknowledged or result.status == -1:
css = "state stale"
else:
css = "state state%d" % result.status
table.cell(site_id, css=css)
html.open_div(title=result.text)
html.write_text(result.status_name())
html.close_div()
table.cell("", css="buttons")
if result.status != 0:
if is_acknowledged:
html.icon_button(
html.makeactionuri([
("_do", "unack"),
("_site_id", result.site_id),
("_status_id", result.status),
("_test_id", result.test_id),
]),
_("Unacknowledge this test result for site %s") %
site_id,
"unacknowledge_test",
)
else:
html.icon_button(
html.makeactionuri([
("_do", "ack"),
("_site_id", result.site_id),
("_status_id", result.status),
("_test_id", result.test_id),
]),
_("Acknowledge this test result for site %s") %
site_id,
"acknowledge_test",
)
else:
html.write("")
# Add toggleable notitication context
table.row(class_="ac_test_details hidden",
id_="test_result_details_%s" % test_id)
table.cell(colspan=2 + 2 * len(site_ids))
html.write_text(test_results_by_site["test"]["help"])
if not is_test_disabled:
html.open_table()
for site_id in site_ids:
result = test_results_by_site["site_results"].get(site_id)
if result is None:
continue
html.open_tr()
html.td(escaping.escape_attribute(site_id))
html.td("%s: %s" % (result.status_name(), result.text))
html.close_tr()
html.close_table()
# This dummy row is needed for not destroying the odd/even row highlighting
table.row(class_="hidden")
def _render_headers(self, actions_enabled, actions_visible, empty_columns):
if self.options["omit_headers"]:
return
table_id = self.id
html.open_tr()
first_col = True
for nr, (header, css, help_txt, sortable) in enumerate(self.headers):
if self.options["omit_empty_columns"] and empty_columns[nr]:
continue
text = header
if help_txt:
header = '<span title="%s">%s</span>' % (
html.attrencode(help_txt), header)
css_class = "header_%s" % css if css else None
if not self.options["sortable"] or not sortable:
html.open_th(class_=css_class)
else:
reverse = 0
sort = html.request.var('_%s_sort' % table_id)
if sort:
sort_col, sort_reverse = map(int, sort.split(',', 1))
if sort_col == nr:
reverse = 1 if sort_reverse == 0 else 0
action_uri = html.makeactionuri([('_%s_sort' % table_id,
'%d,%d' % (nr, reverse))])
html.open_th(class_=["sort", css_class],
title=_("Sort by %s") % text,
onclick="location.href='%s'" % action_uri)
# Add the table action link
if first_col:
first_col = False
if actions_enabled:
if not header:
header = " " # Fixes layout problem with white triangle
if actions_visible:
state = '0'
help_txt = _('Hide table actions')
img = 'table_actions_on'
else:
state = '1'
help_txt = _('Display table actions')
img = 'table_actions_off'
html.open_div(class_=["toggle_actions"])
html.icon_button(html.makeuri([('_%s_actions' % table_id,
state)]),
help_txt,
img,
cssclass='toggle_actions')
html.open_span()
html.write(header)
html.close_span()
html.close_div()
else:
html.write(header)
else:
html.write(header)
html.close_th()
html.close_tr()