puppet 4.2.0 → 4.3.0

data/lib/puppet/functions/inline_epp.rb

@@ -1,74 +1,47 @@
-# Evaluates an Embedded Puppet Template (EPP) string and returns the rendered text result as a String.
-#
-# EPP support the following tags:
-#
-# * `<%= puppet expression %>` - This tag renders the value of the expression it contains.
-# * `<% puppet expression(s) %>` - This tag will execute the expression(s) it contains, but renders nothing.
-# * `<%# comment %>` - The tag and its content renders nothing.
-# * `<%%` or `%%>` - Renders a literal `<%` or `%>` respectively.
-# * `<%-` - Same as `<%` but suppresses any leading whitespace.
-# * `-%>` - Same as `%>` but suppresses any trailing whitespace on the same line (including line break).
-# * `<%- |parameters| -%>` - When placed as the first tag declares the template's parameters.
-#
-# Inline EPP supports the following visibilities of variables in scope which depends on how EPP parameters
-# are used - see further below:
-#
-# * Global scope (i.e. top + node scopes) - global scope is always visible
-# * Global + Enclosing scope - if the EPP template does not declare parameters, and no arguments are given
-# * Global + all given arguments - if the EPP template does not declare parameters, and arguments are given
-# * Global + declared parameters - if the EPP declares parameters, given argument names must match
-#
-# EPP supports parameters by placing an optional parameter list as the very first element in the EPP. As an example,
-# `<%- |$x, $y, $z='unicorn'| -%>` when placed first in the EPP text declares that the parameters `x` and `y` must be
-# given as template arguments when calling `inline_epp`, and that `z` if not given as a template argument
-# defaults to `'unicorn'`. Template parameters are available as variables, e.g.arguments `$x`, `$y` and `$z` in the example.
-# Note that `<%-` must be used or any leading whitespace will be interpreted as text
-#
-# Arguments are passed to the template by calling `inline_epp` with a Hash as the last argument, where parameters
-# are bound to values, e.g. `inline_epp('...', {'x'=>10, 'y'=>20})`. Excess arguments may be given
-# (i.e. undeclared parameters) only if the EPP templates does not declare any parameters at all.
-# Template parameters shadow variables in outer scopes.
-#
-# Note: An inline template is best stated using a single-quoted string, or a heredoc since a double-quoted string
-# is subject to expression interpolation before the string is parsed as an EPP template. Here are examples
-# (using heredoc to define the EPP text):
-#
-# @example Various Examples using `inline_epp`
-#
-#     # produces 'Hello local variable world!'
-#     $x ='local variable'
-#     inline_epptemplate(@(END:epp))
-#     <%- |$x| -%>
-#     Hello <%= $x %> world!
-#     END
-# 
-#     # produces 'Hello given argument world!'
-#     $x ='local variable world'
-#     inline_epptemplate(@(END:epp), { x =>'given argument'})
-#     <%- |$x| -%>
-#     Hello <%= $x %> world!
-#     END
-#
-#     # produces 'Hello given argument world!'
-#     $x ='local variable world'
-#     inline_epptemplate(@(END:epp), { x =>'given argument'})
-#     <%- |$x| -%>
-#     Hello <%= $x %>!
-#     END
-#
-#     # results in error, missing value for y
-#     $x ='local variable world'
-#     inline_epptemplate(@(END:epp), { x =>'given argument'})
-#     <%- |$x, $y| -%>
-#     Hello <%= $x %>!
-#     END
-#
-#     # Produces 'Hello given argument planet'
-#     $x ='local variable world'
-#     inline_epptemplate(@(END:epp), { x =>'given argument'})
-#     <%- |$x, $y=planet| -%>
-#     Hello <%= $x %> <%= $y %>!
-#     END
+# 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](/puppet/latest/reference/lang_data_hash.html) that contains parameters to
+# pass to the template.
+#
+# - See the [template](/puppet/latest/reference/lang_template.html) documentation
+# for general template usage information.
+# - See the [EPP syntax](/puppet/latest/reference/lang_template_epp.html)
+# 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](puppet/latest/reference/lang_data_string.html#heredocs).
+# 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:
+#
+# ~~~ puppet
+# # Outputs 'Hello given argument planet!'
+# inline_epp(@(END), { x => 'given argument' })
+# <%- | $x, $y = planet | -%>
+# Hello <%= $x %> <%= $y %>!
+# END
+# ~~~
 #
 # @since 4.0.0
 #

data/lib/puppet/functions/lookup.rb

@@ -150,18 +150,16 @@
 # - Since 4.0.0
 Puppet::Functions.create_function(:lookup, Puppet::Functions::InternalFunction) do
   name_t = 'Variant[String,Array[String]]'
-  value_type_t = 'Optional[Type]'
+  value_type_t = 'Type'
   default_value_t = 'Any'
-  override_t = 'Optional[Hash[String,Any]]'
-  default_values_hash_t = 'Optional[Hash[String,Any]]'
-  merge_t = 'Optional[Variant[String[1],Hash[String,Scalar]]]'
+  merge_t = 'Variant[String[1],Hash[String,Scalar]]'
   block_t = "Callable[#{name_t}]"
   option_pairs =
-      "value_type=>#{value_type_t},"\
+      "value_type=>Optional[#{value_type_t}],"\
       "default_value=>Optional[#{default_value_t}],"\
-      "override=>#{override_t},"\
-      "default_values_hash=>#{default_values_hash_t},"\
-      "merge=>#{merge_t}"\
+      "override=>Optional[Hash[String,Any]],"\
+      "default_values_hash=>Optional[Hash[String,Any]],"\
+      "merge=>Optional[#{merge_t}]"
 
   dispatch :lookup_1 do
     scope_param
@@ -172,10 +170,10 @@ Puppet::Functions.create_function(:lookup, Puppet::Functions::InternalFunction)
 
   dispatch :lookup_2 do
     scope_param
-    param  name_t,         :name
-    param  value_type_t,   :value_type
-    param  merge_t,        :merge
-    param default_value_t, :default_value
+    param name_t,                     :name
+    param "Optional[#{value_type_t}]", :value_type
+    param "Optional[#{merge_t}]",      :merge
+    param default_value_t,            :default_value
   end
 
   dispatch :lookup_3 do
@@ -202,23 +200,27 @@ Puppet::Functions.create_function(:lookup, Puppet::Functions::InternalFunction)
   end
 
   def lookup_1(scope, name, value_type=nil, merge=nil)
-    Puppet::Pops::Lookup.lookup(scope, name, value_type, nil, false, {}, {}, merge)
+    do_lookup(scope, name, value_type, nil, false, {}, {}, merge)
   end
 
   def lookup_2(scope, name, value_type, merge, default_value)
-    Puppet::Pops::Lookup.lookup(scope, name, value_type, default_value, true, {}, {}, merge)
+    do_lookup(scope, name, value_type, default_value, true, {}, {}, merge)
   end
 
   def lookup_3(scope, name, value_type=nil, merge=nil, &block)
-    Puppet::Pops::Lookup.lookup(scope, name, value_type, nil, false, {}, {}, merge, &block)
+    do_lookup(scope, name, value_type, nil, false, {}, {}, merge, &block)
   end
 
   def lookup_4(scope, options_hash, &block)
-    Puppet::Pops::Lookup.lookup(scope, options_hash['name'], *hash_args(options_hash), &block)
+    do_lookup(scope, options_hash['name'], *hash_args(options_hash), &block)
   end
 
   def lookup_5(scope, name, options_hash, &block)
-    Puppet::Pops::Lookup.lookup(scope, name, *hash_args(options_hash), &block)
+    do_lookup(scope, name, *hash_args(options_hash), &block)
+  end
+
+  def do_lookup(scope, name, value_type, default_value, has_default, override, default_values_hash, merge, &block)
+    Puppet::Pops::Lookup.lookup(name, value_type, default_value, has_default, merge, Puppet::Pops::Lookup::Invocation.new(scope, override, default_values_hash), &block)
   end
 
   def hash_args(options_hash)

data/lib/puppet/functions/map.rb

@@ -1,33 +1,68 @@
-# Applies a parameterized block to each element in a sequence of entries from the first
-# argument and returns an array with the result of each invocation of the parameterized block.
+# Applies a [lambda](http://docs.puppetlabs.com/puppet/latest/reference/lang_lambdas.html)
+# to every value in a data structure and returns an array containing the results.
 #
-# This function takes two mandatory arguments: the first should be an Array, Hash, or of Enumerable type
-# (integer, Integer range, or String), and the second a parameterized block as produced by the puppet syntax:
+# This function takes two mandatory arguments, in this order:
 #
-#       $a.map |$x| { ... }
-#       map($a) |$x| { ... }
+# 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.
 #
-# When the first argument `$a` is an Array or of enumerable type, the block is called with each entry in turn.
-# When the first argument is a hash the entry is an array with `[key, value]`.
+# @example Using the `map` function
 #
-# @example Using map with two arguments
+# `$transformed_data = $data.map |$parameter| { <PUPPET CODE BLOCK> }`
 #
-#      # Turns hash into array of values
-#      $a.map |$x|{ $x[1] }
+# or
 #
-#      # Turns hash into array of keys
-#      $a.map |$x| { $x[0] }
+# `$transformed_data = map($data) |$parameter| { <PUPPET CODE BLOCK> }`
 #
-# When using a block with 2 parameters, the element's index (starting from 0) for an array, and the key for a hash
-# is given to the block's first parameter, and the value is given to the block's second parameter.args.
+# When the first argument (`$data` in the above example) is an array, Puppet passes each
+# value in turn to the lambda.
 #
-# @example Using map with two arguments
+# @example Using the `map` function with an array and a one-parameter lambda
 #
-#      # Turns hash into array of values
-#      $a.map |$key,$val|{ $val }
+# ~~~ puppet
+# # 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]
+# ~~~
 #
-#      # Turns hash into array of keys
-#      $a.map |$key,$val|{ $key }
+# 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
+#
+# ~~~ puppet
+# # 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
+#
+# ~~~ puppet
+# # 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
+#
+# ~~~ puppet
+# # 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
 #
@@ -57,7 +92,7 @@ Puppet::Functions.create_function(:map) do
   end
 
   def map_Hash_2(hash)
-      hash.map {|x, y| yield(x, y) }
+    hash.map {|x, y| yield(x, y) }
   end
 
   def map_Enumerable_1(enumerable)

data/lib/puppet/functions/match.rb

@@ -1,19 +1,36 @@
-# Returns the match result of matching a String or Array[String] with one of:
+# Matches a regular expression against a string and returns an array containing the match
+# and any matched capturing groups.
 #
-# * Regexp
-# * String - transformed to a Regexp
-# * Pattern type
-# * Regexp type
+# 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.
 #
-# Returns An Array with the entire match at index 0, and each subsequent submatch at index 1-n.
-# If there was no match, nil (ie. undef) is returned. If the value to match is an Array, a array
-# with mapped match results is returned.
+# 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.
 #
-# @example matching
-#   "abc123".match(/([a-z]+)[1-9]+/)  # => ["abc"]
-#   "abc123".match(/([a-z]+)([1-9]+)/)  # => ["abc", "123"]
+# If the function doesn't find a match, it returns 'undef'.
+#
+# @example Matching a regular expression in a string
+#
+# ~~~ ruby
+# $matches = "abc123".match(/[a-z]+[1-9]+/)
+# # $matches contains [abc123]
+# ~~~
+#
+# @example Matching a regular expressions with grouping captures in a string
+#
+# ~~~ ruby
+# $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
+#
+# ~~~ ruby
+# $matches = ["abc123","def456"].match(/([a-z]+)([1-9]+)/)
+# # $matches contains [[abc123, abc, 123], [def456, def, 456]]
 #
-# See the documentation for "The Puppet Type System" for more information about types.
 # @since 4.0.0
 #
 Puppet::Functions.create_function(:match) do

data/lib/puppet/functions/reduce.rb

@@ -1,61 +1,98 @@
-# Applies a parameterized block to each element in a sequence of entries from the first
-# argument (_the enumerable_) and returns the last result of the invocation of the parameterized block.
-#
-# This function takes two mandatory arguments: the first should be an Array, Hash, or something of
-# enumerable type, and the last a parameterized block as produced by the puppet syntax:
-#
-#       $a.reduce |$memo, $x| { ... }
-#       reduce($a) |$memo, $x| { ... }
-#
-# When the first argument is an Array or someting of an enumerable type, the block is called with each entry in turn.
-# When the first argument is a hash each entry is converted to an array with `[key, value]` before being
-# fed to the block. An optional 'start memo' value may be supplied as an argument between the array/hash
-# and mandatory block.
-#
-#       $a.reduce(start) |$memo, $x| { ... }
-#       reduce($a, start) |$memo, $x| { ... }
-#
-# If no 'start memo' is given, the first invocation of the parameterized block will be given the first and second
-# elements of the enumeration, and if the enumerable has fewer than 2 elements, the first
-# element is produced as the result of the reduction without invocation of the block.
-#
-# On each subsequent invocation, the produced value of the invoked parameterized block is given as the memo in the
-# next invocation.
-#
-# @example Using reduce
-#
-#       # Reduce an array
-#       $a = [1,2,3]
-#       $a.reduce |$memo, $entry| { $memo + $entry }
-#       #=> 6
-#
-#       # Reduce hash values
-#       $a = {a => 1, b => 2, c => 3}
-#       $a.reduce |$memo, $entry| { [sum, $memo[1]+$entry[1]] }
-#       #=> [sum, 6]
-#
-#       # reverse a string
-#       "abc".reduce |$memo, $char| { "$char$memo" }
-#       #=>"cbe"
-#
-# It is possible to provide a starting 'memo' as an argument.
-#
-# @example Using reduce with given start 'memo'
-#
-#       # Reduce an array
-#       $a = [1,2,3]
-#       $a.reduce(4) |$memo, $entry| { $memo + $entry }
-#       #=> 10
-#
-#       # Reduce hash values
-#       $a = {a => 1, b => 2, c => 3}
-#       $a.reduce([na, 4]) |$memo, $entry| { [sum, $memo[1]+$entry[1]] }
-#       #=> [sum, 10]
-#
-# @example Using reduce with an Integer range
-#
-#       Integer[1,4].reduce |$memo, $x| { $memo + $x }
-#       #=> 10
+# Applies a [lambda](https://docs.puppetlabs.com/puppet/latest/reference/lang_lambdas.html)
+# 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
+#
+# ~~~ puppet
+# # 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
+#
+# ~~~ puppet
+# # 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
 #

data/lib/puppet/functions/versioncmp.rb

@@ -0,0 +1,36 @@
+require 'puppet/util/package'
+
+# 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.
+#
+Puppet::Functions.create_function(:versioncmp) do
+
+  dispatch :versioncmp do
+    param 'String', :a
+    param 'String', :b
+  end
+
+  def versioncmp(a, b)
+    Puppet::Util::Package.versioncmp(a, b)
+  end
+end

data/lib/puppet/functions/with.rb

@@ -1,12 +1,20 @@
-# Call a lambda with the given arguments. Since the parameters of the lambda
-# are local to the lambda's scope, this can be used to create private sections
-# of logic in a class so that the variables are not visible outside of the
-# class.
+# Call a [lambda](https://docs.puppetlabs.com/puppet/latest/reference/lang_lambdas.html)
+# with the given arguments and return the result. Since a lambda's scope is
+# [local](https://docs.puppetlabs.com/puppet/latest/reference/lang_lambdas.html#lambda-scope)
+# 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
+# @example Using `with`
 #
-#     # notices the array [1, 2, 'foo']
-#     with(1, 2, 'foo') |$x, $y, $z| { notice [$x, $y, $z] }
+# ~~~ puppet
+# # 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
 #

data/lib/puppet/functions.rb

@@ -349,12 +349,10 @@ module Puppet::Functions
     def block_param(*type_and_name)
       case type_and_name.size
       when 0
-        # the type must be an independent instance since it will be contained in another type
-        type = @all_callables.copy
+        type = @all_callables
         name = :block
       when 1
-        # the type must be an independent instance since it will be contained in another type
-        type = @all_callables.copy
+        type = @all_callables
         name = type_and_name[0]
       when 2
         type_string, name = type_and_name

data/lib/puppet/indirector/catalog/compiler.rb

@@ -47,7 +47,7 @@ class Puppet::Resource::Catalog::Compiler < Puppet::Indirector::Code
     node = node_from_request(request)
     node.trusted_data = Puppet.lookup(:trusted_information) { Puppet::Context::TrustedInformation.local(node) }.to_h
 
-    if catalog = compile(node)
+    if catalog = compile(node, request.options[:code_id])
       return catalog
     else
       # This shouldn't actually happen; we should either return
@@ -82,7 +82,7 @@ class Puppet::Resource::Catalog::Compiler < Puppet::Indirector::Code
   end
 
   # Compile the actual catalog.
-  def compile(node)
+  def compile(node, code_id)
     str = "Compiled catalog for #{node.name}"
     str += " in environment #{node.environment}" if node.environment
     config = nil
@@ -90,7 +90,7 @@ class Puppet::Resource::Catalog::Compiler < Puppet::Indirector::Code
     benchmark(:notice, str) do
       Puppet::Util::Profiler.profile(str, [:compiler, :compile, node.environment, node.name]) do
         begin
-          config = Puppet::Parser::Compiler.compile(node)
+          config = Puppet::Parser::Compiler.compile(node, code_id)
         rescue Puppet::Error => detail
           Puppet.err(detail.to_s) if networked?
           raise