This will result in /path/to/extdata/hosts/your.box.com.csv being searched.
This is for back compatibility to interpolate variables with %. % interpolation is a workaround for a problem that has been fixed: Puppet variable interpolation at top scope used to only happen on each run.
- *Type*: rvalue
fail
----
Fail with a parse error.
- *Type*: statement
file
----
Return the contents of a file. Multiple files
can be passed, and the first file that exists will be read in.
- *Type*: rvalue
flatten
-------
This function flattens any deeply nested arrays and returns a single flat array
as a result.
*Examples:*
flatten(['a', ['b', ['c']]])
Would return: ['a','b','c']
- *Type*: rvalue
fqdn_rand
---------
Generates random numbers based on the node's fqdn. Generated random values
will be a range from 0 up to and excluding n, where n is the first parameter.
The second argument specifies a number to add to the seed and is optional, for example:
$random_number = fqdn_rand(30)
$random_number_seed = fqdn_rand(30,30)
- *Type*: rvalue
fqdn_rotate
-----------
Rotates an array a random number of times based on a nodes fqdn.
- *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
get_module_path
---------------
Returns the absolute path of the specified module for the current
environment.
Example:
$module_path = get_module_path('stdlib')
- *Type*: rvalue
getvar
------
Lookup a variable in a remote namespace.
For example:
$foo = getvar('site::data::foo')
# Equivalent to $foo = $site::data::foo
This is useful if the namespace itself is stored in a string:
$datalocation = 'site::data'
$bar = getvar("${datalocation}::bar")
# Equivalent to $bar = $site::data::bar
- *Type*: rvalue
grep
----
This function searches through an array and returns any elements that match
the provided regular expression.
*Examples:*
grep(['aaa','bbb','ccc','aaaddd'], 'aaa')
Would return:
['aaa','aaaddd']
- *Type*: rvalue
has_key
-------
Determine if a hash has a certain key value.
Example:
$my_hash = {'key_one' => 'value_one'}
if has_key($my_hash, 'key_two') {
notice('we will not reach here')
}
if has_key($my_hash, 'key_one') {
notice('this will be printed')
}
- *Type*: rvalue
hash
----
This function converts and array into a hash.
*Examples:*
hash(['a',1,'b',2,'c',3])
Would return: {'a'=>1,'b'=>2,'c'=>3}
- *Type*: rvalue
include
-------
Evaluate one or more classes.
- *Type*: statement
info
----
Log a message on the server at level info.
- *Type*: statement
inline_template
---------------
Evaluate a template string and return its value. See
[the templating docs](http://docs.puppetlabs.com/guides/templating.html) 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
is_array
--------
Returns true if the variable passed to this function is an array.
- *Type*: rvalue
is_domain_name
--------------
Returns true if the string passed to this function is a syntactically correct domain name.
- *Type*: rvalue
is_float
--------
Returns true if the variable passed to this function is a float.
- *Type*: rvalue
is_hash
-------
Returns true if the variable passed to this function is a hash.
- *Type*: rvalue
is_integer
----------
Returns true if the variable returned to this string is an integer.
- *Type*: rvalue
is_ip_address
-------------
Returns true if the string passed to this function is a valid IP address.
- *Type*: rvalue
is_mac_address
--------------
Returns true if the string passed to this function is a valid mac address.
- *Type*: rvalue
is_numeric
----------
Returns true if the variable passed to this function is a number.
- *Type*: rvalue
is_string
---------
Returns true if the variable passed to this function is a string.
- *Type*: rvalue
join
----
This function joins an array into a string using a seperator.
*Examples:*
join(['a','b','c'], ",")
Would result in: "a,b,c"
- *Type*: rvalue
keys
----
Returns the keys of a hash as an array.
- *Type*: rvalue
loadyaml
--------
Load a YAML file containing an array, string, or hash, and return the data
When there is a duplicate key, the key in the rightmost hash will "win."
- *Type*: rvalue
notice
------
Log a message on the server at level notice.
- *Type*: statement
num2bool
--------
This function converts a number into a true boolean. Zero becomes false. Numbers
higher then 0 become true.
- *Type*: rvalue
parsejson
---------
This function accepts JSON as a string and converts into the correct Puppet
structure.
- *Type*: rvalue
parseyaml
---------
This function accepts YAML as a string and converts it into the correct
Puppet structure.
- *Type*: rvalue
prefix
------
This function applies a prefix to all elements in an array.
*Examles:*
prefix(['a','b','c'], 'p')
Will return: ['pa','pb','pc']
- *Type*: rvalue
range
-----
When given range in the form of (start, stop) it will extrapolate a range as
an array.
*Examples:*
range("0", "9")
Will return: [0,1,2,3,4,5,6,7,8,9]
range("00", "09")
Will return: [0,1,2,3,4,5,6,7,8,9] (Zero padded strings are converted to
integers automatically)
range("a", "c")
Will return: ["a","b","c"]
range("host01", "host10")
Will return: ["host01", "host02", ..., "host09", "host10"]
- *Type*: rvalue
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
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:
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.
- *Type*: statement
reverse
-------
Reverses the order of a string or array.
- *Type*: rvalue
rstrip
------
Strips leading spaces to the right of the string.
- *Type*: rvalue
search
------
Add another namespace for this class to search.
This allows you to create classes with sets of definitions and add
those classes to another class's search path.
- *Type*: statement
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
shuffle
-------
Randomizes the order of a string or array elements.
- *Type*: rvalue
size
----
Returns the number of elements in a string or array.
- *Type*: rvalue
sort
----
Sorts strings and arrays lexically.
- *Type*: rvalue
squeeze
-------
Returns a new string where runs of the same character that occur in this set are replaced by a single character.
- *Type*: rvalue
str2bool
--------
This converts a string to a boolean. This attempt to convert strings that
contain things like: y, 1, t, true to 'true' and strings that contain things
like: 0, f, n, false, no to 'false'.
- *Type*: rvalue
str2saltedsha512
----------------
This converts a string to a salted-SHA512 password hash (which is used for
OS X versions >= 10.7). Given any simple string, you will get a hex version
of a salted-SHA512 password hash that can be inserted into your Puppet
manifests as a valid password attribute.
- *Type*: rvalue
strftime
--------
This function returns formatted time.
*Examples:*
To return the time since epoch:
strftime("%s")
To return the date:
strftime("%Y-%m-%d")
*Format meaning:*
%a - The abbreviated weekday name (``Sun'')
%A - The full weekday name (``Sunday'')
%b - The abbreviated month name (``Jan'')
%B - The full month name (``January'')
%c - The preferred local date and time representation
%C - Century (20 in 2009)
%d - Day of the month (01..31)
%D - Date (%m/%d/%y)
%e - Day of the month, blank-padded ( 1..31)
%F - Equivalent to %Y-%m-%d (the ISO 8601 date format)
%h - Equivalent to %b
%H - Hour of the day, 24-hour clock (00..23)
%I - Hour of the day, 12-hour clock (01..12)
%j - Day of the year (001..366)
%k - hour, 24-hour clock, blank-padded ( 0..23)
%l - hour, 12-hour clock, blank-padded ( 0..12)
%L - Millisecond of the second (000..999)
%m - Month of the year (01..12)
%M - Minute of the hour (00..59)
%n - Newline (
)
%N - Fractional seconds digits, default is 9 digits (nanosecond)
%3N millisecond (3 digits)
%6N microsecond (6 digits)
%9N nanosecond (9 digits)
%p - Meridian indicator (``AM'' or ``PM'')
%P - Meridian indicator (``am'' or ``pm'')
%r - time, 12-hour (same as %I:%M:%S %p)
%R - time, 24-hour (%H:%M)
%s - Number of seconds since 1970-01-01 00:00:00 UTC.
%S - Second of the minute (00..60)
%t - Tab character ( )
%T - time, 24-hour (%H:%M:%S)
%u - Day of the week as a decimal, Monday being 1. (1..7)
%U - Week number of the current year,
starting with the first Sunday as the first
day of the first week (00..53)
%v - VMS date (%e-%b-%Y)
%V - Week number of year according to ISO 8601 (01..53)
%W - Week number of the current year,
starting with the first Monday as the first
day of the first week (00..53)
%w - Day of the week (Sunday is 0, 0..6)
%x - Preferred representation for the date alone, no time
%X - Preferred representation for the time alone, no date
%y - Year without a century (00..99)
%Y - Year with century
%z - Time zone as hour offset from UTC (e.g. +0900)
%Z - Time zone name
%% - Literal ``%'' character
- *Type*: rvalue
strip
-----
This function removes leading and trailing whitespace from a string or from
every string inside an array.
*Examples:*
strip(" aaa ")
Would result in: "aaa"
- *Type*: rvalue
swapcase
--------
This function will swap the existing case of a string.
*Examples:*
swapcase("aBcD")
Would result in: "AbCd"
- *Type*: rvalue
time
----
This function will return the current time since epoch as an integer.
*Examples:*
time()
Will return something like: 1311972653
- *Type*: rvalue
to_bytes
--------
Converts the argument into bytes, for example 4 kB becomes 4096.
Takes a single string value as an argument.
- *Type*: rvalue
type
----
Returns the type when passed a variable. Type can be one of:
* string
* array
* hash
* float
* integer
* boolean
- *Type*: rvalue
unique
------
This function will remove duplicates from strings and arrays.
*Examples:*
unique("aabbcc")
Will return:
abc
You can also use this with arrays:
unique(["a","a","b","b","c","c"])
This returns:
["a","b","c"]
- *Type*: rvalue
upcase
------
Converts a string or an array of strings to uppercase.
*Examples:*
upcase("abcd")
Will return:
ASDF
- *Type*: rvalue
validate_absolute_path
----------------------
Validate the string represents an absolute path in the filesystem. This function works
Validate that all passed values are string data structures. Abort catalog
compilation if any value fails this check.
The following values will pass:
$my_string = "one two"
validate_string($my_string, 'three')
The following values will fail, causing compilation to abort:
validate_string(true)
validate_string([ 'some', 'array' ])
$undefined = undef
validate_string($undefined)
- *Type*: statement
values
------
When given a hash this function will return the values of that hash.
*Examples:*
$hash = {
'a' => 1,
'b' => 2,
'c' => 3,
}
values($hash)
This example would return:
[1,2,3]
- *Type*: rvalue
values_at
---------
Finds value inside an array based on location.
The first argument is the array you want to analyze, and the second element can
be a combination of:
* A single numeric index
* A range in the form of 'start-stop' (eg. 4-9)
* An array combining the above
*Examples*:
values_at(['a','b','c'], 2)
Would return ['c'].
values_at(['a','b','c'], ["0-1"])
Would return ['a','b'].
values_at(['a','b','c','d','e'], [0, "2-3"])
Would return ['a','c','d'].
- *Type*: rvalue
zip
---
Takes one element from first array and merges corresponding elements from second array. This generates a sequence of n-element arrays, where n is one more than the count of arguments.
