def _serialize_rule(rule_entry: RuleEntry) -> DomainObject:
rule = rule_entry.rule
return constructors.domain_object(
domain_type="rule",
editable=False,
identifier=rule.id,
title=rule.description(),
extensions={
"ruleset":
rule.ruleset.name,
"folder":
"/" + rule_entry.folder.path(),
"folder_index":
rule_entry.index_nr,
"properties":
rule.rule_options.to_config(),
"value_raw":
rule.value,
"conditions":
denilled({
"host_name": rule.conditions.host_name,
"host_tags": rule.conditions.host_tags,
"host_labels": rule.conditions.host_labels,
"service_description": rule.conditions.service_description,
"service_labels": rule.conditions.service_labels,
}),
},
)
def _serialize_single_downtime(downtime):
links = []
if downtime["is_service"]:
downtime_detail = f"service: {downtime['service_description']}"
else:
host_name = downtime["host_name"]
downtime_detail = f"host: {host_name}"
links.append(
constructors.link_rel(
rel="cmk/host_config",
href=constructors.object_href("host_config", host_name),
title="This host of this downtime.",
method="get",
)
)
downtime_id = downtime["id"]
return constructors.domain_object(
domain_type="downtime",
identifier=str(downtime_id),
title="Downtime for %s" % downtime_detail,
extensions=_downtime_properties(downtime),
links=[
constructors.link_rel(
rel=".../delete",
href=constructors.domain_type_action_href("downtime", "delete"),
method="post",
title="Delete the downtime",
body_params={"delete_type": "by_id", "downtime_id": downtime_id},
),
],
editable=False,
deletable=False,
)
def serialize_host(host):
base = constructors.object_href('host_config', host.ident())
members = constructors.DomainObjectMembers(base)
members.object_property(
name='folder_config',
value=constructors.object_href('folder_config',
host.folder().id()),
prop_format='string',
)
attributes = host.attributes().copy()
del attributes['meta_data']
return constructors.domain_object(
domain_type='host_config',
identifier=host.id(),
title=host.alias(),
members=members.to_dict(),
extensions={
'attributes': attributes,
'is_cluster': host.is_cluster(),
'is_offline': host.is_offline(),
'cluster_nodes': host.cluster_nodes(),
},
)
def list_hosts(param):
"""Show hosts of specific condition"""
live = sites.live()
sites_to_query = param["sites"]
if sites_to_query:
live.only_sites = sites_to_query
q = Query(param["columns"])
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="host",
value=[
constructors.domain_object(
domain_type="host",
title=f"{entry['name']}",
identifier=entry["name"],
editable=False,
deletable=False,
extensions=entry,
) for entry in result
],
))
def _serialize_downtimes(downtimes):
entries = []
for downtime_info in downtimes:
service_description = downtime_info.get("service_description")
if service_description:
downtime_detail = "service: %s" % service_description
else:
downtime_detail = "host: %s" % downtime_info["host_name"]
downtime_id = downtime_info['id']
entries.append(
constructors.domain_object(
domain_type='downtime',
identifier=downtime_id,
title='Downtime for %s' % downtime_detail,
extensions=_downtime_properties(downtime_info),
links=[
constructors.link_rel(rel='.../delete',
href='/objects/host/%s/objects/downtime/%s' %
(downtime_info['host_name'], downtime_id),
method='delete',
title='Delete the downtime'),
]))
return constructors.object_collection(
name='all',
domain_type='downtime',
entries=entries,
base='',
)
def serialize_password(ident, details):
return constructors.domain_object(
domain_type="password",
identifier=ident,
title=details["title"],
members={
"title":
constructors.object_property(
name="title",
value=details["title"],
prop_format="string",
base=constructors.object_href("password", ident),
)
},
extensions={
k: v
for k, v in complement_customer(details).items() if k in (
"comment",
"docu_url",
"password",
"owned_by",
"shared_with",
"customer",
)
},
)
def _folders_collection(
folders: List[CREFolder],
show_hosts: bool,
):
folders_ = []
for folder in folders:
members = {}
if show_hosts:
members["hosts"] = constructors.object_collection(
name="hosts",
domain_type="folder_config",
entries=[
constructors.collection_item("host_config", {
"title": host,
"id": host
}) for host in folder.hosts()
],
base="",
)
folders_.append(
constructors.domain_object(
domain_type="folder_config",
identifier=folder_slug(folder),
title=folder.title(),
extensions={
"path": "/" + folder.path(),
"attributes": folder.attributes().copy(),
},
members=members,
))
return constructors.collection_object(
domain_type="folder_config",
value=folders_,
)
def serialize_password(details):
return constructors.domain_object(domain_type="password",
identifier=details["ident"],
title=details["title"],
members={
"title":
constructors.object_property(
name='title',
value=details["title"],
prop_format='string',
base=constructors.object_href(
'password',
details["ident"]),
)
},
extensions={
key: details[key]
for key in details if key in (
"comment",
"docu_url",
"password",
"owned_by",
"shared_with",
)
})
def list_hosts(param):
"""Show hosts of specific condition"""
live = sites.live()
sites_to_query = param['sites']
if sites_to_query:
live.only_sites = sites_to_query
columns = verify_columns(Hosts, param['columns'])
q = Query(columns)
# TODO: add sites parameter
filter_tree = param.get('query')
if filter_tree:
expr = tree_to_expr(filter_tree)
q = q.filter(expr)
result = q.iterate(live)
return constructors.serve_json(
constructors.collection_object(
domain_type='host',
value=[
constructors.domain_object(
domain_type='host',
title=f"{entry['name']}",
identifier=entry['name'],
editable=False,
deletable=False,
extensions=entry,
) for entry in result
],
))
def serialize_host(host, attributes):
# TODO: readd link mechanism once object ref between endpoints is in place
base = constructors.object_href('host_config', host.ident())
members = constructors.DomainObjectMembers(base)
members.object_property(
name='folder_config',
value=constructors.object_href('folder_config',
host.folder().id()),
prop_format='string',
linkable=False,
)
if 'meta_data' in attributes:
attributes = attributes.copy()
del attributes['meta_data']
return constructors.domain_object(
domain_type='host_config',
identifier=host.id(),
title=host.alias(),
members=members.to_dict(),
extensions={
'attributes': attributes,
'is_cluster': host.is_cluster(),
'is_offline': host.is_offline(),
'cluster_nodes': host.cluster_nodes(),
},
)
def serialize_user(user_id, attributes):
return constructors.domain_object(
domain_type="user_config",
identifier=user_id,
title=attributes["fullname"],
extensions=_filter_keys(
attributes, response_schemas.UserAttributes._declared_fields),
)
def serialize_user(user_id, attributes):
return constructors.domain_object(
domain_type="user_config",
identifier=user_id,
title=attributes["fullname"],
extensions={
"attributes": attributes,
},
)
def serialize_user(user_id, attributes):
return constructors.domain_object(
domain_type='user_config',
identifier=user_id,
title=attributes["alias"],
extensions={
'attributes': attributes,
},
)
def _list_services(param):
live = sites.live()
default_columns = [
'host_name',
'description',
'last_check',
'state',
'state_type',
'acknowledged',
]
column_names = add_if_missing(param.get('columns', default_columns),
['host_name', 'description'])
columns = verify_columns(Services, column_names)
q = Query(columns)
host_name = param.get('host_name')
if host_name is not None:
q = q.filter(Services.host_name.contains(host_name))
alias = param.get('host_alias')
if alias is not None:
q = q.filter(Services.host_alias.contains(alias))
in_downtime = param.get('in_downtime')
if in_downtime is not None:
q = q.filter(Services.scheduled_downtime_depth == int(in_downtime))
acknowledged = param.get('acknowledged')
if acknowledged is not None:
q = q.filter(Services.acknowledged.equals(acknowledged))
status = param.get('status')
if status is not None:
q = q.filter(Services.state.equals(status))
result = q.iterate(live)
return constructors.object_collection(
name='all',
domain_type='service',
entries=[
constructors.domain_object(
domain_type='service',
title=f"{entry['description']} on {entry['host_name']}",
identifier=entry['description'],
editable=False,
deletable=False,
extensions=entry,
) for entry in result
],
base='',
)
def list_hosts(param):
"""List currently monitored hosts."""
live = sites.live()
default_columns = [
'name',
'address',
'alias',
'downtimes_with_info',
'scheduled_downtime_depth',
]
column_names = add_if_missing(param.get('columns', default_columns),
['name', 'address'])
columns = verify_columns(Hosts, column_names)
q = Query(columns)
host_name = param.get('host_name')
if host_name is not None:
q = q.filter(Hosts.name.contains(host_name))
host_alias = param.get('host_alias')
if host_alias is not None:
q = q.filter(Hosts.alias.contains(host_alias))
in_downtime = param.get('in_downtime')
if in_downtime is not None:
q = q.filter(Hosts.scheduled_downtime_depth == int(in_downtime))
acknowledged = param.get('acknowledged')
if acknowledged is not None:
q = q.filter(Hosts.acknowledged.equals(acknowledged))
status = param.get('status')
if status is not None:
q = q.filter(Hosts.state.equals(status))
result = q.iterate(live)
return constructors.object_collection(
name='all',
domain_type='host',
entries=[
constructors.domain_object(
domain_type='host',
title=f"{entry['name']} ({entry['address']})",
identifier=entry['name'],
editable=False,
deletable=False,
extensions=entry,
) for entry in result
],
base='',
)
def serialize_service_discovery(host, discovered_services, discovery_state):
members = {}
for (table_source, check_type, _checkgroup, item, _discovered_params,
_check_params, descr, _service_state, _output, _perfdata,
_service_labels) in discovered_services:
if table_source == SERVICE_DISCOVERY_STATES[discovery_state]:
service_hash = checkbox_id(check_type, item)
members[service_hash] = {
"service_name":
descr,
"check_plugin_name":
check_type,
"state":
object_property(
name=descr,
title="The service is currently %s" % discovery_state,
value=table_source,
prop_format='string',
base='',
links=[
link_rel(
rel="cmk/service.move-monitored",
href=
"/objects/host/%s/service/%s/action/move/monitored"
% (host.ident(), service_hash),
method='put',
title='Move the service to monitored'),
link_rel(
rel="cmk/service.move-undecided",
href=
"/objects/host/%s/service/%s/action/move/undecided"
% (host.ident(), service_hash),
method='put',
title='Move the service to undecided'),
link_rel(
rel="cmk/service.move-ignored",
href=
"/objects/host/%s/service/%s/action/move/ignored" %
(host.ident(), service_hash),
method='put',
title='Move the service to ignored'),
]),
}
return domain_object(
domain_type='service_discovery',
identifier='%s-services-%s' % (host.ident(), "wato"),
title='Services discovery',
members=members,
extensions={},
)
def serialize_host(host: watolib.CREHost, effective_attributes: bool):
extensions = {
"folder":
host.folder().path(),
"attributes":
host.attributes(),
"effective_attributes":
host.effective_attributes() if effective_attributes else None,
"is_cluster":
host.is_cluster(),
"is_offline":
host.is_offline(),
"cluster_nodes":
host.cluster_nodes(),
}
agent_links = []
if not cmk_version.is_raw_edition():
import cmk.gui.cee.agent_bakery as agent_bakery # pylint: disable=no-name-in-module
for agent_type in sorted(agent_bakery.agent_package_types().keys()):
agent_links.append(
constructors.link_rel(
rel="cmk/download",
href="{}?{}".format(
constructors.domain_type_action_href(
"agent", "download"),
urlencode({
"os_type": agent_type,
"host_name": host.id()
}),
),
method="get",
title=f"Download the {agent_type} agent of the host.",
))
return constructors.domain_object(
domain_type="host_config",
identifier=host.id(),
title=host.alias() or host.name(),
links=[
constructors.link_rel(
rel="cmk/folder_config",
href=constructors.object_href("folder_config",
folder_slug(host.folder())),
method="get",
title="The folder config of the host.",
),
] + agent_links,
extensions=extensions,
)
def serialize_host_tag_group(details: Dict[str, Any]):
return constructors.domain_object(
domain_type='host_tag_group',
identifier=details['id'],
title=details['title'],
members={
"title": constructors.object_property(
name='title',
value=details['title'],
prop_format='string',
base=constructors.object_href('host_tag_group', details['id']),
)
},
extensions={key: details[key] for key in details if key in ('topic', 'tags')})
def _list_services(param):
live = sites.live()
q = Query([
Services.host_name,
Services.description,
Services.last_check,
Services.state,
Services.state_type,
Services.acknowledged,
])
host_name = param.get('host_name')
if host_name is not None:
q = q.filter(Services.host_name.contains(host_name))
alias = param.get('host_alias')
if alias is not None:
q = q.filter(Services.host_alias.contains(alias))
in_downtime = param.get('in_downtime')
if in_downtime is not None:
q = q.filter(Services.scheduled_downtime_depth == int(in_downtime))
acknowledged = param.get('acknowledged')
if acknowledged is not None:
q = q.filter(Services.acknowledged.equals(acknowledged))
status = param.get('status')
if status is not None:
q = q.filter(Services.state.equals(status))
result = q.iterate(live)
return constructors.object_collection(
name='all',
domain_type='service',
entries=[
constructors.domain_object(
domain_type='service',
title=f"{entry['description']} on {entry['host_name']}",
identifier=entry['description'],
editable=False,
deletable=False,
extensions=dict(entry),
) for entry in result
],
base='',
)
def serialize_host(host):
base = '/objects/host/%s' % (host.ident(), )
return constructors.domain_object(
domain_type='host',
identifier=host.id(),
title=host.alias(),
members=dict([
constructors.object_property_member(
'folder',
constructors.object_href('folder', host.folder()),
base,
),
]),
extensions={},
)
def _serve_activation_run(activation_id, is_running=False):
"""Serialize the activation response"""
links = []
action = "has completed"
if is_running:
action = "was started"
links.append(_completion_link(activation_id))
return constructors.serve_json(
constructors.domain_object(
domain_type='activation_run',
identifier=activation_id,
title=f'Activation {activation_id} {action}.',
deletable=False,
editable=False,
links=links,
))
def serialize_host(host):
base = '/objects/host/%s' % (host.ident(),)
return constructors.domain_object(
domain_type='host',
identifier=host.id(),
title=host.alias(),
members={
'folder': constructors.object_property(
name='folder',
value=constructors.object_href('folder', host.folder()),
prop_format='string',
base=base,
),
},
extensions={},
)
def get_bi_pack(params):
"""Get a BI pack and its rules and aggregations"""
user.need_permission("wato.bi_rules")
bi_packs = get_cached_bi_packs()
bi_packs.load_config()
bi_pack = bi_packs.get_pack(params["pack_id"])
if bi_pack is None:
_bailout_with_message("This pack_id does not exist: %s" % params["pack_id"])
assert bi_pack is not None
uri = constructors.object_href("bi_pack", bi_pack.id)
domain_members = {}
for (name, entities) in [
("aggregation", bi_pack.get_aggregations()),
("rule", bi_pack.get_rules()),
]:
elements = entities.values()
domain_members["%ss" % name] = constructors.object_collection(
name=name,
domain_type="bi_" + name, # type: ignore[arg-type]
entries=[
constructors.link_rel(
rel=".../value",
parameters={"collection": "items"},
href=constructors.object_href(
"bi_" + name, element.id # type: ignore[arg-type]
),
)
for element in elements
],
base=uri,
)
extensions = {
"title": bi_pack.title,
"contact_groups": bi_pack.contact_groups,
"public": bi_pack.public,
}
domain_object = constructors.domain_object(
domain_type="bi_pack",
identifier=bi_pack.id,
title=bi_pack.title,
extensions=extensions,
members=domain_members,
)
return constructors.serve_json(domain_object)
def list_hosts(param):
live = sites.live()
q = Query([
Hosts.name,
Hosts.address,
Hosts.alias,
Hosts.downtimes_with_info,
Hosts.scheduled_downtime_depth,
])
hostname = param.get('host_name')
if hostname is not None:
q = q.filter(Hosts.name.contains(hostname))
alias = param.get('host_alias')
if alias is not None:
q = q.filter(Hosts.alias.contains(alias))
in_downtime = param.get('in_downtime')
if in_downtime is not None:
q = q.filter(Hosts.scheduled_downtime_depth == int(in_downtime))
acknowledged = param.get('acknowledged')
if acknowledged is not None:
q = q.filter(Hosts.acknowledged.equals(acknowledged))
status = param.get('status')
if status is not None:
q = q.filter(Hosts.state.equals(status))
result = q.iterate(live)
return constructors.object_collection(
name='all',
domain_type='host',
entries=[
constructors.domain_object(
domain_type='host',
title=f"{entry['name']} ({entry['address']})",
identifier=entry['name'],
editable=False,
deletable=False,
) for entry in result
],
base='',
)
def _serialize_folder(folder):
# type: (CREFolder) -> DomainObject
uri = '/objects/folder/%s' % (folder.id(), )
return constructors.domain_object(
domain_type='folder',
identifier=folder.id(),
title=folder.title(),
members={
'hosts':
constructors.object_collection(
name='hosts',
entries=[
constructors.link_rel(
rel='.../value;collection="items"',
href=constructors.object_href('host', host),
) for host in folder.hosts().values()
],
base=uri,
),
'move':
constructors.object_action(
name='move',
base=uri,
parameters=dict([
constructors.action_parameter(
action='move',
parameter='destination',
friendly_name=
'The destination folder of this move action',
optional=False,
pattern="[0-9a-fA-F]{32}|root",
),
]),
),
'title':
constructors.object_property(
name='title',
value=folder.title(),
prop_format='string',
base=uri,
),
},
extensions={
'attributes': folder.attributes(),
},
)
def _serve_background_job(job: BulkDiscoveryBackgroundJob) -> Response:
job_id = job.get_job_id()
status_details = bulk_discovery_job_status(job)
return constructors.serve_json(
constructors.domain_object(
domain_type="discovery_run",
identifier=job_id,
title=
f"Background job {job_id} {'is active' if status_details['is_active'] else 'is finished'}",
extensions={
"active": status_details["is_active"],
"state": status_details["job_state"],
"logs": status_details["logs"],
},
deletable=False,
editable=False,
))
def _serializer(group):
# type: (Dict[str, str]) -> Any
ident = group['id']
return constructors.domain_object(
domain_type=name,
identifier=ident,
title=group['alias'],
members={
'title': constructors.object_property(
name='title',
value=group['alias'],
prop_format='string',
base=constructors.object_href(name, ident),
),
},
extensions={},
)
def _serializer(group):
# type: (Dict[str, str]) -> Any
ident = group["id"]
extensions = {}
if "customer" in group:
customer_id = group["customer"]
extensions["customer"] = "global" if customer_id is None else customer_id
elif is_managed_edition():
extensions["customer"] = managed.default_customer_id()
extensions["alias"] = group["alias"]
return constructors.domain_object(
domain_type=name,
identifier=ident,
title=group["alias"] or ident,
extensions=extensions,
)
def serialize_host(host):
base = constructors.object_href('host_config', host.ident())
members = constructors.DomainObjectMembers(base)
members.object_property(
name='folder_config',
value=constructors.object_href('folder_config',
host.folder().id()),
prop_format='string',
)
return constructors.domain_object(
domain_type='host_config',
identifier=host.id(),
title=host.alias(),
members=members.to_dict(),
extensions={},
)
def _serve_activation_run(activation_id, is_running=False):
"""Serialize the activation response."""
links = []
if is_running:
links.append(
constructors.link_endpoint(
'cmk.gui.plugins.openapi.endpoints.activate_changes',
'cmk/wait-for-completion',
parameters={'activation_id': activation_id}))
return constructors.domain_object(
domain_type='activation_run',
identifier=activation_id,
title='Activation %s was started.' % (activation_id, ),
deletable=False,
editable=False,
links=links,
)
