openssh-formula/openssh/map.jinja

# -*- coding: utf-8 -*-
# vim: ft=jinja

{#- Get the `tplroot` from `tpldir` #}
{%- set tplroot = tpldir.split("/")[0] %}
{%- from tplroot ~ "/libsaltcli.jinja" import cli with context %}

{#- Where to lookup parameters source files #}
{%- set map_sources_dir = tplroot | path_join("parameters") %}

{#- Load defaults first to allow per formula default map.jinja configuration #}
{%- set _defaults_filename = map_sources_dir | path_join("defaults.yaml") %}
{%- do salt["log.debug"](
      "map.jinja: initialise parameters from "
      ~ _defaults_filename
    ) %}
{%- import_yaml _defaults_filename as default_settings %}

{#- List of sources to lookup for parameters #}
{%- do salt["log.debug"]("map.jinja: lookup 'map_jinja' configuration sources") %}
{#- Fallback to previously used grains plus minion `id` #}
{%- set map_sources = [
      "osarch",
      "os_family",
      "os",
      "osfinger",
      "config_get_lookup",
      "config_get",
      "id",
    ] %}
{#- Configure map.jinja from defaults.yaml #}
{%- set map_sources = default_settings | traverse(
      "values:map_jinja:sources",
      map_sources,
    ) %}

{#- Lookup global sources #}
{%- set map_sources = salt["config.get"]("map_jinja:sources", map_sources) %}
{#- Lookup per formula sources #}
{%- set map_sources = salt["config.get"](
      tplroot ~ ":map_jinja:sources",
      map_sources,
    ) %}

{%- do salt["log.debug"](
      "map.jinja: load parameters with sources from "
      ~ map_sources
    ) %}

{#- Lookup with `config.get` from configurable roots #}
{%- do salt["log.debug"](
      "map.jinja: initialise 'config.get' roots with 'tplroot' "
      ~ tplroot
    ) %}
{%- set config_get_roots = [tplroot] %}
{#- Configure `config.get` from defaults.yaml #}
{%- set config_get_roots = default_settings | traverse(
      "values:map_jinja:config_get_roots",
      config_get_roots
    ) %}
{#- Lookup global `config.get` roots #}
{%- set config_get_roots = salt["config.get"](
      "map_jinja:config_get_roots",
      config_get_roots
    ) %}
{#- Lookup per formula `config.get` roots #}
{%- set config_get_roots = salt["config.get"](
      tplroot ~ ":map_jinja:config_get_roots",
      config_get_roots,
    ) %}
{%- do salt["log.debug"](
      "map.jinja: load parameters with 'config.get' from roots "
      ~ config_get_roots
    ) %}

{#- Work around assignment inside for loop #}
{#- load configuration values used in `config.get` merging strategies #}
{%- set _config = {
      "stack": default_settings.get("values", {}),
      "merge_strategy": salt["config.get"](tplroot ~ ":strategy", None),
      "merge_lists": salt["config.get"](tplroot ~ ":merge_lists", False),
    } %}

{#- the `config.get` merge option only works for `minion` or `local` salt command types #}
{%- if cli in ["minion", "local"] %}
{%-   do _config.update(
        {
          "merge_opt": {"merge": _config["merge_strategy"]},
          "merge_msg": ", merge: strategy='" ~ _config["merge_strategy"] ~ "'",
        }
      ) %}
{#- the `config.get` merge option is not available for `ssh` or `unknown` salt command types #}
{%- else %}
{%-   if _config["merge_strategy"] %}
{%-     do salt["log.error"](
          "map.jinja: the 'merge' option of 'config.get' is skipped when the salt command type is '"
          ~ cli
          ~ "'"
        ) %}
{%-   endif %}
{%-   do _config.update(
        {
          "merge_opt": {},
          "merge_msg": "",
        }
      ) %}
{%- endif %}


{#- process each `map.jinja` source #}
{%- for map_source in map_sources %}
{%-   if map_source  in ["config_get", "config_get_lookup"] %}
{%-     for _config_root in config_get_roots %}
{%-       set _config_key = {
            "config_get": _config_root,
            "config_get_lookup": _config_root ~ ":lookup",
          }.get(map_source) %}

{%-       do salt["log.debug"](
            "map.jinja: retrieve '"
            ~ _config_key
            ~ "' with 'config.get'"
            ~ _config["merge_msg"]
          ) %}
{%-       set _config_get = salt["config.get"](
            _config_key, default={}, **_config["merge_opt"]
          ) %}

{#-       `slsutil.merge` defaults to `smart` instead of `None` for `config.get` #}
{%-       set _strategy = _config["merge_strategy"] | default("smart", boolean=True) %}
{%-       do salt["log.debug"](
            "map.jinja: merge '"
            ~ _config_key
            ~ "' retrieved with 'config.get'"
            ~ ", merge: strategy='"
            ~ _strategy
            ~ "', lists='"
            ~ _config["merge_lists"]
            ~ "'"
          ) %}

{#-       Keep values under each root key when there are more than one #}
{%-       if config_get_roots|length > 1 %}
{%-         set _config_get = { _config_root: _config_get } %}
{%-       endif %}
{%-       do _config.update(
            {
              "stack": salt["slsutil.merge"](
                _config["stack"],
                _config_get,
                strategy=_strategy,
                merge_lists=_config["merge_lists"],
              )
            }
          ) %}
{%-     endfor %}
{%-   else %}
{#-     Lookup the grain/pillar/... #}
{#-     Fallback to use the source name as a direct filename #}
{%-     set map_values = salt["config.get"](map_source, []) %}

{#-     Mangle `map_source` to use it as literal path #}
{%-     if map_values | length == 0 %}
{%-       set map_source_parts = map_source.split("/") %}
{%-       set map_source = map_source_parts[0:-1] | join("/") %}
{%-       set map_values = map_source_parts[-1].rstrip(".yaml") %}
{%-     endif %}

{#-     Some configuration return list #}
{%-     if map_values is string %}
{%-       set map_values = [map_values] %}
{%-     endif %}

{%-     for map_value in map_values %}
{%-       set yamlfile = map_sources_dir | path_join(
            map_source,
            map_value ~ ".yaml",
          ) %}
{%-       do salt["log.debug"]("map.jinja: load parameters from file " ~ yamlfile) %}
{%-       load_yaml as loaded_values %}
{%-         include yamlfile ignore missing %}
{%-       endload %}

{%-       if loaded_values %}
{#-         Merge loaded values on the stack #}
{%-         do salt["log.debug"]("map.jinja: merge parameters from " ~ yamlfile) %}
{%-         do _config.update(
              {
                "stack": salt["slsutil.merge"](
                  _config["stack"],
                  loaded_values.get("values", {}),
                  strategy=loaded_values.get("strategy", "smart"),
                  merge_lists=loaded_values.get("merge_lists", False)
                  | to_bool,
                )
              }
            ) %}
{%-       endif %}
{%-     endfor %}
{%-   endif %}
{%- endfor %}

{%- do salt["log.debug"]("map.jinja: save parameters in variable 'mapdata'") %}
{%- set mapdata = _config["stack"] %}