diff --git a/.gitlab-ci.yml b/.gitlab-ci.yml
index 1c6c241..82b4492 100644
--- a/.gitlab-ci.yml
+++ b/.gitlab-ci.yml
@@ -146,24 +146,24 @@ rubocop:
 # default-rockylinux-8-tiamat-py3: {extends: '.test_instance'}
 default-debian-11-master-py3: {extends: '.test_instance'}
 default-debian-10-master-py3: {extends: '.test_instance'}
-default-debian-9-master-py3: {extends: '.test_instance'}
+# default-debian-9-master-py3: {extends: '.test_instance'}
 default-ubuntu-2204-master-py3: {extends: '.test_instance_failure_permitted'}
 default-ubuntu-2004-master-py3: {extends: '.test_instance'}
 default-ubuntu-1804-master-py3: {extends: '.test_instance'}
-default-centos-stream8-master-py3: {extends: '.test_instance_failure_permitted'}
-default-centos-7-master-py3: {extends: '.test_instance'}
-default-fedora-36-master-py3: {extends: '.test_instance_failure_permitted'}
-default-fedora-35-master-py3: {extends: '.test_instance'}
-default-opensuse-leap-153-master-py3: {extends: '.test_instance'}
-default-opensuse-tmbl-latest-master-py3: {extends: '.test_instance_failure_permitted'}
-default-amazonlinux-2-master-py3: {extends: '.test_instance'}
-default-oraclelinux-8-master-py3: {extends: '.test_instance'}
-default-oraclelinux-7-master-py3: {extends: '.test_instance'}
+# default-centos-stream8-master-py3: {extends: '.test_instance_failure_permitted'}
+# default-centos-7-master-py3: {extends: '.test_instance'}
+# default-fedora-36-master-py3: {extends: '.test_instance'}
+# default-fedora-35-master-py3: {extends: '.test_instance'}
+# default-opensuse-leap-153-master-py3: {extends: '.test_instance'}
+# default-opensuse-tmbl-latest-master-py3: {extends: '.test_instance_failure_permitted'}
+# default-amazonlinux-2-master-py3: {extends: '.test_instance'}
+# default-oraclelinux-8-master-py3: {extends: '.test_instance'}
+# default-oraclelinux-7-master-py3: {extends: '.test_instance'}
 # default-arch-base-latest-master-py3: {extends: '.test_instance'}
 # default-gentoo-stage3-latest-master-py3: {extends: '.test_instance'}
 # default-gentoo-stage3-systemd-master-py3: {extends: '.test_instance'}
-default-almalinux-8-master-py3: {extends: '.test_instance'}
-default-rockylinux-8-master-py3: {extends: '.test_instance'}
+# default-almalinux-8-master-py3: {extends: '.test_instance'}
+# default-rockylinux-8-master-py3: {extends: '.test_instance'}
 # default-debian-11-3004-1-py3: {extends: '.test_instance'}
 # default-debian-10-3004-1-py3: {extends: '.test_instance'}
 # default-debian-9-3004-1-py3: {extends: '.test_instance'}
diff --git a/.travis.yml b/.travis.yml
index 7435e35..834ff23 100644
--- a/.travis.yml
+++ b/.travis.yml
@@ -83,6 +83,17 @@ jobs:
     ## Define the rest of the matrix based on Kitchen testing
     # Make sure the instances listed below match up with
     # the `platforms` defined in `kitchen.yml`
+    # NOTE: Please try to select up to six instances that add some meaningful
+    #       testing of the formula's behaviour. If possible, try to refrain from
+    #       the classical "chosing all the instances because I want to test on
+    #       another/all distro/s" trap: it will just add time to the testing (see
+    #       the discussion on #121).  As an example, the set chosen below covers
+    #       the most used distros families, systemd and non-systemd and the latest
+    #       three supported Saltstack versions with python2 and 3.
+    #       As for `kitchen.yml`, that should still contain all of the platforms,
+    #       to allow for comprehensive local testing
+    #       Ref: https://github.com/saltstack-formulas/template-formula/issues/118
+    #       Ref: https://github.com/saltstack-formulas/template-formula/issues/121
     # - env: INSTANCE=default-debian-11-tiamat-py3
     # - env: INSTANCE=default-debian-10-tiamat-py3
     # - env: INSTANCE=default-debian-9-tiamat-py3
@@ -111,9 +122,9 @@ jobs:
     - env: INSTANCE=default-amazonlinux-2-master-py3
     - env: INSTANCE=default-oraclelinux-8-master-py3
     - env: INSTANCE=default-oraclelinux-7-master-py3
-    # - env: INSTANCE=default-arch-base-latest-master-py3
-    # - env: INSTANCE=default-gentoo-stage3-latest-master-py3
-    # - env: INSTANCE=default-gentoo-stage3-systemd-master-py3
+    - env: INSTANCE=default-arch-base-latest-master-py3
+    - env: INSTANCE=default-gentoo-stage3-latest-master-py3
+    - env: INSTANCE=default-gentoo-stage3-systemd-master-py3
     - env: INSTANCE=default-almalinux-8-master-py3
     - env: INSTANCE=default-rockylinux-8-master-py3
     # - env: INSTANCE=default-debian-11-3004-1-py3
@@ -172,15 +183,3 @@ jobs:
         edge: true
         # Run `semantic-release`
         script: 'npx semantic-release@15.14'
-
-# Notification options: `always`, `never` or `change`
-notifications:
-  webhooks:
-    if: 'repo = saltstack-formulas/influxdb-formula'
-    urls:
-      - https://saltstack-formulas.zulipchat.com/api/v1/external/travis?api_key=HsIq3o5QmLxdnVCKF9is0FUIpkpAY79P&stream=CI&topic=saltstack-formulas%2Finfluxdb-formula&ignore_pull_requests=true
-    on_success: always  # default: always
-    on_failure: always  # default: always
-    on_start: always    # default: never
-    on_cancel: always   # default: always
-    on_error: always    # default: always
diff --git a/_modules/toml_lang.py b/_modules/toml_lang.py
index 75008c4..d346844 100644
--- a/_modules/toml_lang.py
+++ b/_modules/toml_lang.py
@@ -1,6 +1,9 @@
 # -*- coding: utf-8 -*-
 
-import toml
+try:
+  import pytoml as toml
+except:
+  import toml
 
 def dumps(data):
-    return toml.dumps(data)
+  return toml.dumps(data)
diff --git a/docs/README.rst b/docs/README.rst
index 5a730d0..13d3c32 100644
--- a/docs/README.rst
+++ b/docs/README.rst
@@ -47,29 +47,47 @@ Available states
 
 ``influxdb``
 ^^^^^^^^^^^^
-Installs InfluxDB from [provided packages](http://influxdb.com/download/).
+Installs and configures the influxdb package from upstream repository.
 
-At the moment you **have** to specify the InfluxDB version in the
-``influxdb:version`` pillar.
+``influxdb.dependencies``
+^^^^^^^^^^^^^^^^^^^^^^^^^
+Installs any dependencies that may be needed to support the install of influxdb.
 
-``influxdb.cli``
-^^^^^^^^^^^^^^^^
-Installs the [influxdb-cli](https://github.com/phstc/influxdb-cli) gem system wide.
+``influxdb.repo``
+^^^^^^^^^^^^^^^^^
+Installs the influxdb repository. See `InfluxDB doc <https://portal.influxdata.com/downloads/>`_ for more details.
+
+``influxdb.package``
+^^^^^^^^^^^^^^^^^^^^
+Installs the influxdb package.
 
 ``influxdb.config``
 ^^^^^^^^^^^^^^^^^^^
-Renders the InfluxDB configuration from data provided in the ``influxdb:conf``
-pillar.
-
-It requires the installation of the
-[toml Python module](https://github.com/hit9/toml.py) via pip.
-
-The formula ships with default configuration settings for various minor versions
-of InfluxDB. That means that, if you define configuration settings in your
-``influxdb.conf`` pillar, your settings will be merged with the default ones of
-that minor version. You can set ``influxdb:no_conf_defaults`` in your pillar if
-you want to completely specify the configuration yourself, without falling back
-to defaults.
+This state manages the file ``influxdb.conf`` under ``/etc/influxdb`` (template found in "influxdb/files"). The configuration is populated by values in "influxdb/map.jinja" based on the package's default values (and RedHat, Debian, Suse and Arch family distribution specific values), which can then be overridden by values of the same name in pillar.
+
+``influxdb.service``
+^^^^^^^^^^^^^^^^^^^^
+Manages the startup and running state of the influxdb service.
+
+``influxdb.clean``
+^^^^^^^^^^^^^^^^^^
+uninstalls and removes configs for the influxdb package from upstream repository.
+
+``influxdb.repo.clean``
+^^^^^^^^^^^^^^^^^^^^^^^
+Uninstalls the influxdb repository.
+
+``influxdb.package.clean``
+^^^^^^^^^^^^^^^^^^^^^^^^^^
+Uninstalls the influxdb package.
+
+``influxdb.config.clean``
+^^^^^^^^^^^^^^^^^^^^^^^^^
+remoe the influxdb config files
+
+``influxdb.service.clean``
+^^^^^^^^^^^^^^^^^^^^^^^^^^
+disables and stops the influxdb service
 
 Testing
 -------
diff --git a/docs/TOFS_pattern.rst b/docs/TOFS_pattern.rst
new file mode 100644
index 0000000..dd2c17e
--- /dev/null
+++ b/docs/TOFS_pattern.rst
@@ -0,0 +1,518 @@
+.. _tofs_pattern:
+
+TOFS: A pattern for using SaltStack
+===================================
+
+.. list-table::
+   :name: tofs-authors
+   :header-rows: 1
+   :stub-columns: 1
+   :widths: 2,2,3,2
+
+   * -
+     - Person
+     - Contact
+     - Date
+   * - Authored by
+     - Roberto Moreda
+     - moreda@allenta.com
+     - 29/12/2014
+   * - Modified by
+     - Daniel Dehennin
+     - daniel.dehennin@baby-gnu.org
+     - 07/02/2019
+   * - Modified by
+     - Imran Iqbal
+     - https://github.com/myii
+     - 23/02/2019
+
+All that follows is a proposal based on my experience with `SaltStack <http://www.saltstack.com/>`_. The good thing of a piece of software like this is that you can "bend it" to suit your needs in many possible ways, and this is one of them. All the recommendations and thoughts are given "as it is" with no warranty of any type.
+
+.. contents:: **Table of Contents**
+
+Usage of values in pillar vs templates in ``file_roots``
+--------------------------------------------------------
+
+Among other functions, the *master* (or *salt-master*) serves files to the *minions* (or *salt-minions*). The `file_roots <http://docs.saltstack.com/en/latest/ref/file_server/file_roots.html>`_ is the list of directories used in sequence to find a file when a minion requires it: the first match is served to the minion. Those files could be `state files <http://docs.saltstack.com/en/latest/topics/tutorials/starting_states.html>`_ or configuration templates, among others.
+
+Using SaltStack is a simple and effective way to implement configuration management, but even in a `non-multitenant <http://en.wikipedia.org/wiki/Multitenancy>`_ scenario, it is not a good idea to generally access some data (e.g. the database password in our `Zabbix <http://www.zabbix.com/>`_ server configuration file or the private key of our `Nginx <http://nginx.org/en/>`_ TLS certificate).
+
+To avoid this situation we can use the `pillar mechanism <http://docs.saltstack.com/en/latest/topics/pillar/>`_, which is designed to provide controlled access to data from the minions based on some selection rules. As pillar data could be easily integrated in the `Jinja <http://docs.saltstack.com/en/latest/topics/tutorials/pillar.html>`_ templates, it is a good mechanism to store values to be used in the final rendering of state files and templates.
+
+There are a variety of approaches on the usage of pillar and templates as seen in the `saltstack-formulas <https://github.com/saltstack-formulas>`_' repositories. `Some <https://github.com/saltstack-formulas/nginx-formula/pull/18>`_ `developments <https://github.com/saltstack-formulas/php-formula/pull/14>`_ stress the initial purpose of pillar data into a storage for most of the possible variables for a determined system configuration. This, in my opinion, is shifting too much load from the original template files approach. Adding up some `non-trivial Jinja <https://github.com/saltstack-formulas/nginx-formula/blob/f74254c07e188bd448eaf1c5f9c802d78c4c005e/nginx/files/default/nginx.conf>`_ code as essential part of composing the state file definitely makes SaltStack state files (hence formulas) more difficult to read. The extreme of this approach is that we could end up with a new render mechanism, implemented in Jinja, storing everything needed in pillar data to compose configurations. Additionally, we are establishing a strong dependency with the Jinja renderer.
+
+In opposition to the *put the code in file_roots and the data in pillars* approach, there is the *pillar as a store for a set of key-values* approach. A full-blown configuration file abstracted in pillar and jinja is complicated to develop, understand and maintain. I think a better and simpler approach is to keep a configuration file templated using just a basic (non-extensive but extensible) set of pillar values.
+
+On the reusability of SaltStack state files
+-------------------------------------------
+
+There is a brilliant initiative of the SaltStack community called `salt-formulas <https://github.com/saltstack-formulas>`_. Their goal is to provide state files, pillar examples and configuration templates ready to be used for provisioning. I am a contributor for two small ones: `zabbix-formula <https://github.com/saltstack-formulas/zabbix-formula>`_ and `varnish-formula <https://github.com/saltstack-formulas/varnish-formula>`_.
+
+The `design guidelines <http://docs.saltstack.com/en/latest/topics/development/conventions/formulas.html>`_ for formulas are clear in many aspects and it is a recommended reading for anyone willing to write state files, even non-formulaic ones.
+
+In the next section, I am going to describe my proposal to extend further the reusability of formulas, suggesting some patterns of usage.
+
+The Template Override and Files Switch (TOFS) pattern
+-----------------------------------------------------
+
+I understand a formula as a **complete, independent set of SaltStack state and configuration template files sufficient to configure a system**. A system could be something as simple as an NTP server or some other much more complex service that requires many state and configuration template files.
+
+The customization of a formula should be done mainly by providing pillar data used later to render either the state or the configuration template files.
+
+Example: NTP before applying TOFS
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+Let's work with the NTP example. A basic formula that follows the `design guidelines <http://docs.saltstack.com/en/latest/topics/development/conventions/formulas.html>`_ has the following files and directories tree:
+
+.. code-block:: console
+
+   /srv/saltstack/salt-formulas/ntp-saltstack-formula/
+     ntp/
+       map.jinja
+       init.sls
+       conf.sls
+       files/
+         default/
+           etc/
+             ntp.conf.jinja
+
+In order to use it, let's assume a `masterless configuration <http://docs.saltstack.com/en/latest/topics/tutorials/quickstart.html>`_ and this relevant section of ``/etc/salt/minion``:
+
+.. code-block:: yaml
+
+   pillar_roots:
+     base:
+       - /srv/saltstack/pillar
+   file_client: local
+   file_roots:
+     base:
+       - /srv/saltstack/salt
+       - /srv/saltstack/salt-formulas/ntp-saltstack-formula
+
+.. code-block:: jinja
+
+   {#- /srv/saltstack/salt-formulas/ntp-saltstack-formula/ntp/map.jinja #}
+   {%- set ntp = salt['grains.filter_by']({
+     'default': {
+       'pkg': 'ntp',
+       'service': 'ntp',
+       'config': '/etc/ntp.conf',
+     },
+   }, merge=salt['pillar.get']('ntp:lookup')) %}
+
+In ``init.sls`` we have the minimal states required to have NTP configured. In many cases ``init.sls`` is almost equivalent to an ``apt-get install`` or a ``yum install`` of the package.
+
+.. code-block:: sls
+
+   ## /srv/saltstack/salt-formulas/ntp-saltstack-formula/ntp/init.sls
+   {%- from 'ntp/map.jinja' import ntp with context %}
+
+   Install NTP:
+     pkg.installed:
+       - name: {{ ntp.pkg }}
+
+   Enable and start NTP:
+     service.running:
+       - name: {{ ntp.service }}
+       - enabled: True
+       - require:
+         - pkg: Install NTP package
+
+In ``conf.sls`` we have the configuration states. In most cases, that is just managing configuration file templates and making them to be watched by the service.
+
+.. code-block:: sls
+
+   ## /srv/saltstack/salt-formulas/ntp-saltstack-formula/ntp/conf.sls
+   include:
+     - ntp
+
+   {%- from 'ntp/map.jinja' import ntp with context %}
+
+   Configure NTP:
+     file.managed:
+       - name: {{ ntp.config }}
+       - template: jinja
+       - source: salt://ntp/files/default/etc/ntp.conf.jinja
+       - watch_in:
+         - service: Enable and start NTP service
+       - require:
+         - pkg: Install NTP package
+
+Under ``files/default``, there is a structure that mimics the one in the minion in order to avoid clashes and confusion on where to put the needed templates. There you can find a mostly standard template for the configuration file.
+
+.. code-block:: jinja
+
+   {#- /srv/saltstack/salt-formulas/ntp-saltstack-formula/ntp/files/default/etc/ntp.conf.jinja #}
+   {#- Managed by saltstack #}
+   {#- Edit pillars or override this template in saltstack if you need customization #}
+   {%- set settings = salt['pillar.get']('ntp', {}) %}
+   {%- set default_servers = ['0.ubuntu.pool.ntp.org',
+                             '1.ubuntu.pool.ntp.org',
+                             '2.ubuntu.pool.ntp.org',
+                             '3.ubuntu.pool.ntp.org'] %}
+
+   driftfile /var/lib/ntp/ntp.drift
+   statistics loopstats peerstats clockstats
+   filegen loopstats file loopstats type day enable
+   filegen peerstats file peerstats type day enable
+   filegen clockstats file clockstats type day enable
+
+   {%- for server in settings.get('servers', default_servers) %}
+   server {{ server }}
+   {%- endfor %}
+
+   restrict -4 default kod notrap nomodify nopeer noquery
+   restrict -6 default kod notrap nomodify nopeer noquery
+
+   restrict 127.0.0.1
+   restrict ::1
+
+With all this, it is easy to install and configure a simple NTP server by just running ``salt-call state.sls ntp.conf``: the package will be installed, the service will be running and the configuration should be correct for most of cases, even without pillar data.
+
+Alternatively, you can define a highstate in ``/srv/saltstack/salt/top.sls`` and run ``salt-call state.highstate``.
+
+.. code-block:: sls
+
+   ## /srv/saltstack/salt/top.sls
+   base:
+     '*':
+       - ntp.conf
+
+**Customizing the formula just with pillar data**, we have the option to define the NTP servers.
+
+.. code-block:: sls
+
+   ## /srv/saltstack/pillar/top.sls
+   base:
+     '*':
+       - ntp
+
+.. code-block:: sls
+
+   ## /srv/saltstack/pillar/ntp.sls
+   ntp:
+     servers:
+       - 0.ch.pool.ntp.org
+       - 1.ch.pool.ntp.org
+       - 2.ch.pool.ntp.org
+       - 3.ch.pool.ntp.org
+
+Template Override
+^^^^^^^^^^^^^^^^^
+
+If the customization based on pillar data is not enough, we can override the template by creating a new one in ``/srv/saltstack/salt/ntp/files/default/etc/ntp.conf.jinja``
+
+.. code-block:: jinja
+
+   {#- /srv/saltstack/salt/ntp/files/default/etc/ntp.conf.jinja #}
+   {#- Managed by saltstack #}
+   {#- Edit pillars or override this template in saltstack if you need customization #}
+
+   {#- Some bizarre configurations here #}
+   {#- ... #}
+
+   {%- for server in settings.get('servers', default_servers) %}
+   server {{ server }}
+   {%- endfor %}
+
+This way we are locally **overriding the template files** offered by the formula in order to make a more complex adaptation. Of course, this could be applied as well to any of the files, including the state files.
+
+Files Switch
+^^^^^^^^^^^^
+
+To bring some order into the set of template files included in a formula, as we commented, we suggest having a similar structure to a normal final file system under ``files/default``.
+
+We can make different templates coexist for different minions, classified by any `grain <http://docs.saltstack.com/en/latest/topics/targeting/grains.html>`_ value, by simply creating new directories under ``files``. This mechanism is based on **using values of some grains as a switch for the directories under** ``files/``.
+
+If we decide that we want ``os_family`` as switch, then we could provide the formula template variants for both the ``RedHat`` and ``Debian`` families.
+
+.. code-block:: console
+
+   /srv/saltstack/salt-formulas/ntp-saltstack-formula/ntp/files/
+     default/
+       etc/
+         ntp.conf.jinja
+     RedHat/
+       etc/
+         ntp.conf.jinja
+     Debian/
+       etc/
+         ntp.conf.jinja
+
+To make this work we need a ``conf.sls`` state file that takes a list of possible files as the configuration template.
+
+.. code-block:: sls
+
+   ## /srv/saltstack/salt-formulas/ntp-saltstack-formula/ntp/conf.sls
+   include:
+     - ntp
+
+   {%- from 'ntp/map.jinja' import ntp with context %}
+
+   Configure NTP:
+     file.managed:
+       - name: {{ ntp.config }}
+       - template: jinja
+       - source:
+         - salt://ntp/files/{{ grains.get('os_family', 'default') }}/etc/ntp.conf.jinja
+         - salt://ntp/files/default/etc/ntp.conf.jinja
+       - watch_in:
+         - service: Enable and start NTP service
+       - require:
+         - pkg: Install NTP package
+
+If we want to cover the possibility of a special template for a minion identified by ``node01`` then we could have a specific template in ``/srv/saltstack/salt/ntp/files/node01/etc/ntp.conf.jinja``.
+
+.. code-block:: jinja
+
+   {#- /srv/saltstack/salt/ntp/files/node01/etc/ntp.conf.jinja #}
+   {#- Managed by saltstack #}
+   {#- Edit pillars or override this template in saltstack if you need customization #}
+
+   {#- Some crazy configurations here for node01 #}
+   {#- ... #}
+
+To make this work we could write a specially crafted ``conf.sls``.
+
+.. code-block:: sls
+
+   ## /srv/saltstack/salt-formulas/ntp-saltstack-formula/ntp/conf.sls
+   include:
+     - ntp
+
+   {%- from 'ntp/map.jinja' import ntp with context %}
+
+   Configure NTP:
+     file.managed:
+       - name: {{ ntp.config }}
+       - template: jinja
+       - source:
+         - salt://ntp/files/{{ grains.get('id') }}/etc/ntp.conf.jinja
+         - salt://ntp/files/{{ grains.get('os_family') }}/etc/ntp.conf.jinja
+         - salt://ntp/files/default/etc/ntp.conf.jinja
+       - watch_in:
+         - service: Enable and start NTP service
+       - require:
+         - pkg: Install NTP package
+
+Using the ``files_switch`` macro
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+We can simplify the ``conf.sls`` with the new ``files_switch`` macro to use in the ``source`` parameter for the ``file.managed`` state.
+
+.. code-block:: sls
+
+   ## /srv/saltstack/salt-formulas/ntp-saltstack-formula/ntp/conf.sls
+   include:
+     - ntp
+
+   {%- set tplroot = tpldir.split('/')[0] %}
+   {%- from 'ntp/map.jinja' import ntp with context %}
+   {%- from 'ntp/libtofs.jinja' import files_switch %}
+
+   Configure NTP:
+     file.managed:
+       - name: {{ ntp.config }}
+       - template: jinja
+       - source: {{ files_switch(['/etc/ntp.conf.jinja'],
+                                 lookup='Configure NTP'
+                    )
+                 }}
+       - watch_in:
+         - service: Enable and start NTP service
+       - require:
+         - pkg: Install NTP package
+
+
+* This uses ``config.get``, searching for ``ntp:tofs:source_files:Configure NTP`` to determine the list of template files to use.
+* If this returns a result, the default of ``['/etc/ntp.conf.jinja']`` will be appended to it.
+* If this does not yield any results, the default of ``['/etc/ntp.conf.jinja']`` will be used.
+
+In ``libtofs.jinja``, we define this new macro ``files_switch``.
+
+.. literalinclude:: ../template/libtofs.jinja
+   :caption: /srv/saltstack/salt-formulas/ntp-saltstack-formula/ntp/libtofs.jinja
+   :language: jinja
+
+How to customise the ``source`` further
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+The examples below are based on an ``Ubuntu`` minion called ``theminion`` being configured via. pillar.
+
+Using the default settings of the ``files_switch`` macro above,
+the ``source`` will be:
+
+.. code-block:: sls
+
+         - source:
+           - salt://ntp/files/theminion/etc/ntp.conf.jinja
+           - salt://ntp/files/Debian/etc/ntp.conf.jinja
+           - salt://ntp/files/default/etc/ntp.conf.jinja
+
+Customise ``files``
+~~~~~~~~~~~~~~~~~~~
+
+The ``files`` portion can be customised:
+
+.. code-block:: sls
+
+   ntp:
+     tofs:
+       dirs:
+         files: files_alt
+
+Resulting in:
+
+.. code-block:: sls
+
+         - source:
+           - salt://ntp/files_alt/theminion/etc/ntp.conf.jinja
+           - salt://ntp/files_alt/Debian/etc/ntp.conf.jinja
+           - salt://ntp/files_alt/default/etc/ntp.conf.jinja
+
+Customise the use of grains
+~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+Grains can be customised and even arbitrary paths can be supplied:
+
+.. code-block:: sls
+
+   ntp:
+     tofs:
+       files_switch:
+         - any/path/can/be/used/here
+         - id
+         - os
+         - os_family
+
+Resulting in:
+
+.. code-block:: sls
+
+         - source:
+           - salt://ntp/files/any/path/can/be/used/here/etc/ntp.conf.jinja
+           - salt://ntp/files/theminion/etc/ntp.conf.jinja
+           - salt://ntp/files/Ubuntu/etc/ntp.conf.jinja
+           - salt://ntp/files/Debian/etc/ntp.conf.jinja
+           - salt://ntp/files/default/etc/ntp.conf.jinja
+
+Customise the ``default`` path
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+The ``default`` portion of the path can be customised:
+
+.. code-block:: sls
+
+   ntp:
+     tofs:
+       dirs:
+         default: default_alt
+
+Resulting in:
+
+.. code-block:: sls
+
+         - source:
+           ...
+           - salt://ntp/files/default_alt/etc/ntp.conf.jinja
+
+Customise the list of ``source_files``
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+The list of ``source_files`` can be given:
+
+.. code-block:: sls
+
+   ntp:
+     tofs:
+       source_files:
+         Configure NTP:
+           - '/etc/ntp.conf_alt.jinja'
+
+Resulting in:
+
+.. code-block:: sls
+
+         - source:
+           - salt://ntp/files/theminion/etc/ntp.conf_alt.jinja
+           - salt://ntp/files/theminion/etc/ntp.conf.jinja
+           - salt://ntp/files/Debian/etc/ntp.conf_alt.jinja
+           - salt://ntp/files/Debian/etc/ntp.conf.jinja
+           - salt://ntp/files/default/etc/ntp.conf_alt.jinja
+           - salt://ntp/files/default/etc/ntp.conf.jinja
+
+Note: This does *not* override the default value.
+Rather, the value from the pillar/config is prepended to the default.
+
+Using sub-directories for ``components``
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+If your formula is composed of several components, you may prefer to provides files under sub-directories, like in the `systemd-formula <https://github.com/saltstack-formulas/systemd-formula>`_.
+
+.. code-block:: console
+
+   /srv/saltstack/systemd-formula/
+     systemd/
+       init.sls
+       libtofs.jinja
+       map.jinja
+       networkd/
+         init.sls
+         files/
+           default/
+             network/
+               99-default.link
+       resolved/
+         init.sls
+         files/
+           default/
+             resolved.conf
+       timesyncd/
+         init.sls
+         files/
+           Arch/
+             resolved.conf
+           Debian/
+             resolved.conf
+           default/
+             resolved.conf
+           Ubuntu/
+             resolved.conf
+
+For example, the following ``formula.component.config`` SLS:
+
+.. code-block:: sls
+
+   {%- from "formula/libtofs.jinja" import files_switch with context %}
+
+   formula configuration file:
+     file.managed:
+       - name: /etc/formula.conf
+       - user: root
+       - group: root
+       - mode: 644
+       - template: jinja
+       - source: {{ files_switch(['formula.conf'],
+                                 lookup='formula',
+                                 use_subpath=True
+                    )
+                 }}
+
+will be rendered on a ``Debian`` minion named ``salt-formula.ci.local`` as:
+
+.. code-block:: sls
+
+   formula configuration file:
+     file.managed:
+       - name: /etc/formula.conf
+       - user: root
+       - group: root
+       - mode: 644
+       - template: jinja
+       - source:
+         - salt://formula/component/files/salt-formula.ci.local/formula.conf
+         - salt://formula/component/files/Debian/formula.conf
+         - salt://formula/component/files/default/formula.conf
+         - salt://formula/files/salt-formula.ci.local/formula.conf
+         - salt://formula/files/Debian/formula.conf
+         - salt://formula/files/default/formula.conf
diff --git a/docs/map.jinja.rst b/docs/map.jinja.rst
new file mode 100644
index 0000000..55b4bd0
--- /dev/null
+++ b/docs/map.jinja.rst
@@ -0,0 +1,542 @@
+.. _map.jinja:
+
+``map.jinja``: gather formula configuration values
+==================================================
+
+The `documentation`_ explains the use of a ``map.jinja`` to gather parameters values for a formula.
+
+As `pillars`_ are rendered on the Salt master for every minion, this increases the load on the master as the pillar values and the number of minions grows.
+
+As a good practice, you should:
+
+- store non-secret data in YAML files distributed by the `fileserver`_
+- store secret data in:
+
+  - `pillars`_ (and look for the use of something like `pillar.vault`_)
+  - `SDB`_ (and look for the use of something like `sdb.vault`_)
+
+Current best practice is to let ``map.jinja`` handle parameters from all sources, to minimise the use of pillars, grains or configuration from ``sls`` files and templates directly.
+
+
+.. contents:: **Table of Contents**
+
+
+For formula users
+-----------------
+
+
+Quick start: configure per role and per DNS domain name values
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+We will see a quick setup to configure the ``netbox`` formula for different DNS domain names and several roles.
+
+For this example, I'll define 2 kinds of `fileserver`_ sources:
+
+1. formulas git repositories with hard-coded version reference to avoid breaking my setup randomly at upstream update. they are the last sources where files are looked up
+2. parameters of the formulas in the file backend `roots`_
+
+
+Configure the fileserver backends
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+I configure the `fileserver`_ backends to serve:
+
+1. files from `roots`_ first
+2. `gitfs`_ repositories last
+
+Create the file ``/etc/salt/master.d/fileserver.conf`` and restart the ``master``:
+
+.. code-block:: yaml
+
+    ---
+    ##
+    ## file server
+    ##
+    fileserver_backend:
+      # parameters values and override
+      - roots
+      # formulas
+      - gitfs
+
+    # The files in this directory will take precedence over git repositories
+    file_roots:
+      base:
+        - /srv/salt
+
+    # List of formulas I'm using
+    gitfs_remotes:
+      - https://github.com/saltstack-formulas/template-formula.git:
+        - base: v4.1.1
+      - https://github.com/saltstack-formulas/openssh-formula.git:
+        - base: v2.0.1
+    ...
+
+
+Create per DNS configuration for ``netbox`` formula
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+Now, we can provides the per DNS domain name configuration files for the ``netbox`` formulas under ``/srv/salt/netbox/parameters/``.
+
+We create the directory for ``dns:domain`` grain and we add a symlink for the ``domain`` grain which is extracted from the minion ``id``:
+
+.. code-block:: console
+
+    mkdir -p /srv/salt/netbox/parameters/dns:domain/
+    ln -s dns:domain /srv/salt/netbox/parameters/domain
+
+We create a configuration for the DNS domain ``example.net`` in ``/srv/salt/netbox/parameters/dns:domain/example.net.yaml``:
+
+.. code-block:: yaml
+
+    ---
+    values:
+      config: /etc/template-formula-example-net.conf
+    ...
+
+We create another configuration for the DNS domain ``example.com`` in the Jinja YAML template ``/srv/salt/netbox/parameters/dns:domain/example.com.yaml.jinja``:
+
+.. code-block:: yaml
+
+    ---
+    values:
+      config: /etc/template-formula-{{ grains['os_family'] }}.conf
+    ...
+
+
+Create per role configuration for ``netbox`` formula
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+Now, we can provides the per role configuration files for the ``netbox`` formulas under ``/srv/salt/netbox/parameters/``.
+
+We create the directory for roles:
+
+.. code-block:: console
+
+    mkdir -p /srv/salt/netbox/parameters/roles
+
+We will define 2 roles:
+
+- ``netbox/server``
+- ``netbox/client``
+
+We create a configuration for the role ``netbox/server`` in ``/srv/salt/netbox/parameters/roles/netbox/server.yaml``:
+
+.. code-block:: yaml
+
+    ---
+    values:
+      config: /etc/template-formula-server.conf
+    ...
+
+We create another configuration for the role ``netbox/client`` in ``/srv/salt/netbox/parameters/roles/netbox/client.yaml``:
+
+.. code-block:: yaml
+
+    ---
+    values:
+      config: /etc/template-formula-client.conf
+    ...
+
+
+Enable roles and the ``dns:domain`` and ``domain`` grains for ``map.jinja``
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+We need to redefine the sources for ``map.jinja`` to load values from our new configuration files, we provide a global configuration for all our minions.
+
+We create the global parameters file ``/srv/salt/parameters/map_jinja.yaml``:
+
+.. code-block:: yaml
+
+    ---
+    values:
+      sources:
+        # default values
+        - "Y:G@osarch"
+        - "Y:G@os_family"
+        - "Y:G@os"
+        - "Y:G@osfinger"
+        - "C@{{ tplroot ~ ':lookup' }}"
+        - "C@{{ tplroot }}"
+
+        # Roles activate/deactivate things
+        # then thing are configured depending on environment
+        # So roles comes before `dns:domain`, `domain` and `id`
+        - "Y:C@roles"
+
+        # DNS domain configured (DHCP or resolv.conf)
+        - "Y:G@dns:domain"
+
+        # Based on minion ID
+        - "Y:G@domain"
+
+        # default values
+        - "Y:G@id"
+    ...
+
+The syntax is explained later at `Sources of configuration values`_.
+
+
+Bind roles to minions
+~~~~~~~~~~~~~~~~~~~~~
+
+We associate roles `grains`_ to minion using `grains.append`_.
+
+For the servers:
+
+.. code-block:: console
+
+    salt 'server-*' grains.append roles netbox/server
+
+For the clients:
+
+.. code-block:: console
+
+    salt 'client-*' grains.append roles netbox/client
+
+.. note::
+
+    Since we used ``Y:C@roles``, ``map.jinja`` will do a ``salt['config.get']('roles')`` to retrieve the roles so you could use any other method to bind roles to minions (`pillars`_ or `SDB`_) but `grains`_ seems to be the preferred method.
+
+Note for Microsoft Windows systems
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+If you have a minion running under windows, you can't use colon ``:`` as a delimiter for grain path query (see `bug 58726`_) in which case you should use an alternate delimiter:
+
+Modify ``/srv/salt/parameters/map_jinja.yaml`` to change the query for ``dns:domain`` to define the `alternate delimiter`_:
+
+.. code-block:: yaml
+
+    ---
+    values:
+      sources:
+        # default values
+        - "Y:G@osarch"
+        - "Y:G@os_family"
+        - "Y:G@os"
+        - "Y:G@osfinger"
+        - "C@{{ tplroot ~ ':lookup' }}"
+        - "C@{{ tplroot }}"
+
+        # Roles activate/deactivate things
+        # then thing are configured depending on environment
+        # So roles comes before `dns:domain`, `domain` and `id`
+        - "Y:C@roles"
+
+        # DNS domain configured (DHCP or resolv.conf)
+        - "Y:G:!@dns!domain"
+
+        # Based on minion ID
+        - "Y:G@domain"
+
+        # default values
+        - "Y:G@id"
+    ...
+
+And then, rename the directory:
+
+.. code-block:: console
+
+    mv /srv/salt/netbox/parameters/dns:domain/  '/srv/salt/netbox/parameters/dns!domain/'
+
+
+Format of configuration YAML files
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+When you write a new YAML file, note that it must conform to the following layout:
+
+- a mandatory ``values`` key to store the configuration values
+- two optional keys to configure the use of `salt.slsutil.merge`_
+
+  - an optional ``strategy`` key to configure the merging strategy, for example ``strategy: 'recurse'``, the default is ``smart``
+  - an optional ``merge_lists`` key to configure if lists should be merged or overridden for the ``recurse`` and ``overwrite`` strategy, for example ``merge_lists: 'true'``
+
+Here is a valid example:
+
+.. code-block:: yaml
+
+    ---
+    strategy: 'recurse'
+    merge_lists: 'false'
+    values:
+      pkg:
+        name: 'some-package'
+      config: '/path/to/a/configuration/file'
+    ...
+
+
+Using Jinja2 YAML template
+~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+You can provide a Jinja2 YAML template file with a name suffixed with ``.yaml.jinja``, it must produce a YAML file conform to the `Format of configuration YAML files`_, for example:
+
+.. code-block:: jinja
+
+    ---
+    strategy: 'overwrite'
+    merge_lists: 'true'
+    values:
+    {%- if grains["os"] == "Debian" %}
+      output_dir: /tmp/{{ grains["id"] }}
+    {%- endif %}
+    ...
+
+
+Sources of configuration values
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+The ``map.jinja`` file aggregates configuration values from several sources:
+
+- YAML files stored in the `fileserver`_
+- `pillars`_
+- `grains`_
+- configuration gathered with `salt['config.get']`_
+
+For the values loaded from YAML files, ``map.jinja`` will automatically try to load a Jinja2 template with the same name as the YAML file with the addition of the ``.jinja`` extension, for example ``foo/bar/quux.yaml.jinja``.
+
+After loading values from all sources, it will try to include the ``salt://{{ tplroot }}/post-map.jinja`` Jinja file if it exists which can post-process the ``mapdata`` variable.
+
+Configuring ``map.jinja`` sources
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+The ``map.jinja`` file uses several sources where to lookup parameter values. The list of sources can be configured in two places:
+
+1. globally
+
+   1. with a plain YAML file ``salt://parameters/map_jinja.yaml``
+   2. with a Jinja2 YAML template file ``salt://parameters/map_jinja.yaml.jinja``
+
+2. per formula
+
+   1. with a plain YAML file ``salt://{{ tplroot }}/parameters/map_jinja.yaml``
+   2. with a Jinja2 YAML template file ``salt://{{ tplroot }}/parameters/map_jinja.yaml.jinja``
+
+.. note::
+
+    The ``map.jinja`` configuration files must conform to the `format of configuration YAML files`_.
+
+Each source definition has the form ``[<TYPE>[:<OPTION>[:<DELIMITER>]]@]<KEY>`` where ``<TYPE>`` can be one of:
+
+- ``Y`` to load values from YAML files from the `fileserver`_, this is the default when no type is defined
+- ``C`` to lookup values with `salt['config.get']`_
+- ``G`` to lookup values with `salt['grains.get']`_
+- ``I`` to lookup values with `salt['pillar.get']`_
+
+The YAML type option can define the query method to lookup the key value to build the file name:
+
+- ``C`` to query with `salt['config.get']`_, this is the default when no query method is defined
+- ``G`` to query with `salt['grains.get']`_
+- ``I`` to query with `salt['pillar.get']`_
+
+The ``C``, ``G`` or ``I`` types can define the ``SUB`` option to store values in the sub key ``mapdata.<KEY>`` instead of directly in ``mapdata``.
+
+All types can define the ``<DELIMITER>`` option to use an `alternate delimiter`_ of the ``<KEY>``, for example: on windows system you can't use colon ``:`` for YAML file path name and you should use something else like exclamation mark ``!``.
+
+Finally, the ``<KEY>`` describes what to lookup to either build the YAML filename or gather values using one of the query methods.
+
+.. note::
+
+    For the YAML type:
+
+    - if the ``<KEY>`` can't be looked up, then it's used a literal string path to a YAML file, for example: ``any/path/can/be/used/here.yaml`` will result in the loading of ``salt://{{ tplroot }}/parameters/any/path/can/be/used/here.yaml`` if it exists
+    - ``map.jinja`` will automatically try to load a Jinja2 template, after the corresponding YAML file, with the same name as the YAML file extended with the ``.jinja`` extension, for example ``any/path/can/be/used/here.yaml.jinja``
+
+The built-in ``map.jinja`` sources are:
+
+.. code-block:: yaml
+
+    - "Y:G@osarch"
+    - "Y:G@os_family"
+    - "Y:G@os"
+    - "Y:G@osfinger"
+    - "C@{{ tplroot ~ ':lookup' }}"
+    - "C@{{ tplroot }}"
+    - "Y:G@id"
+
+This is strictly equivalent to the following ``map_jinja.yaml.jinja``:
+
+.. code-block:: sls
+
+    values:
+      sources:
+        - "parameters/osarch/{{ salt['grains.get']('osarch') }}.yaml"
+        - "parameters/osarch/{{ salt['grains.get']('osarch') }}.yaml.jinja"
+        - "parameters/os_family/{{ salt['grains.get']('os_family') }}.yaml"
+        - "parameters/os_family/{{ salt['grains.get']('os_family') }}.yaml.jinja"
+        - "parameters/os/{{ salt['grains.get']('os') }}.yaml"
+        - "parameters/os/{{ salt['grains.get']('os') }}.yaml.jinja"
+        - "parameters/osfinger/{{ salt['grains.get']('osfinger') }}.yaml"
+        - "parameters/osfinger/{{ salt['grains.get']('osfinger') }}.yaml.jinja"
+        - "C@{{ tplroot ~ ':lookup' }}"
+        - "C@{{ tplroot }}"
+        - "parameters/id/{{ salt['grains.get']('id') }}.yaml"
+        - "parameters/id/{{ salt['grains.get']('id') }}.yaml.jinja"
+
+
+Loading values from the configuration sources
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+For each configuration source defined, ``map.jinja`` will:
+
+#. load values depending on the source type:
+
+   - for YAML file sources
+
+     - if the ``<KEY>`` can be looked up:
+
+       - load values from the YAML file named ``salt://{{ tplroot }}/paramaters/<KEY>/{{ salt['<QUERY_METHOD>']('<KEY>') }}.yaml`` if it exists
+       - load values from the Jinja2 YAML template file named ``salt://{{ tplroot }}/paramaters/<KEY>/{{ salt['<QUERY_METHOD>']('<KEY>') }}.yaml.jinja`` if it exists
+
+     - otherwise:
+
+       - load the YAML file named ``salt://{{ tplroot }}/parameters/<KEY>.yaml`` if it exists
+       - load the Jinja2 YAML template file named ``salt://{{ tplroot }}/parameters/<KEY>.yaml.jinja`` if it exists
+
+   - for ``C``, ``G`` or ``I`` source type, lookup the value of ``salt['<QUERY_METHOD>']('<KEY>')``
+
+#. merge the loaded values with the previous ones using `salt.slsutil.merge`_
+
+There will be no error if a YAML or Jinja2 file does not exists, they are all optional.
+
+
+Configuration values from ``salt['config.get']``
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+For sources with of type ``C`` declared in ``map_jinja:sources``, you can configure the ``merge`` option of `salt['config.get']`_ by defining per formula ``strategy`` configuration key (retrieved with ``salt['config.get'](tplroot ~ ':strategy')`` with one of the following values:
+
+- ``recurse`` merge recursively dictionaries. Non dictionary values replace already defined values
+- ``overwrite`` new value completely replace old ones
+
+By default, no merging is done, the first value found is returned.
+
+
+Global view of the order of preferences
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+To summarise, here is a complete example of the load order of formula configuration values for an ``AMD64`` ``Ubuntu 18.04`` minion named ``minion1.example.net`` for the ``libvirt`` formula:
+
+#. ``parameters/defaults.yaml``
+#. ``parameters/defaults.yaml.jinja``
+#. ``parameters/osarch/amd64.yaml``
+#. ``parameters/osarch/amd64.yaml.jinja``
+#. ``parameters/os_family/Debian.yaml``
+#. ``parameters/os_family/Debian.yaml.jinja``
+#. ``parameters/os/Ubuntu.yaml``
+#. ``parameters/os/Ubuntu.yaml.jinja``
+#. ``parameters/osfinger/Ubuntu-18.04.yaml``
+#. ``parameters/osfinger/Ubuntu-18.04.yaml.jinja``
+#. ``salt['config.get']('libvirt:lookup')``
+#. ``salt['config.get']('libvirt')``
+#. ``parameters/id/minion1.example.net.yaml``
+#. ``parameters/id/minion1.example.net.yaml.jinja``
+
+Remember that the order is important, for example, the value of ``key1:subkey1`` loaded from ``parameters/os_family/Debian.yaml`` is overridden by a value loaded from ``parameters/id/minion1.example.net.yaml``.
+
+
+For formula authors and contributors
+------------------------------------
+
+Dependencies
+^^^^^^^^^^^^
+
+``map.jinja`` requires:
+
+- salt minion 2018.3.3 minimum to use the `traverse`_ jinja filter
+- to be located at the root of the formula named directory (e.g. ``libvirt-formula/libvirt/map.jinja``)
+- the ``libsaltcli.jinja`` library, stored in the same directory, to disable the ``merge`` option of `salt['config.get']`_ over `salt-ssh`_
+- the ``libmapstack.jinja`` library to load the configuration values
+- the ``libmatchers.jinja`` library used by ``libmapstack.jinja`` to parse compound like matchers
+
+
+Use formula configuration values in ``sls``
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+The ``map.jinja`` exports a unique ``mapdata`` variable which could be renamed during import.
+
+Here is the best way to use it in an ``sls`` file:
+
+.. code-block:: sls
+
+    {#- Get the `tplroot` from `tpldir` #}
+    {%- set tplroot = tpldir.split("/")[0] %}
+    {%- from tplroot ~ "/map.jinja" import mapdata as netbox with context %}
+
+    test-does-nothing-but-display-netbox-as-json:
+      test.nop:
+        - name: {{ netbox | json }}
+
+
+Use formula configuration values in templates
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+When you need to process salt templates, you should avoid calling `salt['config.get']`_ (or `salt['pillar.get']`_ and `salt['grains.get']`_) directly from the template. All the needed values should be available within the ``mapdata`` variable exported by ``map.jinja``.
+
+Here is an example based on `template-formula/netbox/config/file.sls`_:
+
+.. code-block:: sls
+
+    # -*- coding: utf-8 -*-
+    # vim: ft=sls
+
+    {#- Get the `tplroot` from `tpldir` #}
+    {%- set tplroot = tpldir.split('/')[0] %}
+    {%- set sls_package_install = tplroot ~ '.package.install' %}
+    {%- from tplroot ~ "/map.jinja" import mapdata as netbox with context %}
+    {%- from tplroot ~ "/libtofs.jinja" import files_switch with context %}
+
+    include:
+      - {{ sls_package_install }}
+
+    netbox-config-file-file-managed:
+      file.managed:
+        - name: {{ netbox.config }}
+        - source: {{ files_switch(['example.tmpl'],
+                                  lookup='netbox-config-file-file-managed'
+                     )
+                  }}
+        - mode: 644
+        - user: root
+        - group: {{ netbox.rootgroup }}
+        - makedirs: True
+        - template: jinja
+        - require:
+          - sls: {{ sls_package_install }}
+        - context:
+            netbox: {{ netbox | json }}
+
+This ``sls`` file expose a ``netbox`` context variable to the jinja template which could be used like this:
+
+.. code-block:: jinja
+
+    ########################################################################
+    # File managed by Salt at <{{ source }}>.
+    # Your changes will be overwritten.
+    ########################################################################
+
+    This is another example file from SaltStack template-formula.
+
+    # This is here for testing purposes
+    {{ netbox | json }}
+
+    winner of the merge: {{ netbox['winner'] }}
+
+
+.. _documentation: https://docs.saltproject.io/en/latest/topics/development/conventions/formulas.html#writing-formulas
+.. _fileserver: https://docs.saltproject.io/en/latest/ref/file_server
+.. _salt['config.get']: https://docs.saltproject.io/en/latest/ref/modules/all/salt.modules.config.html#salt.modules.config.get
+.. _salt['grains.get']: https://docs.saltproject.io/en/latest/ref/modules/all/salt.modules.grains.html#salt.modules.grains.get
+.. _salt['pillar.get']: https://docs.saltproject.io/en/latest/ref/modules/all/salt.modules.pillar.html#salt.modules.pillar.get
+.. _alternate delimiter: https://docs.saltproject.io/en/latest/topics/targeting/compound.html#alternate-delimiters
+.. _pillar.vault: https://docs.saltproject.io/en/latest/ref/pillar/all/salt.pillar.vault.html
+.. _pillars: https://docs.saltproject.io/en/latest/topics/pillar/
+.. _grains: https://docs.saltproject.io/en/latest/topics/grains/
+.. _grains.append: https://docs.saltproject.io/en/latest/ref/modules/all/salt.modules.grains.html#salt.modules.grains.append
+.. _SDB: https://docs.saltproject.io/en/latest/topics/sdb/index.html
+.. _sdb.vault: https://docs.saltproject.io/en/latest/ref/sdb/all/salt.sdb.vault.html
+.. _Jinja: https://docs.saltproject.io/en/latest/topics/jinja
+.. _roots: https://docs.saltproject.io/en/latest/ref/file_server/all/salt.fileserver.roots.html
+.. _gitfs: https://docs.saltproject.io/en/latest/topics/tutorials/gitfs.html
+.. _salt.slsutil.merge: https://docs.saltproject.io/en/latest/ref/modules/all/salt.modules.slsutil.html#salt.modules.slsutil.merge
+.. _traverse: https://docs.saltproject.io/en/latest/topics/jinja/index.html#traverse
+.. _salt-ssh: https://docs.saltproject.io/en/latest/topics/ssh/
+.. _template-formula/netbox/config/file.sls: https://github.com/saltstack-formulas/template-formula/blob/master/netbox/config/file.sls
+.. _bug 58726: https://github.com/saltstack/salt/issues/58726
diff --git a/influxdb/clean.sls b/influxdb/clean.sls
new file mode 100644
index 0000000..002928d
--- /dev/null
+++ b/influxdb/clean.sls
@@ -0,0 +1,8 @@
+# -*- coding: utf-8 -*-
+# vim: ft=sls
+
+include:
+  - .service.clean
+  - .config.clean
+  - .package.clean
+  - .repo.clean
diff --git a/influxdb/cli.sls b/influxdb/cli.sls
deleted file mode 100644
index 53a9008..0000000
--- a/influxdb/cli.sls
+++ /dev/null
@@ -1,19 +0,0 @@
-cli_dependencies:
-  pkg.installed:
-    - pkgs:
-{% if grains['os_family'] == 'Debian' %}
-      - build-essential
-      - ruby-dev
-{% elif grains['os_family'] == 'RedHat' %}
-      - gcc
-      - make
-      - automake
-      - ruby-devel
-{% endif %}
-      - ruby
-
-cli_gem:
-  gem.installed:
-    - name: influxdb-cli
-    - require:
-        - pkg: cli_dependencies
diff --git a/influxdb/config.sls b/influxdb/config.sls
deleted file mode 100644
index 9eafe55..0000000
--- a/influxdb/config.sls
+++ /dev/null
@@ -1,41 +0,0 @@
-{% from "influxdb/map.jinja" import influxdb_settings with context %}
-
-include:
-  - influxdb
-
-influxdb_pip:
-  pkg.installed:
-    - name: {{ influxdb_settings.pip_pkg }}
-
-toml-python-module:
-  pip.installed:
-    - name: {{ influxdb_settings.toml_module }}
-    - require:
-      - pkg: {{ influxdb_settings.pip_pkg }}
-
-influxdb_config:
-  file.managed:
-    - name: {{ influxdb_settings.config }}
-    - source: {{ influxdb_settings.tmpl.config }}
-    - user: root
-    - group: root
-    - makedirs: True
-    - dir_mode: 755
-    - mode: 644
-    - template: jinja
-    - listen_in:
-      - service: {{ influxdb_settings.service }}
-    - require:
-      - pip: {{ influxdb_settings.toml_module }}
-    - require_in:
-      - service: {{ influxdb_settings.service }}
-
-
-influxdb_default:
-  file.managed:
-    - name: {{ influxdb_settings.etc_default }}
-    - source: {{ influxdb_settings.tmpl.etc_default }}
-    - user: root
-    - group: root
-    - mode: 755
-    - template: jinja
diff --git a/influxdb/config/clean.sls b/influxdb/config/clean.sls
new file mode 100644
index 0000000..7faa69b
--- /dev/null
+++ b/influxdb/config/clean.sls
@@ -0,0 +1,16 @@
+# -*- coding: utf-8 -*-
+# vim: ft=sls
+
+{#- Get the `tplroot` from `tpldir` #}
+{%- set tplroot = tpldir.split('/')[0] %}
+{%- set sls_service_clean = tplroot ~ '.service.clean' %}
+{%- from tplroot ~ "/map.jinja" import mapdata as influxdb with context %}
+
+include:
+  - {{ sls_service_clean }}
+
+influxdb-config-clean-file-absent:
+  file.absent:
+    - name: {{ influxdb.config }}
+    - require:
+      - sls: {{ sls_service_clean }}
diff --git a/influxdb/config/file.sls b/influxdb/config/file.sls
new file mode 100644
index 0000000..ce6002a
--- /dev/null
+++ b/influxdb/config/file.sls
@@ -0,0 +1,26 @@
+# -*- coding: utf-8 -*-
+# vim: ft=sls
+
+{#- Get the `tplroot` from `tpldir` #}
+{%- set tplroot = tpldir.split('/')[0] %}
+{%- set sls_package_install = tplroot ~ '.package.install' %}
+{%- from tplroot ~ "/map.jinja" import mapdata as influxdb with context %}
+{%- from tplroot ~ "/libtofs.jinja" import files_switch with context %}
+include:
+  - {{ sls_package_install }}
+influxdb/config/install:
+  file.managed:
+    - name: {{ influxdb.config }}
+    - source: {{ files_switch(['influxdb.tmpl.jinja'],
+                              lookup='influxdb/config/install'
+                 )
+              }}
+    - mode: 644
+    - user: root
+    - group: root
+    - makedirs: True
+    - template: jinja
+    - require:
+      - sls: {{ sls_package_install }}
+    - context:
+        influxdb: {{ influxdb.conf | json }}
diff --git a/influxdb/config/init.sls b/influxdb/config/init.sls
new file mode 100644
index 0000000..150baaf
--- /dev/null
+++ b/influxdb/config/init.sls
@@ -0,0 +1,13 @@
+# -*- coding: utf-8 -*-
+# vim: ft=sls
+
+{#- Get the `tplroot` from `tpldir` #}
+{%- set tplroot = tpldir.split('/')[0] %}
+{%- from tplroot ~ "/map.jinja" import mapdata as influxdb with context %}
+
+include:
+  - .file
+{% if influxdb.ssl is defined %}
+  - .ssl
+{% endif %}
+
diff --git a/influxdb/config/ssl.sls b/influxdb/config/ssl.sls
new file mode 100644
index 0000000..6635900
--- /dev/null
+++ b/influxdb/config/ssl.sls
@@ -0,0 +1,32 @@
+# -*- coding: utf-8 -*-
+# vim: ft=sls
+
+{#- Get the `tplroot` from `tpldir` #}
+{%- set tplroot = tpldir.split('/')[0] %}
+{%- set sls_config_file = tplroot ~ '.config.file' %}
+{%- from tplroot ~ "/map.jinja" import mapdata as influxdb with context %}
+
+include:
+  - {{ sls_config_file }}
+
+influxdb/config/ssl/cert:
+  file.managed:
+    - name: {{ influxdb.conf["tls-cert"] }}
+    - mode: 644
+    - user: {{ influxdb.system_user }}
+    - group: {{ influxdb.system_group }}
+    - makedirs: True
+    - contents_pillar: influxdb:ssl:cert
+    - require:
+      - sls: {{ sls_config_file }}
+
+influxdb/config/ssl/key:
+  file.managed:
+    - name: {{ influxdb.conf["tls-key"] }}
+    - mode: 600
+    - user: {{ influxdb.system_user }}
+    - group: {{ influxdb.system_group }}
+    - makedirs: True
+    - contents_pillar: influxdb:ssl:key
+    - require:
+      - sls: {{ sls_config_file }}
diff --git a/influxdb/config_defaults.yaml b/influxdb/config_defaults.yaml
deleted file mode 100644
index b57ac0d..0000000
--- a/influxdb/config_defaults.yaml
+++ /dev/null
@@ -1,343 +0,0 @@
-# -*- coding: utf-8 -*-
-# vim: ft=yaml
----
-'0':
-  '13':
-    admin:
-      bind-address: :8083
-      enabled: true
-      https-certificate: /etc/ssl/influxdb.pem
-      https-enabled: false
-    cluster:
-      max-concurrent-queries: 0
-      max-select-buckets: 0
-      max-select-point: 0
-      max-select-series: 0
-      query-timeout: 0s
-      shard-writer-timeout: 5s
-      write-timeout: 10s
-    collectd:
-      - enabled: false
-    continuous_queries:
-      enabled: true
-      log-enabled: true
-    data:
-      data-logging-enabled: true
-      dir: /var/lib/influxdb/data
-      enabled: true
-      wal-dir: /var/lib/influxdb/wal
-      wal-logging-enabled: true
-    graphite:
-      - enabled: false
-    http:
-      auth-enabled: false
-      bind-address: :8086
-      enabled: true
-      https-certificate: /etc/ssl/influxdb.pem
-      https-enabled: false
-      log-enabled: true
-      max-row-limit: 10000
-      pprof-enabled: false
-      write-tracing: false
-    meta:
-      dir: /var/lib/influxdb/meta
-      lease-duration: 1m0s
-      logging-enabled: true
-      pprof-enabled: false
-      retention-autocreate: true
-    monitor:
-      store-database: _internal
-      store-enabled: true
-      store-interval: 10s
-    opentsdb:
-      - enabled: false
-    reporting-disabled: false
-    retention:
-      check-interval: 30m
-      enabled: true
-    shard-precreation:
-      advance-period: 30m
-      check-interval: 10m
-      enabled: true
-    udp:
-      - enabled: false
-  '12':
-    admin:
-      bind-address: :8083
-      enabled: true
-      https-certificate: /etc/ssl/influxdb.pem
-      https-enabled: false
-    cluster:
-      shard-writer-timeout: 5s
-      write-timeout: 10s
-    collectd:
-      enabled: false
-    continuous_queries:
-      enabled: true
-      log-enabled: true
-    data:
-      data-logging-enabled: true
-      dir: /var/lib/influxdb/data
-      enabled: true
-      wal-dir: /var/lib/influxdb/wal
-      wal-logging-enabled: true
-    graphite:
-      - enabled: false
-    hinted-handoff:
-      dir: /var/lib/influxdb/hh
-      enabled: true
-      max-age: 168h
-      max-size: 1073741824
-      purge-interval: 1h
-      retry-interval: 1s
-      retry-max-interval: 1m
-      retry-rate-limit: 0
-    http:
-      auth-enabled: false
-      bind-address: :8086
-      enabled: true
-      https-certificate: /etc/ssl/influxdb.pem
-      https-enabled: false
-      log-enabled: true
-      pprof-enabled: false
-      write-tracing: false
-    meta:
-      bind-address: :8088
-      cluster-tracing: false
-      commit-timeout: 50ms
-      dir: /var/lib/influxdb/meta
-      election-timeout: 1s
-      enabled: true
-      heartbeat-timeout: 1s
-      http-bind-address: :8091
-      https-certificate: ''
-      https-enabled: false
-      leader-lease-timeout: 500ms
-      lease-duration: 1m0s
-      logging-enabled: true
-      pprof-enabled: false
-      raft-promotion-enabled: true
-      retention-autocreate: true
-    monitor:
-      store-database: _internal
-      store-enabled: true
-      store-interval: 10s
-    opentsdb:
-      enabled: false
-    reporting-disabled: true
-    retention:
-      check-interval: 30m
-      enabled: true
-    shard-precreation:
-      advance-period: 30m
-      check-interval: 10m
-      enabled: true
-    udp:
-      - enabled: false
-  '11':
-    admin:
-      bind-address: :8083
-      enabled: true
-      https-certificate: /etc/ssl/influxdb.pem
-      https-enabled: false
-    cluster:
-      shard-writer-timeout: 5s
-      write-timeout: 10s
-    collectd:
-      enabled: false
-    continuous_queries:
-      enabled: true
-      log-enabled: true
-    data:
-      data-logging-enabled: true
-      dir: /var/lib/influxdb/data
-      enabled: true
-      wal-dir: /var/lib/influxdb/wal
-      wal-logging-enabled: true
-    graphite:
-      - enabled: false
-    hinted-handoff:
-      dir: /var/lib/influxdb/hh
-      enabled: true
-      max-age: 168h
-      max-size: 1073741824
-      purge-interval: 1h
-      retry-interval: 1s
-      retry-max-interval: 1m
-      retry-rate-limit: 0
-    http:
-      auth-enabled: false
-      bind-address: :8086
-      enabled: true
-      https-certificate: /etc/ssl/influxdb.pem
-      https-enabled: false
-      log-enabled: true
-      pprof-enabled: false
-      write-tracing: false
-    meta:
-      bind-address: :8088
-      cluster-tracing: false
-      commit-timeout: 50ms
-      dir: /var/lib/influxdb/meta
-      election-timeout: 1s
-      enabled: true
-      heartbeat-timeout: 1s
-      http-bind-address: :8091
-      https-certificate: ''
-      https-enabled: false
-      leader-lease-timeout: 500ms
-      lease-duration: 1m0s
-      logging-enabled: true
-      pprof-enabled: false
-      raft-promotion-enabled: true
-      retention-autocreate: true
-    monitor:
-      store-database: _internal
-      store-enabled: true
-      store-interval: 10s
-    opentsdb:
-      enabled: false
-    reporting-disabled: true
-    retention:
-      check-interval: 30m
-      enabled: true
-    shard-precreation:
-      advance-period: 30m
-      check-interval: 10m
-      enabled: true
-    udp:
-      - enabled: false
-  '10':
-    admin:
-      bind-address: :8083
-      enabled: true
-      https-certificate: /etc/ssl/influxdb.pem
-      https-enabled: false
-    cluster:
-      shard-writer-timeout: 5s
-      write-timeout: 10s
-    collectd:
-      enabled: false
-    continuous_queries:
-      enabled: true
-      log-enabled: true
-    data:
-      data-logging-enabled: true
-      dir: /var/lib/influxdb/data
-      enabled: true
-      max-wal-size: 104857600
-      wal-dir: /var/lib/influxdb/wal
-      wal-flush-interval: 10m
-      wal-logging-enabled: true
-      wal-partition-flush-delay: 2s
-    graphite:
-      - enabled: false
-    hinted-handoff:
-      dir: /var/lib/influxdb/hh
-      enabled: true
-      max-age: 168h
-      max-size: 1073741824
-      purge-interval: 1h
-      retry-interval: 1s
-      retry-max-interval: 1m
-      retry-rate-limit: 0
-    http:
-      auth-enabled: false
-      bind-address: :8086
-      enabled: true
-      https-certificate: /etc/ssl/influxdb.pem
-      https-enabled: false
-      log-enabled: true
-      pprof-enabled: false
-      write-tracing: false
-    meta:
-      bind-address: :8088
-      cluster-tracing: false
-      commit-timeout: 50ms
-      dir: /var/lib/influxdb/meta
-      election-timeout: 1s
-      enabled: true
-      heartbeat-timeout: 1s
-      leader-lease-timeout: 500ms
-      retention-autocreate: true
-    monitor:
-      store-database: _internal
-      store-enabled: true
-      store-interval: 10s
-    opentsdb:
-      enabled: false
-    reporting-disabled: true
-    retention:
-      check-interval: 30m
-      enabled: true
-    shard-precreation:
-      advance-period: 30m
-      check-interval: 10m
-      enabled: true
-    udp:
-      - enabled: false
-  '9':
-    admin:
-      bind-address: ':8083'
-      enabled: true
-      https-certificate: /etc/ssl/influxdb.pem
-      https-enabled: false
-    cluster: {}
-    collectd:
-      enabled: false
-    continuous_queries:
-      compute-no-more-than: 2m
-      compute-runs-per-interval: 10
-      enabled: true
-      log-enabled: true
-      recompute-no-older-than: 10m
-      recompute-previous-n: 2
-    data:
-      dir: /var/lib/influxdb/data
-      wal-dir: /var/lib/influxdb/wal
-      wal-logging-enabled: true
-    graphite:
-      - enabled: false
-    hinted-handoff:
-      dir: /var/lib/influxdb/hh
-      enabled: true
-      max-age: 168h
-      max-size: 1073741824
-      purge-interval: 1h
-      retry-interval: 1s
-      retry-max-interval: 1m
-      retry-rate-limit: 0
-    http:
-      auth-enabled: false
-      bind-address: ':8086'
-      enabled: true
-      https-certificate: /etc/ssl/influxdb.pem
-      https-enabled: false
-      log-enabled: true
-      pprof-enabled: false
-      write-tracing: false
-    meta:
-      bind-address: ':8088'
-      cluster-tracing: false
-      commit-timeout: 50ms
-      dir: /var/lib/influxdb/meta
-      election-timeout: 1s
-      heartbeat-timeout: 1s
-      hostname: localhost
-      leader-lease-timeout: 500ms
-      raft-promotion-enabled: true
-      retention-autocreate: true
-    monitor: {}
-    opentsdb:
-      enabled: false
-    registration: {}
-    reporting-disabled: true
-    retention:
-      check-interval: 30m
-      enabled: true
-    shard-precreation:
-      advance-period: 30m
-      check-interval: 10m
-      enabled: true
-    udp:
-      - enabled: false
diff --git a/influxdb/defaults.yaml b/influxdb/defaults.yaml
deleted file mode 100644
index ff6190b..0000000
--- a/influxdb/defaults.yaml
+++ /dev/null
@@ -1,24 +0,0 @@
-# -*- coding: utf-8 -*-
-# vim: ft=yaml
----
-influxdb:
-  config: '/etc/influxdb/influxdb.conf'
-  conf: {}
-  etc_default: '/etc/default/influxdb'
-  fullname: 'InfluxDB Service User'
-  home: '/var/lib/influxdb'
-  logging:
-    directory: '/var/log/influxdb'
-    file: 'influxd.log'
-  logrotate_conf: '/etc/logrotate.d/influxdb'
-  pip_pkg: 'python-pip'
-  service: 'influxdb'
-  shell: '/bin/false'
-  system_group: 'influxdb'
-  system_user: 'influxdb'
-  toml_module: toml
-  use_wget_on_install: true
-  tmpl:
-    config: 'salt://influxdb/files/influxdb.config.jinja'
-    etc_default: 'salt://influxdb/files/influxdb.etc_default'
-    logrotate: 'salt://influxdb/files/logrotate.conf.jinja'
diff --git a/influxdb/dependencies/init.sls b/influxdb/dependencies/init.sls
new file mode 100644
index 0000000..d3e5518
--- /dev/null
+++ b/influxdb/dependencies/init.sls
@@ -0,0 +1,5 @@
+# -*- coding: utf-8 -*-
+# vim: ft=sls
+
+include:
+  - .install
diff --git a/influxdb/dependencies/install.sls b/influxdb/dependencies/install.sls
new file mode 100644
index 0000000..56792b0
--- /dev/null
+++ b/influxdb/dependencies/install.sls
@@ -0,0 +1,17 @@
+# -*- coding: utf-8 -*-
+# vim: ft=sls
+
+{#- Get the `tplroot` from `tpldir` #}
+{%- set tplroot = tpldir.split('/')[0] %}
+{%- from tplroot ~ "/map.jinja" import mapdata as influxdb with context %}
+
+
+{% if influxdb.pkg.dependencies is defined %}
+influxdb/dependencies/install:
+  pkg.installed:
+    - pkgs:
+    {% for package in influxdb.pkg.dependencies %}
+      - {{ package }}
+    {% endfor %}
+{% endif %}
+
diff --git a/influxdb/files/default/influxdb.tmpl.jinja b/influxdb/files/default/influxdb.tmpl.jinja
new file mode 100644
index 0000000..42ec0c8
--- /dev/null
+++ b/influxdb/files/default/influxdb.tmpl.jinja
@@ -0,0 +1,6 @@
+########################################################################
+# File managed by Salt at <{{ source }}>.
+# Your changes will be overwritten.
+########################################################################
+
+{{ salt['slsutil.serialize']('toml', influxdb) }}
diff --git a/influxdb/files/influxdb.config.jinja b/influxdb/files/influxdb.config.jinja
deleted file mode 100644
index 85ca88e..0000000
--- a/influxdb/files/influxdb.config.jinja
+++ /dev/null
@@ -1,10 +0,0 @@
-{% from "influxdb/map.jinja" import influxdb_settings with context -%}
-
-#
-# DO NOT EDIT
-#
-# This file is managed by salt via {{ source }}
-# Modify the config that generates this file instead
-#
-
-{{ salt['toml_lang.dumps'](influxdb_settings.conf) }}
diff --git a/influxdb/files/influxdb.etc_default b/influxdb/files/influxdb.etc_default
deleted file mode 100644
index f8ca897..0000000
--- a/influxdb/files/influxdb.etc_default
+++ /dev/null
@@ -1,10 +0,0 @@
-{% from "influxdb/map.jinja" import influxdb_settings with context -%}
-
-#
-# DO NOT EDIT
-#
-# This file is managed by salt via {{ source }}
-# Modify the config that generates this file instead
-#
-
-STDERR={{ influxdb_settings.logging.directory }}/{{ influxdb_settings.logging.file }}
diff --git a/influxdb/files/logrotate.conf.jinja b/influxdb/files/logrotate.conf.jinja
deleted file mode 100644
index 244ab04..0000000
--- a/influxdb/files/logrotate.conf.jinja
+++ /dev/null
@@ -1,21 +0,0 @@
-{% from "influxdb/map.jinja" import influxdb_settings with context -%}
-
-#
-# DO NOT EDIT
-#
-# This file is managed by salt via {{ source }}
-# Modify the config that generates this file instead
-#
-
-{{ influxdb_settings.logging.directory }}/*.log {
-  daily
-  rotate 3
-  copytruncate
-  compress
-  delaycompress
-  notifempty
-  missingok
-  su influxdb influxdb
-}
-
-# vi: set ft=sls :
diff --git a/influxdb/init.sls b/influxdb/init.sls
index 8918143..61e5a43 100644
--- a/influxdb/init.sls
+++ b/influxdb/init.sls
@@ -1,117 +1,15 @@
-{% from "influxdb/map.jinja" import influxdb_settings with context %}
+# -*- coding: utf-8 -*-
+# vim: ft=sls
 
-{% if influxdb_settings['version'] is defined %}
-  {% set influxdb_version = salt['pillar.get']('influxdb:version') %}
-  {% set major, minor = influxdb_version.split('.')[:2] %}
+{#- Get the `tplroot` from `tpldir` #}
+{%- set tplroot = tpldir.split('/')[0] %}
+{%- from tplroot ~ "/map.jinja" import mapdata as influxdb with context %}
 
-  {% if major == '0' and minor|int < 10 %}
-    {% set base_url = 'http://s3.amazonaws.com/influxdb' %}
-    {% if grains['os_family'] == 'Debian' %}
-      {% set filename = "influxdb_" + influxdb_settings['version'] + "_" + grains['osarch'] + ".deb" %}
-    {% elif grains['os_family'] == 'RedHat' or grains['os_family'] == 'Suse' %}
-      {% set filename = "influxdb-" + influxdb_settings['version'] + "-1." + grains['osarch'] + ".rpm" %}
-    {% endif %}
-  {% elif major == '0' and minor|int >= 10 and minor|int < 13 %}
-    {% set base_url = 'http://s3.amazonaws.com/influxdb' %}
-    {% if grains['os_family'] == 'Debian' %}
-      {% set filename = "influxdb_" + influxdb_settings['version'] + "-1_" + grains['osarch'] + ".deb" %}
-    {% elif grains['os_family'] == 'RedHat' or grains['os_family'] == 'Suse' %}
-      {% set filename = "influxdb-" + influxdb_settings['version'] + "-1." + grains['osarch'] + ".rpm" %}
-    {% endif %}
-  {% else %}
-    {% set base_url = 'https://dl.influxdata.com/influxdb/releases' %}
-    {% if grains['os_family'] == 'Debian' %}
-      {% set filename = "influxdb_" + influxdb_settings['version'] + "_" + grains['osarch'] + ".deb" %}
-    {% elif grains['os_family'] == 'RedHat' or grains['os_family'] == 'Suse' %}
-      {% set filename = "influxdb-" + influxdb_settings['version'] + "." + grains['osarch'] + ".rpm" %}
-    {% endif %}
-  {% endif %}
+include:
+{% if influxdb.pkg.dependencies is defined %}
+  - .dependencies
 {% endif %}
-
-{% if influxdb_settings['use_wget_on_install'] == True %}
-influxdb_package:
-  cmd.run:
-    - name: curl -s --output /tmp/{{ filename }} {{ base_url }}/{{ filename }}
-    - unless: test -f /tmp/{{ filename }}
-
-influxdb_remove_broken_download:
-  file.absent:
-    - name: /tmp/{{ filename }}
-    - onfail:
-      - cmd: influxdb_package
-
-
-influxdb_install:
-  pkg.installed:
-    - sources:
-      - influxdb: /tmp/{{ filename }}
-    - require:
-      - cmd: influxdb_package
-    - watch:
-      - cmd: influxdb_package
-  {% if grains['os_family'] == 'Suse' %}
-    - skip_verify: true
-  {% endif %}
-
-
-{% if grains['os_family'] == 'Suse' %}
-influxdb_install_systemd_unit:
-  file.copy:
-    - name: /usr/lib/systemd/system/influxdb.service
-    - source: /usr/lib/influxdb/scripts/influxdb.service
-{% endif %}
-
-{% else %}
-
-
-influxdb_install:
-  pkg.installed:
-    - sources:
-      - influxdb: {{ base_url }}/{{ filename }}
-
-{% endif %}
-
-influxdb_group:
-  group.present:
-    - name: {{ influxdb_settings.system_group }}
-    - system: True
-
-influxdb_user:
-  user.present:
-    - name: {{ influxdb_settings.system_user }}
-    - fullname: {{ influxdb_settings.fullname }}
-    - shell: {{ influxdb_settings.shell }}
-    - home: {{ influxdb_settings.home }}
-    - gid: {{ influxdb_settings.system_user }}
-    - require:
-      - group: influxdb_group
-
-influxdb_log:
-  file.directory:
-    - name: {{ influxdb_settings.logging.directory }}
-    - user: {{ influxdb_settings.system_user }}
-    - group: {{ influxdb_settings.system_group }}
-    - mode: 755
-    - require:
-      - group: influxdb_group
-      - user: influxdb_user
-
-influxdb_logrotate:
-  file.managed:
-    - name: {{ influxdb_settings.logrotate_conf }}
-    - source: {{ influxdb_settings.tmpl.logrotate }}
-    - template: jinja
-    - user: root
-    - group: root
-    - mode: 644
-    - watch:
-      - file: influxdb_log
-
-influxdb_start:
-  service.running:
-    - name: {{ influxdb_settings.service }}
-    - enable: True
-    - watch:
-      - pkg: influxdb_install
-    - require:
-      - pkg: influxdb_install
+  - .repo
+  - .package
+  - .config
+  - .service
diff --git a/influxdb/libmapstack.jinja b/influxdb/libmapstack.jinja
new file mode 100644
index 0000000..8f54ef3
--- /dev/null
+++ b/influxdb/libmapstack.jinja
@@ -0,0 +1,315 @@
+{#- -*- coding: utf-8 -*- #}
+{#- vim: ft=jinja #}
+
+{#- Get the `tplroot` from `tpldir` #}
+{%- set tplroot = tpldir.split("/")[0] %}
+{%- from tplroot ~ "/libmatchers.jinja" import parse_matchers, query_map with context %}
+
+{%- set _default_config_dirs = [
+      "parameters/",
+      tplroot ~ "/parameters"
+    ] %}
+
+{%- macro mapstack(
+      matchers,
+      defaults=None,
+      dirs=_default_config_dirs,
+      log_prefix="libmapstack: "
+    ) %}
+{#-
+    Load configuration in the order of `matchers` and merge
+    successively the values with `defaults`.
+
+    The `matchers` are processed using `libmatchers.jinja` to select
+    the configuration sources from where the values are loaded.
+
+    Parameters:
+
+      - `matchers`: list of matchers in the form
+        `[<TYPE>[:<OPTION>[:<DELIMITER>]]@]<QUERY>`
+
+      - `defaults`: dictionary of default values to start the merging,
+        they are considered built-ins. It must conform to the same
+        layout as the YAML files: a mandatory `values` key and two
+        optional `strategy` and `merge_lists` keys.
+
+      - `dirs`: list of directory where to look-up the configuration
+        file matching the matchers, by default a global `salt://parameters/`
+        and a per formula `salt://<tplroot>/parameters`
+
+      - `log_prefix`: prefix used in the log outputs, by default it is
+        `libmapstack: `
+
+    Example: On a Debian system with `roles=["nginx/server", "telegraf"]`
+
+      {%- set settings = mapstack(
+            matchers=[
+              "Y:G@os_family",
+              "I@" ~ tplroot,
+              "Y:C@roles",
+            ],
+            dirs=["defaults", tplroot ~ "/parameters"],
+          )
+          | load_yaml %}
+
+      This will merge the values:
+
+        - starting with the default empty dictionary `{}` (no
+          `defaults` parameter)
+
+        - from the YAML files
+
+          - `salt://defaults/os_family/Debian.yaml`
+
+          - `salt://{{ tplroot }}/parameters/os_family/Debian.yaml`
+
+        - from the pillar `salt["pillar.get"](tplroot)`
+
+        - from the `nginx/server` YAML files:
+
+          - `salt://defaults/roles/nginx/server.yaml`
+
+          - `salt://{{ tplroot }}/parameters/roles/nginx/server.yaml`
+
+        - from the `telegraf` YAML files:
+
+          - `salt://defaults/roles/telegraf.yaml`
+
+          - `salt://{{ tplroot }}/parameters/roles/telegraf.yaml`
+
+    Each YAML file and the `defaults` parameters must conform to the
+    following layout:
+
+      - a mandatory `values` key to store the configuration values
+
+      - two optional keys to configure the use of `salt.slsutil.merge`
+
+        - an optional `strategy` key to configure the merging
+          strategy, for example `strategy: 'recurse'`, the default is
+          `smart`
+
+        - an optional `merge_lists` key to configure if lists should
+          be merged or overridden for the `recurse` and `overwrite`
+          strategies, for example `merge_lists: 'true'`
+#}
+{%-   set stack = defaults | default({"values": {} }, boolean=True) %}
+
+{#-   Build configuration file names based on matchers #}
+{%-   set config_get_strategy = salt["config.get"](tplroot ~ ":strategy", None) %}
+{%-   set matchers = parse_matchers(
+        matchers,
+        config_get_strategy=config_get_strategy,
+        log_prefix=log_prefix
+      )
+      | load_yaml %}
+
+{%-   do salt["log.debug"](
+        log_prefix
+        ~ "built-in configuration:\n"
+        ~ {"values": defaults | traverse("values")}
+        | yaml(False)
+      ) %}
+
+{%-   for param_dir in dirs %}
+{%-     for matcher in matchers %}
+{#-       `slsutil.merge` options from #}
+{#-       1. the `value` #}
+{#-       2. the `defaults` #}
+{#-       3. the built-in #}
+{%-       set strategy = matcher.value
+          | traverse(
+            "strategy",
+            defaults
+            | traverse(
+              "strategy",
+              "smart"
+            )
+          ) %}
+{%-       set merge_lists = matcher.value
+          | traverse(
+            "merge_lists",
+            defaults
+            | traverse(
+              "merge_lists",
+              False
+            )
+          )
+          | to_bool %}
+
+{%-       if matcher.type in query_map.keys() %}
+{#-         No value is an empty list, must be a dict for `stack.update` #}
+{%-         set normalized_value = matcher.value | default({}, boolean=True) %}
+
+{#-         Merge in `mapdata.<query>` instead of directly in `mapdata` #}
+{%-         set is_sub_key = matcher.option | default(False) == "SUB" %}
+{%-         if is_sub_key %}
+{#-           Merge values with `mapdata.<key>`, `<key>` and `<key>:lookup` are merged together #}
+{%-           set value = { matcher.query | regex_replace(":lookup$", ""): normalized_value } %}
+{%-         else %}
+{%-           set value = normalized_value %}
+{%-         endif %}
+
+{%-         do salt["log.debug"](
+              log_prefix
+              ~ "merge "
+              ~ "sub key " * is_sub_key
+              ~ "'"
+              ~ matcher.query
+              ~ "' retrieved with '"
+              ~ matcher.query_method
+              ~ "', merge: strategy='"
+              ~ strategy
+              ~ "', lists='"
+              ~ merge_lists
+              ~ "':\n"
+              ~ value
+              | yaml(False)
+            ) %}
+
+{%-         do stack.update(
+              {
+                "values": salt["slsutil.merge"](
+                  stack["values"],
+                  value,
+                  strategy=strategy,
+                  merge_lists=merge_lists,
+                )
+              }
+            ) %}
+
+{%-       else %}
+{#-         Load YAML file matching the grain/pillar/... #}
+{#-         Fallback to use the source name as a direct filename #}
+
+{%-         if matcher.value is sequence and matcher.value | length == 0 %}
+{#-           Mangle `matcher.value` to use it as literal path #}
+{%-           set query_parts = matcher.query.split("/") %}
+{%-           set yaml_dirname = query_parts[0:-1] | join("/") %}
+{%-           set yaml_names = query_parts[-1] %}
+{%-         else %}
+{%-           set yaml_dirname = matcher.query %}
+{%-           set yaml_names = matcher.value %}
+{%-         endif %}
+
+{#-         Some configuration return list #}
+{%-         if yaml_names is string %}
+{%-           set yaml_names = [yaml_names] %}
+{%-         elif yaml_names is sequence %}
+{#-           Convert to strings if it's a sequence of numbers #}
+{%-           set yaml_names = yaml_names | map("string") | list %}
+{%-         else %}
+{%-           set yaml_names = [yaml_names | string] %}
+{%-         endif %}
+
+{#-         Try to load a `.yaml.jinja` file for each `.yaml` file #}
+{%-         set all_yaml_names = [] %}
+{%-         for name in yaml_names %}
+{%-           set extension = name.rpartition(".")[2] %}
+{%-           if extension not in ["yaml", "jinja"] %}
+{%-             do all_yaml_names.extend([name ~ ".yaml", name ~ ".yaml.jinja"]) %}
+{%-           elif extension == "yaml" %}
+{%-             do all_yaml_names.extend([name, name ~ ".jinja"]) %}
+{%-           else %}
+{%-             do all_yaml_names.append(name) %}
+{%-           endif %}
+{%-         endfor %}
+
+{#-         `yaml_dirname` can be an empty string with literal path like `myconf.yaml` #}
+{%-         set yaml_dir = [
+              param_dir,
+              yaml_dirname
+            ]
+            | select
+            | join("/") %}
+
+{%-         for yaml_name in all_yaml_names %}
+{%-           set yaml_filename = [
+                yaml_dir.rstrip("/"),
+                yaml_name
+              ]
+              | select
+              | join("/") %}
+
+{%-           do salt["log.debug"](
+                log_prefix
+                ~ "load configuration values from "
+                ~ yaml_filename
+              ) %}
+{%-           load_yaml as yaml_values %}
+{%-             include yaml_filename ignore missing %}
+{%-           endload %}
+
+{%-           if yaml_values %}
+{%-             do salt["log.debug"](
+                  log_prefix
+                  ~ "loaded configuration values from "
+                  ~ yaml_filename
+                  ~ ":\n"
+                  ~ yaml_values
+                  | yaml(False)
+                ) %}
+
+{#-             `slsutil.merge` options from #}
+{#-             1. the `value` #}
+{#-             2. the `defaults` #}
+{#-             3. the built-in #}
+{%-             set strategy = yaml_values
+                  | traverse(
+                    "strategy",
+                    defaults
+                    | traverse(
+                      "strategy",
+                      "smart"
+                    )
+                  ) %}
+{%-             set merge_lists = yaml_values
+                  | traverse(
+                    "merge_lists",
+                    defaults
+                    | traverse(
+                      "merge_lists",
+                      False
+                    )
+                  )
+                  | to_bool %}
+{%-             do stack.update(
+                  {
+                    "values": salt["slsutil.merge"](
+                      stack["values"],
+                      yaml_values
+                      | traverse("values", {}),
+                      strategy=strategy,
+                      merge_lists=merge_lists,
+                    )
+                  }
+                ) %}
+{%-             do salt["log.debug"](
+                  log_prefix
+                  ~ "merged configuration values from "
+                  ~ yaml_filename
+                  ~ ", merge: strategy='"
+                  ~ strategy
+                  ~ "', merge_lists='"
+                  ~ merge_lists
+                  ~ "':\n"
+                  ~ {"values": stack["values"]}
+                  | yaml(False)
+                ) %}
+{%-           endif %}
+{%-         endfor %}
+{%-       endif %}
+{%-     endfor %}
+{%-   endfor %}
+
+{%-   do salt["log.debug"](
+        log_prefix
+        ~ "final configuration values:\n"
+        ~ {"values": stack["values"]}
+        | yaml(False)
+      ) %}
+
+{#- Output stack as YAML, caller should use with something like #}
+{#- `{%- set config = mapstack(matchers=["foo"]) | load_yaml %}` #}
+{{ stack | yaml }}
+
+{%- endmacro %}
diff --git a/influxdb/libmatchers.jinja b/influxdb/libmatchers.jinja
new file mode 100644
index 0000000..10ff8bd
--- /dev/null
+++ b/influxdb/libmatchers.jinja
@@ -0,0 +1,222 @@
+{#- -*- coding: utf-8 -*- #}
+{#- vim: ft=jinja #}
+
+{#- Get the `tplroot` from `tpldir` #}
+{%- set tplroot = tpldir.split("/")[0] %}
+{%- from tplroot ~ "/libsaltcli.jinja" import cli with context %}
+
+{%- set query_map = {
+      "C": "config.get",
+      "G": "grains.get",
+      "I": "pillar.get",
+    } %}
+
+{#- When no part before `@` is provided: #}
+{#-   - define a YAML file path, noted `Y` #}
+{#-   - use `salt["config.get"]`, noted `C` #}
+{#-   - use colon `:` delimiter for querying #}
+{%- set _defaults = {
+      "type": "Y",
+      "query_type": "C",
+      "query_delimiter": ":"
+    } %}
+
+{%- macro parse_matchers(
+      matchers,
+      config_get_strategy=None,
+      log_prefix="libmatchers: "
+    ) %}
+{#-   matcher format is `[<TYPE>[:<OPTION>[:DELIMITER]]@]<KEY>` #}
+{#-   each matcher has a type: #}
+{#-   - `Y` to build a YAML file name (the default when no type is set) #}
+{#-   - `C` to lookup values with `config.get` #}
+{#-   - `G` to lookup values with `grains.get` #}
+{#-   - `I` to lookup values with `pillar.get` #}
+{#-   The `YAML` type option can define query type to build the file name: #}
+{#-   - `C` for query with `config.get` (the default when to query type is set) #}
+{#-   - `G` for query with `grains.get` #}
+{#-   - `I` for query with `pillar.get` #}
+{#-   With `DELIMITER`, you can choose a different delimiter when doing queries #}
+{%-   set parsed_matchers = [] %}
+{%-   for matcher in matchers %}
+{%-     do salt["log.debug"](
+          log_prefix
+          ~ "process matcher: '"
+          ~ matcher
+          ~ "'"
+        ) %}
+
+{%-     set parsed = {} %}
+{%-     set matcher_parts = matcher.split('@') %}
+{%-     if matcher_parts | length == 1 %}
+{#-       By default we load YAML files for config looked up by `config.get` #}
+{%-       do parsed.update(
+            {
+              "type": _defaults["type"],
+              "option": None,
+              "query_method": query_map[_defaults["query_type"]],
+              "query_delimiter": _defaults["query_delimiter"],
+              "query": matcher
+            }
+          ) %}
+{%-       do salt["log.debug"](
+            log_prefix
+            ~ "use built-in defaults for matcher:\n"
+            ~ parsed
+            | yaml(False)
+            | indent(4, True)
+          ) %}
+{%-     else %}
+{%-       do salt["log.debug"](
+            log_prefix
+            ~ "parse matcher: '"
+            ~ matcher
+            ~ "'"
+          ) %}
+{%-       set metadatas = matcher_parts[0].split(":") %}
+{%-       do parsed.update(
+            {
+              "query": matcher_parts[1]
+            }
+          ) %}
+{%-       if metadatas | length == 1 %}
+{%-         do parsed.update(
+              {
+                "type": metadatas[0],
+                "option": "C",
+                "query_delimiter": ":"
+              }
+            ) %}
+{%-         do salt["log.debug"](
+              log_prefix
+              ~ "parse as 1 metadata matcher:\n"
+              ~ parsed
+              | yaml(False)
+              | indent(4, True)
+            ) %}
+{%-       elif metadatas | length == 2 %}
+{%-         do parsed.update(
+              {
+                "type": metadatas[0],
+                "option": metadatas[1],
+                "query_delimiter": ":"
+              }
+            ) %}
+{%-         do salt["log.debug"](
+              log_prefix
+              ~ "parse as 2 metadata matcher:\n"
+              ~ parsed
+              | yaml(False)
+              | indent(4, True)
+            ) %}
+{%-       elif metadatas | length == 3 %}
+{%-         do parsed.update(
+              {
+                "type": metadatas[0],
+                "option": metadatas[1],
+                "query_delimiter": metadatas[2] | default(":", boolean=True)
+              }
+            ) %}
+{%-         do salt["log.debug"](
+              log_prefix
+              ~ "parse as 3 metadata matcher:\n"
+              ~ parsed
+              | yaml(False)
+              | indent(4, True)
+            ) %}
+{%-       elif metadatas | length == 4 %}
+{#-         The delimiter is `:` #}
+{%-         do parsed.update(
+              {
+                "type": metadatas[0],
+                "option": metadatas[1],
+                "query_delimiter": ":"
+              }
+            ) %}
+{%-         do salt["log.debug"](
+              log_prefix
+              ~ "parse as 4 metadata matcher:\n"
+              ~ parsed
+              | yaml(False)
+              | indent(4, True)
+            ) %}
+{%-       endif %}
+{%-     endif %}
+
+{#-     The `<OPTION>` has different meaning based on type #}
+{%-     if query_map.get(parsed.type, False) %}
+{%-       do parsed.update(
+            {
+              "query_method": query_map[parsed.type]
+            }
+          ) %}
+{%-     else %}
+{%-       do parsed.update(
+            {
+              "query_method": query_map[
+                parsed.option
+                | default("C", boolean=True)
+              ]
+            }
+          ) %}
+{%-     endif %}
+
+{#-     Add `merge:` option to `salt["config.get"]` if configured #}
+{%-     if cli not in ["ssh", "unknown"] and parsed.query_method == "config.get" and config_get_strategy %}
+{%-       set query_opts = {
+            "merge": config_get_strategy,
+            "delimiter": parsed.query_delimiter,
+          } %}
+{%-       set query_opts_msg = (
+            ", delimiter='"
+            ~ parsed.query_delimiter
+            ~ "', merge: strategy='"
+            ~ config_get_strategy
+            ~ "'"
+          ) %}
+{%-     else %}
+{%-       if cli in ["ssh", "unknown"] %}
+{%-         do salt["log.warning"](
+              log_prefix
+              ~ "the 'delimiter' and 'merge' options of 'config.get' are skipped when the salt command type is '"
+              ~ cli
+              ~ "'"
+            ) %}
+{%-       endif %}
+{%-       set query_opts = {} %}
+{%-       set query_opts_msg = "" %}
+{%-     endif %}
+
+{%-     do salt["log.debug"](
+          log_prefix
+          ~ "lookup '"
+          ~ parsed.query
+          ~ "' with '"
+          ~ parsed.query_method
+          ~ "'"
+          ~ query_opts_msg
+        ) %}
+{%-     set values = salt[parsed.query_method](
+          parsed.query,
+          default=[],
+          **query_opts
+        ) %}
+{%-     do parsed.update(
+          {
+            "value": values
+          }
+        ) %}
+
+{%-     do parsed_matchers.append(parsed) %}
+
+{%-   endfor %}
+{%-   do salt["log.debug"](
+        log_prefix
+        ~ "parsed matchers:\n"
+        ~ parsed_matchers
+        | yaml(False)
+        | indent(4, True)
+      ) %}
+
+{{ parsed_matchers | yaml }}
+{%- endmacro %}
diff --git a/influxdb/libsaltcli.jinja b/influxdb/libsaltcli.jinja
new file mode 100644
index 0000000..c473723
--- /dev/null
+++ b/influxdb/libsaltcli.jinja
@@ -0,0 +1,18 @@
+{#- -*- 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' %}
+{%- elif opts_cli %}
+{%-   set cli = 'api' %}
+{%- else %}
+{%-   set cli = 'unknown' %}
+{%- endif %}
+{%- do salt['log.debug']('[libsaltcli] the salt command type has been identified to be: ' ~ cli) %}
diff --git a/influxdb/libtofs.jinja b/influxdb/libtofs.jinja
new file mode 100644
index 0000000..f39fd42
--- /dev/null
+++ b/influxdb/libtofs.jinja
@@ -0,0 +1,115 @@
+{%- macro files_switch(
+      source_files,
+      lookup=None,
+      default_files_switch=["id", "os_family"],
+      indent_width=6,
+      use_subpath=False
+    ) %}
+{#-
+    Returns a valid value for the "source" parameter of a "file.managed"
+    state function. This makes easier the usage of the Template Override and
+    Files Switch (TOFS) pattern.
+    Params:
+      * source_files: ordered list of files to look for
+      * lookup: key under "<tplroot>:tofs:source_files" to prepend to the
+        list of source files
+      * default_files_switch: if there's no config (e.g. pillar)
+        "<tplroot>:tofs:files_switch" this is the ordered list of grains to
+        use as selector switch of the directories under
+        "<path_prefix>/files"
+      * indent_width: indentation of the result value to conform to YAML
+      * use_subpath: defaults to `False` but if set, lookup the source file
+        recursively from the current state directory up to `tplroot`
+    Example (based on a `tplroot` of `xxx`):
+    If we have a state:
+      Deploy configuration:
+        file.managed:
+          - name: /etc/yyy/zzz.conf
+          - source: {{ files_switch(
+                         ["/etc/yyy/zzz.conf", "/etc/yyy/zzz.conf.jinja"],
+                         lookup="Deploy configuration",
+                       ) }}
+          - template: jinja
+    In a minion with id=theminion and os_family=RedHat, it's going to be
+    rendered as:
+      Deploy configuration:
+        file.managed:
+          - name: /etc/yyy/zzz.conf
+          - source:
+            - salt://xxx/files/theminion/etc/yyy/zzz.conf
+            - salt://xxx/files/theminion/etc/yyy/zzz.conf.jinja
+            - salt://xxx/files/RedHat/etc/yyy/zzz.conf
+            - salt://xxx/files/RedHat/etc/yyy/zzz.conf.jinja
+            - salt://xxx/files/default/etc/yyy/zzz.conf
+            - salt://xxx/files/default/etc/yyy/zzz.conf.jinja
+          - template: jinja
+#}
+{#-   Get the `tplroot` from `tpldir` #}
+{%-   set tplroot = tpldir.split("/")[0] %}
+{%-   set path_prefix = salt["config.get"](tplroot ~ ":tofs:path_prefix", tplroot) %}
+{%-   set files_dir = salt["config.get"](tplroot ~ ":tofs:dirs:files", "files") %}
+{%-   set files_switch_list = salt["config.get"](
+        tplroot ~ ":tofs:files_switch", default_files_switch
+      ) %}
+{#-   Lookup source_files (v2), files (v1), or fallback to an empty list #}
+{%-   set src_files = salt["config.get"](
+        tplroot ~ ":tofs:source_files:" ~ lookup,
+        salt["config.get"](tplroot ~ ":tofs:files:" ~ lookup, []),
+      ) %}
+{#-   Append the default source_files #}
+{%-   set src_files = src_files + source_files %}
+{#-   Only add to [""] when supporting older TOFS implementations #}
+{%-   set path_prefix_exts = [""] %}
+{%-   if use_subpath and tplroot != tpldir %}
+{#-     Walk directory tree to find {{ files_dir }} #}
+{%-     set subpath_parts = tpldir.lstrip(tplroot).lstrip("/").split("/") %}
+{%-     for path in subpath_parts %}
+{%-       set subpath = subpath_parts[0 : loop.index] | join("/") %}
+{%-       do path_prefix_exts.append("/" ~ subpath) %}
+{%-     endfor %}
+{%-   endif %}
+{%-   for path_prefix_ext in path_prefix_exts | reverse %}
+{%-     set path_prefix_inc_ext = path_prefix ~ path_prefix_ext %}
+{#-     For older TOFS implementation, use `files_switch` from the config #}
+{#-     Use the default, new method otherwise #}
+{%-     set fsl = salt["config.get"](
+          tplroot ~ path_prefix_ext | replace("/", ":") ~ ":files_switch",
+          files_switch_list,
+        ) %}
+{#-     Append an empty value to evaluate as `default` in the loop below #}
+{%-     if "" not in fsl %}
+{%-       set fsl = fsl + [""] %}
+{%-     endif %}
+{%-     for fs in fsl %}
+{%-       for src_file in src_files %}
+{%-         if fs %}
+{%-           set fs_dirs = salt["config.get"](fs, fs) %}
+{%-         else %}
+{%-           set fs_dirs = salt["config.get"](
+                tplroot ~ ":tofs:dirs:default", "default"
+              ) %}
+{%-         endif %}
+{#-         Force the `config.get` lookup result as a list where necessary #}
+{#-         since we need to also handle grains that are lists #}
+{%-         if fs_dirs is string %}
+{%-           set fs_dirs = [fs_dirs] %}
+{%-         endif %}
+{%-         for fs_dir in fs_dirs %}
+{#-           strip empty elements by using a select #}
+{%-           set url = (
+                [
+                  "- salt:/",
+                  path_prefix_inc_ext.strip("/"),
+                  files_dir.strip("/"),
+                  fs_dir.strip("/"),
+                  src_file.strip("/"),
+                ]
+                | select
+                | join("/")
+              ) %}
+{{ url | indent(indent_width, true) }}
+{%-         endfor %}
+{%-       endfor %}
+{%-     endfor %}
+{%-   endfor %}
+{%- endmacro %}
diff --git a/influxdb/macros.jinja b/influxdb/macros.jinja
new file mode 100644
index 0000000..aeeb852
--- /dev/null
+++ b/influxdb/macros.jinja
@@ -0,0 +1,12 @@
+# -*- coding: utf-8 -*-
+# vim: ft=jinja
+#
+# Collection of common macros
+
+{%- macro format_kwargs(kwarg) -%}
+  {%- filter indent(4) %}
+    {%- for k, v in kwarg|dictsort() %}
+- {{ k }}: {{ v }}
+    {%- endfor %}
+  {%- endfilter %}
+{%- endmacro %}
diff --git a/influxdb/map.jinja b/influxdb/map.jinja
index 32b4bae..cc25c18 100644
--- a/influxdb/map.jinja
+++ b/influxdb/map.jinja
@@ -1,44 +1,66 @@
-{% import_yaml "influxdb/defaults.yaml" as defaults %}
-{% import_yaml "influxdb/config_defaults.yaml" as config_defaults %}
-
-{#-
-Setup variable using grains['os_family'] based logic, only add key:values here
-that differ from whats in defaults.yaml
-#}
-
-{% set os_family_map = salt['grains.filter_by']({
-   'Debian': {},
-   'RedHat': {},
-   'Suse': {},
-  },
-  grain="os_family",
-  merge=salt['pillar.get']('influxdb:lookup'))
-%}
-
-{#-
-Use configuration defaults appropriate for the version of InfluxDB that is being
-installed unless the user explicitly requested to not use any default values in
-which case normal pillar merging behaviour will be used.
-
-The formula supports different configuration file formats for each MAJOR.MINOR
-version of InfluxDB and will provide the configuration that ships with the
-latest release off that branch.
-#}
-
-{% if not salt['pillar.get']('influxdb:no_conf_defaults', False) %}
-{% set influxdb_version = salt['pillar.get']('influxdb:version') %}
-{% set major, minor = influxdb_version.split('.')[:2] %}
-{% do defaults.influxdb.conf.update(config_defaults.get(major).get(minor)) %}
-{% endif %}
-
-{#- Merge the os_family_map into default settings #}
-{% do defaults.influxdb.update(os_family_map) %}
-
-{# Update settings defaults from pillar data #}
-{% set influxdb_settings = salt['pillar.get'](
-    'influxdb',
-    default=defaults.influxdb,
-    merge=True)
-%}
-
-# vi: set ft=sls :
+{#- -*- coding: utf-8 -*- #}
+{#- vim: ft=jinja #}
+
+{#- Get the `tplroot` from `tpldir` #}
+{%- set tplroot = tpldir.split("/")[0] %}
+{%- from tplroot ~ "/libmapstack.jinja" import mapstack with context %}
+
+{#- Where to lookup parameters source files #}
+{%- set formula_param_dir = tplroot ~ "/parameters" %}
+
+{#- List of sources to lookup for parameters #}
+{#- Fallback to previously used grains plus minion `id` #}
+{%- set map_sources = [
+      "Y:G@osarch",
+      "Y:G@os_family",
+      "Y:G@os",
+      "Y:G@osfinger",
+      "C@" ~ tplroot ~ ":lookup",
+      "C@" ~ tplroot,
+      "Y:G@id",
+    ] %}
+
+{%- set _map_settings = mapstack(
+      matchers=["map_jinja.yaml"],
+      defaults={
+        "values": {"sources": map_sources}
+      },
+      log_prefix="map.jinja configuration: ",
+    )
+    | load_yaml %}
+
+{%- set map_sources = _map_settings | traverse("values:sources") %}
+{%- do salt["log.debug"](
+      "map.jinja: load parameters from sources:\n"
+      ~ map_sources
+      | yaml(False)
+    ) %}
+
+{#- Load formula parameters values #}
+{%- set _formula_matchers = ["defaults.yaml"] + map_sources %}
+
+{%- set _formula_settings = mapstack(
+      matchers=_formula_matchers,
+      dirs=[formula_param_dir],
+      defaults={
+        "values": {},
+        "merge_strategy": salt["config.get"](tplroot ~ ":strategy", None),
+        "merge_lists": salt["config.get"](tplroot ~ ":merge_lists", False),
+      },
+      log_prefix="map.jinja: ",
+    )
+    | load_yaml %}
+
+{#- Make sure to track `map.jinja` configuration with `_mapdata` #}
+{%- do _formula_settings["values"].update(
+      {
+        "map_jinja": _map_settings["values"]
+      }
+    ) %}
+
+{%- do salt["log.debug"]("map.jinja: save parameters in variable 'mapdata'") %}
+{%- set mapdata = _formula_settings["values"] %}
+
+{#- Per formula post-processing of `mapdata` if it exists #}
+{%- do salt["log.debug"]("map.jinja: post-processing of 'mapdata'") %}
+{%- include tplroot ~ "/post-map.jinja" ignore missing %}
diff --git a/influxdb/package/clean.sls b/influxdb/package/clean.sls
new file mode 100644
index 0000000..f112950
--- /dev/null
+++ b/influxdb/package/clean.sls
@@ -0,0 +1,15 @@
+# -*- coding: utf-8 -*-
+# vim: ft=sls
+
+{#- Get the `tplroot` from `tpldir` #}
+{%- set tplroot = tpldir.split('/')[0] %}
+{%- set sls_config_clean = tplroot ~ '.config.clean' %}
+{%- from tplroot ~ "/map.jinja" import mapdata as influxdb with context %}
+include:
+  - {{ sls_config_clean }}
+influxdb-package-clean-pkg-removed:
+  pkg.removed:
+    - name: {{ influxdb.pkg.name }}
+    - require:
+      - sls: {{ sls_config_clean }}
+
diff --git a/influxdb/package/init.sls b/influxdb/package/init.sls
new file mode 100644
index 0000000..d3e5518
--- /dev/null
+++ b/influxdb/package/init.sls
@@ -0,0 +1,5 @@
+# -*- coding: utf-8 -*-
+# vim: ft=sls
+
+include:
+  - .install
diff --git a/influxdb/package/install.sls b/influxdb/package/install.sls
new file mode 100644
index 0000000..a8c3d52
--- /dev/null
+++ b/influxdb/package/install.sls
@@ -0,0 +1,30 @@
+# -*- coding: utf-8 -*-
+# vim: ft=sls
+
+{#- Get the `tplroot` from `tpldir` #}
+{%- set tplroot = tpldir.split('/')[0] %}
+{%- set sls_repo_install = tplroot ~ '.repo.install' %}
+{%- set sls_dependencies_install = tplroot ~ '.dependencies.install' %}
+{%- from tplroot ~ "/map.jinja" import mapdata as influxdb with context %}
+
+include:
+  - {{ sls_repo_install }}
+
+influxdb/package/install:
+  pkg.installed:
+    - name: {{ influxdb.pkg.name }}
+    - require:
+      - sls: {{ sls_repo_install }}
+      {% if influxdb.pkg.dependencies is defined %}
+      - sls: {{ sls_dependencies_install }}
+      {% endif %}
+
+
+{% if grains['pythonexecutable'].startswith('/opt/saltstack/') %}
+
+influxdb/package/install/pip/toml:
+  pip.installed:
+    - name: {{ influxdb.toml_module }}
+
+{% endif %}
+
diff --git a/influxdb/parameters/defaults.yaml b/influxdb/parameters/defaults.yaml
new file mode 100644
index 0000000..155d832
--- /dev/null
+++ b/influxdb/parameters/defaults.yaml
@@ -0,0 +1,19 @@
+# -*- coding: utf-8 -*-
+# vim: ft=yaml
+#
+# Set default values.
+---
+values:
+  config: /etc/influxdb/config.toml
+  system_user: influxdb
+  system_group: influxdb
+  toml_module: toml
+  pip_pkg: python3-pip
+  pkg:
+    name: influxdb2
+  service:
+    name: influxdb
+  conf:
+    bolt-path: /var/lib/influxdb/influxd.bolt
+    engine-path: /var/lib/influxdb/engine
+...
diff --git a/influxdb/parameters/os_family/Debian.yaml b/influxdb/parameters/os_family/Debian.yaml
new file mode 100644
index 0000000..f3289d5
--- /dev/null
+++ b/influxdb/parameters/os_family/Debian.yaml
@@ -0,0 +1,25 @@
+# -*- coding: utf-8 -*-
+# vim: ft=yaml
+#
+# Set values specific to:
+#   salt['config.get']('os_family') == Debian.
+#
+# You just need to add the key:values for this `os_family` that differ
+# from `defaults.yaml` + `<osarch>.yaml`.
+#
+# If you do not need to provide defaults via the `os_family` config,
+# you can remove this file or provide at least an empty dict, e.g.
+# values: {}
+---
+values:
+  repo:
+    humanname: influxdb repo
+    name: deb https://repos.influxdata.com/debian {{ grains['oscodename'] }} stable
+    file: /etc/apt/sources.list.d/influxdata.list
+    key_url: https://repos.influxdata.com/influxdata-archive.key
+  pkg:
+    dependencies:
+      - gpg
+      - python3-toml
+
+...
diff --git a/influxdb/parameters/os_family/RedHat.yaml b/influxdb/parameters/os_family/RedHat.yaml
new file mode 100644
index 0000000..aefaf74
--- /dev/null
+++ b/influxdb/parameters/os_family/RedHat.yaml
@@ -0,0 +1,25 @@
+# -*- coding: utf-8 -*-
+# vim: ft=yaml
+#
+# Set values specific to:
+#   salt['config.get']('os_family') == RedHat.
+#
+# You just need to add the key:values for this `os_family` that differ
+# from `defaults.yaml` + `<osarch>.yaml`.
+#
+# If you do not need to provide defaults via the `os_family` config,
+# you can remove this file or provide at least an empty dict, e.g.
+# values: {}
+---
+values:
+  repo:
+    humanname: influxdb repo
+    name: influxdb
+    enabled: true
+    gpgcheck: 1
+    baseurl: https://repos.influxdata.com/rhel/$releasever/$basearch/stable/
+    gpgkey: https://repos.influxdata.com/influxdata-archive.key
+  pkg:
+    dependencies:
+      - python3-pytoml
+...
diff --git a/influxdb/parameters/os_family/Suse.yaml b/influxdb/parameters/os_family/Suse.yaml
new file mode 100644
index 0000000..e846a7f
--- /dev/null
+++ b/influxdb/parameters/os_family/Suse.yaml
@@ -0,0 +1,22 @@
+# -*- coding: utf-8 -*-
+# vim: ft=yaml
+#
+# Set values specific to:
+#   salt['config.get']('os_family') == Suse.
+#
+# You just need to add the key:values for this `os_family` that differ
+# from `defaults.yaml` + `<osarch>.yaml`.
+#
+# If you do not need to provide defaults via the `os_family` config,
+# you can remove this file or provide at least an empty dict, e.g.
+# values: {}
+---
+values:
+  repo:
+    humanname: influxdb repo
+    name: influxdb
+    enabled: 1
+    gpgautoimport: true
+    # yamllint disable-line rule:line-length
+    baseurl: https://download.opensuse.org/repositories/Cloud:/OpenStack:/Master/openSUSE_Leap_$releasever
+...
diff --git a/influxdb/parameters/osarch/386.yaml b/influxdb/parameters/osarch/386.yaml
new file mode 100644
index 0000000..ccf033a
--- /dev/null
+++ b/influxdb/parameters/osarch/386.yaml
@@ -0,0 +1,16 @@
+# -*- coding: utf-8 -*-
+# vim: ft=yaml
+#
+# Set values specific to:
+#   salt['config.get']('osarch') == 386.
+#
+# You just need to add the key:values for this `osarch` that differ
+# from `defaults.yaml`.
+#
+# If you do not need to provide defaults via the `osarch` config,
+# you can remove this file or provide at least an empty dict, e.g.
+# values: {}
+---
+values:
+  arch: 386
+...
diff --git a/influxdb/parameters/osarch/amd64.yaml b/influxdb/parameters/osarch/amd64.yaml
new file mode 100644
index 0000000..aefa6f1
--- /dev/null
+++ b/influxdb/parameters/osarch/amd64.yaml
@@ -0,0 +1,16 @@
+# -*- coding: utf-8 -*-
+# vim: ft=yaml
+#
+# Set values specific to:
+#   salt['config.get']('osarch') == amd64.
+#
+# You just need to add the key:values for this `osarch` that differ
+# from `defaults.yaml`.
+#
+# If you do not need to provide defaults via the `osarch` config,
+# you can remove this file or provide at least an empty dict, e.g.
+# values: {}
+---
+values:
+  arch: amd64
+...
diff --git a/influxdb/parameters/osarch/arm64.yaml b/influxdb/parameters/osarch/arm64.yaml
new file mode 100644
index 0000000..d9c1787
--- /dev/null
+++ b/influxdb/parameters/osarch/arm64.yaml
@@ -0,0 +1,16 @@
+# -*- coding: utf-8 -*-
+# vim: ft=yaml
+#
+# Set values specific to:
+#   salt['config.get']('osarch') == arm64.
+#
+# You just need to add the key:values for this `osarch` that differ
+# from `defaults.yaml`.
+#
+# If you do not need to provide defaults via the `osarch` config,
+# you can remove this file or provide at least an empty dict, e.g.
+# values: {}
+---
+values:
+  arch: arm64
+...
diff --git a/influxdb/parameters/osarch/armv6l.yaml b/influxdb/parameters/osarch/armv6l.yaml
new file mode 100644
index 0000000..87791df
--- /dev/null
+++ b/influxdb/parameters/osarch/armv6l.yaml
@@ -0,0 +1,16 @@
+# -*- coding: utf-8 -*-
+# vim: ft=yaml
+#
+# Set values specific to:
+#   salt['config.get']('osarch') == armv6l.
+#
+# You just need to add the key:values for this `osarch` that differ
+# from `defaults.yaml`.
+#
+# If you do not need to provide defaults via the `osarch` config,
+# you can remove this file or provide at least an empty dict, e.g.
+# values: {}
+---
+values:
+  arch: armv6l
+...
diff --git a/influxdb/parameters/osarch/armv7l.yaml b/influxdb/parameters/osarch/armv7l.yaml
new file mode 100644
index 0000000..3d2fac7
--- /dev/null
+++ b/influxdb/parameters/osarch/armv7l.yaml
@@ -0,0 +1,16 @@
+# -*- coding: utf-8 -*-
+# vim: ft=yaml
+#
+# Set values specific to:
+#   salt['config.get']('osarch') == armv7l.
+#
+# You just need to add the key:values for this `osarch` that differ
+# from `defaults.yaml`.
+#
+# If you do not need to provide defaults via the `osarch` config,
+# you can remove this file or provide at least an empty dict, e.g.
+# values: {}
+---
+values:
+  arch: armv7l
+...
diff --git a/influxdb/parameters/osarch/ppc64le.yaml b/influxdb/parameters/osarch/ppc64le.yaml
new file mode 100644
index 0000000..3673997
--- /dev/null
+++ b/influxdb/parameters/osarch/ppc64le.yaml
@@ -0,0 +1,16 @@
+# -*- coding: utf-8 -*-
+# vim: ft=yaml
+#
+# Set values specific to:
+#   salt['config.get']('osarch') == ppc64le.
+#
+# You just need to add the key:values for this `osarch` that differ
+# from `defaults.yaml`.
+#
+# If you do not need to provide defaults via the `osarch` config,
+# you can remove this file or provide at least an empty dict, e.g.
+# values: {}
+---
+values:
+  arch: ppc64le
+...
diff --git a/influxdb/parameters/osarch/s390x.yaml b/influxdb/parameters/osarch/s390x.yaml
new file mode 100644
index 0000000..a4eba53
--- /dev/null
+++ b/influxdb/parameters/osarch/s390x.yaml
@@ -0,0 +1,16 @@
+# -*- coding: utf-8 -*-
+# vim: ft=yaml
+#
+# Set values specific to:
+#   salt['config.get']('osarch') == s390x.
+#
+# You just need to add the key:values for this `osarch` that differ
+# from `defaults.yaml`.
+#
+# If you do not need to provide defaults via the `osarch` config,
+# you can remove this file or provide at least an empty dict, e.g.
+# values: {}
+---
+values:
+  arch: s390x
+...
diff --git a/influxdb/parameters/osarch/x86_64.yaml b/influxdb/parameters/osarch/x86_64.yaml
new file mode 100644
index 0000000..dc08cc9
--- /dev/null
+++ b/influxdb/parameters/osarch/x86_64.yaml
@@ -0,0 +1,16 @@
+# -*- coding: utf-8 -*-
+# vim: ft=yaml
+#
+# Set values specific to:
+#   salt['config.get']('osarch') == x86_64.
+#
+# You just need to add the key:values for this `osarch` that differ
+# from `defaults.yaml`.
+#
+# If you do not need to provide defaults via the `osarch` config,
+# you can remove this file or provide at least an empty dict, e.g.
+# values: {}
+---
+values:
+  arch: amd64
+...
diff --git a/influxdb/parameters/osfinger/CentOS-7.yaml b/influxdb/parameters/osfinger/CentOS-7.yaml
new file mode 100644
index 0000000..7c42cba
--- /dev/null
+++ b/influxdb/parameters/osfinger/CentOS-7.yaml
@@ -0,0 +1,17 @@
+# -*- coding: utf-8 -*-
+# vim: ft=yaml
+#
+# Set values specific to:
+#   salt['config.get']('os_family') == RedHat.
+#
+# You just need to add the key:values for this `os_family` that differ
+# from `defaults.yaml` + `<osarch>.yaml`.
+#
+# If you do not need to provide defaults via the `os_family` config,
+# you can remove this file or provide at least an empty dict, e.g.
+# values: {}
+---
+values:
+  repo:
+    gpgkey: https://repos.influxdata.com/influxdata-archive_compat.key
+...
diff --git a/influxdb/repo/clean.sls b/influxdb/repo/clean.sls
new file mode 100644
index 0000000..450d00b
--- /dev/null
+++ b/influxdb/repo/clean.sls
@@ -0,0 +1,12 @@
+# -*- coding: utf-8 -*-
+# vim: ft=sls
+
+{#- Get the `tplroot` from `tpldir` #}
+{%- set tplroot = tpldir.split('/')[0] %}
+
+{%- from tplroot ~ "/map.jinja" import mapdata as influxdb with context %}
+{%- from tplroot ~ "/macros.jinja" import format_kwargs with context %}
+
+influxdb-repo-clean-remove-repo:
+  pkgrepo.absent:
+    {{- format_kwargs(influxdb.repo) }}
diff --git a/influxdb/repo/init.sls b/influxdb/repo/init.sls
new file mode 100644
index 0000000..d3e5518
--- /dev/null
+++ b/influxdb/repo/init.sls
@@ -0,0 +1,5 @@
+# -*- coding: utf-8 -*-
+# vim: ft=sls
+
+include:
+  - .install
diff --git a/influxdb/repo/install.sls b/influxdb/repo/install.sls
new file mode 100644
index 0000000..10ffa36
--- /dev/null
+++ b/influxdb/repo/install.sls
@@ -0,0 +1,12 @@
+# -*- coding: utf-8 -*-
+# vim: ft=sls
+
+{#- Get the `tplroot` from `tpldir` #}
+{%- set tplroot = tpldir.split('/')[0] %}
+
+{%- from tplroot ~ "/map.jinja" import mapdata as influxdb with context %}
+{%- from tplroot ~ "/macros.jinja" import format_kwargs with context %}
+
+influxdb/repo/install:
+  pkgrepo.managed:
+    {{- format_kwargs(influxdb.repo) }}
diff --git a/influxdb/service/clean.sls b/influxdb/service/clean.sls
new file mode 100644
index 0000000..164020e
--- /dev/null
+++ b/influxdb/service/clean.sls
@@ -0,0 +1,10 @@
+# -*- coding: utf-8 -*-
+# vim: ft=sls
+
+{#- Get the `tplroot` from `tpldir` #}
+{%- set tplroot = tpldir.split('/')[0] %}
+{%- from tplroot ~ "/map.jinja" import mapdata as influxdb with context %}
+influxdb-service-clean-service-dead:
+  service.dead:
+    - name: {{ influxdb.service.name }}
+    - enable: False
diff --git a/influxdb/service/init.sls b/influxdb/service/init.sls
new file mode 100644
index 0000000..6fe4d1a
--- /dev/null
+++ b/influxdb/service/init.sls
@@ -0,0 +1,5 @@
+# -*- coding: utf-8 -*-
+# vim: ft=sls
+
+include:
+  - .running
diff --git a/influxdb/service/running.sls b/influxdb/service/running.sls
new file mode 100644
index 0000000..532ff23
--- /dev/null
+++ b/influxdb/service/running.sls
@@ -0,0 +1,19 @@
+# -*- coding: utf-8 -*-
+# vim: ft=sls
+
+{#- Get the `tplroot` from `tpldir` #}
+{%- set tplroot = tpldir.split('/')[0] %}
+{%- set sls_config_file = tplroot ~ '.config.file' %}
+{%- from tplroot ~ "/map.jinja" import mapdata as influxdb with context %}
+
+include:
+  - {{ sls_config_file }}
+
+influxdb/service/running:
+  service.running:
+    - name: {{ influxdb.service.name }}
+    - enable: True
+    - require:
+      - sls: {{ sls_config_file }}
+    - watch:
+      - sls: {{ sls_config_file }}
diff --git a/pillar.example b/pillar.example
index 0a2c425..44b6e13 100644
--- a/pillar.example
+++ b/pillar.example
@@ -2,89 +2,19 @@
 # vim: ft=yaml
 ---
 influxdb:
-  version: 0.12.0
-  no_conf_defaults: false
-  use_wget_on_install: true
-  logging:
-    directory: '/var/log/influxdb'
-    file: 'influxd.log'
+  config: /etc/influxdb/config.toml
+  system_user: influxdb
+  system_group: influxdb
+  toml_module: toml
+  pip_pkg: python3-pip
+  pkg:
+    name: influxdb2
+  service:
+    name: influxdb
+  # config options found in the influxdb docs
   conf:
-    admin:
-      bind-address: ':8083'
-      enabled: true
-      https-certificate: /etc/ssl/influxdb.pem
-      https-enabled: false
-    cluster: {}
-    collectd:
-      enabled: false
-    continuous_queries:
-      compute-no-more-than: 2m
-      compute-runs-per-interval: 10
-      enabled: true
-      log-enabled: true
-      recompute-no-older-than: 10m
-      recompute-previous-n: 2
-    data:
-      dir: /var/lib/influxdb/data
-      wal-dir: /var/lib/influxdb/wal
-      wal-logging-enabled: true
-    graphite:
-      - enabled: false
-    hinted-handoff:
-      dir: /var/lib/influxdb/hh
-      enabled: true
-      max-age: 168h
-      max-size: 1073741824
-      purge-interval: 1h
-      retry-interval: 1s
-      retry-max-interval: 1m
-      retry-rate-limit: 0
-    http:
-      auth-enabled: false
-      bind-address: ':8086'
-      enabled: true
-      https-certificate: /etc/ssl/influxdb.pem
-      https-enabled: false
-      log-enabled: true
-      pprof-enabled: false
-      write-tracing: false
-    meta:
-      bind-address: ':8088'
-      cluster-tracing: false
-      commit-timeout: 50ms
-      dir: /var/lib/influxdb/meta
-      election-timeout: 1s
-      heartbeat-timeout: 1s
-      hostname: localhost
-      leader-lease-timeout: 500ms
-      raft-promotion-enabled: true
-      retention-autocreate: true
-    monitor: {}
-    opentsdb:
-      enabled: false
-    registration: {}
-    reporting-disabled: true
-    retention:
-      check-interval: 30m
-      enabled: true
-    shard-precreation:
-      advance-period: 30m
-      check-interval: 10m
-      enabled: true
-    udp:
-      - enabled: false
-  lookup:
-    config: '/etc/influxdb/config.toml'
-    etc_default: '/etc/default/influxdb'
-    fullname: 'InfluxDB Service User'
-    home: '/opt/influxdb'
-    logrotate_conf: '/etc/logrotate.d/influxdb'
-    shell: '/bin/false'
-    system_group: 'influxdb'
-    system_user: 'influxdb'
+    http-bind-address: ':8086'
+    log-level: 'info'
   tmpl:
     config: 'salt://influxdb/files/influxdb.config.jinja'
     etc_default: 'salt://influxdb/files/influxdb.etc_default'
-    logrotate: 'salt://influxdb/files/logrotate.conf.jinja'
-
-# vi: set ft=yaml :
diff --git a/test/integration/default/controls/config_spec.rb b/test/integration/default/controls/config_spec.rb
index 6175767..cdacbce 100644
--- a/test/integration/default/controls/config_spec.rb
+++ b/test/integration/default/controls/config_spec.rb
@@ -3,9 +3,9 @@
 control 'InfluxDB configuration' do
   title 'should match desired lines'
 
-  describe file('/etc/influxdb/influxdb.conf') do
+  describe file('/etc/influxdb/config.toml') do
     # Default config
-    its('content') { should include '[admin]' }
-    its('content') { should include 'bind-address = ":8083"' }
+    its('content') { should include 'File managed by Salt at' }
+    its('content') { should include 'bolt-path = "/var/lib/influxdb/influxd.bolt"' }
   end
 end
diff --git a/test/integration/default/controls/package_spec.rb b/test/integration/default/controls/package_spec.rb
index e492a21..d3886b6 100644
--- a/test/integration/default/controls/package_spec.rb
+++ b/test/integration/default/controls/package_spec.rb
@@ -3,7 +3,7 @@
 control 'InfluxDB package' do
   title 'should be installed'
 
-  describe package('influxdb') do
+  describe package('influxdb2') do
     it { should be_installed }
   end
 end
diff --git a/test/salt/pillar/influxdb.sls b/test/salt/pillar/influxdb.sls
index dfca0aa..1780466 100644
--- a/test/salt/pillar/influxdb.sls
+++ b/test/salt/pillar/influxdb.sls
@@ -1,88 +1,5 @@
-# -*- coding: utf-8 -*-
 # vim: ft=yaml
 ---
 influxdb:
-  version: 0.12.0
-  no_conf_defaults: false
-  use_wget_on_install: true
-  logging:
-    directory: '/var/log/influxdb'
-    file: 'influxd.log'
   conf:
-    admin:
-      bind-address: ':8083'
-      enabled: true
-      https-certificate: /etc/ssl/influxdb.pem
-      https-enabled: false
-    cluster: {}
-    collectd:
-      enabled: false
-    continuous_queries:
-      compute-no-more-than: 2m
-      compute-runs-per-interval: 10
-      enabled: true
-      log-enabled: true
-      recompute-no-older-than: 10m
-      recompute-previous-n: 2
-    data:
-      dir: /var/lib/influxdb/data
-      wal-dir: /var/lib/influxdb/wal
-      wal-logging-enabled: true
-    graphite:
-      - enabled: false
-    hinted-handoff:
-      dir: /var/lib/influxdb/hh
-      enabled: true
-      max-age: 168h
-      max-size: 1073741824
-      purge-interval: 1h
-      retry-interval: 1s
-      retry-max-interval: 1m
-      retry-rate-limit: 0
-    http:
-      auth-enabled: false
-      bind-address: ':8086'
-      enabled: true
-      https-certificate: /etc/ssl/influxdb.pem
-      https-enabled: false
-      log-enabled: true
-      pprof-enabled: false
-      write-tracing: false
-    meta:
-      bind-address: ':8088'
-      cluster-tracing: false
-      commit-timeout: 50ms
-      dir: /var/lib/influxdb/meta
-      election-timeout: 1s
-      heartbeat-timeout: 1s
-      hostname: localhost
-      leader-lease-timeout: 500ms
-      raft-promotion-enabled: true
-      retention-autocreate: true
-    monitor: {}
-    opentsdb:
-      enabled: false
-    registration: {}
-    reporting-disabled: true
-    retention:
-      check-interval: 30m
-      enabled: true
-    shard-precreation:
-      advance-period: 30m
-      check-interval: 10m
-      enabled: true
-    udp:
-      - enabled: false
-  lookup:
-    config: '/etc/influxdb/config.toml'
-    etc_default: '/etc/default/influxdb'
-    fullname: 'InfluxDB Service User'
-    home: '/opt/influxdb'
-    logrotate_conf: '/etc/logrotate.d/influxdb'
-    shell: '/bin/false'
-    system_group: 'influxdb'
-    system_user: 'influxdb'
-  tmpl:
-    config: 'salt://influxdb/files/influxdb.config.jinja'
-    etc_default: 'salt://influxdb/files/influxdb.etc_default'
-    logrotate: 'salt://influxdb/files/logrotate.conf.jinja'
+    log-level: info