def get_check_preview(
*,
host_name: HostName,
max_cachefile_age: int,
use_cached_snmp_data: bool,
on_error: OnError,
) -> Tuple[CheckPreviewTable, QualifiedDiscovery[HostLabel]]:
"""Get the list of service of a host or cluster and guess the current state of
all services if possible"""
config_cache = config.get_config_cache()
host_config = config_cache.get_host_config(host_name)
ip_address = None if host_config.is_cluster else config.lookup_ip_address(host_config)
_set_cache_opts_of_checkers(use_cached_snmp_data=use_cached_snmp_data)
parsed_sections_broker, _source_results = make_broker(
config_cache=config_cache,
host_config=host_config,
ip_address=ip_address,
mode=Mode.DISCOVERY,
file_cache_max_age=max_cachefile_age,
selected_sections=NO_SELECTION,
fetcher_messages=(),
force_snmp_cache_refresh=not use_cached_snmp_data,
on_scan_error=on_error,
)
host_labels = analyse_host_labels(
host_config=host_config,
ipaddress=ip_address,
parsed_sections_broker=parsed_sections_broker,
load_labels=True,
save_labels=False,
on_error=on_error,
)
grouped_services = _get_host_services(
host_config,
ip_address,
parsed_sections_broker,
on_error,
)
with load_host_value_store(host_name, store_changes=False) as value_store_manager:
table = [
_check_preview_table_row(
host_config=host_config,
ip_address=ip_address,
service=service,
check_source=check_source,
parsed_sections_broker=parsed_sections_broker,
found_on_nodes=found_on_nodes,
value_store_manager=value_store_manager,
)
for check_source, services_with_nodes in grouped_services.items()
for service, found_on_nodes in services_with_nodes
]
return table, host_labels
def commandline_discovery(
arg_hostnames: Set[HostName],
*,
selected_sections: SectionNameCollection,
run_plugin_names: Container[CheckPluginName],
arg_only_new: bool,
only_host_labels: bool = False,
) -> None:
"""Implementing cmk -I and cmk -II
This is directly called from the main option parsing code.
The list of hostnames is already prepared by the main code.
If it is empty then we use all hosts and switch to using cache files.
"""
config_cache = config.get_config_cache()
on_error = OnError.RAISE if cmk.utils.debug.enabled() else OnError.WARN
host_names = _preprocess_hostnames(arg_hostnames, config_cache,
only_host_labels)
mode = Mode.DISCOVERY if selected_sections is NO_SELECTION else Mode.FORCE_SECTIONS
# Now loop through all hosts
for host_name in sorted(host_names):
host_config = config_cache.get_host_config(host_name)
section.section_begin(host_name)
try:
ipaddress = config.lookup_ip_address(host_config)
parsed_sections_broker, _results = make_broker(
config_cache=config_cache,
host_config=host_config,
ip_address=ipaddress,
mode=mode,
selected_sections=selected_sections,
file_cache_max_age=config.max_cachefile_age(),
fetcher_messages=(),
force_snmp_cache_refresh=False,
on_scan_error=on_error,
)
_commandline_discovery_on_host(
host_name,
ipaddress,
parsed_sections_broker,
run_plugin_names,
arg_only_new,
load_labels=arg_only_new,
only_host_labels=only_host_labels,
on_error=on_error,
)
except Exception as e:
if cmk.utils.debug.enabled():
raise
section.section_error("%s" % e)
finally:
cmk.utils.cleanup.cleanup_globals()
def do_discovery(
arg_hostnames: Set[HostName],
*,
selected_sections: SectionNameCollection,
run_plugin_names: Container[CheckPluginName],
arg_only_new: bool,
only_host_labels: bool = False,
) -> None:
config_cache = config.get_config_cache()
use_caches = not arg_hostnames or cmk.core_helpers.cache.FileCacheFactory.maybe
on_error = "raise" if cmk.utils.debug.enabled() else "warn"
discovery_parameters = DiscoveryParameters(
on_error=on_error,
load_labels=arg_only_new,
save_labels=True,
only_host_labels=only_host_labels,
)
host_names = _preprocess_hostnames(arg_hostnames, config_cache,
only_host_labels)
mode = Mode.DISCOVERY if selected_sections is NO_SELECTION else Mode.FORCE_SECTIONS
# Now loop through all hosts
for host_name in sorted(host_names):
host_config = config_cache.get_host_config(host_name)
section.section_begin(host_name)
try:
ipaddress = config.lookup_ip_address(host_config)
parsed_sections_broker, _results = make_broker(
config_cache=config_cache,
host_config=host_config,
ip_address=ipaddress,
mode=mode,
selected_sections=selected_sections,
file_cache_max_age=config.discovery_max_cachefile_age()
if use_caches else 0,
fetcher_messages=(),
force_snmp_cache_refresh=False,
on_scan_error=on_error,
)
_do_discovery_for(
host_name,
ipaddress,
parsed_sections_broker,
run_plugin_names,
arg_only_new,
discovery_parameters,
)
except Exception as e:
if cmk.utils.debug.enabled():
raise
section.section_error("%s" % e)
finally:
cmk.utils.cleanup.cleanup_globals()
def _inventorize_host(
*,
host_config: config.HostConfig,
run_plugin_names: Container[InventoryPluginName],
selected_sections: SectionNameCollection,
retentions_tracker: RetentionsTracker,
) -> ActiveInventoryResult:
if host_config.is_cluster:
return ActiveInventoryResult(
trees=_do_inv_for_cluster(host_config),
source_results=(),
parsing_errors=(),
safe_to_write=True,
)
ipaddress = config.lookup_ip_address(host_config)
config_cache = config.get_config_cache()
broker, results = make_broker(
config_cache=config_cache,
host_config=host_config,
ip_address=ipaddress,
selected_sections=selected_sections,
mode=(Mode.INVENTORY
if selected_sections is NO_SELECTION else Mode.FORCE_SECTIONS),
file_cache_max_age=host_config.max_cachefile_age,
fetcher_messages=(),
force_snmp_cache_refresh=False,
on_scan_error=OnError.RAISE,
)
parsing_errors = broker.parsing_errors()
return ActiveInventoryResult(
trees=_do_inv_for_realhost(
host_config,
ipaddress,
parsed_sections_broker=broker,
run_plugin_names=run_plugin_names,
retentions_tracker=retentions_tracker,
),
source_results=results,
parsing_errors=parsing_errors,
safe_to_write=(
_safe_to_write_tree(results)
and selected_sections is NO_SELECTION #
and run_plugin_names is EVERYTHING #
and not parsing_errors #
),
)
def _inventorize_host(
*,
host_config: config.HostConfig,
run_plugin_names: Container[InventoryPluginName],
selected_sections: SectionNameCollection,
retentions_tracker: RetentionsTracker,
) -> ActiveInventoryResult:
if host_config.is_cluster:
return ActiveInventoryResult(
trees=_do_inv_for_cluster(host_config),
source_results=(),
parsing_errors=(),
processing_failed=False,
)
ipaddress = config.lookup_ip_address(host_config)
config_cache = config.get_config_cache()
fetched = fetch_all(
sources=make_sources(
config_cache,
host_config,
ipaddress,
selected_sections=selected_sections,
force_snmp_cache_refresh=False,
on_scan_error=OnError.RAISE,
),
file_cache_max_age=host_config.max_cachefile_age,
mode=(Mode.INVENTORY
if selected_sections is NO_SELECTION else Mode.FORCE_SECTIONS),
)
broker, results = make_broker(
fetched=fetched,
selected_sections=selected_sections,
file_cache_max_age=host_config.max_cachefile_age,
)
parsing_errors = broker.parsing_errors()
return ActiveInventoryResult(
trees=_do_inv_for_realhost(
host_config,
parsed_sections_broker=broker,
run_plugin_names=run_plugin_names,
retentions_tracker=retentions_tracker,
),
source_results=results,
parsing_errors=parsing_errors,
processing_failed=(_sources_failed(results) or bool(parsing_errors)),
)
def _do_active_inventory_for(
*,
host_config: config.HostConfig,
run_plugin_names: Container[InventoryPluginName],
selected_sections: SectionNameCollection,
) -> ActiveInventoryResult:
if host_config.is_cluster:
return ActiveInventoryResult(
trees=_do_inv_for_cluster(host_config),
source_results=[],
safe_to_write=True,
)
ipaddress = config.lookup_ip_address(host_config)
config_cache = config.get_config_cache()
broker, results = make_broker(
config_cache=config_cache,
host_config=host_config,
ip_address=ipaddress,
selected_sections=selected_sections,
mode=(Mode.INVENTORY
if selected_sections is NO_SELECTION else Mode.FORCE_SECTIONS),
file_cache_max_age=host_config.max_cachefile_age,
fetcher_messages=(),
force_snmp_cache_refresh=False,
on_scan_error="raise",
)
return ActiveInventoryResult(
trees=_do_inv_for_realhost(
host_config,
ipaddress,
parsed_sections_broker=broker,
run_plugin_names=run_plugin_names,
),
source_results=results,
safe_to_write=(
_safe_to_write_tree(results) and #
selected_sections is NO_SELECTION and #
run_plugin_names is EVERYTHING),
)
def active_check_discovery(
host_name: HostName,
ipaddress: Optional[HostAddress],
*,
# The next argument *must* remain optional for the DiscoCheckExecutor.
# See Also: `cmk.base.agent_based.checking.active_check_checking()`.
fetcher_messages: Sequence[FetcherMessage] = (),
) -> ActiveCheckResult:
# Note: '--cache' is set in core_cmc, nagios template or even on CL and means:
# 1. use caches as default:
# - Set FileCacheFactory.maybe = True (set max_cachefile_age, else 0)
# - Set FileCacheFactory.use_outdated = True
# 2. Then these settings are used to read cache file or not
config_cache = config.get_config_cache()
host_config = config_cache.get_host_config(host_name)
params = host_config.discovery_check_parameters
if params is None:
params = host_config.default_discovery_check_parameters()
rediscovery_parameters = params.get("inventory_rediscovery", {})
discovery_mode = DiscoveryMode(rediscovery_parameters.get("mode"))
# In case of keepalive discovery we always have an ipaddress. When called as non keepalive
# ipaddress is always None
if ipaddress is None and not host_config.is_cluster:
ipaddress = config.lookup_ip_address(host_config)
parsed_sections_broker, source_results = make_broker(
config_cache=config_cache,
host_config=host_config,
ip_address=ipaddress,
mode=Mode.DISCOVERY,
fetcher_messages=fetcher_messages,
selected_sections=NO_SELECTION,
file_cache_max_age=config.max_cachefile_age(
discovery=None if cmk.core_helpers.cache.FileCacheFactory.
maybe else 0),
force_snmp_cache_refresh=False,
on_scan_error=OnError.RAISE,
)
host_labels = analyse_host_labels(
host_config=host_config,
ipaddress=ipaddress,
parsed_sections_broker=parsed_sections_broker,
load_labels=True,
save_labels=False,
on_error=OnError.RAISE,
)
services = _get_host_services(
host_config,
ipaddress,
parsed_sections_broker,
on_error=OnError.RAISE,
)
services_result, services_need_rediscovery = _check_service_lists(
host_name=host_name,
services_by_transition=services,
params=params,
service_filters=_ServiceFilters.from_settings(rediscovery_parameters),
discovery_mode=discovery_mode,
)
host_labels_result, host_labels_need_rediscovery = _check_host_labels(
host_labels,
int(params.get("severity_new_host_label", 1)),
discovery_mode,
)
parsing_errors_result = check_parsing_errors(
parsed_sections_broker.parsing_errors())
return ActiveCheckResult.from_subresults(
services_result,
host_labels_result,
*check_sources(source_results=source_results, mode=Mode.DISCOVERY),
parsing_errors_result,
_schedule_rediscovery(
host_config=host_config,
need_rediscovery=(services_need_rediscovery
or host_labels_need_rediscovery)
and parsing_errors_result.state == 0,
),
)
def automation_discovery(
*,
config_cache: config.ConfigCache,
host_config: config.HostConfig,
mode: DiscoveryMode,
service_filters: Optional[_ServiceFilters],
on_error: OnError,
use_cached_snmp_data: bool,
max_cachefile_age: cmk.core_helpers.cache.MaxAge,
) -> DiscoveryResult:
console.verbose(" Doing discovery with mode '%s'...\n" % mode)
host_name = host_config.hostname
result = DiscoveryResult()
if host_name not in config_cache.all_active_hosts():
result.error_text = ""
return result
cmk.core_helpers.cache.FileCacheFactory.use_outdated = True
cmk.core_helpers.cache.FileCacheFactory.maybe = use_cached_snmp_data
try:
# in "refresh" mode we first need to remove all previously discovered
# checks of the host, so that _get_host_services() does show us the
# new discovered check parameters.
if mode is DiscoveryMode.REFRESH:
result.self_removed += host_config.remove_autochecks(
) # this is cluster-aware!
if host_config.is_cluster:
ipaddress = None
else:
ipaddress = config.lookup_ip_address(host_config)
parsed_sections_broker, _source_results = make_broker(
config_cache=config_cache,
host_config=host_config,
ip_address=ipaddress,
mode=Mode.DISCOVERY,
selected_sections=NO_SELECTION,
file_cache_max_age=max_cachefile_age,
fetcher_messages=(),
force_snmp_cache_refresh=not use_cached_snmp_data,
on_scan_error=on_error,
)
if mode is not DiscoveryMode.REMOVE:
host_labels = analyse_host_labels(
host_config=host_config,
ipaddress=ipaddress,
parsed_sections_broker=parsed_sections_broker,
load_labels=True,
save_labels=True,
on_error=on_error,
)
result.self_new_host_labels = len(host_labels.new)
result.self_total_host_labels = len(host_labels.present)
if mode is DiscoveryMode.ONLY_HOST_LABELS:
# This is the result of a refactoring, and the following code was added
# to ensure a compatible behaviour. I don't think it is particularly
# sensible. We used to only compare service descriptions of old and new
# services, so `make_object_diff` was always comparing two identical objects
# if the mode was DiscoveryMode.ONLY_HOST_LABEL.
# We brainlessly mimic that behaviour, for now.
result.diff_text = make_object_diff(set(), set())
return result
# Compute current state of new and existing checks
services = _get_host_services(
host_config,
ipaddress,
parsed_sections_broker,
on_error=on_error,
)
old_services = services.get("old", [])
# Create new list of checks
new_services = _get_post_discovery_services(
host_name, services, service_filters
or _ServiceFilters.accept_all(), result, mode)
host_config.set_autochecks(new_services)
# If old_services == new_services, make_object_diff will return
# something along the lines of "nothing changed".
# I guess this was written before discovered host labels were invented.
result.diff_text = make_object_diff(
{x.service.description
for x in old_services},
{x.service.description
for x in new_services},
)
except MKTimeout:
raise # let general timeout through
except Exception as e:
if cmk.utils.debug.enabled():
raise
result.error_text = str(e)
result.self_total = result.self_new + result.self_kept
return result
def check_discovery(
host_name: HostName,
ipaddress: Optional[HostAddress],
*,
# The next argument *must* remain optional for the DiscoCheckExecutor.
# See Also: `cmk.base.agent_based.checking.do_check()`.
fetcher_messages: Sequence[FetcherMessage] = (),
) -> Tuple[int, List[str], List[str], List[Tuple]]:
# Note: '--cache' is set in core_cmc, nagios template or even on CL and means:
# 1. use caches as default:
# - Set FileCacheFactory.maybe = True (set max_cachefile_age, else 0)
# - Set FileCacheFactory.use_outdated = True
# 2. Then these settings are used to read cache file or not
config_cache = config.get_config_cache()
host_config = config_cache.get_host_config(host_name)
discovery_parameters = DiscoveryParameters(
on_error="raise",
load_labels=True,
save_labels=False,
only_host_labels=False,
)
params = host_config.discovery_check_parameters
if params is None:
params = host_config.default_discovery_check_parameters()
discovery_mode = DiscoveryMode(_get_rediscovery_parameters(params).get("mode"))
# In case of keepalive discovery we always have an ipaddress. When called as non keepalive
# ipaddress is always None
if ipaddress is None and not host_config.is_cluster:
ipaddress = config.lookup_ip_address(host_config)
parsed_sections_broker, source_results = make_broker(
config_cache=config_cache,
host_config=host_config,
ip_address=ipaddress,
mode=Mode.DISCOVERY,
fetcher_messages=fetcher_messages,
selected_sections=NO_SELECTION,
file_cache_max_age=(config.discovery_max_cachefile_age()
if cmk.core_helpers.cache.FileCacheFactory.maybe else 0),
force_snmp_cache_refresh=False,
on_scan_error=discovery_parameters.on_error,
)
services, host_label_discovery_result = _get_host_services(
host_config,
ipaddress,
parsed_sections_broker,
discovery_parameters,
)
status, infotexts, long_infotexts, perfdata, need_rediscovery = _aggregate_subresults(
_check_service_lists(host_name, services, params, discovery_mode),
_check_host_labels(
host_label_discovery_result,
int(params.get("severity_new_host_label", 1)),
discovery_mode,
),
_check_data_sources(source_results),
)
if need_rediscovery:
if host_config.is_cluster and host_config.nodes:
for nodename in host_config.nodes:
_set_rediscovery_flag(nodename)
else:
_set_rediscovery_flag(host_name)
infotexts.append(u"rediscovery scheduled")
return status, infotexts, long_infotexts, perfdata
def discover_on_host(
*,
config_cache: config.ConfigCache,
host_config: config.HostConfig,
mode: DiscoveryMode,
service_filters: Optional[_ServiceFilters],
on_error: str,
use_cached_snmp_data: bool,
max_cachefile_age: int,
) -> DiscoveryResult:
console.verbose(" Doing discovery with mode '%s'...\n" % mode)
host_name = host_config.hostname
result = DiscoveryResult()
discovery_parameters = DiscoveryParameters(
on_error=on_error,
load_labels=(mode is not DiscoveryMode.REMOVE),
save_labels=(mode is not DiscoveryMode.REMOVE),
only_host_labels=(mode is DiscoveryMode.ONLY_HOST_LABELS),
)
if host_name not in config_cache.all_active_hosts():
result.error_text = ""
return result
_set_cache_opts_of_checkers(use_cached_snmp_data=use_cached_snmp_data)
try:
# in "refresh" mode we first need to remove all previously discovered
# checks of the host, so that _get_host_services() does show us the
# new discovered check parameters.
if mode is DiscoveryMode.REFRESH:
result.self_removed += host_config.remove_autochecks() # this is cluster-aware!
if host_config.is_cluster:
ipaddress = None
else:
ipaddress = config.lookup_ip_address(host_config)
parsed_sections_broker, _source_results = make_broker(
config_cache=config_cache,
host_config=host_config,
ip_address=ipaddress,
mode=Mode.DISCOVERY,
selected_sections=NO_SELECTION,
file_cache_max_age=max_cachefile_age,
fetcher_messages=(),
force_snmp_cache_refresh=not use_cached_snmp_data,
on_scan_error=on_error,
)
# Compute current state of new and existing checks
services, host_labels = _get_host_services(
host_config,
ipaddress,
parsed_sections_broker,
discovery_parameters,
)
old_services = services.get("old", [])
# Create new list of checks
new_services = _get_post_discovery_services(host_name, services, service_filters or
_ServiceFilters.accept_all(), result, mode)
host_config.set_autochecks(new_services)
result.diff_text = make_object_diff(
_make_services_audit_log_object([x.service for x in old_services]),
_make_services_audit_log_object([x.service for x in new_services]))
except MKTimeout:
raise # let general timeout through
except Exception as e:
if cmk.utils.debug.enabled():
raise
result.error_text = str(e)
else:
if mode is not DiscoveryMode.REMOVE:
result.self_new_host_labels = len(host_labels.new)
result.self_total_host_labels = len(host_labels.present)
result.self_total = result.self_new + result.self_kept
return result
def _execute_checkmk_checks(
*,
hostname: HostName,
ipaddress: Optional[HostAddress],
fetcher_messages: Sequence[FetcherMessage] = (),
run_plugin_names: Container[CheckPluginName],
selected_sections: SectionNameCollection,
dry_run: bool,
show_perfdata: bool,
) -> ActiveCheckResult:
config_cache = config.get_config_cache()
host_config = config_cache.get_host_config(hostname)
exit_spec = host_config.exit_code_spec()
mode = Mode.CHECKING if selected_sections is NO_SELECTION else Mode.FORCE_SECTIONS
try:
license_usage.try_history_update()
# In case of keepalive we always have an ipaddress (can be 0.0.0.0 or :: when
# address is unknown). When called as non keepalive ipaddress may be None or
# is already an address (2nd argument)
if ipaddress is None and not host_config.is_cluster:
ipaddress = config.lookup_ip_address(host_config)
services = config.resolve_service_dependencies(
host_name=hostname,
services=sorted(
check_table.get_check_table(hostname).values(),
key=lambda service: service.description,
),
)
with CPUTracker() as tracker:
broker, source_results = make_broker(
config_cache=config_cache,
host_config=host_config,
ip_address=ipaddress,
mode=mode,
selected_sections=selected_sections,
file_cache_max_age=host_config.max_cachefile_age,
fetcher_messages=fetcher_messages,
force_snmp_cache_refresh=False,
on_scan_error=OnError.RAISE,
)
num_success, plugins_missing_data = check_host_services(
config_cache=config_cache,
host_config=host_config,
ipaddress=ipaddress,
parsed_sections_broker=broker,
services=services,
run_plugin_names=run_plugin_names,
dry_run=dry_run,
show_perfdata=show_perfdata,
)
if run_plugin_names is EVERYTHING:
inventory.do_inventory_actions_during_checking_for(
config_cache,
host_config,
ipaddress,
parsed_sections_broker=broker,
)
timed_results = [
*check_sources(
source_results=source_results,
mode=mode,
include_ok_results=True,
),
*check_parsing_errors(errors=broker.parsing_errors(), ),
*_check_plugins_missing_data(
plugins_missing_data,
exit_spec,
bool(num_success),
),
]
return ActiveCheckResult.from_subresults(
*timed_results,
_timing_results(tracker, fetcher_messages),
)
finally:
_submit_to_core.finalize()
def get_check_preview(
*,
host_name: HostName,
max_cachefile_age: int,
use_cached_snmp_data: bool,
on_error: str,
) -> Tuple[CheckPreviewTable, QualifiedDiscovery[HostLabel]]:
"""Get the list of service of a host or cluster and guess the current state of
all services if possible"""
config_cache = config.get_config_cache()
host_config = config_cache.get_host_config(host_name)
ip_address = None if host_config.is_cluster else config.lookup_ip_address(
host_config)
discovery_parameters = DiscoveryParameters(
on_error=on_error,
load_labels=True,
save_labels=False,
only_host_labels=False,
)
_set_cache_opts_of_checkers(use_cached_snmp_data=use_cached_snmp_data)
parsed_sections_broker, _source_results = make_broker(
config_cache=config_cache,
host_config=host_config,
ip_address=ip_address,
mode=Mode.DISCOVERY,
file_cache_max_age=max_cachefile_age,
selected_sections=NO_SELECTION,
fetcher_messages=(),
force_snmp_cache_refresh=not use_cached_snmp_data,
on_scan_error=on_error,
)
grouped_services, host_label_result = _get_host_services(
host_config,
ip_address,
parsed_sections_broker,
discovery_parameters,
)
table: CheckPreviewTable = []
for check_source, services_with_nodes in grouped_services.items():
for service, found_on_nodes in services_with_nodes:
plugin = agent_based_register.get_check_plugin(
service.check_plugin_name)
params = _preview_params(host_name, service, plugin, check_source)
if check_source in ['legacy', 'active', 'custom']:
exitcode = None
output = u"WAITING - %s check, cannot be done offline" % check_source.title(
)
ruleset_name: Optional[RulesetName] = None
else:
ruleset_name = (str(plugin.check_ruleset_name) if plugin
and plugin.check_ruleset_name else None)
wrapped_params = (
Parameters(wrap_parameters(params)) if plugin
and plugin.check_default_parameters is not None else None)
exitcode, output, _perfdata = checking.get_aggregated_result(
parsed_sections_broker,
host_config,
ip_address,
service,
plugin,
lambda p=wrapped_params:
p, # type: ignore[misc] # "type of lambda"
).result
# Service discovery never uses the perfdata in the check table. That entry
# is constantly discarded, yet passed around(back and forth) as part of the
# discovery result in the request elements. Some perfdata VALUES are not parsable
# by ast.literal_eval such as "inf" it lead to ValueErrors. Thus keep perfdata empty
perfdata: List[MetricTuple] = []
table.append((
_preview_check_source(host_name, service, check_source),
str(service.check_plugin_name),
ruleset_name,
service.item,
service.parameters,
params,
service.description,
exitcode,
output,
perfdata,
service.service_labels.to_dict(),
found_on_nodes,
))
return table, host_label_result
def do_check(
hostname: HostName,
ipaddress: Optional[HostAddress],
*,
# The following arguments *must* remain optional for Nagios and the `DiscoCheckExecutor`.
# See Also: `cmk.base.discovery.check_discovery()`
fetcher_messages: Sequence[FetcherMessage] = (),
run_plugin_names: Container[CheckPluginName] = EVERYTHING,
selected_sections: SectionNameCollection = NO_SELECTION,
dry_run: bool = False,
show_perfdata: bool = False,
) -> Tuple[int, List[ServiceDetails], List[ServiceAdditionalDetails], List[str]]:
console.vverbose("Checkmk version %s\n", cmk_version.__version__)
config_cache = config.get_config_cache()
host_config = config_cache.get_host_config(hostname)
exit_spec = host_config.exit_code_spec()
mode = Mode.CHECKING if selected_sections is NO_SELECTION else Mode.FORCE_SECTIONS
status: ServiceState = 0
infotexts: List[ServiceDetails] = []
long_infotexts: List[ServiceAdditionalDetails] = []
perfdata: List[str] = []
try:
license_usage.try_history_update()
# In case of keepalive we always have an ipaddress (can be 0.0.0.0 or :: when
# address is unknown). When called as non keepalive ipaddress may be None or
# is already an address (2nd argument)
if ipaddress is None and not host_config.is_cluster:
ipaddress = config.lookup_ip_address(host_config)
services_to_check = _get_services_to_check(
config_cache=config_cache,
host_name=hostname,
run_plugin_names=run_plugin_names,
)
with CPUTracker() as tracker:
broker, source_results = make_broker(
config_cache=config_cache,
host_config=host_config,
ip_address=ipaddress,
mode=mode,
selected_sections=selected_sections,
file_cache_max_age=host_config.max_cachefile_age,
fetcher_messages=fetcher_messages,
force_snmp_cache_refresh=False,
on_scan_error="raise",
)
num_success, plugins_missing_data = _do_all_checks_on_host(
config_cache,
host_config,
ipaddress,
parsed_sections_broker=broker,
services=services_to_check,
dry_run=dry_run,
show_perfdata=show_perfdata,
)
if run_plugin_names is EVERYTHING:
inventory.do_inventory_actions_during_checking_for(
config_cache,
host_config,
ipaddress,
parsed_sections_broker=broker,
)
for source, host_sections in source_results:
source_state, source_output = source.summarize(host_sections)
if source_output != "":
status = worst_service_state(status, source_state, default=3)
infotexts.append("[%s] %s" % (source.id, source_output))
if plugins_missing_data:
missing_data_status, missing_data_infotext = _check_plugins_missing_data(
plugins_missing_data,
exit_spec,
bool(num_success),
)
status = max(status, missing_data_status)
infotexts.append(missing_data_infotext)
total_times = tracker.duration
for msg in fetcher_messages:
total_times += msg.stats.duration
infotexts.append("execution time %.1f sec" % total_times.process.elapsed)
if config.check_mk_perfdata_with_times:
perfdata += [
"execution_time=%.3f" % total_times.process.elapsed,
"user_time=%.3f" % total_times.process.user,
"system_time=%.3f" % total_times.process.system,
"children_user_time=%.3f" % total_times.process.children_user,
"children_system_time=%.3f" % total_times.process.children_system,
]
summary: DefaultDict[str, Snapshot] = defaultdict(Snapshot.null)
for msg in fetcher_messages if fetcher_messages else ():
if msg.fetcher_type in (
FetcherType.PIGGYBACK,
FetcherType.PROGRAM,
FetcherType.SNMP,
FetcherType.TCP,
):
summary[{
FetcherType.PIGGYBACK: "agent",
FetcherType.PROGRAM: "ds",
FetcherType.SNMP: "snmp",
FetcherType.TCP: "agent",
}[msg.fetcher_type]] += msg.stats.duration
for phase, duration in summary.items():
perfdata.append("cmk_time_%s=%.3f" % (phase, duration.idle))
else:
perfdata.append("execution_time=%.3f" % total_times.process.elapsed)
return status, infotexts, long_infotexts, perfdata
finally:
_submit_to_core.finalize()
def _execute_checkmk_checks(
*,
hostname: HostName,
ipaddress: Optional[HostAddress],
fetched: Sequence[Tuple[Source, FetcherMessage]],
run_plugin_names: Container[CheckPluginName],
selected_sections: SectionNameCollection,
dry_run: bool,
show_perfdata: bool,
) -> ActiveCheckResult:
config_cache = config.get_config_cache()
host_config = config_cache.get_host_config(hostname)
exit_spec = host_config.exit_code_spec()
try:
license_usage.try_history_update()
services = config.resolve_service_dependencies(
host_name=hostname,
services=sorted(
check_table.get_check_table(hostname).values(),
key=lambda service: service.description,
),
)
broker, source_results = make_broker(
fetched=fetched,
selected_sections=selected_sections,
file_cache_max_age=host_config.max_cachefile_age,
)
with CPUTracker() as tracker:
num_success, plugins_missing_data = check_host_services(
config_cache=config_cache,
host_config=host_config,
ipaddress=ipaddress,
parsed_sections_broker=broker,
services=services,
run_plugin_names=run_plugin_names,
dry_run=dry_run,
show_perfdata=show_perfdata,
)
if run_plugin_names is EVERYTHING:
inventory.do_inventory_actions_during_checking_for(
config_cache,
host_config,
parsed_sections_broker=broker,
)
timed_results = [
*check_sources(
source_results=source_results,
include_ok_results=True,
),
*check_parsing_errors(errors=broker.parsing_errors(), ),
*_check_plugins_missing_data(
plugins_missing_data,
exit_spec,
bool(num_success),
),
]
return ActiveCheckResult.from_subresults(
*timed_results,
_timing_results(tracker.duration,
[fetched_entry[1] for fetched_entry in fetched]),
)
finally:
_submit_to_core.finalize()