def _extract_snmp_sections( inf_info: Dict[InventoryPluginNameStr, InventoryInfo], plugin_file_lookup: Dict[str, str], ) -> None: for plugin_name, plugin_info in sorted(inv_info.items()): if 'snmp_info' not in plugin_info: continue section_name = section_name_of(plugin_name) if isinstance(agent_based_register.get_section_plugin(SectionName(section_name)), SNMPSectionPlugin): continue fallback_files = ([_include_file_path(i) for i in plugin_info.get('includes', [])] + [plugin_file_lookup[plugin_name]]) try: agent_based_register.add_section_plugin( create_snmp_section_plugin_from_legacy( section_name, {}, plugin_info['snmp_scan_function'], plugin_info['snmp_info'], scan_function_fallback_files=fallback_files, )) except (NotImplementedError, KeyError, AssertionError, ValueError): msg = config.AUTO_MIGRATION_ERR_MSG % ('section', plugin_name) if cmk.utils.debug.enabled(): raise MKGeneralException(msg) console.warning(msg)
def _extract_snmp_sections( inf_info: Dict[InventoryPluginNameStr, InventoryInfo], plugin_file_lookup: Dict[str, str], ) -> List[str]: errors = [] for plugin_name, plugin_info in sorted(inv_info.items()): if 'snmp_info' not in plugin_info: continue section_name = section_name_of(plugin_name) if isinstance(agent_based_register.get_section_plugin(SectionName(section_name)), SNMPSectionPlugin): continue fallback_files = ([_include_file_path(i) for i in plugin_info.get('includes', [])] + [plugin_file_lookup[plugin_name]]) try: agent_based_register.add_section_plugin( create_snmp_section_plugin_from_legacy( section_name, {}, plugin_info['snmp_scan_function'], plugin_info['snmp_info'], scan_function_fallback_files=fallback_files, # We have to validate, because we read inventory plugin files # directly, and do not know whether they changed. validate_creation_kwargs=True, )) except (NotImplementedError, KeyError, AssertionError, ValueError): msg = config.AUTO_MIGRATION_ERR_MSG % ('section', plugin_name) if cmk.utils.debug.enabled(): raise MKGeneralException(msg) errors.append(msg) return errors
def agent_section( *, name: str, parse_function: Optional[AgentParseFunction] = None, parsed_section_name: Optional[str] = None, host_label_function: Optional[HostLabelFunction] = None, supersedes: Optional[List[str]] = None, ) -> None: """Register an agent section to checkmk The section marked by '<<<name>>>' in the raw agent output will be processed according to the functions and options given to this function: Args: name: The unique name of the section to be registered. It must match the section header of the agent output ('<<<name>>>'). parse_function: The function responsible for parsing the raw agent data. It must accept exactly one argument by the name 'string_table'. It may return an arbitrary object. Note that if the return value is `None`, no forther processing will take place (just as if the agent had not sent any data). parsed_section_name: The name under which the parsed section will be available to the plugins. Defaults to the original name. host_label_function: The function responsible for extracting host labels from the parsed data. It must accept exactly one argument by the name 'section'. When the function is called, it will be passed the parsed data as returned by the parse function. It is expected to yield objects of type :class:`HostLabel`. supersedes: A list of section names which are superseded by this sections. If this section will be parsed to something that is not `None` (see above) all superseded section will not be considered at all. """ section_plugin = create_agent_section_plugin( name=name, parsed_section_name=parsed_section_name, parse_function=parse_function, host_label_function=host_label_function, supersedes=supersedes, module=get_validated_plugin_module_name(), ) if is_registered_section_plugin(section_plugin.name): raise ValueError("duplicate section definition: %s" % section_plugin.name) add_section_plugin(section_plugin)
def snmp_section( *, name: str, parsed_section_name: Optional[str] = None, parse_function: Optional[SNMPParseFunction] = None, host_label_function: Optional[HostLabelFunction] = None, detect: SNMPDetectSpec, trees: List[SNMPTree], supersedes: Optional[List[str]] = None, ) -> None: """Register an snmp section to checkmk The snmp information will be gathered and parsed according to the functions and options given to this function: :param name: The name of the section to be processed. It must be unique, and match the section header of the agent oufput ('<<<name>>>'). :params parsed_section_name: not yet implemented. :params parse_function: The function responsible for parsing the raw snmp data. It must accept exactly one argument by the name 'string_table'. It may return an arbitrary object. Note that if the return value is falsey, no forther processing will take place. :params host_label_function: The function responsible for extracting HostLabels from the parsed data. It must accept exactly one argument by the name 'section'. When the function is called, it will be passed the parsed data as returned by the parse function. It is expected to yield objects of type 'HostLabel'. :params detect: The conditions on single OIDs that will result in the attempt to fetch snmp data and discover services. This should only match devices to which the section is applicable. :params trees: The specification of snmp data that should be fetched from the device. It must be a list of SNMPTree objects. The parse function will be passed a list of one SNMP table per specified Tree, where an SNMP tree is a list of lists of strings. :params supersedes: not yet implemented. """ section_plugin = create_snmp_section_plugin( name=name, parsed_section_name=parsed_section_name, parse_function=parse_function, host_label_function=host_label_function, detect_spec=detect, trees=trees, supersedes=supersedes, module=get_validated_plugin_module_name(), ) if is_registered_section_plugin(section_plugin.name): raise ValueError("duplicate section definition: %s" % section_plugin.name) add_section_plugin(section_plugin)
def agent_section( *, name: str, parsed_section_name: Optional[str] = None, parse_function: Optional[AgentParseFunction] = None, host_label_function: Optional[HostLabelFunction] = None, supersedes: Optional[List[str]] = None, ) -> None: """Register an agent section to checkmk The section marked by '<<<name>>>' in the raw agent output will be processed according to the functions and options given to this function: :param name: The name of the section to be processed. It must be unique, and match the section header of the agent oufput ('<<<name>>>'). :params parsed_section_name: not yet implemented. :params parse_function: The function responsible for parsing the raw agent data. It must accept exactly one argument by the name 'string_table'. It may return an arbitrary object. Note that if the return value is falsey, no forther processing will take place. :params host_label_function: The function responsible for extracting HostLabels from the parsed data. It must accept exactly one argument by the name 'section'. When the function is called, it will be passed the parsed data as returned by the parse function. It is expected to yield objects of type 'HostLabel'. :params supersedes: not yet implemented. """ section_plugin = create_agent_section_plugin( name=name, parsed_section_name=parsed_section_name, parse_function=parse_function, host_label_function=host_label_function, supersedes=supersedes, module=get_validated_plugin_module_name(), ) if is_registered_section_plugin(section_plugin.name): raise ValueError("duplicate section definition: %s" % section_plugin.name) add_section_plugin(section_plugin)
"17", # ifOutUcastPkts 11 "18", # ifOutNUcastPkts 12 "19", # ifOutDiscards 13 "20", # ifOutErrors 14 "21", # ifOutQLen 15 OIDBytes("6"), # ifPhysAddress 16 ], ), ], detect_spec=never_detect, # does not matter what we put here rule_dependent_detect_spec=SNMPRuleDependentDetectSpec( [RuleSetName('if_disable_if64_hosts')], compute_detect_spec_if, ), ) add_section_plugin(section_plugin) assert section_plugin.rule_dependent_detect_spec for discovery_ruleset in section_plugin.rule_dependent_detect_spec.rulesets: add_discovery_ruleset(discovery_ruleset) # ================================================================================================== register.check_plugin( name="if", service_name="Interface %s", discovery_ruleset_name="inventory_if_rules", discovery_ruleset_type="all", discovery_default_parameters=dict(interfaces.DISCOVERY_DEFAULT_PARAMETERS), discovery_function=interfaces.discover_interfaces, check_ruleset_name="if", check_default_parameters=interfaces.CHECK_DEFAULT_PARAMETERS, check_function=if64.check_if64,
def snmp_section( *, name: str, detect: SNMPDetectSpec, fetch: Union[SNMPTree, List[SNMPTree]], parse_function: Optional[SNMPParseFunction] = None, parsed_section_name: Optional[str] = None, host_label_function: Optional[HostLabelFunction] = None, supersedes: Optional[List[str]] = None, ) -> None: """Register an snmp section to checkmk The snmp information will be gathered and parsed according to the functions and options given to this function: Args: name: The unique name of the section to be registered. detect: The conditions on single OIDs that will result in the attempt to fetch snmp data and discover services. This should only match devices to which the section is applicable. It is higly recomended to check the system description OID at the very first, as this will make the discovery much more responsive and consume less resources. fetch: The specification of snmp data that should be fetched from the device. It must be an :class:`SNMPTree` object, or a non-empty list of them. The parse function will be passed a single :class:`StringTable` or a list of them accordingly. parse_function: The function responsible for parsing the raw snmp data. It must accept exactly one argument by the name 'string_table'. It will be passed either a single :class:`StringTable`, or a list of them, depending on the value type of the `fetch` argument. It may return an arbitrary object. Note that if the return value is `None`, no forther processing will take place (just as if the agent had not sent any data). parsed_section_name: The name under which the parsed section will be available to the plugins. Defaults to the original name. host_label_function: The function responsible for extracting host labels from the parsed data. It must accept exactly one argument by the name 'section'. When the function is called, it will be passed the parsed data as returned by the parse function. It is expected to yield objects of type :class:`HostLabel`. supersedes: A list of section names which are superseded by this sections. If this section will be parsed to something that is not `None` (see above) all superseded section will not be considered at all. """ section_plugin = create_snmp_section_plugin( name=name, parsed_section_name=parsed_section_name, parse_function=parse_function, host_label_function=host_label_function, detect_spec=detect, fetch=fetch, supersedes=supersedes, module=get_validated_plugin_module_name(), ) if is_registered_section_plugin(section_plugin.name): raise ValueError("duplicate section definition: %s" % section_plugin.name) add_section_plugin(section_plugin)
def agent_section( *, name: str, parse_function: Optional[AgentParseFunction] = None, parsed_section_name: Optional[str] = None, host_label_function: Optional[HostLabelFunction] = None, host_label_default_parameters: Optional[Dict[str, Any]] = None, host_label_ruleset_name: Optional[str] = None, host_label_ruleset_type: RuleSetType = RuleSetType.MERGED, supersedes: Optional[List[str]] = None, ) -> None: """Register an agent section to checkmk The section marked by '<<<name>>>' in the raw agent output will be processed according to the functions and options given to this function: Args: name: The unique name of the section to be registered. It must match the section header of the agent output ('<<<name>>>'). parse_function: The function responsible for parsing the raw agent data. It must accept exactly one argument by the name 'string_table'. It may return an arbitrary object. Note that if the return value is `None`, no forther processing will take place (just as if the agent had not sent any data). This function may raise arbitrary exceptions, which will be dealt with by the checking engine. You should expect well formatted data. parsed_section_name: The name under which the parsed section will be available to the plugins. Defaults to the original name. host_label_function: The function responsible for extracting host labels from the parsed data. It must accept exactly one argument by the name 'section'. When the function is called, it will be passed the parsed data as returned by the parse function. It is expected to yield objects of type :class:`HostLabel`. host_label_default_parameters: Default parameters for the host label function. Must match the ValueSpec of the corresponding WATO ruleset, if it exists. host_label_ruleset_name: The name of the host label ruleset. host_label_ruleset_type: The ruleset type is either :class:`RuleSetType.ALL` or :class:`RuleSetType.MERGED`. It describes whether this plugins needs the merged result of the effective rules, or every individual rule matching for the current host. supersedes: A list of section names which are superseded by this sections. If this section will be parsed to something that is not `None` (see above) all superseded section will not be considered at all. """ section_plugin = create_agent_section_plugin( name=name, parsed_section_name=parsed_section_name, parse_function=parse_function, host_label_function=host_label_function, host_label_default_parameters=host_label_default_parameters, host_label_ruleset_name=host_label_ruleset_name, host_label_ruleset_type=host_label_ruleset_type, supersedes=supersedes, module=get_validated_plugin_module_name(), ) if is_registered_section_plugin(section_plugin.name): raise ValueError("duplicate section definition: %s" % section_plugin.name) add_section_plugin(section_plugin)