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