file_from_template_type
Build a file from a template.
⚙️ Compatible targets: Linux
Parameters
Name | Documentation |
---|---|
source_template | Source file containing a template to be expanded (absolute path on the target node). This parameter is required. |
path | Destination file (absolute path on the target node). This parameter is required. |
template_type | Template type (cfengine, jinja2 or mustache). This parameter is required. |
Outcome conditions
You need to replace ${path}
with its actual canonified value.
- ✅ Ok:
file_from_template_${path}_ok
- ☑️ Already compliant:
file_from_template_${path}_kept
- 🟨 Repaired:
file_from_template_${path}_repaired
- ☑️ Already compliant:
- ❌ Error:
file_from_template_${path}_error
Example
method: file_from_template_type
params:
path: VALUE
template_type: VALUE
source_template: VALUE
Documentation
These methods write a file based on a provided template and the data available to the agent.
Usage
To use these methods (file_from_template_*
), you need to have:
- a template file
- data to fill this template
The template file should be somewhere on the local file system, so if you want to use a file shared from the policy server, you need to copy it first (using file_copy_from_remote_source).
It is common to use a specific folder to store those templates after copy,
for example in ${sys.workdir}/tmp/templates/
.
The data that will be used while expanding the template is the data available in the agent at the time of expansion. That means:
- Agent's system variables (
${sys.*}
, ...) and conditions (linux
, ...) - data defined during execution (result conditions of generic methods, ...)
- conditions based on
condition_
generic methods - data defined in ncf using
variable_*
generic methods, which allow for example to load data from local json or yaml files.
Template types
ncf currently supports three templating languages:
- mustache templates, which are documented in file_from_template_mustache
- jinja2 templates, which are documented in file_from_template_jinja2
- CFEngine templates, which are a legacy implementation that is here for compatibility, and should not be used for new templates.
Example
Here is a complete example of templating usage:
The (basic) template file, present on the server in /PATH_TO_MY_FILE/ntp.conf.mustache
(for syntax reference, see file_from_template_mustache):
{{#classes.linux}}
server {{{vars.configuration.ntp.hostname}}}
{{/classes.linux}}
{{^classes.linux}}
server hardcoded.server.example
{{/classes.linux}}
And on your local node in /tmp/ntp.json
, the following json file:
{ "hostname": "my.hostname.example" }
And the following policy:
# Copy the file from the policy server
file_copy_from_remote_source("/PATH_TO_MY_FILE/ntp.conf.mustache", "${sys.workdir}/tmp/templates/ntp.conf.mustache")
# Define the `ntp` variable in the `configuration` prefix from the json file
variable_dict_from_file("configuration", "ntp", "/tmp/ntp.json")
# Expand your template
file_from_template_type("${sys.workdir}/tmp/templates/ntp.conf.mustache", "/etc/ntp.conf", "mustache")
# or
# file_from_template_mustache("${sys.workdir}/tmp/templates/ntp.conf.mustache", "/etc/ntp.conf")
The destination file will contain the expanded content, for example on a Linux node:
server my.hostname.example