def _discover_plugins_services( *, check_plugin_name: CheckPluginName, host_key: HostKey, parsed_sections_broker: ParsedSectionsBroker, on_error: OnError, ) -> Iterator[AutocheckEntry]: # Skip this check type if is ignored for that host if config.service_ignored(host_key.hostname, 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 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_key.hostname, 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))
def check_result_generator(*args, **kwargs): assert not args, "pass arguments as keywords to check function" assert "params" in kwargs, "'params' is missing in kwargs: %r" % ( kwargs, ) parameters = kwargs["params"] if isinstance(parameters, Parameters): # In the new API check_functions will be passed an immutable mapping # instead of a dict. However, we have way too many 'if isinsance(params, dict)' # call sites to introduce this into legacy code, so use the plain dict. parameters = copy.deepcopy(parameters._data) kwargs["params"] = unwrap_parameters(parameters) item_state.reset_wrapped_counters() # not supported by the new API! try: subresults = sig_function(**kwargs) except TypeError: # this handles a very weird case, in which check plugins do not have an '%s' # in their description (^= no item) but do in fact discover an empty string. # We cannot just append "%s" to the service description, because in that case # our tests complain about the ruleset not being for plugins with item :-( # Just retry without item: subresults = sig_function( **{k: v for k, v in kwargs.items() if k != "item"}) if subresults is None: return if isinstance(subresults, tuple): # just one result subresults = [subresults] # Once we have seen a newline in *any* subresult, # all remaining output is sent to the details page! # I'm not saying that is good, but we stay compatible. is_details = False for subresult in subresults: is_details = yield from _create_new_result(is_details, *subresult) item_state.raise_counter_wrap()
def _enriched_discovered_services( host_name: HostName, check_plugin_name: CheckPluginName, plugins_services: checking_classes.DiscoveryResult, ) -> Generator[Service, None, None]: for service in plugins_services: description = config.service_description(host_name, check_plugin_name, service.item) # make sanity check if not description: console.error( f"{host_name}: {check_plugin_name} returned empty service description - ignoring it.\n" ) continue yield Service( check_plugin_name=check_plugin_name, item=service.item, description=description, parameters=unwrap_parameters(service.parameters), # Convert from APIs ServiceLabel to internal ServiceLabel service_labels=DiscoveredServiceLabels(*(ServiceLabel(*l) for l in service.labels)), )
def test_noop_unwrap_parameters(): assert {"levels": (1, 2)} == unwrap_parameters({"levels": (1, 2)})
def test_un_wrap_parameters(params): wrapped = wrap_parameters(params) assert isinstance(wrapped, dict) assert unwrap_parameters(wrapped) == params