Merge pull request #186 from baby-gnu/feature/v4-map.jinja

feat(map): update to v4 and add config.get lookup from multiple roots

openssh/_mapdata/init.sls

@@ -3,23 +3,16 @@
 ---
 {#- Get the `tplroot` from `tpldir` #}
 {%- set tplroot = tpldir.split('/')[0] %}
-{%- from tplroot ~ "/map.jinja" import openssh with context %}
-{%- from tplroot ~ "/map.jinja" import ssh_config with context %}
-{%- from tplroot ~ "/map.jinja" import sshd_config with context %}
+{%- from tplroot ~ "/map.jinja" import mapdata with context %}
 
 {%- set output_file = '/tmp/salt_mapdata_dump.yaml' %}
-{%- set map = {
-      'openssh': openssh,
-      'ssh_config': ssh_config,
-      'sshd_config': sshd_config,
-    } %}
 
-{%- do salt['log.debug']( map | yaml(False) ) %}
+{%- do salt['log.debug']( mapdata | yaml(False) ) %}
 
 {{ tplroot }}-mapdata-dump:
   file.managed:
     - name: {{ output_file }}
     - source: salt://{{ tplroot }}/_mapdata/_mapdata.jinja
     - template: jinja
     - context:
-        map: {{ map | yaml }}
+        map: {{ mapdata | yaml }}

openssh/auth.sls

@@ -29,7 +29,10 @@
 
 include:
   - openssh
-{%- from "openssh/map.jinja" import openssh, sshd_config with context -%}
+{%- from "openssh/map.jinja" import mapdata with context -%}
+{%- set openssh = mapdata.openssh %}
+{%- set sshd_config = mapdata.sshd_config %}
+
 {%- set auth = openssh.get('auth', {}) -%}
 {%- for identifier,keys in auth.items() -%}
   {%- for key in keys -%}

openssh/auth_map.sls

@@ -1,7 +1,9 @@
 include:
   - openssh
 
-{%  from "openssh/map.jinja" import openssh, sshd_config with context -%}
+{%  from "openssh/map.jinja" import mapdata with context -%}
+{%- set openssh = mapdata.openssh %}
+{%- set sshd_config = mapdata.sshd_config %}
 {%- set authorized_keys_file = sshd_config.get("AuthorizedKeysFile", None) %}
 
 {%- for store, config in openssh.get("auth_map", {}).items() %}

openssh/banner.sls

@@ -1,6 +1,7 @@
 {%- set tplroot = tpldir.split('/')[0] %}
-{%- from tplroot ~ "/map.jinja" import openssh with context %}
+{%- from tplroot ~ "/map.jinja" import mapdata with context %}
 {%- from tplroot ~ "/libtofs.jinja" import files_switch %}
+{%- set openssh = mapdata.openssh %}
 
 include:
   - openssh

openssh/client.sls

@@ -1,4 +1,5 @@
-{% from "openssh/map.jinja" import openssh with context %}
+{% from "openssh/map.jinja" import mapdata with context %}
+{%- set openssh = mapdata.openssh %}
 
 openssh_client:
   pkg.installed:

openssh/config.sls

@@ -1,6 +1,9 @@
 {%- set tplroot = tpldir.split('/')[0] %}
-{%- from tplroot ~ "/map.jinja" import openssh, ssh_config, sshd_config with context %}
+{%- from tplroot ~ "/map.jinja" import mapdata with context %}
 {%- from tplroot ~ "/libtofs.jinja" import files_switch %}
+{%- set openssh = mapdata.openssh %}
+{%- set sshd_config = mapdata.sshd_config %}
+{%- set ssh_config = mapdata.ssh_config %}
 
 
 include:

openssh/config_ini.sls

@@ -1,4 +1,6 @@
-{%- from "openssh/map.jinja" import openssh, sshd_config with context %}
+{%- from "openssh/map.jinja" import mapdata with context %}
+{%- set openssh = mapdata.openssh %}
+{%- set sshd_config = mapdata.sshd_config %}
 
 include:
   - openssh

openssh/init.sls

@@ -1,4 +1,5 @@
-{% from "openssh/map.jinja" import openssh with context %}
+{% from "openssh/map.jinja" import mapdata with context %}
+{%- set openssh = mapdata.openssh %}
 
 openssh:
   {% if openssh.server is defined %}

openssh/known_hosts.sls

@@ -1,6 +1,7 @@
 {%- set tplroot = tpldir.split('/')[0] %}
-{%- from tplroot ~ "/map.jinja" import openssh with context %}
+{%- from tplroot ~ "/map.jinja" import mapdata with context %}
 {%- from tplroot ~ "/libtofs.jinja" import files_switch %}
+{%- set openssh = mapdata.openssh %}
 
 ensure dig is available:
   pkg.installed:

openssh/libsaltcli.jinja

@@ -0,0 +1,16 @@
+# -*- coding: utf-8 -*-
+# vim: ft=jinja
+
+{#- Get the relevant values from the `opts` dict #}
+{%- set opts_cli = opts.get('__cli', '') %}
+{%- set opts_masteropts_cli = opts | traverse('__master_opts__:__cli', '') %}
+
+{#- Determine the type of salt command being run #}
+{%- if opts_cli == 'salt-minion' %}
+{%-   set cli = 'minion' %}
+{%- elif opts_cli == 'salt-call' %}
+{%-   set cli = 'ssh' if opts_masteropts_cli in ('salt-ssh', 'salt-master') else 'local' %}
+{%- else %}
+{%-   set cli = 'unknown' %}
+{%- endif %}
+{%- do salt['log.debug']('[libsaltcli] the salt command type has been identified to be: ' ~ cli) %}

openssh/map.jinja

@@ -1,22 +1,204 @@
 # -*- coding: utf-8 -*-
 # vim: ft=jinja
 
-{#- Start imports as #}
-{% import_yaml 'openssh/defaults.yaml' as default_settings %}
-{% import_yaml 'openssh/osfamilymap.yaml' as osfamilymap %}
-{% import_yaml 'openssh/osmap.yaml' as osmap %}
-{% import_yaml 'openssh/osfingermap.yaml' as osfingermap %}
-
-{% set defaults = salt['grains.filter_by'](default_settings,
-    default='default',
-    merge=salt['grains.filter_by'](osfamilymap, grain='os_family',
-      merge=salt['grains.filter_by'](osmap, grain='os',
-        merge=salt['grains.filter_by'](osfingermap, grain='osfinger')
-      )
-    )
-) %}
-
-{#- merge the openssh pillar #}
-{% set openssh = salt['pillar.get']('openssh', default=defaults['openssh'], merge=True) %}
-{% set ssh_config = salt['pillar.get']('ssh_config', default=defaults['ssh_config'], merge=True) %}
-{% set sshd_config = salt['pillar.get']('sshd_config', default=defaults['sshd_config'], merge=True) %}
+{#- 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"] %}

openssh/moduli.sls

@@ -1,4 +1,5 @@
-{% from "openssh/map.jinja" import openssh with context %}
+{% from "openssh/map.jinja" import mapdata with context %}
+{%- set openssh = mapdata.openssh %}
 
 {% set moduli = salt['pillar.get']('openssh:moduli', False) -%}
 {% set moduli_source = salt['pillar.get']('openssh:moduli_source', False) -%}