def _do_inv_for_realhost(
host_config: config.HostConfig,
ipaddress: Optional[HostAddress],
*,
parsed_sections_broker: ParsedSectionsBroker,
run_plugin_names: Container[InventoryPluginName],
retentions_tracker: RetentionsTracker,
) -> InventoryTrees:
tree_aggregator = TreeAggregator()
_set_cluster_property(tree_aggregator.trees.inventory, host_config)
section.section_step("Executing inventory plugins")
for inventory_plugin in agent_based_register.iter_all_inventory_plugins():
if inventory_plugin.name not in run_plugin_names:
continue
for source_type in (SourceType.HOST, SourceType.MANAGEMENT):
kwargs = get_section_kwargs(
parsed_sections_broker,
HostKey(host_config.hostname, ipaddress, source_type),
inventory_plugin.sections,
)
if not kwargs:
console.vverbose(
" %s%s%s%s: skipped (no data)\n",
tty.yellow,
tty.bold,
inventory_plugin.name,
tty.normal,
)
continue
# Inventory functions can optionally have a second argument: parameters.
# These are configured via rule sets (much like check parameters).
if inventory_plugin.inventory_ruleset_name is not None:
kwargs = {
**kwargs,
"params":
host_config.inventory_parameters(
inventory_plugin.inventory_ruleset_name),
}
exception = tree_aggregator.aggregate_results(
inventory_generator=inventory_plugin.inventory_function(
**kwargs),
retentions_tracker=retentions_tracker,
raw_cache_info=parsed_sections_broker.get_cache_info(
inventory_plugin.sections),
is_legacy_plugin=inventory_plugin.module is None,
)
if exception:
console.warning(
" %s%s%s%s: failed: %s",
tty.red,
tty.bold,
inventory_plugin.name,
tty.normal,
exception,
)
else:
console.verbose(" %s%s%s%s", tty.green, tty.bold,
inventory_plugin.name, tty.normal)
console.vverbose(": ok\n")
console.verbose("\n")
return tree_aggregator.trees
def get_aggregated_result(
parsed_sections_broker: ParsedSectionsBroker,
host_config: config.HostConfig,
ipaddress: Optional[HostAddress],
service: Service,
plugin: Optional[checking_classes.CheckPlugin],
# missleading. These are prams that *may* be *partially* time specific
timespecific_parameters: LegacyCheckParameters,
*,
value_store_manager: value_store.ValueStoreManager,
persist_value_store_changes: bool,
) -> AggregatedResult:
"""Run the check function and aggregate the subresults
This function is also called during discovery.
"""
if plugin is None:
return AggregatedResult(
submit=True,
data_received=True,
result=CHECK_NOT_IMPLEMENTED,
cache_info=None,
)
config_cache = config.get_config_cache()
check_function = (
_cluster_modes.get_cluster_check_function(
*config_cache.get_clustered_service_configuration(
host_config.hostname,
service.description,
),
plugin=plugin,
service_id=service.id(),
persist_value_store_changes=persist_value_store_changes,
)
if host_config.is_cluster
else plugin.check_function
)
source_type = (
SourceType.MANAGEMENT if service.check_plugin_name.is_management_name() else SourceType.HOST
)
try:
kwargs = (
get_section_cluster_kwargs(
parsed_sections_broker,
config_cache.get_clustered_service_node_keys(
host_config.hostname,
source_type,
service.description,
)
or [],
plugin.sections,
)
if host_config.is_cluster
else get_section_kwargs(
parsed_sections_broker,
HostKey(host_config.hostname, ipaddress, source_type),
plugin.sections,
)
)
if not kwargs and not service.check_plugin_name.is_management_name():
# in 1.6 some plugins where discovered for management boards, but with
# the regular host plugins name. In this case retry with the source type
# forced to MANAGEMENT:
kwargs = (
get_section_cluster_kwargs(
parsed_sections_broker,
config_cache.get_clustered_service_node_keys(
host_config.hostname,
SourceType.MANAGEMENT,
service.description,
)
or [],
plugin.sections,
)
if host_config.is_cluster
else get_section_kwargs(
parsed_sections_broker,
HostKey(host_config.hostname, ipaddress, SourceType.MANAGEMENT),
plugin.sections,
)
)
if not kwargs: # no data found
return AggregatedResult(
submit=False,
data_received=False,
result=RECEIVED_NO_DATA,
cache_info=None,
)
kwargs = {
**kwargs,
**({} if service.item is None else {"item": service.item}),
**(
{}
if plugin.check_default_parameters is None
else {"params": _final_read_only_check_parameters(timespecific_parameters)}
),
}
with plugin_contexts.current_host(host_config.hostname), plugin_contexts.current_service(
service
), value_store_manager.namespace(service.id()):
result = _aggregate_results(check_function(**kwargs))
except (item_state.MKCounterWrapped, checking_classes.IgnoreResultsError) as e:
msg = str(e) or "No service summary available"
return AggregatedResult(
submit=False,
data_received=True,
result=(0, msg, []),
cache_info=None,
)
except MKTimeout:
raise
except Exception:
if cmk.utils.debug.enabled():
raise
table = check_table.get_check_table(host_config.hostname, skip_autochecks=True)
result = (
3,
cmk.base.crash_reporting.create_check_crash_dump(
host_name=host_config.hostname,
service_name=service.description,
plugin_name=service.check_plugin_name,
plugin_kwargs=globals().get("kwargs", {}),
is_manual=service.id() in table,
),
[],
)
return AggregatedResult(
submit=True,
data_received=True,
result=result,
cache_info=parsed_sections_broker.get_cache_info(plugin.sections),
)
def get_aggregated_result(
parsed_sections_broker: ParsedSectionsBroker,
hostname: HostName,
ipaddress: Optional[HostAddress],
service: Service,
*,
used_params: LegacyCheckParameters,
) -> AggregatedResult:
legacy_check_plugin_name = config.legacy_check_plugin_names.get(
service.check_plugin_name)
if legacy_check_plugin_name is None:
return AggregatedResult(
submit=True,
data_received=True,
result=CHECK_NOT_IMPLEMENTED,
cache_info=None,
)
check_function = config.check_info[legacy_check_plugin_name].get(
"check_function")
if check_function is None:
return AggregatedResult(
submit=True,
data_received=True,
result=CHECK_NOT_IMPLEMENTED,
cache_info=None,
)
section_name = legacy_check_plugin_name.split('.')[0]
main_check_info = config.check_info.get(section_name, {})
section_content = None
multi_host_sections = _MultiHostSections(parsed_sections_broker)
mgmt_board_info = main_check_info.get(
"management_board") or LEGACY_HOST_PRECEDENCE
source_type = SourceType.MANAGEMENT if mgmt_board_info == LEGACY_MGMT_ONLY else SourceType.HOST
try:
section_content = multi_host_sections.get_section_content(
HostKey(hostname, ipaddress, source_type),
mgmt_board_info,
section_name,
for_discovery=False,
cluster_node_keys=config.get_config_cache().
get_clustered_service_node_keys(
hostname,
source_type,
service.description,
),
check_legacy_info=config.check_info,
)
if section_content is None: # No data for this check type
return AggregatedResult(
submit=False,
data_received=False,
result=RECEIVED_NO_DATA,
cache_info=None,
)
# Call the actual check function
item_state.reset_wrapped_counters()
raw_result = check_function(service.item, used_params, section_content)
result = _sanitize_check_result(raw_result)
item_state.raise_counter_wrap()
except item_state.MKCounterWrapped as exc:
# handle check implementations that do not yet support the
# handling of wrapped counters via exception on their own.
# Do not submit any check result in that case:
return AggregatedResult(
submit=False,
data_received=True,
result=(0, f"Cannot compute check result: {exc}\n", []),
cache_info=None,
)
except MKTimeout:
raise
except Exception:
if cmk.utils.debug.enabled():
raise
result = 3, cmk.base.crash_reporting.create_check_crash_dump(
host_name=hostname,
service_name=service.description,
plugin_name=service.check_plugin_name,
plugin_kwargs={
"item": service.item,
"params": used_params,
"section_content": section_content
},
is_manual=service.id()
in check_table.get_check_table(hostname, skip_autochecks=True),
), []
return AggregatedResult(
submit=True,
data_received=True,
result=result,
cache_info=multi_host_sections.legacy_determine_cache_info(
SectionName(section_name)),
)
def _collect_host_sections(
*,
nodes: Iterable[Tuple[HostName, Optional[HostAddress], Sequence['Source']]],
file_cache_max_age: int,
fetcher_messages: Sequence['FetcherMessage'],
selected_sections: 'SectionNameCollection',
) -> Tuple[ #
Mapping[HostKey, HostSections], #
Sequence[Tuple['Source', result.Result[HostSections, Exception]]] #
]:
"""Gather ALL host info data for any host (hosts, nodes, clusters) in Checkmk.
Communication errors are not raised through by this functions. All agent related errors are
caught by the source.run() method and saved in it's _exception attribute. The caller should
use source.get_summary_result() to get the state, output and perfdata of the agent execution
or source.exception to get the exception object.
"""
console.vverbose("%s+%s %s\n", tty.yellow, tty.normal, "Parse fetcher results".upper())
flat_node_sources = [(hn, ip, src) for hn, ip, sources in nodes for src in sources]
# TODO (ml): Can we somehow verify that this is correct?
# if fetcher_message["fetcher_type"] != source.id:
# raise LookupError("Checker and fetcher missmatch")
# (mo): this is not enough, but better than nothing:
if len(flat_node_sources) != len(fetcher_messages):
raise LookupError("Checker and fetcher missmatch")
collected_host_sections: Dict[HostKey, HostSections] = {}
results: List[Tuple['Source', result.Result[HostSections, Exception]]] = []
# Special agents can produce data for the same check_plugin_name on the same host, in this case
# the section lines need to be extended
for fetcher_message, (hostname, ipaddress, source) in zip(fetcher_messages, flat_node_sources):
console.vverbose(" Source: %s/%s\n" % (source.source_type, source.fetcher_type))
source.file_cache_max_age = file_cache_max_age
host_sections = collected_host_sections.setdefault(
HostKey(hostname, ipaddress, source.source_type),
source.default_host_sections,
)
source_result = source.parse(fetcher_message.raw_data, selection=selected_sections)
results.append((source, source_result))
if source_result.is_ok():
console.vverbose(" -> Add sections: %s\n" %
sorted([str(s) for s in source_result.ok.sections.keys()]))
host_sections.add(source_result.ok)
else:
console.vverbose(" -> Not adding sections: %s\n" % source_result.error)
for hostname, ipaddress, _sources in nodes:
# Store piggyback information received from all sources of this host. This
# also implies a removal of piggyback files received during previous calls.
host_sections = collected_host_sections.setdefault(
HostKey(hostname, ipaddress, SourceType.HOST),
AgentHostSections(),
)
cmk.utils.piggyback.store_piggyback_raw_data(
hostname,
host_sections.piggybacked_raw_data,
)
return collected_host_sections, results
def get_aggregated_result(
parsed_sections_broker: ParsedSectionsBroker,
host_config: config.HostConfig,
ipaddress: Optional[HostAddress],
service: Service,
plugin: Optional[checking_classes.CheckPlugin],
params_function: Callable[[], Parameters],
*,
value_store_manager: value_store.ValueStoreManager,
) -> AggregatedResult:
"""Run the check function and aggregate the subresults
This function is also called during discovery.
"""
if plugin is None:
return AggregatedResult(
submit=True,
data_received=True,
result=CHECK_NOT_IMPLEMENTED,
cache_info=None,
)
check_function = (plugin.cluster_check_function
if host_config.is_cluster else plugin.check_function)
source_type = (SourceType.MANAGEMENT
if service.check_plugin_name.is_management_name() else
SourceType.HOST)
config_cache = config.get_config_cache()
kwargs: MutableMapping[str, Any] = {}
try:
kwargs = get_section_cluster_kwargs(
parsed_sections_broker,
config_cache.get_clustered_service_node_keys(
host_config.hostname,
source_type,
service.description,
) or [],
plugin.sections,
) if host_config.is_cluster else get_section_kwargs(
parsed_sections_broker,
HostKey(host_config.hostname, ipaddress, source_type),
plugin.sections,
)
if not kwargs and not service.check_plugin_name.is_management_name():
# in 1.6 some plugins where discovered for management boards, but with
# the regular host plugins name. In this case retry with the source type
# forced to MANAGEMENT:
kwargs = get_section_cluster_kwargs(
parsed_sections_broker,
config_cache.get_clustered_service_node_keys(
host_config.hostname,
SourceType.MANAGEMENT,
service.description,
) or [],
plugin.sections,
) if host_config.is_cluster else get_section_kwargs(
parsed_sections_broker,
HostKey(host_config.hostname, ipaddress,
SourceType.MANAGEMENT),
plugin.sections,
)
if not kwargs: # no data found
return AggregatedResult(
submit=False,
data_received=False,
result=RECEIVED_NO_DATA,
cache_info=None,
)
if service.item is not None:
kwargs["item"] = service.item
if plugin.check_default_parameters is not None:
kwargs["params"] = params_function()
with plugin_contexts.current_host(host_config.hostname), \
plugin_contexts.current_service(service), \
value_store_manager.namespace(service.id()):
result = _aggregate_results(check_function(**kwargs))
except (item_state.MKCounterWrapped,
checking_classes.IgnoreResultsError) as e:
msg = str(e) or "No service summary available"
return AggregatedResult(
submit=False,
data_received=True,
result=(0, msg, []),
cache_info=None,
)
except MKTimeout:
raise
except Exception:
if cmk.utils.debug.enabled():
raise
table = check_table.get_check_table(host_config.hostname,
skip_autochecks=True)
result = 3, cmk.base.crash_reporting.create_check_crash_dump(
host_name=host_config.hostname,
service_name=service.description,
plugin_name=service.check_plugin_name,
plugin_kwargs=kwargs,
is_manual=service.id() in table,
), []
return AggregatedResult(
submit=True,
data_received=True,
result=result,
cache_info=parsed_sections_broker.get_cache_info(plugin.sections),
)
def get_section_content(
self,
host_key: HostKey,
management_board_info: str,
check_plugin_name: str,
for_discovery: bool,
*,
cluster_node_keys: Optional[List[HostKey]] = None,
check_legacy_info: Dict[str, Dict[str, Any]],
) -> Union[None, ParsedSectionContent, List[ParsedSectionContent]]:
"""Prepares the section_content construct for a Check_MK check on ANY host
The section_content construct is then handed over to the check, inventory or
discovery functions for doing their work.
If the host is a cluster, the sections from all its nodes is merged together
here. Optionally the node info is added to the nodes section content.
It handles the whole data and cares about these aspects:
a) Extract the section_content for the given check_plugin_name
b) Adds node_info to the section_content (if check asks for this)
c) Applies the parse function (if check has some)
It can return an section_content construct or None when there is no section content
for this check available.
"""
section_name = section_name_of(check_plugin_name)
cache_key = (host_key, management_board_info, section_name,
for_discovery, bool(cluster_node_keys))
try:
return self._section_content_cache[cache_key]
except KeyError:
pass
section_content = self._get_section_content(
host_key._replace(
source_type=SourceType.MANAGEMENT if management_board_info ==
LEGACY_MGMT_ONLY else SourceType.HOST),
check_plugin_name,
SectionName(section_name),
for_discovery,
cluster_node_keys=cluster_node_keys,
check_legacy_info=check_legacy_info,
)
# If we found nothing, see if we must check the management board:
if (section_content is None and host_key.source_type is SourceType.HOST
and management_board_info == LEGACY_HOST_PRECEDENCE):
section_content = self._get_section_content(
host_key._replace(source_type=SourceType.MANAGEMENT),
check_plugin_name,
SectionName(section_name),
for_discovery,
cluster_node_keys=cluster_node_keys,
check_legacy_info=check_legacy_info,
)
self._section_content_cache[cache_key] = section_content
return section_content
@pytest.mark.parametrize(
"hostname,host_entries,cluster_node_keys,expected_result",
[
# No clusters
("heute", [
('heute', NODE_1),
], None, NODE_1),
# Clusters: host_of_clustered_service returns cluster name. That means that
# the service is assigned to the cluster
("cluster", [
('node1', NODE_1),
('node2', NODE_2),
], [
HostKey("node1", "127.0.0.1", SourceType.HOST),
HostKey("node2", "127.0.0.1", SourceType.HOST),
], NODE_1 + NODE_2),
# host_of_clustered_service returns either the cluster or node name.
# That means that the service is assigned to the cluster resp. not to the cluster
("cluster", [
('node1', NODE_1),
('node2', NODE_2),
], [
HostKey("node2", "127.0.0.1", SourceType.HOST),
], NODE_2),
])
def test_get_section_content(hostname, host_entries, cluster_node_keys, expected_result):
parsed_sections_broker = ParsedSectionsBroker({
HostKey(nodename, "127.0.0.1", SourceType.HOST):
def test_get_host_sections_cluster(monkeypatch, mocker):
hostname = HostName("testhost")
hosts = {
HostName("host0"): "10.0.0.0",
HostName("host1"): "10.0.0.1",
HostName("host2"): "10.0.0.2",
}
address = "1.2.3.4"
tags = {"agent": "no-agent"}
section_name = SectionName("test_section")
config_cache = make_scenario(hostname, tags).apply(monkeypatch)
host_config = config.HostConfig.make_host_config(hostname)
def fake_lookup_ip_address(host_config, family=None):
return hosts[host_config.hostname]
def check(_, *args, **kwargs):
return result.OK(
AgentHostSections(sections={section_name: [[str(section_name)]]}))
monkeypatch.setattr(
config,
"lookup_ip_address",
fake_lookup_ip_address,
)
monkeypatch.setattr(
Source,
"parse",
check,
)
mocker.patch.object(
cmk.utils.piggyback,
"remove_source_status_file",
autospec=True,
)
mocker.patch.object(
cmk.utils.piggyback,
"_store_status_file_of",
autospec=True,
)
# Create a cluster
host_config.nodes = list(hosts.keys())
nodes = make_nodes(
config_cache,
host_config,
address,
sources=make_sources(host_config, address),
)
host_sections = _collect_host_sections(
nodes=nodes,
file_cache_max_age=host_config.max_cachefile_age,
fetcher_messages=[
FetcherMessage.from_raw_data(
result.OK(source.default_raw_data),
Snapshot.null(),
source.fetcher_type,
) for _h, _i, sources in nodes for source in sources
],
selected_sections=NO_SELECTION,
)[0]
assert len(host_sections) == len(hosts) == 3
cmk.utils.piggyback._store_status_file_of.assert_not_called(
) # type: ignore[attr-defined]
assert cmk.utils.piggyback.remove_source_status_file.call_count == 3 # type: ignore[attr-defined]
for host, addr in hosts.items():
remove_source_status_file = cmk.utils.piggyback.remove_source_status_file
remove_source_status_file.assert_any_call(
host) # type: ignore[attr-defined]
key = HostKey(host, addr, SourceType.HOST)
assert key in host_sections
section = host_sections[key]
assert len(section.sections) == 1
assert next(iter(section.sections)) == section_name
assert not section.cache_info
assert not section.piggybacked_raw_data
def _cluster_scenario(monkeypatch):
hostname = "test-clusterhost"
ipaddress = "1.2.3.4"
node1_hostname = 'test-node1'
node2_hostname = 'test-node2'
def fake_lookup_ip_address(*_a, **_kw):
return ipaddress
monkeypatch.setattr(ip_lookup, "lookup_ip_address", fake_lookup_ip_address)
ts = Scenario()
ts.add_host(node1_hostname)
ts.add_host(node2_hostname)
ts.add_cluster(hostname, nodes=[node1_hostname, node2_hostname])
ts.set_ruleset("inventory_df_rules", [{
'value': {
'ignore_fs_types': ['tmpfs', 'nfs', 'smbfs', 'cifs', 'iso9660'],
'never_ignore_mountpoints': ['~.*/omd/sites/[^/]+/tmp$']
},
'condition': {
'host_labels': {
'cmk/check_mk_server': 'yes'
}
}
}])
ts.set_ruleset("clustered_services", [([], [node1_hostname], ['fs_'])])
host_config = ts.apply(monkeypatch).get_host_config(hostname)
DiscoveredHostLabelsStore(node1_hostname).save({
'node1_existing_label': {
'plugin_name': 'node1_plugin',
'value': 'true',
}
})
DiscoveredHostLabelsStore(hostname).save({
'existing_label': {
'plugin_name': 'foo',
'value': 'bar',
},
'another_label': {
'plugin_name': 'labels',
'value': 'true',
}
})
broker = ParsedSectionsBroker({
HostKey(hostname=node1_hostname,
ipaddress=ipaddress,
source_type=SourceType.HOST):
SectionsParser(host_sections=AgentHostSections(sections={
SectionName("labels"): [
[
'{"cmk/check_mk_server":"yes"}',
],
],
SectionName("df"): [
[
'/dev/sda1',
'vfat',
'523248',
'3668',
'519580',
'1%',
'/boot/test-efi',
],
[
'tmpfs',
'tmpfs',
'8152916',
'244',
'8152672',
'1%',
'/opt/omd/sites/test-heute/tmp',
],
],
}, ), ),
HostKey(hostname=node2_hostname,
ipaddress=ipaddress,
source_type=SourceType.HOST):
SectionsParser(host_sections=AgentHostSections(sections={
SectionName("labels"): [
[
'{"node2_live_label":"true"}',
],
],
SectionName("df"): [
[
'/dev/sda1',
'vfat',
'523248',
'3668',
'519580',
'1%',
'/boot/test-efi',
],
[
'tmpfs',
'tmpfs',
'8152916',
'244',
'8152672',
'1%',
'/opt/omd/sites/test-heute2/tmp',
],
],
}, ), ),
})
return ClusterScenario(
host_config,
ipaddress,
broker,
node1_hostname,
node2_hostname,
)
def test__find_candidates():
broker = ParsedSectionsBroker({
# we just care about the keys here, content set to arbitrary values that can be parsed.
# section names are chosen arbitrarily.
HostKey("test_node", "1.2.3.4", SourceType.HOST):
SectionsParser(
host_sections=AgentHostSections({
SectionName("kernel"): [], # host only
SectionName("uptime"): [['123']], # host & mgmt
}), ),
HostKey("test_node", "1.2.3.4", SourceType.MANAGEMENT):
SectionsParser(
host_sections=SNMPHostSections({
# host & mgmt:
SectionName("uptime"): [['123']], # type: ignore[dict-item]
# mgmt only:
SectionName("liebert_fans"):
[[['Fan', '67', 'umin']]], # type: ignore[dict-item]
# is already mgmt_ prefixed:
SectionName("mgmt_snmp_info"):
[[['a', 'b', 'c', 'd']]], # type: ignore[dict-item]
}), ),
})
preliminary_candidates = list(
agent_based_register.iter_all_check_plugins())
parsed_sections_of_interest = {
parsed_section_name
for plugin in preliminary_candidates
for parsed_section_name in plugin.sections
}
assert discovery._discovered_services._find_host_candidates(
broker,
preliminary_candidates,
parsed_sections_of_interest,
) == {
CheckPluginName('docker_container_status_uptime'),
CheckPluginName("kernel"),
CheckPluginName('kernel_performance'),
CheckPluginName('kernel_util'),
CheckPluginName("uptime"),
}
assert discovery._discovered_services._find_mgmt_candidates(
broker,
preliminary_candidates,
parsed_sections_of_interest,
) == {
CheckPluginName('mgmt_docker_container_status_uptime'),
CheckPluginName("mgmt_liebert_fans"),
CheckPluginName("mgmt_uptime"),
}
assert discovery._discovered_services._find_candidates(
broker,
run_plugin_names=EVERYTHING,
) == {
CheckPluginName('docker_container_status_uptime'),
CheckPluginName("kernel"),
CheckPluginName('kernel_performance'),
CheckPluginName('kernel_util'),
CheckPluginName('mgmt_docker_container_status_uptime'),
CheckPluginName("mgmt_liebert_fans"),
CheckPluginName("mgmt_uptime"),
CheckPluginName("uptime"),
}
def _discover_plugins_services(
*,
check_plugin_name: CheckPluginName,
host_name: HostName,
ipaddress: Optional[HostAddress],
parsed_sections_broker: ParsedSectionsBroker,
on_error: OnError,
) -> Iterator[AutocheckEntry]:
# Skip this check type if is ignored for that host
if config.service_ignored(host_name, check_plugin_name, None):
console.vverbose(" Skip ignored check plugin name '%s'\n" %
check_plugin_name)
return
check_plugin = agent_based_register.get_check_plugin(check_plugin_name)
if check_plugin is None:
console.warning(" Missing check plugin: '%s'\n" % check_plugin_name)
return
host_key = HostKey(
host_name,
ipaddress,
SourceType.MANAGEMENT
if check_plugin.name.is_management_name() else SourceType.HOST,
)
try:
kwargs = get_section_kwargs(parsed_sections_broker, host_key,
check_plugin.sections)
except Exception as exc:
if cmk.utils.debug.enabled() or on_error is OnError.RAISE:
raise
if on_error is OnError.WARN:
console.warning(" Exception while parsing agent section: %s\n" %
exc)
return
if not kwargs:
return
disco_params = config.get_discovery_parameters(host_name, check_plugin)
if disco_params is not None:
kwargs = {**kwargs, "params": disco_params}
try:
yield from (
AutocheckEntry(
check_plugin_name=check_plugin.name,
item=service.item,
parameters=unwrap_parameters(service.parameters),
# Convert from APIs ServiceLabel to internal ServiceLabel
service_labels={
label.name: label.value
for label in service.labels
},
) for service in check_plugin.discovery_function(**kwargs))
except Exception as e:
if on_error is OnError.RAISE:
raise
if on_error is OnError.WARN:
console.warning(
" Exception in discovery function of check plugin '%s': %s" %
(check_plugin.name, e))
