def show_details(self, crash_info: CrashInfo, row) -> None:
details = crash_info["details"]
html.h3(_("Details"), class_="table")
html.open_table(class_="data")
_crash_row(_("Page"), details["page"], odd=False, legend=True)
_crash_row(_("Request Method"),
details.get("request_method", _("Unknown")))
html.open_tr(class_="data even0")
html.td(_("HTTP Parameters"), class_="left")
html.open_td()
debug_vars(html,
html.request,
vars_=details["vars"],
hide_with_mouse=False)
html.close_td()
html.close_tr()
_crash_row(_("Referer"), details.get("referer", _("Unknown")))
_crash_row(_("Username"), details["username"], odd=False)
_crash_row(_("User Agent"), details["user_agent"])
_crash_row(_("Mobile GUI"), details["is_mobile"], odd=False)
_crash_row(_("SSL"), details["is_ssl_request"])
_crash_row(_("Language"), details["language"], odd=False)
html.close_table()
def _show_group_header_table(self, group_cells, first_row):
html.open_table(class_="groupheader",
cellspacing="0",
cellpadding="0",
border="0")
html.open_tr(class_="groupheader")
painted = False
for cell in group_cells:
if painted:
html.td(", ")
painted = cell.paint(first_row)
html.close_tr()
html.close_table()
def show(self) -> None:
html.open_table(cellspacing="0", class_="sitestate")
sites.update_site_states_from_dead_sites()
for sitename, _sitealias in user_sites.sorted_sites():
site = site_config.get_site_config(sitename)
state = sites.states().get(sitename,
sites.SiteStatus({})).get("state")
if state is None:
state = "missing"
switch = "missing"
text = escape_to_html(sitename)
else:
if state == "disabled":
switch = "on"
text = escape_to_html(site["alias"])
else:
switch = "off"
text = render_link(
site["alias"],
"view.py?view_name=sitehosts&site=%s" % sitename)
html.open_tr()
html.td(text, class_="left")
html.open_td(class_="state")
if switch == "missing":
html.status_label(content=state,
status=state,
title=_("Site is missing"))
else:
url = makeactionuri_contextless(
request,
transactions,
[
("_site_switch", "%s:%s" % (sitename, switch)),
],
filename="switch_site.py",
)
html.status_label_button(
content=state,
status=state,
title=_("enable this site")
if state == "disabled" else _("disable this site"),
onclick="cmk.sidebar.switch_site(%s)" % (json.dumps(url)),
)
html.close_tr()
html.close_table()
def test_HTMLWriter(request_context):
with output_funnel.plugged():
with output_funnel.plugged():
html.open_div()
text = output_funnel.drain()
assert text.rstrip("\n").rstrip(" ") == "<div>"
with output_funnel.plugged():
# html.open_div().write("test").close_div()
html.open_div()
html.write_text("test")
html.close_div()
assert compare_html(output_funnel.drain(), "<div>test</div>")
with output_funnel.plugged():
# html.open_table().open_tr().td("1").td("2").close_tr().close_table()
html.open_table()
html.open_tr()
html.td("1")
html.td("2")
html.close_tr()
html.close_table()
assert compare_html(
output_funnel.drain(),
"<table><tr><td>1</td><td>2</td></tr></table>")
with output_funnel.plugged():
html.div("test", **{"</div>malicious_code<div>": "trends"})
assert compare_html(
output_funnel.drain(),
"<div </div>malicious_code<div>=trends>test</div>",
)
a = "\u2665"
with output_funnel.plugged():
assert HTMLWriter.render_a("test", href="www.test.case")
HTMLWriter.render_a("test", href="www.test.case")
HTMLWriter.render_a("test", href="www.test.case")
HTMLWriter.render_a("test", href="www.test.case")
try:
assert HTMLWriter.render_a(
"test",
href=str("www.test.case"),
id_=str("something"),
class_=str("test_%s") % a,
)
except Exception as e:
traceback.print_exc()
print(e)
def _show_header_line(self, cells, num_columns, show_checkboxes):
html.open_tr()
for n in range(1, num_columns + 1):
if show_checkboxes:
if n == 1:
render_group_checkbox_th()
else:
html.th("")
for cell in cells:
cell.paint_as_header()
if n < num_columns:
html.td("", class_="gap")
html.close_tr()
def display(self, value: FilterHTTPVariables):
html.open_table(class_="filtertime")
for what, whatname in [("from", _("From")), ("until", _("Until"))]:
varprefix = self.ident + "_" + what
html.open_tr()
html.td("%s:" % whatname)
html.open_td()
html.text_input(varprefix, default_value=value.get(varprefix, ""))
html.close_td()
html.open_td()
html.dropdown(
varprefix + "_range",
query_filters.time_filter_options(),
deflt=value.get(varprefix + "_range", "3600"),
)
html.close_td()
html.close_tr()
html.close_table()
def render(self, rows, view, group_cells, cells, num_columns,
show_checkboxes):
html.open_table(class_="data single")
rownum = 0
odd = "odd"
while rownum < len(rows):
if rownum > 0:
html.open_tr(class_="gap")
html.td("", class_="gap", colspan=(num_columns + 1))
html.close_tr()
thispart = rows[rownum:rownum + num_columns]
for cell in cells:
odd = "even" if odd == "odd" else "odd"
html.open_tr(class_="data %s0" % odd)
if view.get("column_headers") != "off":
html.td(cell.title(use_short=False), class_="left")
for row in thispart:
cell.paint(row)
if len(thispart) < num_columns:
html.td(
"",
class_="gap",
style="border-style: none;",
colspan=(1 + num_columns - len(thispart)),
)
html.close_tr()
rownum += num_columns
html.close_table()
def _render_rule_reason(self, title, title_url, reason, reason_url,
is_default, setting: Union[str, HTML]) -> None:
if title_url:
title = HTMLWriter.render_a(title, href=title_url)
forms.section(title)
if reason:
reason = HTMLWriter.render_a(reason, href=reason_url)
html.open_table(class_="setting")
html.open_tr()
if is_default:
html.td(HTMLWriter.render_i(reason), class_="reason")
html.td(setting, class_=["settingvalue", "unused"])
else:
html.td(reason, class_="reason")
html.td(setting, class_=["settingvalue", "used"])
html.close_tr()
html.close_table()
def page(self):
html.open_table(class_=["data", "headerleft"])
html.open_tr()
html.th(_("Title"))
html.open_td()
html.b(self._manpage.title)
html.close_td()
html.close_tr()
html.open_tr()
html.th(_("Name of plugin"))
html.open_td()
html.tt(self._check_plugin_name)
html.close_td()
html.close_tr()
html.open_tr()
html.th(_("Description"))
html.td(self._manpage_text(self._manpage.description))
html.close_tr()
if self._check_type == "check_mk":
html.open_tr()
html.th(_("Service name"))
html.td(HTML(self._service_description.replace("%s", "☐")))
html.close_tr()
if discovery := self._manpage.discovery:
html.open_tr()
html.th(_("Discovery"))
html.td(self._manpage_text(discovery))
html.close_tr()
if self._manpage.cluster:
html.open_tr()
html.th(_("Cluster behaviour"))
html.td(self._manpage_text(self._manpage.cluster))
html.close_tr()
def _crash_row(title: str,
infotext: HTMLContent,
odd: bool = True,
legend: bool = False,
pre: bool = False) -> None:
trclass = "data odd0" if odd else "data even0"
tdclass = "left legend" if legend else "left"
html.open_tr(class_=trclass)
html.td(title, class_=tdclass)
if pre:
html.td(HTMLWriter.render_pre(infotext))
else:
html.td(infotext)
html.close_tr()
def _write_table(
self,
rows: TableRows,
num_rows_unlimited: int,
actions_enabled: bool,
actions_visible: bool,
search_term: Optional[str],
) -> None:
if not self.options["omit_update_header"]:
row_info = _("1 row") if len(
rows) == 1 else _("%d rows") % num_rows_unlimited
html.javascript("cmk.utils.update_row_info(%s);" %
json.dumps(row_info))
table_id = self.id
num_cols = self._get_num_cols(rows)
empty_columns = self._get_empty_columns(rows, num_cols)
if self.options["omit_empty_columns"]:
num_cols -= len([v for v in empty_columns if v])
html.open_table(class_=["data", "oddeven"] + self.css)
# If we have no group headers then paint the headers now
if self.rows and not isinstance(self.rows[0], GroupHeader):
self._render_headers(
actions_enabled,
actions_visible,
empty_columns,
)
if actions_enabled and actions_visible:
html.open_tr(class_=["data", "even0", "actions"])
html.open_td(colspan=num_cols)
if not html.in_form():
html.begin_form("%s_actions" % table_id)
if request.has_var("_%s_sort" % table_id):
html.open_div(class_=["sort"])
html.button("_%s_reset_sorting" % table_id, _("Reset sorting"))
html.close_div()
if not html.in_form():
html.begin_form("%s_actions" % table_id)
html.hidden_fields()
html.end_form()
html.close_tr()
for nr, row in enumerate(rows):
# Intermediate header
if isinstance(row, GroupHeader):
# Show the header only, if at least one (non-header) row follows
if nr < len(rows) - 1 and not isinstance(
rows[nr + 1], GroupHeader):
html.open_tr(class_="groupheader")
html.open_td(colspan=num_cols)
html.h3(row.title)
html.close_td()
html.close_tr()
self._render_headers(actions_enabled, actions_visible,
empty_columns)
continue
oddeven_name = "even" if nr % 2 == 0 else "odd"
class_ = ["data", "%s%d" % (oddeven_name, row.state)]
if isinstance(row.css, list):
class_.extend([c for c in row.css if c is not None])
elif row.css is not None:
class_.append(row.css)
html.open_tr(class_=class_,
id_=row.id_,
onmouseover=row.onmouseover,
onmouseout=row.onmouseout)
for col_index, cell in enumerate(row.cells):
if self.options["omit_empty_columns"] and empty_columns[
col_index]:
continue
html.td(cell.content, class_=cell.css, colspan=cell.colspan)
html.close_tr()
if not rows and search_term:
html.open_tr(class_=["data", "odd0", "no_match"])
html.td(
_("Found no matching rows. Please try another search term."),
colspan=num_cols)
html.close_tr()
html.close_table()
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(
makeactionuri(
request,
transactions,
[
("_do", "enable"),
("_test_id", worst_result.test_id),
],
),
_("Reenable this test"),
"enable_test",
)
else:
html.icon_button(
makeactionuri(
request,
transactions,
[
("_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.span(result.status_name(),
title=result.text,
class_="state_rounded_fill")
table.cell("", css="buttons")
if result.status != 0:
if is_acknowledged:
html.icon_button(
makeactionuri(
request,
transactions,
[
("_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(
makeactionuri(
request,
transactions,
[
("_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_text("")
# Add toggleable notitication context
table.row(css="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(css="hidden")
def write_line(left, right, show_more):
html.open_tr(class_="show_more_mode" if show_more else "basic")
html.td(left, class_="left")
html.td(HTMLWriter.render_strong(right), class_="right")
html.close_tr()
def werk_table_row(caption, content, css=None):
html.open_tr()
html.th(caption)
html.td(content, class_=css)
html.close_tr()
def _show_master_control_site(
self,
site_id: sites.SiteId,
site_status_info: Dict[sites.SiteId, List],
items: List[Tuple[str, str]],
) -> None:
site_state = sites.states().get(site_id)
if not site_state:
html.show_error(_("Site state is unknown"))
return
if site_state["state"] == "dead":
html.show_error(str(site_state["exception"]))
return
if site_state["state"] == "disabled":
html.show_message(_("Site is disabled"))
return
if site_state["state"] == "unknown":
if site_state.get("exception"):
html.show_error(str(site_state["exception"]))
else:
html.show_error(_("Site state is unknown"))
return
is_cmc = site_state["program_version"].startswith("Check_MK ")
try:
site_info = site_status_info[site_id]
except KeyError:
html.show_error(_("Site state is unknown"))
return
html.open_table(class_="master_control")
for i, (colname, title) in enumerate(items):
# Do not show event handlers on Checkmk Micro Core
if is_cmc and title == _("Event handlers"):
continue
if not is_cmc and title == _("Alert handlers"):
continue
colvalue = site_info[i]
url = makeactionuri_contextless(
request,
transactions,
[
("site", site_id),
("switch", colname),
("state", "%d" % (1 - colvalue)),
],
filename="switch_master_state.py",
)
onclick = (
"cmk.ajax.get_url('%s', cmk.utils.update_contents, 'snapin_master_control')" % url
)
html.open_tr()
html.td(title, class_="left")
html.open_td()
html.toggle_switch(
enabled=colvalue,
help_txt=_("Switch '%s' to '%s'") % (title, _("off") if colvalue else _("on")),
onclick=onclick,
)
html.close_td()
html.close_tr()
html.close_table()
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(
make_confirm_link(
url=makeactionuri(request, transactions,
[(ActionHandler.stop_job_var, job_id)]),
message=_("Stop job %s%s?") %
(job_id, cls._get_extra_info(job_status)),
),
_("Stop this job"),
"disable_test",
)
if job_status.get("may_delete"):
html.icon_button(
make_confirm_link(
url=makeactionuri(
request, transactions,
[(ActionHandler.delete_job_var, job_id)]),
message=_("Delete job %s%s?") %
(job_id, cls._get_extra_info(job_status)),
),
_("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 = 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 += " (%s: %s)" % (
_("estimated duration"),
cmk.utils.render.timespan(job_status["estimated_duration"]),
)
for left, right in [
(_("Runtime"), runtime_info),
(_("PID"), str(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.pre(HTML("\n".join(loginfo["JobResult"])))
html.close_div()
html.close_td()
html.close_tr()
html.close_table()
def _show_rows(self):
rows = self._get_rows()
if bool([r for r in rows if r.stats is None]):
html.center(_("No data from any site"))
return
html.open_table(class_=["tacticaloverview"], cellspacing="2", cellpadding="0", border="0")
show_stales = self.parameters()["show_stale"] and user.may(
"general.see_stales_in_tactical_overview"
)
has_stale_objects = bool([r for r in rows if r.what != "events" and r.stats[-1]])
for row in rows:
if row.what == "events":
amount, problems, unhandled_problems = row.stats
stales = 0
# no events open and disabled in local site: don't show events
if amount == 0 and not active_config.mkeventd_enabled:
continue
else:
amount, problems, unhandled_problems, stales = row.stats
context_vars = get_context_url_variables(row.context)
html.open_tr()
html.th(row.title)
html.th(_("Problems"), class_="show_more_mode")
html.th(
HTMLWriter.render_span(_("Unhandled"), class_="more")
+ HTMLWriter.render_span(_("Unhandled p."), class_="less")
)
if show_stales and has_stale_objects:
html.th(_("Stale"))
html.close_tr()
td_class = "col4" if has_stale_objects else "col3"
html.open_tr()
url = makeuri_contextless(request, row.views.total + context_vars, filename="view.py")
html.open_td(class_=["total", td_class])
html.a("%s" % amount, href=url, target="main")
html.close_td()
for value, ty in [(problems, "handled"), (unhandled_problems, "unhandled")]:
url = makeuri_contextless(
request,
getattr(row.views, ty) + context_vars,
filename="view.py",
)
html.open_td(
class_=[td_class]
+ ([] if value == 0 else ["states prob"])
+ ["show_more_mode" if ty == "handled" else "basic"]
)
link(str(value), url)
html.close_td()
if show_stales and has_stale_objects:
if row.views.stale:
url = makeuri_contextless(
request,
row.views.stale + context_vars,
filename="view.py",
)
html.open_td(class_=[td_class] + ([] if stales == 0 else ["states prob"]))
link(str(stales), url)
html.close_td()
else:
html.td(HTMLWriter.render_span("0"))
html.close_tr()
html.close_table()
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(
makeactionuri(request, transactions,
[(ActionHandler.stop_job_var, job_id)]),
_("Stop this job"),
"disable_test",
)
if job_status.get("may_delete"):
html.icon_button(
makeactionuri(request, transactions,
[(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(
HTMLWriter.render_span(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 render(self, rows, view, group_cells, cells, num_columns,
show_checkboxes):
repeat_heading_every = 20 # in case column_headers is "repeat"
html.open_table(class_="data table")
last_group = None
odd = "odd"
column = 1
group_open = False
num_cells = len(cells)
if show_checkboxes:
num_cells += 1
if not group_cells and view.get("column_headers") != "off":
self._show_header_line(cells, num_columns, show_checkboxes)
rows_with_ids = [(row_id(view, row), row) for row in rows]
groups, rows_with_ids = calculate_view_grouping_of_services(
rows_with_ids, row_group_cells=group_cells)
visible_row_number = 0
group_hidden, num_grouped_rows = None, 0
for index, row in rows_with_ids:
# Show group header, if a new group begins. But only if grouping
# is activated
if group_cells:
this_group = group_value(row, group_cells)
if this_group != last_group:
if column != 1: # not a the beginning of a new line
for _i in range(column - 1, num_columns):
html.td("", class_="gap")
html.td("", class_="fillup", colspan=num_cells)
html.close_tr()
column = 1
group_open = True
visible_row_number = 0
# paint group header, but only if it is non-empty
header_is_empty = True
for cell in group_cells:
_tdclass, content = cell.render(row)
if content:
header_is_empty = False
break
if not header_is_empty:
html.open_tr(class_="groupheader")
html.open_td(
class_="groupheader",
colspan=(num_cells * (num_columns + 2) +
(num_columns - 1)),
)
html.open_table(class_="groupheader",
cellspacing="0",
cellpadding="0",
border="0")
html.open_tr()
painted = False
for cell in group_cells:
if painted:
html.td(", ")
painted = cell.paint(row)
html.close_tr()
html.close_table()
html.close_td()
html.close_tr()
odd = "odd"
# Table headers
if view.get("column_headers") != "off":
self._show_header_line(cells, num_columns,
show_checkboxes)
last_group = this_group
# Should we wrap over to a new line?
if column >= num_columns + 1:
html.close_tr()
column = 1
# At the beginning of the line? Beginn new line
if column == 1:
if view.get("column_headers") == "repeat":
if visible_row_number > 0 and visible_row_number % repeat_heading_every == 0:
self._show_header_line(cells, num_columns,
show_checkboxes)
visible_row_number += 1
# In one-column layout we use the state of the service
# or host - if available - to color the complete line
if num_columns == 1:
# render state, if available through whole tr
if not row.get("service_description"):
state = row.get("host_state", 0)
if state > 0:
state += 1 # 1 is critical for hosts
else:
state = row.get("service_state", 0)
else:
state = 0
if index in groups:
group_spec, num_grouped_rows = groups[index]
group_hidden = grouped_row_title(index, group_spec,
num_grouped_rows, odd,
num_cells)
odd = "even" if odd == "odd" else "odd"
css_classes = []
hide = ""
if num_grouped_rows > 0:
num_grouped_rows -= 1
if group_hidden:
hide = "display:none"
if group_hidden is not None and num_grouped_rows == 0:
# last row in group
css_classes.append("group_end")
group_hidden = None
odd = "even" if odd == "odd" else "odd"
if num_columns > 1:
css_classes.append("multicolumn")
css_classes += ["%s%d" % (odd, state)]
html.open_tr(class_=["data"] + css_classes, style=hide)
# Not first columns: Create one empty column as separator
else:
html.open_td(class_="gap")
html.close_td()
if show_checkboxes:
render_checkbox_td(view, row, num_cells)
for cell in cells:
cell.paint(row)
column += 1
if group_open:
for _i in range(column - 1, num_columns):
html.td("", class_="gap")
html.td("", class_="fillup", colspan=num_cells)
html.close_tr()
html.close_table()
if not user.may("general.act"):
return
init_rowselect(_get_view_name(view))
def render(self, rows, view, group_cells, cells, num_columns,
show_checkboxes):
html.open_table(class_="data tiled")
last_group = None
group_open = False
for row in rows:
# Show group header
if group_cells:
this_group = group_value(row, group_cells)
if this_group != last_group:
# paint group header
if group_open:
html.close_td()
html.close_tr()
html.open_tr()
html.open_td()
html.open_table(class_="groupheader")
html.open_tr(class_="groupheader")
painted = False
for cell in group_cells:
if painted:
html.td(", ")
painted = cell.paint(row)
html.close_tr()
html.close_table()
html.close_td()
html.close_tr()
html.open_tr()
html.open_td(class_="tiles")
group_open = True
last_group = this_group
# background color of tile according to item state
state = row.get("service_state", -1)
if state == -1:
hbc = row.get("host_has_been_checked", 1)
if hbc:
state = row.get("host_state", 0)
sclass = "hhstate%d" % state
else:
sclass = "hhstatep"
else:
hbc = row.get("service_has_been_checked", 1)
if hbc:
sclass = "sstate%d" % state
else:
sclass = "sstatep"
if not group_open:
html.open_tr()
html.open_td(class_="tiles")
group_open = True
html.open_div(class_=["tile", sclass])
html.open_table()
# We need at least five cells
if len(cells) < 5:
cells = cells + ([EmptyCell(view)] * (5 - len(cells)))
rendered = [cell.render(row) for cell in cells]
html.open_tr()
html.open_td(class_=["tl", rendered[1][0]])
if show_checkboxes:
render_checkbox(view, row, len(cells) - 1)
html.write_text(rendered[1][1])
html.close_td()
html.open_td(class_=["tr", rendered[2][0]])
html.write_text(rendered[2][1])
html.close_td()
html.close_tr()
html.open_tr()
html.open_td(colspan=2, class_=["center", rendered[0][0]])
html.write_text(rendered[0][1])
html.close_td()
html.close_tr()
for css, cont in rendered[5:]:
html.open_tr()
html.open_td(colspan=2, class_=["cont", css])
html.write_text(cont)
html.close_td()
html.close_tr()
html.open_tr()
html.open_td(class_=["bl", rendered[3][0]])
html.write_text(rendered[3][1])
html.close_td()
html.open_td(class_=["br", rendered[4][0]])
html.write_text(rendered[4][1])
html.close_td()
html.close_tr()
html.close_table()
html.close_div()
if group_open:
html.close_td()
html.close_tr()
html.close_table()
if not user.may("general.act"):
return
init_rowselect(_get_view_name(view))
def render(self, rows, view, group_cells, cells, num_columns,
show_checkboxes):
header_majorities = self._matrix_find_majorities_for_header(
rows, group_cells)
value_counts, row_majorities = self._matrix_find_majorities(
rows, cells)
painter_options = PainterOptions.get_instance()
for groups, unique_row_ids, matrix_cells in create_matrices(
rows, group_cells, cells, num_columns):
# Paint the matrix. Begin with the group headers
html.open_table(class_="data matrix")
odd = "odd"
for cell_nr, cell in enumerate(group_cells):
odd = "even" if odd == "odd" else "odd"
html.open_tr(class_="data %s0" % odd)
html.open_td(class_="matrixhead")
html.write_text(cell.title(use_short=False))
html.close_td()
for _group, group_row in groups:
tdclass, content = cell.render(group_row)
if cell_nr > 0:
gv = group_value(group_row, [cell])
majority_value = header_majorities.get(
cell_nr - 1, None)
if majority_value is not None and majority_value != gv:
tdclass += " minority"
html.open_td(class_=["left", tdclass])
html.write_text(content)
html.close_td()
html.close_tr()
# Now for each unique service^H^H^H^H^H^H ID column paint one row
for rid in unique_row_ids:
# Omit rows where all cells have the same values
if painter_options.get("matrix_omit_uniform"):
at_least_one_different = False
for counts in value_counts[rid].values():
if len(counts) > 1:
at_least_one_different = True
break
if not at_least_one_different:
continue
odd = "even" if odd == "odd" else "odd"
html.open_tr(class_="data %s0" % odd)
tdclass, content = cells[0].render(
list(matrix_cells[rid].values())[0])
html.open_td(class_=["left", tdclass])
html.write_text(content)
html.close_td()
# Now go through the groups and paint the rest of the
# columns
for group_id, group_row in groups:
cell_row = matrix_cells[rid].get(group_id)
if cell_row is None:
html.td("")
else:
if len(cells) > 2:
html.open_td(class_="cell")
html.open_table()
for cell_nr, cell in enumerate(cells[1:]):
tdclass, content = cell.render(cell_row)
gv = group_value(cell_row, [cell])
majority_value = row_majorities[rid].get(
cell_nr, None)
if majority_value is not None and majority_value != gv:
tdclass += " minority"
if len(cells) > 2:
html.open_tr()
html.td(content, class_=tdclass)
if len(cells) > 2:
html.close_tr()
if len(cells) > 2:
html.close_table()
html.close_td()
html.close_tr()
html.close_table()
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)
make_header(
html, 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 active_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()