Properly parse translation options

... and fix the lying type annotations.

Change-Id: I64d4f185e4e5959fba1a9aabf11a0ab4f02155c5

Author: mo-ki

cmk/base/config.py

@@ -568,9 +568,7 @@ class LoadedConfigFragment:
     checkgroup_parameters: Mapping[str, Sequence[RuleSpec[Mapping[str, object]]]]
     service_rule_groups: set[str]
     service_descriptions: Mapping[str, str]
-    service_description_translation: Sequence[
-        RuleSpec[cmk.utils.translations.TranslationOptionsSpec]
-    ]
+    service_description_translation: Sequence[RuleSpec[Mapping[str, object]]]
     use_new_descriptions_for: Container[str]
     monitoring_core: Literal["nagios", "cmc"]
     nagios_illegal_chars: str
@@ -1264,11 +1262,9 @@ def get_piggyback_translations(
     matcher: RulesetMatcher, labels_of_host: Callable[[HostName], Labels], hostname: HostName
 ) -> cmk.utils.translations.TranslationOptions:
     """Get a dict that specifies the actions to be done during the hostname translation"""
-    rules = matcher.get_host_values_all(hostname, piggyback_translation, labels_of_host)
-    translations: cmk.utils.translations.TranslationOptions = {}
-    for rule in rules[::-1]:
-        translations.update(rule)
-    return translations
+    return cmk.utils.translations.parse_translation_options(
+        matcher.get_host_values_merged(hostname, piggyback_translation, labels_of_host)
+    )
 
 
 def get_http_proxy(http_proxy: tuple[str, str]) -> HTTPProxyConfig:

cmk/base/configlib/servicename.py

@@ -14,9 +14,9 @@
 from cmk.utils.rulesets.ruleset_matcher import RulesetMatcher, RuleSpec
 from cmk.utils.servicename import Item, ServiceName
 from cmk.utils.translations import (
+    parse_translation_options,
     translate_service_description,
     TranslationOptions,
-    TranslationOptionsSpec,
 )
 
 
@@ -25,7 +25,7 @@ def __init__(
         self,
         matcher: RulesetMatcher,
         illegal_chars: str,
-        translations: Sequence[RuleSpec[TranslationOptionsSpec]],
+        translations: Sequence[RuleSpec[Mapping[str, object]]],
     ) -> None:
         self.matcher: Final = matcher
         self.illegal_chars: Final = illegal_chars
@@ -66,20 +66,15 @@ def _get_service_translations(
             return translations_cache[hostname]
 
         rules = self.matcher.get_host_values_all(hostname, self.translations, labels_of_host)
-        translations: TranslationOptions = {}
+        merged = TranslationOptions(case=None, drop_domain=False, regex=[], mapping=[])
         for rule in rules[::-1]:
-            if "case" in rule:
-                translations["case"] = rule["case"]
-            if "regex" in rule:
-                translations["regex"] = list(
-                    set(translations.get("regex", [])) | set(rule["regex"])
-                )
-            if "mapping" in rule:
-                translations["mapping"] = list(
-                    set(translations.get("mapping", [])) | set(rule["mapping"])
-                )
+            parsed_rule = parse_translation_options(rule)
+            if "case" in rule:  # inheritence! Don't check for "case" in parsed_rule!
+                merged["case"] = parsed_rule["case"]
+            merged["regex"] = list(set(merged["regex"]) | set(parsed_rule["regex"]))
+            merged["mapping"] = list(set(merged["mapping"]) | set(parsed_rule["mapping"]))
 
-        return translations_cache.setdefault(hostname, translations)
+        return translations_cache.setdefault(hostname, parse_translation_options(merged))
 
 
 class PassiveServiceNameConfig:

cmk/base/default_config/base.py

@@ -21,7 +21,6 @@
 from cmk.utils.structured_data import RawIntervalFromConfig
 from cmk.utils.tags import TagConfigSpec
 from cmk.utils.timeperiod import TimeperiodSpecs
-from cmk.utils.translations import TranslationOptions, TranslationOptionsSpec
 
 # This file contains the defaults settings for almost all configuration
 # variables that can be overridden in main.mk. Some configuration
@@ -58,9 +57,9 @@
 cluster_max_cachefile_age = 90  # secs.
 piggyback_max_cachefile_age = 3600  # secs
 # Ruleset for translating piggyback host names
-piggyback_translation: list[RuleSpec[TranslationOptions]] = []
+piggyback_translation: Sequence[RuleSpec[Mapping[str, object]]] = []
 # Ruleset for translating service names
-service_description_translation: list[RuleSpec[TranslationOptionsSpec]] = []
+service_description_translation: Sequence[RuleSpec[Mapping[str, object]]] = []
 simulation_mode = False
 fake_dns: str | None = None
 perfdata_format: Literal["pnp", "standard"] = "pnp"

cmk/utils/translations.py

@@ -4,7 +4,7 @@
 # conditions defined in the file COPYING, which is part of this source code package.
 
 import ipaddress
-from collections.abc import Iterable
+from collections.abc import Iterable, Mapping
 from typing import cast, Literal, NotRequired, TypedDict
 
 from cmk.ccc.hostaddress import HostName
@@ -21,6 +21,28 @@ class TranslationOptions(TypedDict, total=False):
     regex: Iterable[tuple[str, str]]
 
 
+def _parse_case(raw_case: object) -> Literal["lower", "upper"] | None:
+    match raw_case:
+        case "lower" | "upper" | None as case_value:
+            return case_value
+    raise (ValueError if isinstance(raw_case, str) else TypeError)(raw_case)
+
+
+def _parse_list_of_tuples(raw: object) -> Iterable[tuple[str, str]]:
+    if not isinstance(raw, Iterable):
+        raise TypeError(raw)
+    return [(str(a), str(b)) for a, b in raw]
+
+
+def parse_translation_options(raw: Mapping[str, object]) -> TranslationOptions:
+    return TranslationOptions(
+        case=_parse_case(raw.get("case")),
+        drop_domain=bool(raw.get("drop_domain")),
+        mapping=_parse_list_of_tuples(raw.get("mapping", [])),
+        regex=_parse_list_of_tuples(raw.get("regex", [])),
+    )
+
+
 # Similar to TranslationOptions, but not the same. This aims to
 # cover exactly the structure that is configured with the valuespec.
 class TranslationOptionsSpec(TypedDict):