puppet 4.3.2-x64-mingw32 → 4.4.0-x64-mingw32

data/lib/puppet/functions/reverse_each.rb

@@ -0,0 +1,82 @@
+# Reverses the order of the elements of something that is iterable and optionally runs a
+# [lambda](http://docs.puppetlabs.com/puppet/latest/reference/lang_lambdas.html) for each
+# element.
+#
+# This function takes one to two arguments.
+#
+# 1. An `Iterable` that the function will iterate over.
+# 2. An optional lambda, which the function calls for each element in the first argument. It must
+# request one parameter.
+#
+# @example Using the `reverse_each` function
+#
+# `$data.reverse_each |$parameter| { <PUPPET CODE BLOCK> }`
+#
+# or
+#
+# `$reverse_data = $data.reverse_each`
+#
+# or
+#
+# `reverse_each($data) |$parameter| { <PUPPET CODE BLOCK> }`
+#
+# or
+#
+# `$reverse_data = reverse_each($data)`
+#
+# When no second argument is present, Puppet returns an `Iterable` that represents the reverse
+# order of its first argument. This allows methods on `Iterable` to be chained.
+#
+# When a lamdba is given as the second argument, Puppet iterates the first argument in reverse
+# order and passes each value in turn to the lambda, then returns `undef`.
+#
+# @example Using the `reverse_each` function with an array and a one-parameter lambda
+#
+# ~~~ puppet
+# # Puppet will log a notice for each of the three items in $data in reverse order.
+# $data = [1,2,3]
+# $data.reverse_each |$item| { notice($item) }
+#
+# ~~~
+#
+# When no second argument is present, Puppet returns a new `Iterable` which allows it to
+# be directly chained into another function that takes an `Iterable` as an argument.
+#
+# @example Using the `reverse_each` function chained with a `map` function.
+#
+# # For the array $data, return an array containing each value multiplied by 10 in reverse order
+# $data = [1,2,3]
+# $transformed_data = $data.reverse_each.map |$item| { $item * 10 }
+# # $transformed_data is set to [30,20,10]
+# ~~~
+#
+# @example The same example using `reverse_each` function chained with a `map` in alternative syntax
+#
+# # For the array $data, return an array containing each value multiplied by 10 in reverse order
+# $data = [1,2,3]
+# $transformed_data = map(reverse_each($data)) |$item| { $item * 10 }
+# # $transformed_data is set to [30,20,10]
+# ~~~
+#
+# @since 4.4.0
+#
+Puppet::Functions.create_function(:reverse_each) do
+  dispatch :reverse_each do
+    param 'Iterable', :iterable
+  end
+
+  dispatch :reverse_each_block do
+    param 'Iterable', :iterable
+    block_param 'Callable[1,1]', :block
+  end
+
+  def reverse_each(iterable)
+    # produces an Iterable
+    Puppet::Pops::Types::Iterable.asserted_iterable(self, iterable).reverse_each
+  end
+
+  def reverse_each_block(iterable, &block)
+    Puppet::Pops::Types::Iterable.asserted_iterable(self, iterable).reverse_each(&block)
+    nil
+  end
+end

data/lib/puppet/functions/scanf.rb

@@ -1,23 +1,16 @@
-# 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. A parameterized block may optionally be given, which 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 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. 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
-#
-# @example scanning an integer in string form (result is an array with
-#   integer, or empty if  unsuccessful)
+# Scans a string and returns an array of one or more converted values based on the given format string.
+# 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 is
+# the format string. The result of the scan is an array, with each sucessfully scanned and transformed value.
+# The scanning stops if a scan is unsuccesful, and the scanned result up to that point is returned. If there
+# was no succesful scan, the result is an empty array.
+#
 #    "42".scanf("%i")
 #
-# @example scanning and processing resulting array to assert result and unwrap
+# You can also optionally pass a lambda to scanf, to do additional validation or processing.
+#
 #
 #     "42".scanf("%i") |$x| {
 #       unless $x[0] =~ Integer {
@@ -26,6 +19,10 @@
 #       $x[0]
 #     }
 #
+#
+#
+#
+#
 # @since 4.0.0
 #
 Puppet::Functions.create_function(:scanf) do

data/lib/puppet/functions/slice.rb

@@ -1,51 +1,45 @@
-# 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 should be an array or hash, and the second specifies
+# the number of elements to include in each slice.
 #
-# 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
+# When the first argument is a hash, each key value pair is counted as one. For example, 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
+# The function produces a concatenated result of the slices.
 #
 #     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]]
 #
+#
+# You can also optionally pass a lambda to slice.
+#
+#     $a.slice($n) |$x| { ... }
+#     slice($a) |$x| { ... }
+#
+# The lambda 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).
+# If there are fewer remaining elements than the slice size for the last slice, it will contain the remaining
+# elements. If the lambda has multiple parameters, excess parameters are set to undef for an array, or
+# to empty arrays for a hash.
+#
+#     $a.slice(2) |$first, $second| { ... }
+#
 # @since 4.0.0
 #
 Puppet::Functions.create_function(:slice) do
   dispatch :slice_Hash do
     param 'Hash[Any, Any]', :hash
-    param 'Integer[1, default]', :slize_size
+    param 'Integer[1, default]', :slice_size
     optional_block_param
   end
 
   dispatch :slice_Enumerable do
-    param 'Any', :enumerable
-    param 'Integer[1, default]', :slize_size
+    param 'Iterable', :enumerable
+    param 'Integer[1, default]', :slice_size
     optional_block_param
   end
 
@@ -55,7 +49,7 @@ Puppet::Functions.create_function(:slice) do
   end
 
   def slice_Enumerable(enumerable, slice_size, &pblock)
-    enum = asserted_enumerable(enumerable)
+    enum = Puppet::Pops::Types::Iterable.asserted_iterable(self, enumerable)
     result = slice_Common(enum, slice_size, nil, block_given? ? pblock : nil)
     block_given? ? enumerable : result
   end
@@ -114,12 +108,4 @@ Puppet::Functions.create_function(:slice) do
     end
     serving_size
   end
-
-  def asserted_enumerable(obj)
-    unless enum = Puppet::Pops::Types::Enumeration.enumerator(obj)
-      raise ArgumentError, ("#{self.class.name}(): wrong argument type (#{obj.class}; must be something enumerable.")
-    end
-    enum
-  end
-
 end

data/lib/puppet/functions/split.rb

@@ -6,7 +6,7 @@
 #     $string     = 'v1.v2:v3.v4'
 #     $array_var1 = split($string, /:/)
 #     $array_var2 = split($string, '[.]')
-#     $array_var3 = split($string, Regexp('[.:]'))
+#     $array_var3 = split($string, Regexp['[.:]'])
 #
 # `$array_var1` now holds the result `['v1.v2', 'v3.v4']`,
 # while `$array_var2` holds `['v1', 'v2:v3', 'v4']`, and
@@ -15,7 +15,7 @@
 # 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.") do |args|
+# brackets; a backslash will also escape a single character.
 #
 Puppet::Functions.create_function(:split) do
   dispatch :split_String do

data/lib/puppet/functions/step.rb

@@ -0,0 +1,88 @@
+# Provides stepping with given interval over elements in an iterable and optionally runs a
+# [lambda](http://docs.puppetlabs.com/puppet/latest/reference/lang_lambdas.html) for each
+# element.
+#
+# This function takes two to three arguments.
+#
+# 1. An 'Iterable' that the function will iterate over.
+# 2. An `Integer` step factor. This must be a positive integer.
+# 3. An optional lambda, which the function calls for each element in the interval. It must
+# request one parameter.
+#
+# @example Using the `step` function
+#
+# `$data.step(<n>) |$parameter| { <PUPPET CODE BLOCK> }`
+#
+# or
+#
+# `$stepped_data = $data.step(<n>)`
+#
+# or
+#
+# `step($data, <n>) |$parameter| { <PUPPET CODE BLOCK> }`
+#
+# or
+#
+# `$stepped_data = step($data, <n>)`
+#
+# When no block is given, Puppet returns an `Iterable` that yields the first element and every nth successor
+# element, from its first argument. This allows functions on iterables to be chained.
+#
+# When a block is given, Puppet iterates and calls the block with the first element and then with
+# every nth successor element. It then returns `undef`.
+#
+# @example Using the `step` function with an array, a step factor, and a one-parameter block
+#
+# ~~~ puppet
+# # For the array $data, call a block with the first element and then with each 3rd successor element
+# $data = [1,2,3,4,5,6,7,8]
+# $data.step(3) |$item| {
+#  notice($item)
+# }
+# # Puppet notices the values '1', '4', '7'.
+# ~~~
+#
+# When no block is given, Puppet returns a new `Iterable` which allows it to be directly chained into
+# another function that takes an `Iterable` as an argument.
+#
+# @example Using the `step` function chained with a `map` function.
+#
+# # For the array $data, return an array, set to the first element and each 5th successor element, in reverse
+# # order multiplied by 10
+# $data = Integer[0,20]
+# $transformed_data = $data.step(5).map |$item| { $item * 10 }
+# # $transformed_data contains [0,50,100,150,200]
+# ~~~
+#
+# @example The same example using `step` function chained with a `map` in alternative syntax
+#
+# # For the array $data, return an array, set to the first and each 5th successor, in reverse order, multiplied by 10
+# $data = Integer[0,20]
+# $transformed_data = map(step($data, 5)) |$item| { $item * 10 }
+# # $transformed_data contains [0,50,100,150,200]
+# ~~~
+#
+# @since 4.4.0
+#
+Puppet::Functions.create_function(:step) do
+  dispatch :step do
+    param 'Iterable', :iterable
+    param 'Integer[1]', :step
+  end
+
+  dispatch :step_block do
+    param 'Iterable', :iterable
+    param 'Integer[1]', :step
+    block_param 'Callable[1,1]', :block
+  end
+
+  def step(iterable, step)
+    # produces an Iterable
+    Puppet::Pops::Types::Iterable.asserted_iterable(self, iterable).step(step)
+  end
+
+  def step_block(iterable, step, &block)
+    Puppet::Pops::Types::Iterable.asserted_iterable(self, iterable).step(step, &block)
+    nil
+  end
+end

data/lib/puppet/functions/type.rb

@@ -0,0 +1,70 @@
+# Returns the data type of a given value with a given degree of generality.
+#
+# @example Using `type()`
+#
+# ~~~ puppet
+# notice type(42) =~ Type[Integer]
+# ~~~
+#
+# Would notice true
+#
+# By default, the best possible inference is made where all details are retained.
+# This is good when the type is used for futher type calculations but is overwhelmingly
+# rich i information if it is used in a error message.
+#
+# The optional argument `inference_method` may be given as (from lowest to highest fidelity):
+#
+# * ´generalized` - reduces to common type and drops size constraints
+# * `reduced` - reduces to common type in collections
+# * `detailed` - (defaut) all details about inferred types is retained
+#
+# @example Using `type()` with different qualities:
+#
+# ~~~ puppet
+# notice type([3.14, 42], generalized)
+# notice type([3.14, 42], reduced)
+# notice type([3.14, 42], detailed)
+# notice type([3.14, 42])
+# ~~~
+#
+# Would notice the four values:
+#
+# 1. 'Array[Numeric]'
+# 2. 'Array[Numeric, 2, 2]'
+# 3. 'Tuple[Float[3.14], Integer[42,42]]]'
+# 4. 'Tuple[Float[3.14], Integer[42,42]]]'
+#
+# @param value [Any] - the value for which data type is returned
+# @param inference_type[Enum[generalized, reduced, detailed]] inference_type
+# @returns [Type] - the inferred type
+#
+# @since 4.4.0
+#
+Puppet::Functions.create_function(:type) do
+  dispatch :type_detailed do
+    param 'Any', :value
+    optional_param 'Enum[detailed]', :inference_method
+  end
+
+  dispatch :type_parameterized do
+    param 'Any', :value
+    param 'Enum[reduced]', :inference_method
+  end
+
+  dispatch :type_generalized do
+    param 'Any', :value
+    param 'Enum[generalized]', :inference_method
+  end
+
+  def type_detailed(value, _ = nil)
+    Puppet::Pops::Types::TypeCalculator.infer_set(value)
+  end
+
+  def type_parameterized(value, _)
+    Puppet::Pops::Types::TypeCalculator.infer(value)
+  end
+
+  def type_generalized(value, _)
+    Puppet::Pops::Types::TypeCalculator.infer(value).generalize
+  end
+end

data/lib/puppet/graph/rb_tree_map.rb

@@ -26,7 +26,7 @@
 # iterated over in order. This is useful for many datasets.
 #
 # The implementation is adapted from Robert Sedgewick's Left Leaning Red-Black Tree implementation,
-# which can be found at http://www.cs.princeton.edu/~rs/talks/LLRB/Java/RedBlackBST.java
+# which can be found at https://www.cs.princeton.edu/~rs/talks/LLRB/Java/RedBlackBST.java
 #
 # Most methods have O(log n) complexity.
 

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

@@ -2,12 +2,15 @@ require 'puppet/node'
 require 'puppet/resource/catalog'
 require 'puppet/indirector/code'
 require 'puppet/util/profiler'
+require 'puppet/util/checksums'
 require 'yaml'
+require 'uri'
 
 class Puppet::Resource::Catalog::Compiler < Puppet::Indirector::Code
   desc "Compiles catalogs on demand using Puppet's compiler."
 
   include Puppet::Util
+  include Puppet::Util::Checksums
 
   attr_accessor :code
 
@@ -47,7 +50,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, request.options[:code_id])
+    if catalog = compile(node, request.options)
       return catalog
     else
       # This shouldn't actually happen; we should either return
@@ -81,23 +84,203 @@ class Puppet::Resource::Catalog::Compiler < Puppet::Indirector::Code
     node.add_server_facts(@server_facts)
   end
 
+  # Determine which checksum to use; if agent_checksum_type is not nil,
+  # use the first entry in it that is also in known_checksum_types.
+  # If no match is found, return nil.
+  def common_checksum_type(agent_checksum_type)
+    if agent_checksum_type
+      agent_checksum_types = agent_checksum_type.split('.').map {|type| type.to_sym}
+      checksum_type = agent_checksum_types.drop_while do |type|
+        not known_checksum_types.include? type
+      end.first
+    end
+    checksum_type
+  end
+
+  def get_content_uri(metadata, source, environment_path)
+    # The static file content server doesn't know how to expand mountpoints, so
+    # we need to do that ourselves from the actual system path of the source file.
+    # This does that, while preserving any user-specified server or port.
+    source_path = Pathname.new(metadata.full_path)
+    path = source_path.relative_path_from(environment_path).to_s
+    source_as_uri = URI.parse(URI.escape(source))
+    server = source_as_uri.host
+    port = ":#{source_as_uri.port}" if source_as_uri.port
+    return "puppet://#{server}#{port}/#{path}"
+  end
+
+  # Helper method to decide if a file resource's metadata can be inlined.
+  # Also used to profile/log reasons for not inlining.
+  def inlineable?(resource, sources)
+    case
+      when resource[:ensure] == 'absent'
+        return Puppet::Util::Profiler.profile("Not inlining absent resource", [:compiler, :static_compile_inlining, :skipped_file_metadata, :absent]) { false }
+      when sources.empty?
+        return Puppet::Util::Profiler.profile("Not inlining resource without sources", [:compiler, :static_compile_inlining, :skipped_file_metadata, :no_sources]) { false }
+      when (not (sources.all? {|source| source =~ /^puppet:/}))
+        return Puppet::Util::Profiler.profile("Not inlining unsupported source scheme", [:compiler, :static_compile_inlining, :skipped_file_metadata, :unsupported_scheme]) { false }
+      else
+        return true
+    end
+  end
+
+  # Return true if metadata is inlineable, meaning the request's source is
+  # for the 'modules' mount and the resolved path is of the form:
+  #   $codedir/environments/$environment/*/*/files/**
+  def inlineable_metadata?(metadata, source, environment_path)
+    source_as_uri = URI.parse(URI.escape(source))
+    location = Puppet::Module::FILETYPES['files']
+
+    !!(source_as_uri.path =~ /^\/modules\// &&
+       metadata.full_path =~ /#{environment_path}[^\/]+\/[^\/]+\/#{location}\/.+/)
+  end
+
+  # Helper method to log file resources that could not be inlined because they
+  # fall outside of an environment.
+  def log_file_outside_environment
+    Puppet::Util::Profiler.profile("Not inlining file outside environment", [:compiler, :static_compile_inlining, :skipped_file_metadata, :file_outside_environment]) { true }
+  end
+
+  # Helper method to log file resources that were successfully inlined.
+  def log_metadata_inlining
+    Puppet::Util::Profiler.profile("Inlining file metadata", [:compiler, :static_compile_inlining, :inlined_file_metadata]) { true }
+  end
+
+  # Inline file metadata for static catalogs
+  # Initially restricted to files sourced from codedir via puppet:/// uri.
+  def inline_metadata(catalog, checksum_type)
+    environment_path = Pathname.new File.join(Puppet[:environmentpath], catalog.environment, "")
+    list_of_resources = catalog.resources.find_all { |res| res.type == "File" }
+
+    # TODO: get property/parameter defaults if entries are nil in the resource
+    # For now they're hard-coded to match the File type.
+
+    file_metadata = {}
+    list_of_resources.each do |resource|
+      sources = [resource[:source]].flatten.compact
+      next unless inlineable?(resource, sources)
+
+      # both need to handle multiple sources
+      if resource[:recurse] == true || resource[:recurse] == 'true' || resource[:recurse] == 'remote'
+        # Construct a hash mapping sources to arrays (list of files found recursively) of metadata
+        options = {
+          :environment        => catalog.environment_instance,
+          :links              => resource[:links] ? resource[:links].to_sym : :manage,
+          :checksum_type      => resource[:checksum] ? resource[:checksum].to_sym : checksum_type.to_sym,
+          :source_permissions => resource[:source_permissions] ? resource[:source_permissions].to_sym : :ignore,
+          :recurse            => true,
+          :recurselimit       => resource[:recurselimit],
+          :ignore             => resource[:ignore],
+        }
+
+        sources_in_environment = true
+
+        source_to_metadatas = {}
+        sources.each do |source|
+          source = Puppet::Type.type(:file).attrclass(:source).normalize(source)
+
+          if list_of_data = Puppet::FileServing::Metadata.indirection.search(source, options)
+            basedir_meta = list_of_data.find {|meta| meta.relative_path == '.'}
+            devfail "FileServing::Metadata search should always return the root search path" if basedir_meta.nil?
+
+            if ! inlineable_metadata?(basedir_meta, source,  environment_path)
+              # If any source is not in the environment path, skip inlining this resource.
+              log_file_outside_environment
+              sources_in_environment = false
+              break
+            end
+
+            base_content_uri = get_content_uri(basedir_meta, source, environment_path)
+            list_of_data.each do |metadata|
+              if metadata.relative_path == '.'
+                metadata.content_uri = base_content_uri
+              else
+                metadata.content_uri = "#{base_content_uri}/#{metadata.relative_path}"
+              end
+            end
+
+            source_to_metadatas[source] = list_of_data
+            # Optimize for returning less data if sourceselect is first
+            if resource[:sourceselect] == 'first' || resource[:sourceselect].nil?
+              break
+            end
+          end
+        end
+
+        if sources_in_environment && !source_to_metadatas.empty?
+          log_metadata_inlining
+          catalog.recursive_metadata[resource.title] = source_to_metadatas
+        end
+      else
+        options = {
+          :environment        => catalog.environment_instance,
+          :links              => resource[:links] ? resource[:links].to_sym : :manage,
+          :checksum_type      => resource[:checksum] ? resource[:checksum].to_sym : checksum_type.to_sym,
+          :source_permissions => resource[:source_permissions] ? resource[:source_permissions].to_sym : :ignore
+        }
+
+        metadata = nil
+        sources.each do |source|
+          source = Puppet::Type.type(:file).attrclass(:source).normalize(source)
+
+          if data = Puppet::FileServing::Metadata.indirection.find(source, options)
+            metadata = data
+            metadata.source = source
+            break
+          end
+        end
+
+        raise "Could not get metadata for #{resource[:source]}" unless metadata
+
+        if inlineable_metadata?(metadata, metadata.source,  environment_path)
+          metadata.content_uri = get_content_uri(metadata, metadata.source, environment_path)
+          log_metadata_inlining
+
+          # If the file is in the environment directory, we can safely inline
+          catalog.metadata[resource.title] = metadata
+        else
+          # Log a profiler event that we skipped this file because it is not in an environment.
+          log_file_outside_environment
+        end
+      end
+    end
+  end
+
   # Compile the actual catalog.
-  def compile(node, code_id)
-    str = "Compiled catalog for #{node.name}"
+  def compile(node, options)
+    if node.environment && node.environment.static_catalogs? && options[:static_catalog] && options[:code_id]
+      # Check for errors before compiling the catalog
+      checksum_type = common_checksum_type(options[:checksum_type])
+      raise Puppet::Error, "Unable to find a common checksum type between agent '#{options[:checksum_type]}' and master '#{known_checksum_types}'." unless checksum_type
+    end
+
+    str = "Compiled %s for #{node.name}" % [checksum_type ? 'static catalog' : 'catalog']
     str += " in environment #{node.environment}" if node.environment
     config = nil
 
     benchmark(:notice, str) do
-      Puppet::Util::Profiler.profile(str, [:compiler, :compile, node.environment, node.name]) do
+      compile_type = checksum_type ? :static_compile : :compile
+      Puppet::Util::Profiler.profile(str, [:compiler, compile_type, node.environment, node.name]) do
         begin
-          config = Puppet::Parser::Compiler.compile(node, code_id)
+          config = Puppet::Parser::Compiler.compile(node, options[:code_id])
         rescue Puppet::Error => detail
           Puppet.err(detail.to_s) if networked?
           raise
         end
+
+        if checksum_type && config.is_a?(model)
+          str = "Inlined resource metadata into static catalog for #{node.name}"
+          str += " in environment #{node.environment}" if node.environment
+          benchmark(:notice, str) do
+            Puppet::Util::Profiler.profile(str, [:compiler, :static_compile_postprocessing, node.environment, node.name]) do
+              inline_metadata(config, checksum_type)
+            end
+          end
+        end
       end
     end
 
+
     config
   end