def get_only_sites_from_context(context: VisualContext) -> Optional[List[SiteId]]:
"""Gather possible existing "only sites" information from context
We need to deal with all possible site filters (sites, site and siteopt).
VisualContext is structured like this:
{"site": {"site": "sitename"}}
{"siteopt": {"site": "sitename"}}
{"sites": {"sites": "sitename|second"}}
The difference is no fault or "old" data structure. We can have both kind of structures.
These are the data structure the visuals work with.
"site" and "sites" are conflicting filters. The new optional filter
"sites" for many sites filter is only used if the view is configured
to only this filter.
"""
if "sites" in context and "site" not in context:
only_sites = context["sites"]["sites"]
only_sites_list = [SiteId(site) for site in only_sites.strip().split("|") if site]
return only_sites_list if only_sites_list else None
for var in ["site", "siteopt"]:
if site_name := context.get(var, {}).get("site"):
return [SiteId(site_name)]
def graph_identification(self, context: VisualContext) -> GraphIdentifier:
host = context.get("host")
if not host:
raise MKUserError('host', _('Missing needed host parameter.'))
service = context.get("service")
if not service:
service = "_HOST_"
site = self._resolve_site(host)
# source changed from int (n'th graph) to the graph id in 2.0.0b6, but we cannot transform this, so we have to
# handle this here
raw_source = self._dashlet_spec["source"]
if isinstance(raw_source, int):
graph_def = {"graph_index": raw_source - 1}
else:
graph_def = {"graph_id": raw_source}
return (
"template",
{
"site": site,
"host_name": host,
"service_description": service,
**graph_def,
},
)
def filter_table(self, context: VisualContext, rows: Rows) -> Rows:
values = context.get(self.ident, {})
assert not isinstance(values, str)
filtertext = self.filtertext(values)
if not filtertext:
return rows
try:
regex = re.compile(filtertext, re.IGNORECASE)
except re.error:
raise MKUserError(
self.htmlvars[0],
_("Your search statement is not valid. You need to provide a regular "
"expression (regex). For example you need to use <tt>\\\\</tt> instead of <tt>\\</tt> "
"if you like to search for a single backslash."),
)
newrows = []
for row in rows:
invdata = inventory.get_inventory_attribute(
row["host_inventory"], self._invpath)
if not isinstance(invdata, str):
invdata = ""
if regex.search(invdata):
newrows.append(row)
return newrows
def _show_filter_form(show_filters: List[Filter], context: VisualContext) -> None:
# Sort filters
s = sorted([(f.sort_index, f.title, f) for f in show_filters if f.available()])
html.begin_form("filter")
html.open_ul(**{"data-role": "listview", "data-inset": "false"})
for _sort_index, title, f in s:
html.open_li(**{"data-role": "fieldcontain"})
html.legend(title)
f.display(context.get(f.ident, {}))
html.close_li()
html.close_ul()
html.hidden_fields()
html.hidden_field("search", "Search")
html.hidden_field("page", "data")
html.form_has_submit_button = True # a.results_button functions as a submit button
html.end_form()
html.final_javascript(
"""
const filter_form = document.getElementById("form_filter");
const results_button = document.getElementsByClassName("results_button")[0];
cmk.forms.enable_select2_dropdowns(filter_form);
results_button.onclick = function(event) {
event.preventDefault();
filter_form.submit();
};
"""
)
def filter_table(self, context: VisualContext, rows: Rows) -> Rows:
value = context.get(self.ident, {})
selection = self.selection_value(value)
if selection == self.ignore:
return rows
return [row for row in rows if self.filter_row(selection, row)]
def discovery_state_filter_table(ident: str, context: VisualContext,
rows: Rows) -> Rows:
filter_options = context.get(ident, {})
return [
row for row in rows
if filter_options.get("discovery_state_" + row["discovery_state"])
]
def filter_table(self, context: VisualContext, rows: Rows) -> Rows:
value = context.get(self.ident, {})
assert not isinstance(value, str)
name: Union[str, re.Pattern] = value.get(self._varprefix + "name", "")
if not name:
return rows
from_version = value[self._varprefix + "from_version"]
to_version = value[self._varprefix + "to_version"]
negate = bool(value[self._varprefix + "negate"])
match = value[self._varprefix + "match"]
if match == "regex":
try:
name = re.compile(name)
except re.error:
raise MKUserError(
self._varprefix + "name",
_(
"Your search statement is not valid. You need to provide a regular "
"expression (regex). For example you need to use <tt>\\\\</tt> instead of <tt>\\</tt> "
"if you like to search for a single backslash."
),
)
new_rows = []
for row in rows:
packages_table = row["host_inventory"].get_table(["software", "packages"])
if packages_table is None:
continue
packages = packages_table.data
is_in = self.find_package(packages, name, from_version, to_version)
if is_in != negate:
new_rows.append(row)
return new_rows
def filter_table(self, context: VisualContext, rows: Rows) -> Rows:
value = context.get(self.ident, {})
assert not isinstance(value, str)
current = self.selection(value)
if len(current) == 0:
return rows # No types selected, filter is unused
return [row for row in rows if str(row[self.ident]) in current]
def filter_table(self, context: VisualContext, rows: Rows) -> Rows:
values = context.get(self.ident, {})
assert not isinstance(values, str)
current = values.get(self.ident, '-1')
if current == "-1":
return rows
return [row for row in rows if str(row["invinterface_admin_status"]) == current]
def filter_table(self, context: VisualContext, rows: Rows) -> Rows:
value = context.get(self.ident, {})
current = value if isinstance(value, str) else value.get(self.ident, "")
if current not in ("no", "yes"):
return rows
return [row for row in rows if (current == "yes") == row.get("invinterface_available")]
def filter_table(self, context: VisualContext, rows: Rows) -> Rows:
value = context.get(self.query_filter.ident, {})
assert not isinstance(value, str)
selection = self.query_filter.selection(value)
if not selection:
return rows # No types selected, filter is unused
return [row for row in rows if str(row[self.query_filter.column]) in selection]
def filter_table(self, context: VisualContext, rows: Rows) -> Rows:
value = context.get(self.ident, {})
assert not isinstance(value, str)
tri = self.tristate_value(value)
if tri == -1:
return rows
if tri == 1:
return [row for row in rows if row["host_inventory"]]
# not
return [row for row in rows if not row["host_inventory"]]
def filter_table(self, context: VisualContext, rows: Rows) -> Rows:
value = context.get(self.ident, {})
assert not isinstance(value, str)
column = self.column
filtertext = value.get(column, "").strip().lower()
if not filtertext:
return rows
keep = self.row_filter(filtertext, column)
return [row for row in rows if keep(row)]
def if_oper_status_filter_table(ident: str, context: VisualContext,
rows: Rows) -> Rows:
values = context.get(ident, {})
def _add_row(row) -> bool:
# Apply filter if and only if a filter value is set
if (filter_key :=
"%s_%d" % (ident, row["invinterface_oper_status"])) in values:
return values[filter_key] == "on"
return True
def get_livestatus_filter_headers(
context: VisualContext, filters: Iterable[Filter]
) -> Iterable[FilterHeader]:
"""Prepare Filter headers for Livestatus"""
for filt in filters:
try:
value = context.get(filt.ident, {})
filt.validate_value(value)
if header := filt.filter(value):
yield header
except MKUserError as e:
user_errors.add(e)
def filter_table(self, context: VisualContext, rows: Rows) -> Rows:
# We consider the filter active if not all checkboxes
# are either on (default) or off (unset)
values = context.get(self.ident, {})
assert not isinstance(values, str)
settings = {values.get(v, "") for v in self.htmlvars}
if len(settings) == 1:
return rows
return [
row for row in rows if values.get(
"%s_%d" % (self.ident, row["invinterface_oper_status"]), "")
]
def filter_table(self, context: VisualContext, rows: Rows) -> Rows:
values = context.get(self.ident, {})
assert not isinstance(values, str)
from_value, to_value = self.extractor(values)
if (self.filter_row is None) or (from_value is None
and to_value is None):
return rows
return [
row for row in rows
if self.filter_row(row, self.column, (from_value, to_value))
]
def filter_table(self, context: VisualContext, rows: Rows) -> Rows:
value = context.get(self.ident, {})
assert not isinstance(value, str)
tri = self.tristate_value(value)
if tri == -1:
return rows
wanted_value = tri == 1
newrows = []
for row in rows:
invdata = inventory.get_inventory_attribute(row["host_inventory"], self._invpath)
if wanted_value == invdata:
newrows.append(row)
return newrows
def if_oper_status_filter_table(ident: str, context: VisualContext,
rows: Rows) -> Rows:
values = context.get(ident, {})
assert not isinstance(values, str)
# We consider the filter active if not all checkboxes
# are either on (default) or off (unset)
settings = set(values.values())
if len(settings) == 1 and len(values) > 1:
return rows
return [
row for row in rows
if values.get("%s_%d" % (ident, row["invinterface_oper_status"]))
]
def version_in_range(ident: str, request_vars: List[str],
context: VisualContext, rows: Rows) -> Rows:
values = context.get(ident, {})
assert not isinstance(values, str)
from_version, to_version = (values.get(v) for v in request_vars)
new_rows = []
for row in rows:
version = row.get(ident, "")
if from_version and utils.cmp_version(version, from_version) == -1:
continue
if to_version and utils.cmp_version(version, to_version) == 1:
continue
new_rows.append(row)
return new_rows
def filter_table(self, context: VisualContext, rows: Rows) -> Rows:
values = context.get(self.ident, {})
assert not isinstance(values, str)
from_version, to_version = (values.get(v) for v in self.htmlvars)
if not from_version and not to_version:
return rows # Filter not used
new_rows = []
for row in rows:
version = row.get(self.ident, "")
if from_version and utils.cmp_version(version, from_version) == -1:
continue
if to_version and utils.cmp_version(version, to_version) == 1:
continue
new_rows.append(row)
return new_rows
def filter_table(self, context: VisualContext, rows: Rows) -> Rows:
values = context.get(self.ident, {})
assert not isinstance(values, str)
lower, upper = self.filter_configs(values)
if not any((lower, upper)):
return rows
newrows = []
for row in rows:
invdata = inventory.get_inventory_attribute(row["host_inventory"], self._invpath)
if not isinstance(invdata, (int, float)):
continue
if lower is not None and invdata < lower:
continue
if upper is not None and invdata > upper:
continue
newrows.append(row)
return newrows
def compute_bi_aggregation_filter(
context: VisualContext, all_active_filters: Iterable[Filter]
) -> BIAggregationFilter:
only_hosts = []
only_group = []
only_service = []
only_aggr_name = []
group_prefix = []
for active_filter in all_active_filters:
conf = context.get(active_filter.ident, {})
if active_filter.ident == "aggr_hosts":
if (host_name := conf.get("aggr_host_host", "")) != "":
only_hosts = [host_name]
elif active_filter.ident == "aggr_group":
if aggr_group := conf.get(active_filter.htmlvars[0]):
only_group = [aggr_group]
def filter_table(self, context: VisualContext, rows: Rows) -> Rows:
value = context.get(self.ident, {})
assert not isinstance(value, str)
htmlvar = self.htmlvars[0]
filtertext = value.get(htmlvar, "").strip().lower()
if not filtertext:
return rows
try:
regex = re.compile(filtertext, re.IGNORECASE)
except re.error:
raise MKUserError(
htmlvar,
_('Your search statement is not valid. You need to provide a regular '
'expression (regex). For example you need to use <tt>\\\\</tt> instead of <tt>\\</tt> '
'if you like to search for a single backslash.'))
return [row for row in rows if regex.search(row.get(htmlvar, ""))]
def filter_table(self, context: VisualContext, rows: Rows) -> Rows:
values = context.get(self.ident, {})
assert not isinstance(values, str)
from_value, to_value = (utils.saveint(values.get(v, 0)) for v in self.htmlvars)
if not from_value and not to_value:
return rows
newrows = []
for row in rows:
value = row.get(self.ident, None)
if value is not None:
if from_value and value < from_value:
continue
if to_value and value > to_value:
continue
newrows.append(row)
return newrows
def filter_table(self, context: VisualContext, rows: Rows) -> Rows:
values = context.get(self.ident, {})
assert not isinstance(values, str)
from_value, to_value = (self._days_to_seconds(values.get(v, "")) for v in self.htmlvars)
if not from_value and not to_value:
return rows
now = time.time()
newrows = []
for row in rows:
value = row.get(self.ident, None)
if value is not None:
age = now - value
if from_value and age < from_value:
continue
if to_value and age > to_value:
continue
newrows.append(row)
return newrows
def filter_table(self, context: VisualContext, rows: Rows) -> Rows:
value = context.get(self.ident, {})
selection = self.selection_value(value)
if selection == self.ignore or self.filter_rows is None:
return rows
return self.filter_rows(selection, context, rows)
