/

Function Reference

Included in Puppet Enterprise 2015.3.

This page is autogenerated; any changes will get overwritten (last generated on 2016-01-27 14:15:07 +0000)

There are two types of functions in Puppet: Statements and rvalues. Statements stand on their own and do not return arguments; they are used for performing stand-alone work like importing. Rvalues return values and can only be used in a statement requiring a value, such as an assignment or a case statement.

Functions execute on the Puppet master. They do not execute on the Puppet agent. Hence they only have access to the commands and data available on the Puppet master host.

Here are the functions available in Puppet:

alert

Log a message on the server at level alert.

  • Type: statement

assert_type

Returns the given value if it is of the given data type, or otherwise either raises an error or executes an optional two-parameter lambda.

The function takes two mandatory arguments, in this order:

  1. The expected data type.
  2. A value to compare against the expected data type.

Example: Using assert_type

$raw_username = 'Amy Berry'

# Assert that $raw_username is a non-empty string and assign it to $valid_username.
$valid_username = assert_type(String[1], $raw_username)

# $valid_username contains "Amy Berry".
# If $raw_username was an empty string or a different data type, the Puppet run would
# fail with an "Expected type does not match actual" error.

You can use an optional lambda to provide enhanced feedback. The lambda takes two mandatory parameters, in this order:

  1. The expected data type as described in the function’s first argument.
  2. The actual data type of the value.

Example: Using assert_type with a warning and default value

$raw_username = 'Amy Berry'

# Assert that $raw_username is a non-empty string and assign it to $valid_username.
# If it isn't, output a warning describing the problem and use a default value.
$valid_username = assert_type(String[1], $raw_username) |$expected, $actual| {
  warning( "The username should be '${expected}', not '${actual}'. Using 'anonymous'." )
  'anonymous'
}

# $valid_username contains "Amy Berry".
# If $raw_username was an empty string, the Puppet run would set $valid_username to
# "anonymous" and output a warning: "The username should be 'String[1, default]', not
# 'String[0, 0]'. Using 'anonymous'."

For more information about data types, see the documentation.

  • Since 4.0.0

  • Type: rvalue

contain

Contain one or more classes inside the current class. If any of these classes are undeclared, they will be declared as if called with the include function. Accepts a class name, an array of class names, or a comma-separated list of class names.

A contained class will not be applied before the containing class is begun, and will be finished before the containing class is finished.

You must use the class’s full name; relative names are not allowed. In addition to names in string form, you may also directly use Class and Resource Type values that are produced by evaluating resource and relationship expressions.

  • Since 4.0.0 support for Class and Resource Type values, absolute names

  • Type: statement

create_resources

Converts a hash into a set of resources and adds them to the catalog.

This function takes two mandatory arguments: a resource type, and a hash describing a set of resources. The hash should be in the form {title => {parameters} }:

# A hash of user resources:
$myusers = {
  'nick' => { uid    => '1330',
              gid    => allstaff,
              groups => ['developers', 'operations', 'release'], },
  'dan'  => { uid    => '1308',
              gid    => allstaff,
              groups => ['developers', 'prosvc', 'release'], },
}

create_resources(user, $myusers)

A third, optional parameter may be given, also as a hash:

$defaults = {
  'ensure'   => present,
  'provider' => 'ldap',
}

create_resources(user, $myusers, $defaults)

The values given on the third argument are added to the parameters of each resource present in the set given on the second argument. If a parameter is present on both the second and third arguments, the one on the second argument takes precedence.

This function can be used to create defined resources and classes, as well as native resources.

Virtual and Exported resources may be created by prefixing the type name with @ or @@ respectively. For example, the $myusers hash may be exported in the following manner:

create_resources("@@user", $myusers)

The $myusers may be declared as virtual resources using:

create_resources("@user", $myusers)
  • Type: statement

crit

Log a message on the server at level crit.

  • Type: statement

debug

Log a message on the server at level debug.

  • Type: statement

defined

Determines whether a given class or resource type is defined and returns a Boolean value. You can also use defined to determine whether a specific resource is defined, or whether a variable has a value (including undef, as opposed to the variable never being declared or assigned).

This function takes at least one string argument, which can be a class name, type name, resource reference, or variable reference of the form '$name'.

The defined function checks both native and defined types, including types provided by modules. Types and classes are matched by their names. The function matches resource declarations by using resource references.

Examples: Different types of defined function matches

# Matching resource types
defined("file")
defined("customtype")

# Matching defines and classes
defined("foo")
defined("foo::bar")

# Matching variables
defined('$name')

# Matching declared resources
defined(File['/tmp/file'])

Puppet depends on the configuration’s evaluation order when checking whether a resource is declared.

Example: Importance of evaluation order when using defined

# Assign values to $is_defined_before and $is_defined_after using identical `defined`
# functions.

$is_defined_before = defined(File['/tmp/file'])

file { "/tmp/file":
  ensure => present,
}

$is_defined_after = defined(File['/tmp/file'])

# $is_defined_before returns false, but $is_defined_after returns true.

This order requirement only refers to evaluation order. The order of resources in the configuration graph (e.g. with before or require) does not affect the defined function’s behavior.

Warning: Avoid relying on the result of the defined function in modules, as you might not be able to guarantee the evaluation order well enough to produce consistent results. This can cause other code that relies on the function’s result to behave inconsistently or fail.

If you pass more than one argument to defined, the function returns true if any of the arguments are defined. You can also match resources by type, allowing you to match conditions of different levels of specificity, such as whether a specific resource is of a specific data type.

Example: Matching multiple resources and resources by different types with defined

file { "/tmp/file1":
  ensure => file,
}

$tmp_file = file { "/tmp/file2":
  ensure => file,
}

# Each of these statements return `true` ...
defined(File['/tmp/file1'])
defined(File['/tmp/file1'],File['/tmp/file2'])
defined(File['/tmp/file1'],File['/tmp/file2'],File['/tmp/file3'])
# ... but this returns `false`.
defined(File['/tmp/file3'])

# Each of these statements returns `true` ...
defined(Type[Resource['file','/tmp/file2']])
defined(Resource['file','/tmp/file2'])
defined(File['/tmp/file2'])
defined('$tmp_file')
# ... but each of these returns `false`.
defined(Type[Resource['exec','/tmp/file2']])
defined(Resource['exec','/tmp/file2'])
defined(File['/tmp/file3'])
defined('$tmp_file2')
  • Since 2.7.0
  • Since 3.6.0 variable reference and future parser types
  • Since 3.8.1 type specific requests with future parser
  • Since 4.0.0

  • Type: rvalue

digest

Returns a hash value from a provided string using the digest_algorithm setting from the Puppet config file.

  • Type: rvalue

each

Runs a lambda repeatedly using each value in a data structure, then returns the values unchanged.

This function takes two mandatory arguments, in this order:

  1. An array or hash the function will iterate over.
  2. A lambda, which the function calls for each element in the first argument. It can request one or two parameters.

Example: Using the each function

$data.each |$parameter| { <PUPPET CODE BLOCK> }

or

each($data) |$parameter| { <PUPPET CODE BLOCK> }

When the first argument ($data in the above example) is an array, Puppet passes each value in turn to the lambda, then returns the original values.

Example: Using the each function with an array and a one-parameter lambda

# For the array $data, run a lambda that creates a resource for each item.
$data = ["routers", "servers", "workstations"]
$data.each |$item| {
 notify { $item:
   message => $item
 }
}
# Puppet creates one resource for each of the three items in $data. Each resource is
# named after the item's value and uses the item's value in a parameter.

When the first argument is a hash, Puppet passes each key and value pair to the lambda as an array in the form [key, value] and returns the original hash.

Example: Using the each function with a hash and a one-parameter lambda

# For the hash $data, run a lambda using each item as a key-value array that creates a
# resource for each item.
$data = {"rtr" => "Router", "svr" => "Server", "wks" => "Workstation"}
$data.each |$items| {
 notify { $items[0]:
   message => $items[1]
 }
}
# Puppet creates one resource for each of the three items in $data, each named after the
# item's key and containing a parameter using the item's value.

When the first argument is an array and the lambda has two parameters, Puppet passes the array’s indexes (enumerated from 0) in the first parameter and its values in the second parameter.

Example: Using the each function with an array and a two-parameter lambda

# For the array $data, run a lambda using each item's index and value that creates a
# resource for each item.
$data = ["routers", "servers", "workstations"]
$data.each |$index, $value| {
 notify { $value:
   message => $index
 }
}
# Puppet creates one resource for each of the three items in $data, each named after the
# item's value and containing a parameter using the item's index.

When the first argument is a hash, Puppet passes its keys to the first parameter and its values to the second parameter.

Example: Using the each function with a hash and a two-parameter lambda

# For the hash $data, run a lambda using each item's key and value to create a resource
# for each item.
$data = {"rtr" => "Router", "svr" => "Server", "wks" => "Workstation"}
$data.each |$key, $value| {
 notify { $key:
   message => $value
 }
}
# Puppet creates one resource for each of the three items in $data, each named after the
# item's key and containing a parameter using the item's value.

For an example that demonstrates how to create multiple file resources using each, see the Puppet iteration documentation.

  • Since 4.0.0

  • Type: rvalue

emerg

Log a message on the server at level emerg.

  • Type: statement

epp

Evaluates an Embedded Puppet (EPP) template file and returns the rendered text result as a String.

epp('<MODULE NAME>/<TEMPLATE FILE>', <PARAMETER HASH>)

The first argument to this function should be a <MODULE NAME>/<TEMPLATE FILE> reference, which loads <TEMPLATE FILE> from <MODULE NAME>’s templates directory. In most cases, the last argument is optional; if used, it should be a hash that contains parameters to pass to the template.

  • See the template documentation for general template usage information.
  • See the EPP syntax documentation for examples of EPP.

For example, to call the apache module’s templates/vhost/_docroot.epp template and pass the docroot and virtual_docroot parameters, call the epp function like this:

epp('apache/templates/vhost/_docroot.epp', { 'docroot' => '/var/www/html', 'virtual_docroot' => '/var/www/example' })

Puppet produces a syntax error if you pass more parameters than are declared in the template’s parameter tag. When passing parameters to a template that contains a parameter tag, use the same names as the tag’s declared parameters.

Parameters are required only if they are declared in the called template’s parameter tag without default values. Puppet produces an error if the epp function fails to pass any required parameter.

  • Since 4.0.0

  • Type: rvalue

err

Log a message on the server at level err.

  • Type: statement

fail

Fail with a parse error.

  • Type: statement

file

Loads a file from a module and returns its contents as a string.

The argument to this function should be a <MODULE NAME>/<FILE> reference, which will load <FILE> from a module’s files directory. (For example, the reference mysql/mysqltuner.pl will load the file <MODULES DIRECTORY>/mysql/files/mysqltuner.pl.)

This function can also accept:

  • An absolute path, which can load a file from anywhere on disk.
  • Multiple arguments, which will return the contents of the first file found, skipping any files that don’t exist.

  • Type: rvalue

filter

Applies a lambda to every value in a data structure and returns an array or hash containing any elements for which the lambda evaluates to true.

This function takes two mandatory arguments, in this order:

  1. An array or hash the function will iterate over.
  2. A lambda, which the function calls for each element in the first argument. It can request one or two parameters.

Example: Using the filter function

$filtered_data = $data.filter |$parameter| { <PUPPET CODE BLOCK> }

or

$filtered_data = filter($data) |$parameter| { <PUPPET CODE BLOCK> }

When the first argument ($data in the above example) is an array, Puppet passes each value in turn to the lambda and returns an array containing the results.

Example: Using the filter function with an array and a one-parameter lambda

# For the array $data, return an array containing the values that end with "berry"
$data = ["orange", "blueberry", "raspberry"]
$filtered_data = $data.filter |$items| { $items =~ /berry$/ }
# $filtered_data = [blueberry, raspberry]

When the first argument is a hash, Puppet passes each key and value pair to the lambda as an array in the form [key, value] and returns a hash containing the results.

Example: Using the filter function with a hash and a one-parameter lambda

# For the hash $data, return a hash containing all values of keys that end with "berry"
$data = { "orange" => 0, "blueberry" => 1, "raspberry" => 2 }
$filtered_data = $data.filter |$items| { $items[0] =~ /berry$/ }
# $filtered_data = {blueberry => 1, raspberry => 2}

When the first argument is an array and the lambda has two parameters, Puppet passes the
array's indexes (enumerated from 0) in the first parameter and its values in the second
parameter.

**Example**: Using the `filter` function with an array and a two-parameter lambda

~~~ puppet
# For the array $data, return an array of all keys that both end with "berry" and have
# an even-numbered index
$data = ["orange", "blueberry", "raspberry"]
$filtered_data = $data.filter |$indexes, $values| { $indexes % 2 == 0 and $values =~ /berry$/ }
# $filtered_data = [raspberry]

When the first argument is a hash, Puppet passes its keys to the first parameter and its values to the second parameter.

Example: Using the filter function with a hash and a two-parameter lambda

# For the hash $data, return a hash of all keys that both end with "berry" and have
# values less than or equal to 1
$data = { "orange" => 0, "blueberry" => 1, "raspberry" => 2 }
$filtered_data = $data.filter |$keys, $values| { $keys =~ /berry$/ and $values <= 1 }
# $filtered_data = {blueberry => 1}
  • Since 4.0.0

  • Type: rvalue

fqdn_rand

Usage: fqdn_rand(MAX, [SEED]). MAX is required and must be a positive integer; SEED is optional and may be any number or string.

Generates a random Integer number greater than or equal to 0 and less than MAX, combining the $fqdn fact and the value of SEED for repeatable randomness. (That is, each node will get a different random number from this function, but a given node’s result will be the same every time unless its hostname changes.)

This function is usually used for spacing out runs of resource-intensive cron tasks that run on many nodes, which could cause a thundering herd or degrade other services if they all fire at once. Adding a SEED can be useful when you have more than one such task and need several unrelated random numbers per node. (For example, fqdn_rand(30), fqdn_rand(30, 'expensive job 1'), and fqdn_rand(30, 'expensive job 2') will produce totally different numbers.)

  • Type: rvalue

generate

Calls an external command on the Puppet master and returns the results of the command. Any arguments are passed to the external command as arguments. If the generator does not exit with return code of 0, the generator is considered to have failed and a parse error is thrown. Generators can only have file separators, alphanumerics, dashes, and periods in them. This function will attempt to protect you from malicious generator calls (e.g., those with ‘..’ in them), but it can never be entirely safe. No subshell is used to execute generators, so all shell metacharacters are passed directly to the generator.

  • Type: rvalue

hiera

Performs a standard priority lookup of the hierarchy and returns the most specific value for a given key. The returned value can be any type of data.

The function takes up to three arguments, in this order:

  1. A string key that Hiera searches for in the hierarchy. Required.
  2. An optional default value to return if Hiera doesn’t find anything matching the key.
    • If this argument isn’t provided and this function results in a lookup failure, Puppet fails with a compilation error.
  3. The optional name of an arbitrary hierarchy level to insert at the top of the hierarchy. This lets you temporarily modify the hierarchy for a single lookup.
    • If Hiera doesn’t find a matching key in the overriding hierarchy level, it continues searching the rest of the hierarchy.

The hiera function does not find all matches throughout a hierarchy, instead returining the first specific value starting at the top of the hierarchy. To search throughout a hierarchy, use the hiera_array or hiera_hash functions.

Example: Using hiera

# Assuming hiera.yaml
# :hierarchy:
#   - web01.example.com
#   - common

# Assuming web01.example.com.yaml:
# users:
#   - "Amy Barry"
#   - "Carrie Douglas"

# Assuming common.yaml:
users:
  admins:
    - "Edith Franklin"
    - "Ginny Hamilton"
  regular:
    - "Iris Jackson"
    - "Kelly Lambert"
# Assuming we are not web01.example.com:

$users = hiera('users', undef)

# $users contains {admins  => ["Edith Franklin", "Ginny Hamilton"],
#                  regular => ["Iris Jackson", "Kelly Lambert"]}

You can optionally generate the default value with a lambda that takes one parameter.

Example: Using hiera with a lambda

# Assuming the same Hiera data as the previous example:

$users = hiera('users') | $key | { "Key '${key}' not found" }

# $users contains {admins  => ["Edith Franklin", "Ginny Hamilton"],
#                  regular => ["Iris Jackson", "Kelly Lambert"]}
# If hiera couldn't match its key, it would return the lambda result,
# "Key 'users' not found".

The returned value’s data type depends on the types of the results. In the example above, Hiera matches the ‘users’ key and returns it as a hash.

See the documentation for more information about Hiera lookup functions.

  • Since 4.0.0

  • Type: rvalue

hiera_array

Finds all matches of a key throughout the hierarchy and returns them as a single flattened array of unique values. If any of the matched values are arrays, they’re flattened and included in the results. This is called an array merge lookup.

The hiera_array function takes up to three arguments, in this order:

  1. A string key that Hiera searches for in the hierarchy. Required.
  2. An optional default value to return if Hiera doesn’t find anything matching the key.
    • If this argument isn’t provided and this function results in a lookup failure, Puppet fails with a compilation error.
  3. The optional name of an arbitrary hierarchy level to insert at the top of the hierarchy. This lets you temporarily modify the hierarchy for a single lookup.
    • If Hiera doesn’t find a matching key in the overriding hierarchy level, it continues searching the rest of the hierarchy.

Example: Using hiera_array

# Assuming hiera.yaml
# :hierarchy:
#   - web01.example.com
#   - common

# Assuming common.yaml:
# users:
#   - 'cdouglas = regular'
#   - 'efranklin = regular'

# Assuming web01.example.com.yaml:
# users: 'abarry = admin'
$allusers = hiera_array('users', undef)

# $allusers contains ["cdouglas = regular", "efranklin = regular", "abarry = admin"].

You can optionally generate the default value with a lambda that takes one parameter.

Example: Using hiera_array with a lambda

# Assuming the same Hiera data as the previous example:

$allusers = hiera_array('users') | $key | { "Key '${key}' not found" }

# $allusers contains ["cdouglas = regular", "efranklin = regular", "abarry = admin"].
# If hiera_array couldn't match its key, it would return the lambda result,
# "Key 'users' not found".

hiera_array expects that all values returned will be strings or arrays. If any matched value is a hash, Puppet raises a type mismatch error.

See the documentation for more information about Hiera lookup functions.

  • Since 4.0.0

  • Type: rvalue

hiera_hash

Finds all matches of a key throughout the hierarchy and returns them in a merged hash. If any of the matched hashes share keys, the final hash uses the value from the highest priority match. This is called a hash merge lookup.

The merge strategy is determined by Hiera’s :merge_behavior setting.

The hiera_hash function takes up to three arguments, in this order:

  1. A string key that Hiera searches for in the hierarchy. Required.
  2. An optional default value to return if Hiera doesn’t find anything matching the key.
    • If this argument isn’t provided and this function results in a lookup failure, Puppet fails with a compilation error.
  3. The optional name of an arbitrary hierarchy level to insert at the top of the hierarchy. This lets you temporarily modify the hierarchy for a single lookup.
    • If Hiera doesn’t find a matching key in the overriding hierarchy level, it continues searching the rest of the hierarchy.

Example: Using hiera_hash

# Assuming hiera.yaml
# :hierarchy:
#   - web01.example.com
#   - common

# Assuming common.yaml:
# users:
#   regular:
#     'cdouglas': 'Carrie Douglas'

# Assuming web01.example.com.yaml:
# users:
#   administrators:
#     'aberry': 'Amy Berry'
# Assuming we are not web01.example.com:

$allusers = hiera_hash('users', undef)

# $allusers contains {regular => {"cdouglas" => "Carrie Douglas"},
#                     administrators => {"aberry" => "Amy Berry"}}

You can optionally generate the default value with a lambda that takes one parameter.

Example: Using hiera_hash with a lambda

# Assuming the same Hiera data as the previous example:

$allusers = hiera_hash('users') | $key | { "Key '${key}' not found" }

# $allusers contains {regular => {"cdouglas" => "Carrie Douglas"},
#                     administrators => {"aberry" => "Amy Berry"}}
# If hiera_hash couldn't match its key, it would return the lambda result,
# "Key 'users' not found".

hiera_hash expects that all values returned will be hashes. If any of the values found in the data sources are strings or arrays, Puppet raises a type mismatch error.

See the documentation for more information about Hiera lookup functions.

  • Since 4.0.0

  • Type: rvalue

hiera_include

Assigns classes to a node using an array merge lookup that retrieves the value for a user-specified key from Hiera’s data.

The hiera_include function requires:

  • A string key name to use for classes.
  • A call to this function (i.e. hiera_include('classes')) in your environment’s sites.pp manifest, outside of any node definitions and below any top-scope variables that Hiera uses in lookups.
  • classes keys in the appropriate Hiera data sources, with an array for each classes key and each value of the array containing the name of a class.

The function takes up to three arguments, in this order:

  1. A string key that Hiera searches for in the hierarchy. Required.
  2. An optional default value to return if Hiera doesn’t find anything matching the key.
    • If this argument isn’t provided and this function results in a lookup failure, Puppet fails with a compilation error.
  3. The optional name of an arbitrary hierarchy level to insert at the top of the hierarchy. This lets you temporarily modify the hierarchy for a single lookup.
    • If Hiera doesn’t find a matching key in the overriding hierarchy level, it continues searching the rest of the hierarchy.

The function uses an array merge lookup to retrieve the classes array, so every node gets every class from the hierarchy.

Example: Using hiera_include

# Assuming hiera.yaml
# :hierarchy:
#   - web01.example.com
#   - common

# Assuming web01.example.com.yaml:
# classes:
#   - apache::mod::php

# Assuming common.yaml:
# classes:
#   - apache
# In site.pp, outside of any node definitions and below any top-scope variables:
hiera_include('classes', undef)

# Puppet assigns the apache and apache::mod::php classes to the web01.example.com node.

You can optionally generate the default value with a lambda that takes one parameter.

Example: Using hiera_include with a lambda

# Assuming the same Hiera data as the previous example:

# In site.pp, outside of any node definitions and below any top-scope variables:
hiera_include('classes') | $key | {"Key '${key}' not found" }

# Puppet assigns the apache and apache::mod::php classes to the web01.example.com node.
# If hiera_include couldn't match its key, it would return the lambda result,
# "Key 'classes' not found".

See the documentation for more information and a more detailed example of how hiera_include uses array merge lookups to classify nodes.

  • Since 4.0.0

  • Type: statement

include

Declares one or more classes, causing the resources in them to be evaluated and added to the catalog. Accepts a class name, an array of class names, or a comma-separated list of class names.

The include function can be used multiple times on the same class and will only declare a given class once. If a class declared with include has any parameters, Puppet will automatically look up values for them in Hiera, using <class name>::<parameter name> as the lookup key.

Contrast this behavior with resource-like class declarations (class {'name': parameter => 'value',}), which must be used in only one place per class and can directly set parameters. You should avoid using both include and resource-like declarations with the same class.

The include function does not cause classes to be contained in the class where they are declared. For that, see the contain function. It also does not create a dependency relationship between the declared class and the surrounding class; for that, see the require function.

You must use the class’s full name; relative names are not allowed. In addition to names in string form, you may also directly use Class and Resource Type values that are produced by the future parser’s resource and relationship expressions.

  • Since < 3.0.0
  • Since 4.0.0 support for class and resource type values, absolute names

  • Type: statement

info

Log a message on the server at level info.

  • Type: statement

inline_epp

Evaluates an Embedded Puppet (EPP) template string and returns the rendered text result as a String.

inline_epp('<EPP TEMPLATE STRING>', <PARAMETER HASH>)

The first argument to this function should be a string containing an EPP template. In most cases, the last argument is optional; if used, it should be a hash that contains parameters to pass to the template.

  • See the template documentation for general template usage information.
  • See the EPP syntax documentation for examples of EPP.

For example, to evaluate an inline EPP template and pass it the docroot and virtual_docroot parameters, call the inline_epp function like this:

inline_epp('docroot: <%= $docroot %> Virtual docroot: <%= $virtual_docroot %>', { 'docroot' => '/var/www/html', 'virtual_docroot' => '/var/www/example' })

Puppet produces a syntax error if you pass more parameters than are declared in the template’s parameter tag. When passing parameters to a template that contains a parameter tag, use the same names as the tag’s declared parameters.

Parameters are required only if they are declared in the called template’s parameter tag without default values. Puppet produces an error if the inline_epp function fails to pass any required parameter.

An inline EPP template should be written as a single-quoted string or heredoc. A double-quoted string is subject to expression interpolation before the string is parsed as an EPP template.

For example, to evaluate an inline EPP template using a heredoc, call the inline_epp function like this:

# Outputs 'Hello given argument planet!'
inline_epp(@(END), { x => 'given argument' })
<%- | $x, $y = planet | -%>
Hello <%= $x %> <%= $y %>!
END
  • Since 3.5
  • Requires future parser in Puppet 3.5 to 3.8

  • Type: rvalue

inline_template

Evaluate a template string and return its value. See the templating docs for more information. Note that if multiple template strings are specified, their output is all concatenated and returned as the output of the function.

  • Type: rvalue

lookup

Uses the Puppet lookup system to retrieve a value for a given key. By default, this returns the first value found (and fails compilation if no values are available), but you can configure it to merge multiple values into one, fail gracefully, and more.

When looking up a key, Puppet will search up to three tiers of data, in the following order:

  1. Hiera.
  2. The current environment’s data provider.
  3. The indicated module’s data provider, if the key is of the form <MODULE NAME>::<SOMETHING>.

Arguments

You must provide the name of a key to look up, and can optionally provide other arguments. You can combine these arguments in the following ways:

  • lookup( <NAME>, [<VALUE TYPE>], [<MERGE BEHAVIOR>], [<DEFAULT VALUE>] )
  • lookup( [<NAME>], <OPTIONS HASH> )
  • lookup( as above ) |$key| { # lambda returns a default value }

Arguments in [square brackets] are optional.

The arguments accepted by lookup are as follows:

  1. <NAME> (string or array) — The name of the key to look up.
    • This can also be an array of keys. If Puppet doesn’t find anything for the first key, it will try again with the subsequent ones, only resorting to a default value if none of them succeed.
  2. <VALUE TYPE> (data type) — A data type that must match the retrieved value; if not, the lookup (and catalog compilation) will fail. Defaults to Data (accepts any normal value).
  3. <MERGE BEHAVIOR> (string or hash; see “Merge Behaviors” below) — Whether (and how) to combine multiple values. If present, this overrides any merge behavior specified in the data sources. Defaults to no value; Puppet will use merge behavior from the data sources if present, and will otherwise do a first-found lookup.
  4. <DEFAULT VALUE> (any normal value) — If present, lookup returns this when it can’t find a normal value. Default values are never merged with found values. Like a normal value, the default must match the value type. Defaults to no value; if Puppet can’t find a normal value, the lookup (and compilation) will fail.
  5. <OPTIONS HASH> (hash) — Alternate way to set the arguments above, plus some less-common extra options. If you pass an options hash, you can’t combine it with any regular arguments (except <NAME>). An options hash can have the following keys:
    • 'name' — Same as <NAME> (argument 1). You can pass this as an argument or in the hash, but not both.
    • 'value_type' — Same as <VALUE TYPE> (argument 2).
    • 'merge' — Same as <MERGE BEHAVIOR> (argument 3).
    • 'default_value' — Same as <DEFAULT VALUE> (argument 4).
    • 'default_values_hash' (hash) — A hash of lookup keys and default values. If Puppet can’t find a normal value, it will check this hash for the requested key before giving up. You can combine this with default_value or a lambda, which will be used if the key isn’t present in this hash. Defaults to an empty hash.
    • 'override' (hash) — A hash of lookup keys and override values. Puppet will check for the requested key in the overrides hash first; if found, it returns that value as the final value, ignoring merge behavior. Defaults to an empty hash.

Finally, lookup can take a lambda, which must accept a single parameter. This is yet another way to set a default value for the lookup; if no results are found, Puppet will pass the requested key to the lambda and use its result as the default value.

Merge Behaviors

Puppet lookup uses a hierarchy of data sources, and a given key might have values in multiple sources. By default, Puppet returns the first value it finds, but it can also continue searching and merge all the values together.

Note: Data sources can use the special lookup_options metadata key to request a specific merge behavior for a key. The lookup function will use that requested behavior unless you explicitly specify one.

The valid merge behaviors are:

  • 'first' — Returns the first value found, with no merging. Puppet lookup’s default behavior.
  • 'unique' (called “array merge” in classic Hiera) — Combines any number of arrays and scalar values to return a merged, flattened array with all duplicate values removed. The lookup will fail if any hash values are found.
  • 'hash' — Combines the keys and values of any number of hashes to return a merged hash. If the same key exists in multiple source hashes, Puppet will use the value from the highest-priority data source; it won’t recursively merge the values.
  • 'deep' — Combines the keys and values of any number of hashes to return a merged hash. If the same key exists in multiple source hashes, Puppet will recursively merge hash or array values (with duplicate values removed from arrays). For conflicting scalar values, the highest-priority value will win.
  • {'strategy' => 'first|unique|hash'} — Same as the string versions of these merge behaviors.
  • {'strategy' => 'deep', <DEEP OPTION> => <VALUE>, ...} — Same as 'deep', but can adjust the merge with additional options. The available options are:
    • 'knockout_prefix' (string or undef) — A string prefix to indicate a value should be removed from the final result. Defaults to undef, which disables this feature.
    • 'sort_merged_arrays' (boolean) — Whether to sort all arrays that are merged together. Defaults to false.
    • 'unpack_arrays' (string or undef) — A delimiter string; Puppet will join merged arrays with this delimiter, then split them again. Defaults to undef, which disables this feature.
    • 'merge_hash_arrays' (boolean) — Whether to merge hashes within arrays. Defaults to false.

Examples

Look up a key and return the first value found:

lookup('ntp::service_name')

Do a unique merge lookup of class names, then add all of those classes to the catalog (like hiera_include):

lookup('classes', Array[String], 'unique').include

Do a deep hash merge lookup of user data, but let higher priority sources remove values by prefixing them with --:

lookup( { 'name'  => 'users',
          'merge' => {
            'strategy'        => 'deep',
            'knockout_prefix' => '--',
          },
})
  • Type: rvalue

map

Applies a lambda to every value in a data structure and returns an array containing the results.

This function takes two mandatory arguments, in this order:

  1. An array or hash the function will iterate over.
  2. A lambda, which the function calls for each element in the first argument. It can request one or two parameters.

Example: Using the map function

$transformed_data = $data.map |$parameter| { <PUPPET CODE BLOCK> }

or

$transformed_data = map($data) |$parameter| { <PUPPET CODE BLOCK> }

When the first argument ($data in the above example) is an array, Puppet passes each value in turn to the lambda.

Example: Using the map function with an array and a one-parameter lambda

# For the array $data, return an array containing each value multiplied by 10
$data = [1,2,3]
$transformed_data = $data.map |$items| { $items * 10 }
# $transformed_data contains [10,20,30]

When the first argument is a hash, Puppet passes each key and value pair to the lambda as an array in the form [key, value].

Example: Using the map function with a hash and a one-parameter lambda

# For the hash $data, return an array containing the keys
$data = {'a'=>1,'b'=>2,'c'=>3}
$transformed_data = $data.map |$items| { $items[0] }
# $transformed_data contains ['a','b','c']

When the first argument is an array and the lambda has two parameters, Puppet passes the array’s indexes (enumerated from 0) in the first parameter and its values in the second parameter.

Example: Using the map function with an array and a two-parameter lambda

# For the array $data, return an array containing the indexes
$data = [1,2,3]
$transformed_data = $data.map |$index,$value| { $index }
# $transformed_data contains [0,1,2]

When the first argument is a hash, Puppet passes its keys to the first parameter and its values to the second parameter.

Example: Using the map function with a hash and a two-parameter lambda

# For the hash $data, return an array containing each value
$data = {'a'=>1,'b'=>2,'c'=>3}
$transformed_data = $data.map |$key,$value| { $value }
# $transformed_data contains [1,2,3]
  • Since 4.0.0

  • Type: rvalue

match

Matches a regular expression against a string and returns an array containing the match and any matched capturing groups.

The first argument is a string or array of strings. The second argument is either a regular expression, regular expression represented as a string, or Regex or Pattern data type that the function matches against the first argument.

The returned array contains the entire match at index 0, and each captured group at subsequent index values. If the value or expression being matched is an array, the function returns an array with mapped match results.

If the function doesn’t find a match, it returns ‘undef’.

Example: Matching a regular expression in a string

$matches = "abc123".match(/[a-z]+[1-9]+/)
# $matches contains [abc123]

Example: Matching a regular expressions with grouping captures in a string

$matches = "abc123".match(/([a-z]+)([1-9]+)/)
# $matches contains [abc123, abc, 123]

Example: Matching a regular expression with grouping captures in an array of strings

$matches = ["abc123","def456"].match(/([a-z]+)([1-9]+)/)
# $matches contains [[abc123, abc, 123], [def456, def, 456]]
  • Since 4.0.0

  • Type: statement

md5

Returns a MD5 hash value from a provided string.

  • Type: rvalue

notice

Log a message on the server at level notice.

  • Type: statement

realize

Make a virtual object real. This is useful when you want to know the name of the virtual object and don’t want to bother with a full collection. It is slightly faster than a collection, and, of course, is a bit shorter. You must pass the object using a reference; e.g.: realize User[luke].

  • Type: statement

reduce

Applies a lambda to every value in a data structure from the first argument, carrying over the returned value of each iteration, and returns the result of the lambda’s final iteration. This lets you create a new value or data structure by combining values from the first argument’s data structure.

This function takes two mandatory arguments, in this order:

  1. An array or hash the function will iterate over.
  2. A lambda, which the function calls for each element in the first argument. It takes two mandatory parameters:
    1. A memo value that is overwritten after each iteration with the iteration’s result.
    2. A second value that is overwritten after each iteration with the next value in the function’s first argument.

Example: Using the reduce function

$data.reduce |$memo, $value| { ... }

or

reduce($data) |$memo, $value| { ... }

You can also pass an optional “start memo” value as an argument, such as start below:

$data.reduce(start) |$memo, $value| { ... }

or

reduce($data, start) |$memo, $value| { ... }

When the first argument ($data in the above example) is an array, Puppet passes each of the data structure’s values in turn to the lambda’s parameters. When the first argument is a hash, Puppet converts each of the hash’s values to an array in the form [key, value].

If you pass a start memo value, Puppet executes the lambda with the provided memo value and the data structure’s first value. Otherwise, Puppet passes the structure’s first two values to the lambda.

Puppet calls the lambda for each of the data structure’s remaining values. For each call, it passes the result of the previous call as the first parameter ($memo in the above examples) and the next value from the data structure as the second parameter ($value).

If the structure has one value, Puppet returns the value and does not call the lambda.

Example: Using the reduce function

# Reduce the array $data, returning the sum of all values in the array.
$data = [1, 2, 3]
$sum = $data.reduce |$memo, $value| { $memo + $value }
# $sum contains 6

# Reduce the array $data, returning the sum of a start memo value and all values in the
# array.
$data = [1, 2, 3]
$sum = $data.reduce(4) |$memo, $value| { $memo + $value }
# $sum contains 10

# Reduce the hash $data, returning the sum of all values and concatenated string of all
# keys.
$data = {a => 1, b => 2, c => 3}
$combine = $data.reduce |$memo, $value| {
  $string = "${memo[0]}${value[0]}"
  $number = $memo[1] + $value[1]
  [$string, $number]
}
# $combine contains [abc, 6]

Example: Using the reduce function with a start memo and two-parameter lambda

# Reduce the array $data, returning the sum of all values in the array and starting
# with $memo set to an arbitrary value instead of $data's first value.
$data = [1, 2, 3]
$sum = $data.reduce(4) |$memo, $value| { $memo + $value }
# At the start of the lambda's first iteration, $memo contains 4 and $value contains 1.
# After all iterations, $sum contains 10.

# Reduce the hash $data, returning the sum of all values and concatenated string of
# all keys, and starting with $memo set to an arbitrary array instead of $data's first
# key-value pair.
$data = {a => 1, b => 2, c => 3}
$combine = $data.reduce( [d, 4] ) |$memo, $value| {
  $string = "${memo[0]}${value[0]}"
  $number = $memo[1] + $value[1]
  [$string, $number]
}
# At the start of the lambda's first iteration, $memo contains [d, 4] and $value
# contains [a, 1].
# $combine contains [dabc, 10]
  • Since 4.0.0

  • Type: rvalue

regsubst

Perform regexp replacement on a string or array of strings.

  • Parameters (in order):
    • target The string or array of strings to operate on. If an array, the replacement will be performed on each of the elements in the array, and the return value will be an array.
    • regexp The regular expression matching the target string. If you want it anchored at the start and or end of the string, you must do that with ^ and $ yourself.
    • replacement Replacement string. Can contain backreferences to what was matched using \0 (whole match), \1 (first set of parentheses), and so on.
    • flags Optional. String of single letter flags for how the regexp is interpreted:
      • E Extended regexps
      • I Ignore case in regexps
      • M Multiline regexps
      • G Global replacement; all occurrences of the regexp in each target string will be replaced. Without this, only the first occurrence will be replaced.
    • encoding Optional. How to handle multibyte characters. A single-character string with the following values:
      • N None
      • E EUC
      • S SJIS
      • U UTF-8
  • Examples

Get the third octet from the node’s IP address:

$i3 = regsubst($ipaddress,'^(\d+)\.(\d+)\.(\d+)\.(\d+)$','\3')

Put angle brackets around each octet in the node’s IP address:

$x = regsubst($ipaddress, '([0-9]+)', '<\1>', 'G')
  • Type: rvalue

require

Evaluate one or more classes, adding the required class as a dependency.

The relationship metaparameters work well for specifying relationships between individual resources, but they can be clumsy for specifying relationships between classes. This function is a superset of the ‘include’ function, adding a class relationship so that the requiring class depends on the required class.

Warning: using require in place of include can lead to unwanted dependency cycles.

For instance the following manifest, with ‘require’ instead of ‘include’ would produce a nasty dependence cycle, because notify imposes a before between File[/foo] and Service[foo]:

class myservice {
  service { foo: ensure => running }
}

class otherstuff {
  include myservice
  file { '/foo': notify => Service[foo] }
}

Note that this function only works with clients 0.25 and later, and it will fail if used with earlier clients.

You must use the class’s full name; relative names are not allowed. In addition to names in string form, you may also directly use Class and Resource Type values that are produced when evaluating resource and relationship expressions.

  • Since 4.0.0 Class and Resource types, absolute names

  • Type: statement

scanf

Scans a string and returns an array of one or more converted values as directed by a given format string.args See the documenation of Ruby’s String::scanf method for details about the supported formats (which are similar but not identical to the formats used in Puppet’s sprintf function.

This function takes two mandatory arguments: the first is the String to convert, and the second the format String. The result of the scan is an Array, with each sucessfully scanned and transformed value.args The scanning stops if a scan is unsuccesful and the scanned result up to that point is returned. If there was no succesful scan at all, the result is an empty Array.

  scanf("42", "%i")[0] == 42

When used with the future parser, an optional parameterized block may be given. The block is called with the result that is produced by scanf if no block is present, the result of the block is then returned by the function.

The optional code block is typically used to assert that the scan was succesful, and either produce the same input, or perform unwrapping of the result:

  "42".scanf("%i")
  "42".scanf("%i") |$x| {
    unless $x[0] =~ Integer {
      fail "Expected a well formed integer value, got '$x[0]'"
    }
    $x[0]
  }
  • since 3.7.4 with parser = future
  • since 3.7.5 with classic parser

  • Type: rvalue

sha1

Returns a SHA1 hash value from a provided string.

  • Type: rvalue

shellquote

Quote and concatenate arguments for use in Bourne shell.

Each argument is quoted separately, and then all are concatenated with spaces. If an argument is an array, the elements of that array is interpolated within the rest of the arguments; this makes it possible to have an array of arguments and pass that array to shellquote instead of having to specify each argument individually in the call.

  • Type: rvalue

slice

Applies a parameterized block to each slice of elements in a sequence of selected entries from the first argument and returns the first argument, or if no block is given returns a new array with a concatenation of the slices.

This function takes two mandatory arguments: the first, $a, should be an Array, Hash, or something of enumerable type (integer, Integer range, or String), and the second, $n, the number of elements to include in each slice. The optional third argument should be a a parameterized block as produced by the puppet syntax:

$a.slice($n) |$x| { ... }
slice($a) |$x| { ... }

The parameterized block should have either one parameter (receiving an array with the slice), or the same number of parameters as specified by the slice size (each parameter receiving its part of the slice). In case there are fewer remaining elements than the slice size for the last slice it will contain the remaining elements. When the block has multiple parameters, excess parameters are set to undef for an array or enumerable type, and to empty arrays for a Hash.

$a.slice(2) |$first, $second| { ... }

When the first argument is a Hash, each key,value entry is counted as one, e.g, a slice size of 2 will produce an array of two arrays with key, and value.

Example Using slice with Hash

$a.slice(2) |$entry|          { notice "first ${$entry[0]}, second ${$entry[1]}" }
$a.slice(2) |$first, $second| { notice "first ${first}, second ${second}" }

When called without a block, the function produces a concatenated result of the slices.

Example Using slice without a block

slice([1,2,3,4,5,6], 2) # produces [[1,2], [3,4], [5,6]]
slice(Integer[1,6], 2)  # produces [[1,2], [3,4], [5,6]]
slice(4,2)              # produces [[0,1], [2,3]]
slice('hello',2)        # produces [[h, e], [l, l], [o]]
  • Since 4.0.0

  • Type: rvalue

split

Split a string variable into an array using the specified split regexp.

Example:

$string     = 'v1.v2:v3.v4'
$array_var1 = split($string, ':')
$array_var2 = split($string, '[.]')
$array_var3 = split($string, '[.:]')

$array_var1 now holds the result ['v1.v2', 'v3.v4'], while $array_var2 holds ['v1', 'v2:v3', 'v4'], and $array_var3 holds ['v1', 'v2', 'v3', 'v4'].

Note that in the second example, we split on a literal string that contains a regexp meta-character (.), which must be escaped. A simple way to do that for a single character is to enclose it in square brackets; a backslash will also escape a single character.

  • Type: rvalue

sprintf

Perform printf-style formatting of text.

The first parameter is format string describing how the rest of the parameters should be formatted. See the documentation for the Kernel::sprintf function in Ruby for all the details.

  • Type: rvalue

tag

Add the specified tags to the containing class or definition. All contained objects will then acquire that tag, also.

  • Type: statement

tagged

A boolean function that tells you whether the current container is tagged with the specified tags. The tags are ANDed, so that all of the specified tags must be included for the function to return true.

  • Type: rvalue

template

Loads an ERB template from a module, evaluates it, and returns the resulting value as a string.

The argument to this function should be a <MODULE NAME>/<TEMPLATE FILE> reference, which will load <TEMPLATE FILE> from a module’s templates directory. (For example, the reference apache/vhost.conf.erb will load the file <MODULES DIRECTORY>/apache/templates/vhost.conf.erb.)

This function can also accept:

  • An absolute path, which can load a template file from anywhere on disk.
  • Multiple arguments, which will evaluate all of the specified templates and return their outputs concatenated into a single string.

  • Type: rvalue

versioncmp

Compares two version numbers.

Prototype:

$result = versioncmp(a, b)

Where a and b are arbitrary version strings.

This function returns:

  • 1 if version a is greater than version b
  • 0 if the versions are equal
  • -1 if version a is less than version b

Example:

if versioncmp('2.6-1', '2.4.5') > 0 {
    notice('2.6-1 is > than 2.4.5')
}

This function uses the same version comparison algorithm used by Puppet’s package type.

  • Type: rvalue

warning

Log a message on the server at level warning.

  • Type: statement

with

Call a lambda with the given arguments and return the result. Since a lambda’s scope is local to the lambda, you can use the with function to create private blocks of code within a class using variables whose values cannot be accessed outside of the lambda.

Example: Using with

# Concatenate three strings into a single string formatted as a list.
$fruit = with("apples", "oranges", "bananas") |$x, $y, $z| {
  "${x}, ${y}, and ${z}"
}
$check_var = $x
# $fruit contains "apples, oranges, and bananas"
# $check_var is undefined, as the value of $x is local to the lambda.
  • Since 4.0.0

  • Type: rvalue


This page autogenerated on 2016-01-27 14:15:08 +0000

↑ Back to top