def _create_host_label_function( host_label_function: Optional[HostLabelFunction], has_params: bool, ) -> HostLabelFunction: if host_label_function is None: return _noop_host_label_function validate_function_arguments( "host_label", host_label_function, has_item=False, sections=[ParsedSectionName("__always_just_one_section__")], has_params=has_params, ) @functools.wraps(host_label_function) def filtered_generator(*args, **kwargs): """Only let HostLabel through This allows for better typing in base code. """ for label in host_label_function( # type: ignore[misc] # Bug: None not callable *args, **kwargs, ): if not isinstance(label, HostLabel): raise TypeError("unexpected type in host label function: %r" % type(label)) yield label return filtered_generator
def create_snmp_section_plugin( *, name: str, detect_spec: SNMPDetectBaseType, fetch: Union[SNMPTree, List[SNMPTree]], parsed_section_name: Optional[str] = None, parse_function: Union[SimpleSNMPParseFunction, SNMPParseFunction, None] = None, host_label_function: Optional[HostLabelFunction] = None, supersedes: Optional[List[str]] = None, module: Optional[str] = None, validate_creation_kwargs: bool = True, ) -> SNMPSectionPlugin: """Return an SNMPSectionPlugin object after validating and converting the arguments one by one For a detailed description of the parameters please refer to the exposed function in the 'register' namespace of the API. """ section_name = SectionName(name) # normalize to List[SNMPTree] tree_list = [fetch] if isinstance(fetch, SNMPTree) else fetch if validate_creation_kwargs: _validate_detect_spec(detect_spec) _validate_fetch_spec(tree_list) if parse_function is not None: needs_bytes = any(oid.encoding == "binary" for tree in tree_list for oid in tree.oids) _validate_parse_function( parse_function, expected_annotation=_create_parse_annotation( needs_bytes=needs_bytes, is_list=isinstance(fetch, list), ), ) if host_label_function is not None: validate_function_arguments( type_label="host_label", function=host_label_function, has_item=False, default_params=None, # CMK-5181 sections=[ParsedSectionName("__always_just_one_section__")], ) return SNMPSectionPlugin( section_name, ParsedSectionName( parsed_section_name if parsed_section_name else str(section_name)), _create_snmp_parse_function(parse_function, isinstance(fetch, SNMPTree)), _create_host_label_function(host_label_function), _create_supersedes(section_name, supersedes), detect_spec, tree_list, module, )
def create_snmp_section_plugin( *, name: str, detect_spec: SNMPDetectSpec, trees: List[SNMPTree], parsed_section_name: Optional[str] = None, parse_function: Optional[SNMPParseFunction] = None, host_label_function: Optional[HostLabelFunction] = None, supersedes: Optional[List[str]] = None, module: Optional[str] = None, validate_creation_kwargs: bool = True, ) -> SNMPSectionPlugin: """Return an SNMPSectionPlugin object after validating and converting the arguments one by one For a detailed description of the parameters please refer to the exposed function in the 'register' namespace of the API. """ section_name = SectionName(name) if validate_creation_kwargs: _validate_detect_spec(detect_spec) _validate_snmp_trees(trees) if parse_function is not None: needs_bytes = any( isinstance(oid, OIDBytes) for tree in trees for oid in tree.oids) _validate_parse_function( parse_function, expected_annotation=( # (SNMPStringByteTable, "SNMPStringByteTable") if needs_bytes else (SNMPStringTable, "SNMPStringTable")), ) if host_label_function is not None: validate_function_arguments( type_label="host_label", function=host_label_function, has_item=False, default_params=None, # CMK-5181 sections=[ParsedSectionName("__always_just_one_section__")], ) return SNMPSectionPlugin( section_name, ParsedSectionName( parsed_section_name if parsed_section_name else str(section_name)), _create_snmp_parse_function(parse_function, trees), _create_host_label_function(host_label_function), _create_supersedes(section_name, supersedes), detect_spec, trees, module, )
def create_agent_section_plugin( *, name: str, parsed_section_name: Optional[str] = None, parse_function: Optional[AgentParseFunction] = None, host_label_function: Optional[HostLabelFunction] = None, supersedes: Optional[List[str]] = None, module: Optional[str] = None, validate_creation_kwargs: bool = True, ) -> AgentSectionPlugin: """Return an AgentSectionPlugin object after validating and converting the arguments one by one For a detailed description of the parameters please refer to the exposed function in the 'register' namespace of the API. """ section_name = SectionName(name) if validate_creation_kwargs: if parse_function is not None: _validate_parse_function( parse_function, expected_annotation=_create_parse_annotation(), ) if host_label_function is not None: validate_function_arguments( type_label="host_label", function=host_label_function, has_item=False, # TODO: # The following is a special case for the ps plugin. This should be done # in a more general sense when CMK-5158 is addressed. Make sure to grep for # "CMK-5158" in the code base. default_params={} if name in ("ps", "ps_lnx") else None, sections=[ParsedSectionName("__always_just_one_section__")], ) return AgentSectionPlugin( section_name, ParsedSectionName( parsed_section_name if parsed_section_name else str(section_name)), _create_agent_parse_function(parse_function), _create_host_label_function(host_label_function), _create_supersedes(section_name, supersedes), module, )
def create_inventory_plugin( *, name: str, sections: Optional[List[str]] = None, inventory_function: Callable, inventory_default_parameters: Optional[Dict] = None, inventory_ruleset_name: Optional[str] = None, module: Optional[str] = None, ) -> InventoryPlugin: """Return an InventoryPlugin object after validating and converting the arguments one by one For a detailed description of the parameters please refer to the exposed function in the 'register' namespace of the API. """ plugin_name = InventoryPluginName(name) subscribed_sections = create_subscribed_sections(sections, plugin_name) validate_function_arguments( type_label="inventory", function=inventory_function, has_item=False, default_params=inventory_default_parameters, sections=subscribed_sections, ) # validate check arguments validate_default_parameters( "inventory", inventory_ruleset_name, inventory_default_parameters, ) return InventoryPlugin( name=plugin_name, sections=subscribed_sections, inventory_function=_filter_inventory(inventory_function), inventory_default_parameters=inventory_default_parameters or {}, inventory_ruleset_name=(RuleSetName(inventory_ruleset_name) if inventory_ruleset_name else None), module=module, )
def _validate_host_label_kwargs( *, host_label_function: HostLabelFunction, host_label_default_parameters: Optional[Dict[str, Any]], host_label_ruleset_name: Optional[str], host_label_ruleset_type: RuleSetType, ) -> None: validate_ruleset_type(host_label_ruleset_type) validate_default_parameters( "host_label", host_label_ruleset_name, host_label_default_parameters, ) validate_function_arguments( type_label="host_label", function=host_label_function, has_item=False, default_params=host_label_default_parameters, sections=[ParsedSectionName("__always_just_one_section__")], )
def _validate_kwargs( *, plugin_name: CheckPluginName, subscribed_sections: List[ParsedSectionName], service_name: str, requires_item: bool, discovery_function: Callable, discovery_default_parameters: Optional[Dict], discovery_ruleset_name: Optional[str], discovery_ruleset_type: RuleSetType, check_function: Callable, check_default_parameters: Optional[Dict], check_ruleset_name: Optional[str], cluster_check_function: Optional[Callable], ) -> None: _validate_service_name(plugin_name, service_name) # validate discovery arguments validate_default_parameters( "discovery", discovery_ruleset_name, discovery_default_parameters, ) validate_ruleset_type(discovery_ruleset_type) validate_function_arguments( type_label="discovery", function=discovery_function, has_item=False, default_params=discovery_default_parameters, sections=subscribed_sections, ) # validate check arguments validate_default_parameters( "check", check_ruleset_name, check_default_parameters, ) validate_function_arguments( type_label="check", function=check_function, has_item=requires_item, default_params=check_default_parameters, sections=subscribed_sections, ) if cluster_check_function is None: return validate_function_arguments( type_label="cluster_check", function=cluster_check_function, has_item=requires_item, default_params=check_default_parameters, sections=subscribed_sections, )
def create_check_plugin( *, name: str, sections: Optional[List[str]] = None, service_name: str, discovery_function: Callable, discovery_default_parameters: Optional[Dict] = None, discovery_ruleset_name: Optional[str] = None, discovery_ruleset_type: DiscoveryRuleSetType = "merged", check_function: Callable, check_default_parameters: Optional[Dict] = None, check_ruleset_name: Optional[str] = None, cluster_check_function: Optional[Callable] = None, module: Optional[str] = None, validate_item: bool = True, ) -> CheckPlugin: """Return an CheckPlugin object after validating and converting the arguments one by one For a detailed description of the parameters please refer to the exposed function in the 'register' namespace of the API. """ plugin_name = CheckPluginName(name) subscribed_sections = create_subscribed_sections(sections, plugin_name) _validate_service_name(plugin_name, service_name) requires_item = _requires_item(service_name) # validate discovery arguments validate_default_parameters( "discovery", discovery_ruleset_name, discovery_default_parameters, ) _validate_discovery_ruleset( discovery_ruleset_name, discovery_default_parameters, ) _validate_discovery_ruleset_type(discovery_ruleset_type, ) validate_function_arguments( type_label="discovery", function=discovery_function, has_item=False, has_params=discovery_ruleset_name is not None, sections=subscribed_sections, ) disco_func = _filter_discovery(discovery_function, requires_item, validate_item) disco_params = discovery_default_parameters or {} disco_ruleset_name = RuleSetName( discovery_ruleset_name) if discovery_ruleset_name else None # validate check arguments validate_default_parameters( "check", check_ruleset_name, check_default_parameters, ) _validate_check_ruleset( check_ruleset_name, check_default_parameters, ) validate_function_arguments( type_label="check", function=check_function, has_item=requires_item, has_params=check_default_parameters is not None, sections=subscribed_sections, ) if cluster_check_function is None: cluster_check_function = unfit_for_clustering_wrapper(check_function) else: validate_function_arguments( type_label="cluster_check", function=cluster_check_function, has_item=requires_item, has_params=check_ruleset_name is not None, sections=subscribed_sections, ) cluster_check_function = _filter_check(cluster_check_function) return CheckPlugin( name=plugin_name, sections=subscribed_sections, service_name=service_name, discovery_function=disco_func, discovery_default_parameters=disco_params, discovery_ruleset_name=disco_ruleset_name, discovery_ruleset_type=discovery_ruleset_type, check_function=_filter_check(check_function), check_default_parameters=check_default_parameters or {}, check_ruleset_name=RuleSetName(check_ruleset_name) if check_ruleset_name else None, cluster_check_function=cluster_check_function, module=module, )