def test_ruleset_to_config(request_context, monkeypatch, wato_use_git, expected_result): monkeypatch.setattr(config, "wato_use_git", wato_use_git) ruleset = rulesets.Ruleset( "checkgroup_parameters:local", ruleset_matcher.get_tag_to_group_map(config.tags)) ruleset.from_config( hosts_and_folders.Folder.root_folder(), [ { "id": "1", "value": "VAL", "condition": { "host_name": ["HOSTLIST"], "service_description": [{ "$regex": "SVC" }, { "$regex": "LIST" }], }, }, { "id": "2", "value": "VAL2", "condition": { "host_name": ["HOSTLIST"], "service_description": [{ "$regex": "SVC" }, { "$regex": "LIST" }], }, }, ], ) assert ruleset.to_config( hosts_and_folders.Folder.root_folder()) == expected_result
def test_ruleset_to_config_sub_folder(register_builtin_html, monkeypatch, load_config, wato_use_git, expected_result): monkeypatch.setattr(config, "wato_use_git", wato_use_git) ruleset = rulesets.Ruleset( "checkgroup_parameters:local", ruleset_matcher.get_tag_to_group_map(config.tags)) monkeypatch.setattr(config, "user", config.LoggedInSuperUser()) hosts_and_folders.Folder.create_missing_folders("abc") folder = hosts_and_folders.Folder.folder("abc") ruleset.from_config(folder, [ { "value": "VAL", "condition": { 'host_name': ['HOSTLIST'], 'service_description': [{ '$regex': 'SVC' }, { '$regex': 'LIST' }], }, }, { "value": "VAL2", "condition": { 'host_name': ['HOSTLIST'], 'service_description': [{ '$regex': 'SVC' }, { '$regex': 'LIST' }], }, }, ]) assert ruleset.to_config(folder) == expected_result
def _save_service_enable_disable_rules(self, services, value): if not services: return rulesets = watolib.AllRulesets() rulesets.load() try: ruleset = rulesets.get("ignored_services") except KeyError: ruleset = watolib.Ruleset( "ignored_services", ruleset_matcher.get_tag_to_group_map(config.tags) ) modified_folders = [] service_patterns = [service_description_to_condition(s) for s in services] modified_folders += self._remove_from_rule_of_host( ruleset, service_patterns, value=not value ) # Check whether or not the service still needs a host specific setting after removing # the host specific setting above and remove all services from the service list # that are fine without an additional change. for service in list(services): value_without_host_rule = ruleset.analyse_ruleset(self._host.name(), service, service)[ 0 ] if ( not value and value_without_host_rule in [None, False] ) or value == value_without_host_rule: services.remove(service) service_patterns = [service_description_to_condition(s) for s in services] modified_folders += self._update_rule_of_host(ruleset, service_patterns, value=value) for folder in modified_folders: rulesets.save_folder(folder)
def _get_mismatch_reasons_of_match_object(self, match_object, host_tags): matcher = ruleset_matcher.RulesetMatcher( tag_to_group_map=ruleset_matcher.get_tag_to_group_map(config.tags), host_tag_lists={match_object.host_name: host_tags}, host_paths={match_object.host_name: match_object.host_folder}, # TODO: What about the host_label_rules? labels=LabelManager({match_object.host_name: match_object.host_labels}, []), all_configured_hosts={match_object.host_name}, clusters_of={}, nodes_of={}, ) rule_dict = self.to_config() rule_dict["condition"]["host_folder"] = self.folder.path_for_rule_matching() if self.ruleset.item_type(): if matcher.is_matching_service_ruleset(match_object, [rule_dict]): return else: if matcher.is_matching_host_ruleset(match_object, [rule_dict]): return yield _("The rule does not match")
def __init__(self): super(RulesetCollection, self).__init__() # A dictionary containing all ruleset objects of the collection. # The name of the ruleset is used as key in the dict. self._tag_to_group_map = ruleset_matcher.get_tag_to_group_map(config.tags) self._rulesets = {}
def _set(self, request): # Py2: This encoding here should be kept Otherwise and unicode encoded text will be written # into the configuration file with unknown side effects ruleset_name = ensure_str(request["ruleset_name"]) # Future validation, currently the rule API actions are admin only, so the check is pointless # may_edit_ruleset(ruleset_name) # Check if configuration hash has changed in the meantime ruleset_dict = self._get_ruleset_configuration(ruleset_name) if "configuration_hash" in request: validate_config_hash(request["configuration_hash"], ruleset_dict) # Check permissions of new rules and rules we are going to delete new_ruleset = request["ruleset"] folders_set_ruleset = set(new_ruleset.keys()) folders_obsolete_ruleset = set(ruleset_dict.keys()) - folders_set_ruleset for check_folders in [folders_set_ruleset, folders_obsolete_ruleset]: for folder_path in check_folders: if not watolib.Folder.folder_exists(folder_path): raise MKUserError(None, _("Folder %s does not exist") % folder_path) rule_folder = watolib.Folder.folder(folder_path) rule_folder.need_permission("write") tag_to_group_map = ruleset_matcher.get_tag_to_group_map(config.tags) # Verify all rules rule_vs = watolib.Ruleset(ruleset_name, tag_to_group_map).rulespec.valuespec for folder_path, rules in new_ruleset.items(): for rule in rules: value = rule["value"] try: rule_vs.validate_datatype(value, "test_value") rule_vs.validate_value(value, "test_value") except MKException as e: raise MKGeneralException("ERROR: %s. Affected Rule %r" % (str(e), rule)) # Add new rulesets for folder_path, rules in new_ruleset.items(): folder = watolib.Folder.folder(folder_path) new_ruleset = watolib.Ruleset(ruleset_name, tag_to_group_map) new_ruleset.from_config(folder, rules) folder_rulesets = watolib.FolderRulesets(folder) folder_rulesets.load() # TODO: This add_change() call should be made by the data classes watolib.add_change("edit-ruleset", _("Set ruleset '%s' for '%s' with %d rules") % ( new_ruleset.title(), folder.title(), len(rules), ), sites=folder.all_site_ids(), object_ref=new_ruleset.object_ref()) folder_rulesets.set(ruleset_name, new_ruleset) folder_rulesets.save() # Remove obsolete rulesets for folder_path in folders_obsolete_ruleset: folder = watolib.Folder.folder(folder_path) folder_rulesets = watolib.FolderRulesets(folder) folder_rulesets.load() new_ruleset = watolib.Ruleset(ruleset_name, tag_to_group_map) new_ruleset.from_config(folder, []) # TODO: This add_change() call should be made by the data classes watolib.add_change("edit-ruleset", _("Deleted ruleset '%s' for '%s'") % ( new_ruleset.title(), folder.title(), ), sites=folder.all_site_ids(), object_ref=new_ruleset.object_ref()) folder_rulesets.set(ruleset_name, new_ruleset) folder_rulesets.save()
def __init__(self) -> None: super().__init__() # A dictionary containing all ruleset objects of the collection. # The name of the ruleset is used as key in the dict. self._tag_to_group_map = ruleset_matcher.get_tag_to_group_map(active_config.tags) self._rulesets: Dict[RulesetName, Ruleset] = {}
def _load_config(self): self._bi_constants = { 'ALL_HOSTS': 'ALL_HOSTS-f41e728b-0bce-40dc-82ea-51091d034fc3', 'HOST_STATE': 'HOST_STATE-f41e728b-0bce-40dc-82ea-51091d034fc3', 'HIDDEN': 'HIDDEN-f41e728b-0bce-40dc-82ea-51091d034fc3', 'FOREACH_HOST': 'FOREACH_HOST-f41e728b-0bce-40dc-82ea-51091d034fc3', 'FOREACH_CHILD': 'FOREACH_CHILD-f41e728b-0bce-40dc-82ea-51091d034fc3', 'FOREACH_CHILD_WITH': 'FOREACH_CHILD_WITH-f41e728b-0bce-40dc-82ea-51091d034fc3', 'FOREACH_PARENT': 'FOREACH_PARENT-f41e728b-0bce-40dc-82ea-51091d034fc3', 'FOREACH_SERVICE': 'FOREACH_SERVICE-f41e728b-0bce-40dc-82ea-51091d034fc3', 'REMAINING': 'REMAINING-f41e728b-0bce-40dc-82ea-51091d034fc3', 'DISABLED': 'DISABLED-f41e728b-0bce-40dc-82ea-51091d034fc3', 'HARD_STATES': 'HARD_STATES-f41e728b-0bce-40dc-82ea-51091d034fc3', 'DT_AGGR_WARN': 'DT_AGGR_WARN-f41e728b-0bce-40dc-82ea-51091d034fc3', } self._hosttags_transformer = RulesetToDictTransformer( tag_to_group_map=get_tag_to_group_map(config.tags)) try: vars_: Dict[str, Any] = { "aggregation_rules": {}, "aggregations": [], "host_aggregations": [], "bi_packs": {}, } vars_.update(self._bi_constants) exec(self._get_config_string(), vars_, vars_) # put legacy non-pack stuff into packs if (vars_["aggregation_rules"] or vars_["aggregations"] or vars_["host_aggregations"]) and \ "default" not in vars_["bi_packs"]: vars_["bi_packs"]["default"] = { "title": "Default Pack", "rules": vars_["aggregation_rules"], "aggregations": vars_["aggregations"], "host_aggregations": vars_["host_aggregations"], "public": True, "contact_groups": [], } self._packs = {} for pack_id, pack in vars_["bi_packs"].items(): # Convert rules from old-style tuples to new-style dicts aggregation_rules = {} for ruleid, rule in pack["rules"].items(): aggregation_rules[ruleid] = self._convert_rule_from_bi( rule, ruleid) aggregations = [] for aggregation in pack["aggregations"]: aggregations.append( self._convert_aggregation_from_bi(aggregation, single_host=False)) for aggregation in pack["host_aggregations"]: aggregations.append( self._convert_aggregation_from_bi(aggregation, single_host=True)) self._packs[pack_id] = { "id": pack_id, "title": pack["title"], "rules": aggregation_rules, "aggregations": aggregations, "public": pack["public"], "contact_groups": pack["contact_groups"], } self._add_missing_aggr_ids() except Exception as e: logger.error("Unable to load legacy bi.mk configuration %s", str(e)) raise
def _rule(ruleset_name): ruleset = rulesets.Ruleset( ruleset_name, ruleset_matcher.get_tag_to_group_map(config.tags)) return rulesets.Rule(hosts_and_folders.Folder.root_folder(), ruleset)
def _ruleset(ruleset_name) -> rulesets.Ruleset: return rulesets.Ruleset( ruleset_name, ruleset_matcher.get_tag_to_group_map(active_config.tags))