def to_config(self, folder: CREFolder) -> str: content = "" if ":" in self.name: dictname, subkey = self.name.split(":") varname = "%s[%r]" % (dictname, subkey) content += "\n%s.setdefault(%r, [])\n" % (dictname, subkey) else: varname = self.name content += "\nglobals().setdefault(%r, [])\n" % (varname) if self.is_optional(): content += "\nif %s is None:\n %s = []\n" % (varname, varname) content += "\n%s = [\n" % varname for rule in self._rules[folder.path()]: # When using pprint we get a deterministic representation of the # data structures because it cares about sorting of the dict keys if active_config.wato_use_git: text = pprint.pformat(rule.to_config()) else: text = repr(rule.to_config()) content += "%s,\n" % text content += "] + %s\n\n" % varname return content
def _parse_dict_rule( cls, folder: CREFolder, ruleset: Ruleset, rule_config: Dict[Any, Any], ) -> Rule: # cmk-update-config uses this to load rules from the config file for rewriting them To make # this possible, we need to accept missing "id" fields here. During runtime this is not # needed anymore, since cmk-update-config has updated all rules from the user configuration. id_ = rule_config["id"] if "id" in rule_config else utils.gen_id() assert isinstance(id_, str) rule_options = rule_config.get("options", {}) assert all(isinstance(k, str) for k in rule_options) conditions = rule_config["condition"].copy() # Is known because of the folder associated with this object. Remove the # rendundant information here. It will be added dynamically in to_config() # for writing it back conditions.pop("host_folder", None) rule_conditions = RuleConditions(folder.path()) rule_conditions.from_config(conditions) return cls( id_, folder, ruleset, rule_conditions, RuleOptions.from_config(rule_options), rule_config["value"], )
def _load_folder_rulesets( self, folder: CREFolder, only_varname: Optional[RulesetName] = None ) -> None: path = folder.rules_file_path() if not os.path.exists(path): return # Do not initialize rulesets when no rule at all exists config_dict = { "ALL_HOSTS": ALL_HOSTS, "ALL_SERVICES": ALL_SERVICES, "NEGATE": NEGATE, "FOLDER_PATH": folder.path(), } # Prepare empty rulesets so that rules.mk has something to # append to. We need to initialize all variables here, even # when only loading with only_varname. for varname in rulespec_registry.keys(): if ":" in varname: dictname, _subkey = varname.split(":") config_dict[dictname] = {} else: config_dict[varname] = [] self.from_config(folder, store.load_mk_file(path, config_dict), only_varname)
def append_rule(self, folder: CREFolder, rule: Rule) -> int: rules = self._rules.setdefault(folder.path(), []) index = len(rules) rules.append(rule) self._rules_by_id[rule.id] = rule self._on_change() return index
def folder_slug(folder: CREFolder) -> str: """Create a tilde separated path identifier to be used in URLs Args: folder: The folder instance for which to generate the URL. Returns: A path looking like this: `~folder~subfolder~leaf_folder` """ return "~" + folder.path().rstrip("/").replace("/", "~")
def from_config(self, folder: CREFolder, rules_config) -> None: if not rules_config: return if folder.path() in self._rules: for rule in self._rules[folder.path()]: del self._rules_by_id[rule.id] # Resets the rules of this ruleset for this folder! self._rules[folder.path()] = [] self.tuple_transformer.transform_in_place(rules_config, is_service=self.rulespec.is_for_services, is_binary=self.rulespec.is_binary_ruleset, use_ruleset_id_cache=False) for rule_config in rules_config: rule = Rule(folder, self) rule.from_config(rule_config) self._rules[folder.path()].append(rule) self._rules_by_id[rule.id] = rule
def from_ruleset_defaults(cls, folder: CREFolder, ruleset: Ruleset) -> Rule: return Rule( utils.gen_id(), folder, ruleset, RuleConditions(folder.path()), RuleOptions( disabled=False, description="", comment="", docu_url="", predefined_condition_id=None, ), ruleset.valuespec().default_value(), )
def make_folder_status_link(folder: CREFolder, view_name: str) -> PageMenuEntry: return PageMenuEntry( title=_("Status"), icon_name="status", item=make_simple_link( makeuri_contextless( request, [ ("view_name", view_name), ("wato_folder", folder.path()), ], filename="view.py", )), )
def _serialize_folder(folder: CREFolder, show_hosts): links = [] if not folder.is_root(): links.append( constructors.link_rel( rel="cmk/move", href=constructors.object_action_href( "folder_config", folder_slug(folder), action_name="move", ), method="post", title="Move the folder", )) rv = constructors.domain_object( domain_type="folder_config", identifier=folder_slug(folder), title=folder.title(), extensions={ "path": "/" + folder.path(), "attributes": folder.attributes().copy(), }, links=links, ) if show_hosts: rv["members"]["hosts"] = constructors.collection_property( name="hosts", base=constructors.object_href("folder_config", folder_slug(folder)), value=[ constructors.collection_item( domain_type="host_config", identifier=host.id(), title=host.name(), ) for host in folder.hosts().values() ], ) return rv
def get_rule(self, folder: CREFolder, rule_index: int) -> Rule: return self._rules[folder.path()][rule_index]
def prepend_rule(self, folder: CREFolder, rule: Rule) -> None: rules = self._rules.setdefault(folder.path(), []) rules.insert(0, rule) self._rules_by_id[rule.id] = rule self._on_change()
def get_folder_rules(self, folder: CREFolder) -> List[Rule]: try: return self._rules[folder.path()] except KeyError: return []
def etag_of_folder(folder: CREFolder) -> ETags: return constructors.etag_of_dict({ "path": folder.path(), "attributes": folder.attributes(), "hosts": folder.host_names(), })