def __live_query_to_choices(
query_callback: Callable[[MultiSiteConnection],
Collection[LivestatusColumn]],
limit: int,
value: str,
params: Dict,
) -> Choices:
selected_sites = get_only_sites_from_context(params.get("context", {}))
with sites.only_sites(selected_sites), sites.set_limit(limit):
query_result = query_callback(sites.live())
choices = [(h, h)
for h in sorted(query_result, key=lambda h: h.lower())]
if len(choices) > limit:
choices.insert(
0, (None, _("(Max suggestions reached, be more specific)")))
if (value, value) not in choices and params["strict"] is False:
choices.insert(
0, (value, value)) # User is allowed to enter anything they want
return choices
def service_table_query(properties, context, column_generator):
filter_headers, only_sites = visuals.get_filter_headers(
"services", ["host", "service"], context)
columns = column_generator(properties, context)
query = ("GET services\n"
"Columns: %(cols)s\n"
"%(filter)s" % {
"cols": " ".join(columns),
"filter": filter_headers,
})
with sites.only_sites(only_sites), sites.prepend_site():
try:
rows = sites.live().query(query)
except MKTimeout:
raise
except Exception:
raise MKGeneralException(_("The query returned no data."))
return ['site'] + columns, rows
def _list_services(param):
live = sites.live()
q = Query(param['columns'])
host_name = param.get('host_name')
if host_name is not None:
q = q.filter(Services.host_name == host_name)
query_expr = param.get('query')
if query_expr:
q = q.filter(query_expr)
result = q.iterate(live)
return constructors.serve_json(
constructors.collection_object(
domain_type='service',
value=[
constructors.domain_object(
domain_type='service',
title=f"{entry['description']} on {entry['host_name']}",
identifier=f"{entry['host_name']}:{entry['description']}",
editable=False,
deletable=False,
extensions=entry,
self_link=constructors.link_rel(
rel='cmk/show',
href=constructors.object_action_href(
'host',
entry['host_name'],
'show_service',
query_params=[('service_description', entry['description'])],
),
method='get',
title=f"Show the service {entry['description']}",
),
) for entry in result
],
))
def test_servicegroup_service_downtime_and_hosts(mock_livestatus,
register_builtin_html, dates):
start_time, end_time = dates
with mock_livestatus(expect_status_query=True) as live:
live.expect_query([
"GET servicegroups",
"Columns: members",
"Filter: name = example",
])
live.expect_query(
'COMMAND [...] SCHEDULE_SVC_DOWNTIME;example.com;Memory;0;86400;17;0;120;;Boom',
match_type='ellipsis',
)
live.expect_query(
'COMMAND [...] SCHEDULE_SVC_DOWNTIME;example.com;CPU load;0;86400;17;0;120;;Boom',
match_type='ellipsis',
)
live.expect_query(
'COMMAND [...] SCHEDULE_SVC_DOWNTIME;heute;CPU load;0;86400;17;0;120;;Boom',
match_type='ellipsis',
)
live.expect_query(
'COMMAND [...] SCHEDULE_HOST_DOWNTIME;example.com;0;86400;17;0;120;;Boom',
match_type='ellipsis',
)
live.expect_query(
'COMMAND [...] SCHEDULE_HOST_DOWNTIME;heute;0;86400;17;0;120;;Boom',
match_type='ellipsis',
)
downtimes.schedule_servicegroup_service_downtime(
sites.live(),
'example',
start_time,
end_time,
include_hosts=True,
recur="day_of_month",
duration=120,
comment="Boom",
)
def autocomplete_choices(cls, value: str, params: Dict) -> Choices:
"""Return the matching list of dropdown choices
Called by the webservice with the current input field value and the
completions_params to get the list of choices"""
if not (params.get("host") or params.get("service")):
choices: Iterable[TupleType[str, str]] = ((
graph_id,
graph_details.get(
"title",
graph_id,
),
) for graph_id, graph_details in graph_info.items())
else:
query = "\n".join([
"GET services",
"Columns: perf_data metrics check_command",
] + [
f"Filter: {filter_name} = {livestatus.lqencode(filter_value)}"
for filter_name, filter_value in (
("host_name", params.get("host")),
("service_description", params.get("service")),
) if filter_value
])
with sites.set_limit(None):
choices = set(
chain.from_iterable(
cls._graph_choices_from_livestatus_row(
perf_data,
metrics,
check_cmd,
) for perf_data, metrics, check_cmd in
sites.live().query(query)))
val_lower = value.lower()
return sorted(
(choice for choice in choices if val_lower in choice[1].lower()),
key=lambda tuple_id_title: tuple_id_title[1],
)
def test_host_downtime(mock_livestatus, with_request_context, dates):
start_time, end_time = dates
with mock_livestatus(
expect_status_query=True) as live, application_and_request_context(
), SuperUserContext():
load_config()
live.expect_query(
"GET hosts\nColumns: name\nFilter: name = example.com")
live.expect_query(
"COMMAND [...] SCHEDULE_HOST_DOWNTIME;example.com;0;86400;12;0;120;;Going down",
match_type="ellipsis",
)
downtimes.schedule_host_downtime(
sites.live(),
"example.com",
start_time,
end_time,
recur="weekday_start",
duration=120,
comment="Going down",
)
def _table_query(properties, context, column_generator, table: str,
infos: List[str]):
filter_headers, only_sites = visuals.get_filter_headers(
table, infos, context)
columns = column_generator(properties, context)
query = (f"GET {table}\n"
"Columns: %(cols)s\n"
"%(filter)s" % {
"cols": " ".join(columns),
"filter": filter_headers,
})
with sites.only_sites(only_sites), sites.prepend_site():
try:
rows = sites.live().query(query)
except MKTimeout:
raise
except Exception:
raise MKGeneralException(_("The query returned no data."))
return ['site'] + columns, rows
def _query_for_metrics_of_host(self, host_name, site_id):
if not host_name:
return {}
query = (
"GET services\n"
"Columns: description check_command metrics\n"
"Filter: host_name = %s\n" % livestatus.lqencode(host_name)
)
response = {}
with sites.only_sites(site_id):
rows = sites.live().query(query)
for service_description, check_command, metrics in rows:
response[service_description] = {
"check_command": check_command,
"metrics": self._get_metric_infos(metrics, check_command),
}
return response
def _livestatus_get_labels(
self, only_sites: List[str]) -> List[Dict[SiteId, _Labels]]:
"""Get labels for all sites that need an update and the user is authorized for"""
query: str = "GET services\n" "Cache: reload\n" "Columns: host_labels labels\n" # #
with sites.prepend_site(), sites.only_sites(only_sites):
rows = [(x[0], x[1], x[2]) for x in sites.live(user).query(query)]
host_labels: Dict[SiteId, _Labels] = {}
service_labels: Dict[SiteId, _Labels] = {}
for row in rows:
site_id = row[0]
host_label = row[1]
service_label = row[2]
for key, value in host_label.items():
host_labels.setdefault(site_id, {}).update({key: value})
for key, value in service_label.items():
service_labels.setdefault(site_id, {}).update({key: value})
return [host_labels, service_labels]
def find_host_services(
host_name: str,
service_description: str = ""
) -> Iterator[Tuple[str, str, Tuple[str, ...]]]:
if not host_name and not service_description: # optimization: avoid query with empty result
return
# TODO: site hint!
# Also fetch host data with the *same* query. This saves one round trip. And head
# host has at least one service
query = (
"GET services\n"
"Columns: description check_command perf_data metrics host_check_command host_metrics \n"
)
if host_name:
query += "Filter: host_name = %s\n" % livestatus.lqencode(host_name)
if service_description:
query += "Filter: service_description = %s\n" % livestatus.lqencode(
service_description)
host_check_command, host_metrics = None, None
for (
svc_desc,
check_command,
perf_data,
rrd_metrics,
host_check_command,
host_metrics,
) in sites.live().query(query):
parsed_perf_data, check_command = parse_perf_data(
perf_data, check_command)
known_metrics = set([perf[0]
for perf in parsed_perf_data] + rrd_metrics)
yield svc_desc, check_command, tuple(known_metrics)
if host_check_command:
yield "_HOST_", host_check_command, tuple(host_metrics)
def _fetch_simple_number_data(self, properties, context):
mode_properties = properties["render_mode"][1]
time_range = self._int_time_range_from_rangespec(
mode_properties["time_range"])
filter_headers, only_sites = get_filter_headers(
"log", self.filter_infos(), context)
object_type_filter = self._get_object_type_filter(properties)
query = ("GET log\n"
"Stats: log_type != \n"
"Filter: class = %d\n"
"Filter: log_time >= %f\n"
"Filter: log_time <= %f\n"
"%s"
"%s" % (self.log_class, time_range[0], time_range[1],
object_type_filter, lqencode(filter_headers)))
with sites.only_sites(only_sites):
try:
return sites.live().query_summed_stats(query)
except livestatus.MKLivestatusNotFoundError:
raise MKGeneralException(_("The query returned no data."))
def set_acknowledgement_for_service(params):
"""Acknowledge for a service globally"""
service_description = unquote(params['service_description'])
body = params['body']
live = sites.live()
services = Query(
[Services.host_name, Services.description],
And(
Services.description.equals(service_description),
Or(
Services.state == 1,
Services.state == 2,
),
),
).fetch_values(live)
if not len(services):
return problem(
status=400,
title=f'No services {service_description!r} with problems found.',
detail='All services are OK.',
)
for _host_name, _service_description in services:
acknowledge_service_problem(
live,
_host_name,
_service_description,
sticky=body.get('sticky', False),
notify=body.get('notify', False),
persistent=body.get('persistent', False),
user=_user_id(),
comment=body.get('comment', 'Acknowledged'),
)
return http.Response(status=204)
def choices(self) -> Choices:
self.check_wato_data_update()
# Note: WATO Folders that the user has not permissions to must not be visible.
# Permissions in this case means, that the user has view permissions for at
# least one host in that folder.
result = sites.live().query(
"GET hosts\nCache: reload\nColumns: filename\nStats: state >= 0\n")
allowed_folders = {""} # The root(Main directory)
for path, _host_count in result:
# convert '/wato/server/hosts.mk' to 'server'
folder = path[6:-9]
# allow the folder an all of its parents
parts = folder.split("/")
subfolder = ""
for part in parts:
if subfolder:
subfolder += "/"
subfolder += part
allowed_folders.add(subfolder)
return [
entry for entry in self.selection if entry[0] in allowed_folders
]
def fetch_rrd_data(
site: SiteId,
host_name: HostName,
service_description: ServiceName,
metrics: set[MetricProperties],
graph_recipe: GraphRecipe,
graph_data_range: GraphDataRange,
) -> list[tuple[MetricProperties, TimeSeriesValues]]:
start_time, end_time = graph_data_range["time_range"]
step = graph_data_range["step"]
# assumes str step is well formatted, colon separated step length & rrd point count
if not isinstance(step, str):
step = max(1, step)
point_range = ":".join(map(str, (start_time, end_time, step)))
lql_columns = list(
rrd_columns(metrics, graph_recipe["consolidation_function"],
point_range))
query = livestatus_lql([host_name], lql_columns, service_description)
with sites.only_sites(site):
return list(zip(metrics, sites.live().query_row(query)))
def display(self):
self.check_wato_data_update()
# Note: WATO Folders that the user has not permissions to must not be visible.
# Permissions in this case means, that the user has view permissions for at
# least one host in that folder.
result = sites.live().query(
"GET hosts\nCache: reload\nColumns: filename\nStats: state >= 0\n")
allowed_folders = set([""])
for path, _host_count in result:
# convert '/wato/server/hosts.mk' to 'server'
folder = path[6:-9]
# allow the folder an all of its parents
parts = folder.split("/")
subfolder = ""
for part in parts:
if subfolder:
subfolder += "/"
subfolder += part
allowed_folders.add(subfolder)
html.dropdown(
self.ident, [("", "")] +
[entry for entry in self.selection if entry[0] in allowed_folders])
def _query_for_metrics_of_host(self, site_id, host_name, service_name):
if not host_name or not service_name:
return {}
query = ("GET services\n"
"Columns: description check_command service_perf_data host_state service_state\n"
"Filter: host_name = %s\n"
"Filter: service_description = %s\n" %
(livestatus.lqencode(host_name), service_name))
try:
rows = sites.live().query(query)
except Exception:
raise MKGeneralException(
_("The query for the given metric, service and host names returned no data."))
for service_description, check_command, service_perf_data, host_state, svc_state in rows:
return {
"service_description": service_description,
"check_command": check_command,
"service_perf_data": service_perf_data,
"host_state": host_state,
"svc_state": svc_state,
}
def _get_data(cls, properties, context, return_column_headers=True):
time_range = cls.int_time_range_from_rangespec(properties["time_range"])
c_headers = "ColumnHeaders: on\n" if return_column_headers else ""
filter_headers, only_sites = get_filter_headers("log", ["host", "service"], context)
metrics = {
"CPU load": "load1",
"CPU utilization": "util",
}
service_desc = properties["service"]
query = (
"GET services\n"
"Columns: host_name host_state service_description service_state service_check_command service_metrics service_perf_data rrddata:v1:%(metric)s:%(start)s:%(end)s:%(step)s\n"
# rrddata:m1:load1.max:%(start)s:%(end)s:%(step)s rrddata:m5:load5.max:%(start)s:%(end)s:%(step)s rrddata:m15:load15.max:%(start)s:%(end)s:%(step)s
"%(column)s"
"Filter: service_description ~~ %(service)s\n"
"%(filter)s" % {
"metric": metrics[service_desc],
"start": time_range[0],
"end": time_range[1],
"step": 300,
"service": service_desc,
"column": c_headers,
"filter": filter_headers,
})
with sites.only_sites(only_sites), sites.prepend_site():
try:
rows = sites.live().query(query)
except MKTimeout:
raise
except Exception:
raise MKGeneralException(_("The query returned no data."))
if return_column_headers:
return rows[0], rows[1:]
return rows, ""
def show_service(params):
"""Show the monitored service of a host"""
service_description = params["service_description"]
host_name = params["host_name"]
live = sites.live()
q = Query(
[
Services.description,
Services.host_name,
Services.state_type,
Services.state,
Services.last_check,
],
filter_expr=And(
Services.host_name.op("=", params["host_name"]),
Services.description.op("=", service_description),
),
)
try:
service = q.fetchone(live)
except ValueError:
return problem(
status=404,
title="The requested service was not found",
detail=
f"The service description {service_description} did not match any service",
)
return constructors.serve_json(
constructors.domain_object(
domain_type="service",
identifier=f"{host_name}-{service_description}",
title=f"Service {service_description}",
extensions=service,
links=[],
editable=False,
deletable=False,
))
def _get_data(cls, properties, context):
time_range = cls._int_time_range_from_rangespec(
properties["time_range"])
filter_headers, only_sites = get_filter_headers(
"log", cls.filter_infos(), context)
query = (
"GET log\n"
"Columns: log_state host_name service_description log_type log_time\n"
"Filter: class = %d\n"
"Filter: log_time >= %f\n"
"Filter: log_time <= %f\n"
"Filter: log_type ~ %s .*\n"
"%s" % (cls.log_class(), time_range[0], time_range[1],
lqencode(properties["log_target"].upper()),
lqencode(filter_headers)))
with sites.only_sites(only_sites):
try:
return sites.live().query(query)
except MKTimeout:
raise
except Exception as _e:
raise MKGeneralException(_("The query returned no data."))
def delete_downtime(params):
"""Delete a scheduled downtime"""
body = params['body']
live = sites.live()
delete_type = body['delete_type']
if delete_type == "query":
downtime_commands.delete_downtime_with_query(live, body['query'])
elif delete_type == "by_id":
downtime_commands.delete_downtime(live, body['downtime_id'])
elif delete_type == "params":
hostname = body['hostname']
if "services" not in body:
host_query = {"op": "~", "left": "downtimes.host_name", "right": hostname}
downtime_commands.delete_downtime_with_query(live, host_query)
else:
services_query = {
"op": "and",
"expr": [{
'op': '=',
'left': 'downtimes.host_name',
'right': body['hostname']
}, {
'op': 'or',
'expr': [{
'op': '=',
'left': 'downtimes.service_description',
'right': service_description
} for service_description in body['services']]
}]
}
downtime_commands.delete_downtime_with_query(live, services_query)
else:
return problem(status=400,
title="Unhandled delete_type.",
detail=f"The downtime-type {delete_type!r} is not supported.")
return Response(status=204)
def show_downtimes(param):
"""Show all scheduled downtimes"""
live = sites.live()
sites_to_query = param.get('sites')
if sites_to_query:
live.only_sites = sites_to_query
q = Query([
Downtimes.id,
Downtimes.host_name,
Downtimes.service_description,
Downtimes.is_service,
Downtimes.author,
Downtimes.start_time,
Downtimes.end_time,
Downtimes.recurring,
Downtimes.comment,
])
query_expr = param.get('query')
if query_expr is not None:
q = q.filter(query_expr)
host_name = param.get('host_name')
if host_name is not None:
q = q.filter(
And(Downtimes.host_name.op("=", host_name),
Downtimes.is_service.equals(0)))
service_description = param.get('service_description')
if service_description is not None:
q = q.filter(
Downtimes.service_description.contains(service_description))
gen_downtimes = q.iterate(live)
return _serve_downtimes(gen_downtimes)
def show(self):
mode = self._host_mode_ident()
sites.live().set_prepend_site(True)
query = "GET hosts\nColumns: name state worst_service_state\nLimit: 100\n"
view = "host"
if mode == "problems":
view = "problemsofhost"
# Exclude hosts and services in downtime
svc_query = "GET services\nColumns: host_name\n"\
"Filter: state > 0\nFilter: scheduled_downtime_depth = 0\n"\
"Filter: host_scheduled_downtime_depth = 0\nAnd: 3"
problem_hosts = {x[1] for x in sites.live().query(svc_query)}
query += "Filter: state > 0\nFilter: scheduled_downtime_depth = 0\nAnd: 2\n"
for host in problem_hosts:
query += "Filter: name = %s\n" % host
query += "Or: %d\n" % (len(problem_hosts) + 1)
hosts = sites.live().query(query)
sites.live().set_prepend_site(False)
hosts.sort()
longestname = 0
for site, host, state, worstsvc in hosts:
longestname = max(longestname, len(host))
if longestname > 15:
num_columns = 1
else:
num_columns = 2
target = views.get_context_link(config.user.id, view)
html.open_table(class_="allhosts")
col = 1
for site, host, state, worstsvc in hosts:
if col == 1:
html.open_tr()
html.open_td()
if state > 0 or worstsvc == 2:
statecolor = 2
elif worstsvc == 1:
statecolor = 1
elif worstsvc == 3:
statecolor = 3
else:
statecolor = 0
html.open_div(class_=["statebullet", "state%d" % statecolor])
html.nbsp()
html.close_div()
link(host, target + "&host=%s&site=%s" % (html.urlencode(host), html.urlencode(site)))
html.close_td()
if col == num_columns:
html.close_tr()
col = 1
else:
col += 1
if col < num_columns:
html.close_tr()
html.close_table()
def show(self):
items = [
("enable_notifications", _("Notifications")),
("execute_service_checks", _("Service checks")),
("execute_host_checks", _("Host checks")),
("enable_flap_detection", _("Flap Detection")),
("enable_event_handlers", _("Event handlers")),
("process_performance_data", _("Performance data")),
("enable_event_handlers", _("Alert handlers")),
]
sites.update_site_states_from_dead_sites()
site_status_info = {}
try:
sites.live().set_prepend_site(True)
for row in sites.live().query("GET status\nColumns: %s" %
" ".join([i[0] for i in items])):
site_id, values = row[0], row[1:]
site_status_info[site_id] = values
finally:
sites.live().set_prepend_site(False)
def _render_master_control_site(site_id):
site_state = sites.states().get(site_id)
if site_state["state"] == "dead":
html.show_error(site_state["exception"])
elif site_state["state"] == "disabled":
html.show_message(_("Site is disabled"))
elif site_state["state"] == "unknown":
if site_state.get("exception"):
html.show_error(site_state["exception"])
else:
html.show_error(_("Site state is unknown"))
else:
is_cmc = site_state["program_version"].startswith("Check_MK ")
try:
site_info = site_status_info[site_id]
except KeyError:
site_info = None
html.open_table(class_="master_control")
for i, (colname, title) in enumerate(items):
# Do not show event handlers on Check_MK Micro Core
if is_cmc and title == _("Event handlers"):
continue
elif not is_cmc and title == _("Alert handlers"):
continue
colvalue = site_info[i]
url = html.makeactionuri_contextless(
[
("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()
for site_id, site_alias in config.sorted_sites():
if not config.is_single_local_site():
html.begin_foldable_container("master_control", site_id, True,
site_alias)
try:
_render_master_control_site(site_id)
except Exception as e:
logger.exception("error rendering master control for site %s",
site_id)
write_snapin_exception(e)
finally:
if not config.is_single_local_site():
html.end_foldable_container()
def create_downtime(params):
"""Create a scheduled downtime"""
body = params['body']
downtime_type: DowntimeType = body['downtime_type']
if downtime_type == 'host':
downtime_commands.schedule_host_downtime(
sites.live(),
host_name=body['host_name'],
start_time=body['start_time'],
end_time=body['end_time'],
recur=body['recur'],
duration=body['duration'],
user_id=config.user.ident,
comment=body.get('comment',
f"Downtime for host {body['host_name']!r}"),
)
elif downtime_type == 'hostgroup':
downtime_commands.schedule_hostgroup_host_downtime(
sites.live(),
hostgroup_name=body['hostgroup_name'],
start_time=body['start_time'],
end_time=body['end_time'],
recur=body['recur'],
duration=body['duration'],
user_id=config.user.ident,
comment=body.get(
'comment',
f"Downtime for hostgroup {body['hostgroup_name']!r}"),
)
elif downtime_type == 'service':
downtime_commands.schedule_service_downtime(
sites.live(),
host_name=body['host_name'],
service_description=body['service_descriptions'],
start_time=body['start_time'],
end_time=body['end_time'],
recur=body['recur'],
duration=body['duration'],
user_id=config.user.ident,
comment=body.get(
'comment',
f"Downtime for services {', '.join(body['service_descriptions'])!r}@{body['host_name']!r}"
),
)
elif downtime_type == 'servicegroup':
downtime_commands.schedule_servicegroup_service_downtime(
sites.live(),
servicegroup_name=body['servicegroup_name'],
start_time=body['start_time'],
end_time=body['end_time'],
recur=body['recur'],
duration=body['duration'],
user_id=config.user.ident,
comment=body.get(
'comment',
f"Downtime for servicegroup {body['servicegroup_name']!r}"),
)
else:
return problem(
status=400,
title="Unhandled downtime-type.",
detail=f"The downtime-type {downtime_type!r} is not supported.")
return Response(status=204)
def set_acknowledgement_on_hosts(params):
"""Set acknowledgement on related hosts"""
body = params['body']
live = sites.live()
sticky = body['sticky']
notify = body['notify']
persistent = body['persistent']
comment = body['comment']
acknowledge_type = body['acknowledge_type']
if acknowledge_type == 'host':
name = body['host_name']
host_state = Query([Hosts.state], Hosts.name == name).value(live)
if not host_state:
raise ProblemException(
status=422,
title=f'Host {name!r} has no problem.',
)
acknowledge_host_problem(
live,
name,
sticky=sticky,
notify=notify,
persistent=persistent,
user=config.user.ident,
comment=comment,
)
elif acknowledge_type == 'hostgroup':
host_group = body['hostgroup_name']
try:
acknowledge_hostgroup_problem(
live,
host_group,
sticky=sticky,
notify=notify,
persistent=persistent,
user=config.user.ident,
comment=comment,
)
except ValueError:
raise ProblemException(
404,
title="Hostgroup could not be found.",
detail=f"Unknown hostgroup: {host_group}",
)
elif acknowledge_type == 'host_by_query':
query = body['query']
hosts = Query([Hosts.name], query).fetchall(live)
if not hosts:
raise ProblemException(
status=422,
title="The provided query returned no monitored hosts",
)
for host in hosts:
acknowledge_host_problem(
live,
host.name,
sticky=sticky,
notify=notify,
persistent=persistent,
user=config.user.ident,
comment=comment,
)
else:
raise ProblemException(
status=400,
title="Unhandled acknowledge-type.",
detail=
f"The acknowledge-type {acknowledge_type!r} is not supported.",
)
return http.Response(status=204)
def set_acknowledgement_on_services(params):
"""Set acknowledgement on related services"""
body = params['body']
live = sites.live()
sticky = body['sticky']
notify = body['notify']
persistent = body['persistent']
comment = body['comment']
acknowledge_type = body['acknowledge_type']
if acknowledge_type == 'service':
description = unquote(body['service_description'])
host_name = body['host_name']
service = Query(
[Services.host_name, Services.description, Services.state],
And(Services.host_name == host_name,
Services.description == description)).first(live)
if not service:
raise ProblemException(
status=404,
title=
f'Service {description!r}@{host_name!r} could not be found.',
)
if not service.state:
raise ProblemException(
status=422,
title=f'Service {description!r}@{host_name!r} has no problem.',
)
acknowledge_service_problem(
live,
service.host_name,
service.description,
sticky=sticky,
notify=notify,
persistent=persistent,
user=config.user.ident,
comment=comment,
)
elif acknowledge_type == 'servicegroup':
service_group = body['servicegroup_name']
try:
acknowledge_servicegroup_problem(
live,
service_group,
sticky=sticky,
notify=notify,
persistent=persistent,
user=config.user.ident,
comment=comment,
)
except ValueError:
raise ProblemException(
status=404,
title="Servicegroup could not be found.",
detail=f"Unknown servicegroup: {service_group}",
)
elif acknowledge_type == 'service_by_query':
services = Query(
[Services.host_name, Services.description, Services.state],
body['query'],
).fetchall(live)
if not services:
raise ProblemException(
status=422,
title='No services with problems found.',
detail='All queried services are OK.',
)
for service in services:
if not service.state:
continue
acknowledge_service_problem(
live,
service.host_name,
service.description,
sticky=sticky,
notify=notify,
persistent=persistent,
user=config.user.ident,
comment=comment,
)
else:
raise ProblemException(
status=400,
title="Unhandled acknowledge-type.",
detail=
f"The acknowledge-type {acknowledge_type!r} is not supported.",
)
return http.Response(status=204)
def host_is_monitored(host_name: str) -> bool:
return bool(
Query([Hosts.name], Hosts.name == host_name).first_value(sites.live()))
def _query_for_host_names(self, site_id):
with sites.only_sites(site_id):
return sites.live().query_column("GET hosts\nColumns: name\n")
def all_logs():
sites.live().set_prepend_site(True)
rows = sites.live().query("GET hosts\n"
"Columns: name mk_logwatch_files\n")
sites.live().set_prepend_site(False)
return rows
def acknowledge_logfile(site, host_name, int_filename, display_name):
if not may_see(site, host_name):
raise MKAuthException(_('Permission denied.'))
command = "MK_LOGWATCH_ACKNOWLEDGE;%s;%s" % (host_name, int_filename)
sites.live().command("[%d] %s" % (int(time.time()), command), site)
