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,
)
