[checkmk-commits] Add host / service label rulesets

Module: check_mk Branch: master Commit: c947cf8b75c8c432a0ad13346a3511c0c4754046 URL: http://git.mathias-kettner.de/git/?p=check_mk.git;a=commit;h=c947cf8b75c8c4… Author: Lars Michelsen <lm(a)mathias-kettner.de> Date: Fri Apr 5 11:09:28 2019 +0200 Add host / service label rulesets These rulesets can be used to assign labels to hosts and services in addition to the labels configured using the host attribute. Thes ruleset make it possible to assign lables to hosts and services based on tags and other host / service conditions. CMK-1934 Change-Id: I1178eb17bce89f85dc75527e42038a967cf5fc8b --- cmk/gui/plugins/wato/check_mk_configuration.py | 43 +++++++++++++++++++ cmk_base/config.py | 35 +++++++++++++++- cmk_base/default_config/base.py | 2 + tests/unit/cmk_base/test_config.py | 58 ++++++++++++++++++++++++++ 4 files changed, 137 insertions(+), 1 deletion(-) diff --git a/cmk/gui/plugins/wato/check_mk_configuration.py b/cmk/gui/plugins/wato/check_mk_configuration.py index 2d1aaae..297a045 100644 --- a/cmk/gui/plugins/wato/check_mk_configuration.py +++ b/cmk/gui/plugins/wato/check_mk_configuration.py @@ -66,6 +66,7 @@ from cmk.gui.valuespec import ( ID, ListOfCAs, LogLevelChoice, + Labels, ) from cmk.gui.plugins.wato import ( @@ -1321,6 +1322,48 @@ class RulespecServiceTags(ServiceRulespec): seen_ids.append(entry[0]) +(a)rulespec_registry.register +class RulespecServiceLabels(ServiceRulespec): + @property + def group(self): + return RulespecGroupMonitoringConfigurationServiceChecks + + @property + def name(self): + return "service_label_rules" + + @property + def match_type(self): + return "all" + + @property + def item_type(self): + return "dict" + + @property + def valuespec(self): + return Labels(title=_("Service labels")) + + +(a)rulespec_registry.register +class RulespecHostLabels(HostRulespec): + @property + def group(self): + return RulespecGroupMonitoringConfigurationHostChecks + + @property + def name(self): + return "host_label_rules" + + @property + def match_type(self): + return "dict" + + @property + def valuespec(self): + return Labels(title=_("Host labels")) + + @config_variable_registry.register class ConfigVariableUserDowntimeTimeranges(ConfigVariable): def group(self): diff --git a/cmk_base/config.py b/cmk_base/config.py index 52841d0..40344f3 100644 --- a/cmk_base/config.py +++ b/cmk_base/config.py @@ -2713,7 +2713,7 @@ class HostConfig(object): # TODO: Rename self.tags to self.tag_list and self.tag_groups to self.tags self.tags = self._config_cache.tag_list_of_host(self.hostname) self.tag_groups = host_tags.get(hostname, {}) - self.labels = host_labels.get(hostname, {}) + self.labels = self._get_host_labels() # Basic types self.is_tcp_host = self._config_cache.in_binary_hostlist(hostname, tcp_hosts) @@ -2770,6 +2770,20 @@ class HostConfig(object): return rules[0] return "ipv4" + def _get_host_labels(self): + """Returns the effective set of host labels from all available sources + + 1. Discovered labels + 2. Ruleset "Host labels" + 3. Explicit labels (via host/folder config) + + Last one wins. + """ + labels = {} + labels.update(self._config_cache.host_extra_conf_merged(self.hostname, host_label_rules)) + labels.update(host_labels.get(self.hostname, {})) + return labels + #. # .--Configuration Cache-------------------------------------------------. @@ -2908,6 +2922,18 @@ class ConfigCache(object): tags.update(entry) return tags + def labels_of_service(self, hostname, svc_desc): + """Returns the effective set of service labels from all available sources + + 1. Discovered labels + 2. Ruleset "Service labels" + + Last one wins. + """ + labels = {} + labels.update(self.service_extra_conf_merged(hostname, svc_desc, service_label_rules)) + return labels + def set_all_processed_hosts(self, all_processed_hosts): self._all_processed_hosts = set(all_processed_hosts) @@ -3196,6 +3222,13 @@ class ConfigCache(object): return entries + def service_extra_conf_merged(self, hostname, service, ruleset): + rule_dict = {} + for rule in self.service_extra_conf(hostname, service, ruleset): + for key, value in rule.items(): + rule_dict.setdefault(key, value) + return rule_dict + def _convert_service_ruleset(self, ruleset, with_foreign_hosts): new_rules = [] for rule in ruleset: diff --git a/cmk_base/default_config/base.py b/cmk_base/default_config/base.py index 1312aa9..bb7ae96 100644 --- a/cmk_base/default_config/base.py +++ b/cmk_base/default_config/base.py @@ -139,6 +139,8 @@ custom_checks = [] # WATO variant for free-form custom checks without formaliza all_hosts = [] host_tags = {} # store host tag config per host host_labels = {} # store explicit host labels per host +host_label_rules = [] # Assign labels via ruleset to hosts +service_label_rules = [] # Asssing labels via ruleset to services # TODO: This is a derived variable. Should be handled like others # (hosttags, service_service_levels, ...) host_paths = {} diff --git a/tests/unit/cmk_base/test_config.py b/tests/unit/cmk_base/test_config.py index 3a65b18..92ea603 100644 --- a/tests/unit/cmk_base/test_config.py +++ b/tests/unit/cmk_base/test_config.py @@ -370,6 +370,64 @@ def test_tags_of_service(monkeypatch): assert config_cache.tags_of_service("test-host", "CPU load") == {"tag_group1": "val1"} +def test_host_label_rules_default(): + assert isinstance(config.host_label_rules, list) + + +def test_host_config_labels(monkeypatch): + monkeypatch.setattr(config, "host_labels", { + "test-host": { + "explicit": "ding", + }, + }) + + ruleset = [ + ({ + "from-rule": "rule1" + }, ["abc"], config.ALL_HOSTS, {}), + ({ + "from-rule2": "rule2" + }, ["abc"], config.ALL_HOSTS, {}), + ] + monkeypatch.setattr(config, "host_label_rules", ruleset) + + config_cache = _setup_host(monkeypatch, "test-host", ["abc"]) + + cfg = config_cache.get_host_config("xyz") + assert cfg.labels == {} + + cfg = config_cache.get_host_config("test-host") + assert cfg.labels == { + "explicit": "ding", + "from-rule": "rule1", + "from-rule2": "rule2", + } + + +def test_service_label_rules_default(): + assert isinstance(config.service_label_rules, list) + + +def test_labels_of_service(monkeypatch): + ruleset = [ + ({ + "label1": "val1" + }, ["abc"], config.ALL_HOSTS, ["CPU load$"], {}), + ({ + "label2": "val2" + }, ["abc"], config.ALL_HOSTS, ["CPU load$"], {}), + ] + monkeypatch.setattr(config, "service_label_rules", ruleset) + + config_cache = _setup_host(monkeypatch, "test-host", ["abc"]) + + assert config_cache.labels_of_service("xyz", "CPU load") == {} + assert config_cache.labels_of_service("test-host", "CPU load") == { + "label1": "val1", + "label2": "val2", + } + + def test_config_cache_get_host_config(): cache = config.ConfigCache() assert cache._host_configs == {}