puppet 4.6.1-x64-mingw32 → 4.6.2-x64-mingw32

data/lib/puppet/functions.rb

@@ -521,7 +521,7 @@ module Puppet::Functions
         @type_parser.parse(t, loader)
       end
 
-      if from != to
+      if from == 0 || from != to
         # :optional and/or :repeated parameters are present.
         mapped_types << from
         mapped_types << to

data/lib/puppet/functions/defined.rb

@@ -126,15 +126,12 @@ Puppet::Functions.create_function(:'defined', Puppet::Functions::InternalFunctio
         end
       when Puppet::Resource
         # Find instance of given resource type and title that is in the catalog
-        scope.compiler.findresource(val.type, val.title)
+        scope.compiler.findresource(val.resource_type, val.title)
 
       when Puppet::Pops::Types::PResourceType
         raise ArgumentError, 'The given resource type is a reference to all kind of types' if val.type_name.nil?
-        if val.title.nil?
-          Puppet::Pops::Evaluator::Runtime3ResourceSupport.find_resource_type(scope, val.type_name)
-        else
-          scope.compiler.findresource(val.type_name, val.title)
-        end
+        type = Puppet::Pops::Evaluator::Runtime3ResourceSupport.find_resource_type(scope, val.type_name)
+        val.title.nil? ? type : scope.compiler.findresource(type, val.title)
 
       when Puppet::Pops::Types::PHostClassType
         raise  ArgumentError, 'The given class type is a reference to all classes' if val.class_name.nil?

data/lib/puppet/parser/environment_compiler.rb

@@ -17,12 +17,34 @@ class Puppet::Parser::EnvironmentCompiler < Puppet::Parser::Compiler
 
   def initialize(node, options = {})
     super
-    add_function_overrides
+    @overridden_functions = {}
   end
 
   def add_function_overrides
-    hiera_include = proc { Puppet.debug "Ignoring hiera_include() during environment catalog compilation" }
-    loaders.puppet_system_loader.add_entry(:function, 'hiera_include', hiera_include, nil)
+    add_function_override('hiera_include', proc { Puppet.debug "Ignoring hiera_include() during environment catalog compilation" })
+  end
+
+  def add_function_override(func_name, override)
+    typed_name = Puppet::Pops::Loader::TypedName.new(:function, func_name)
+    loader = loaders.puppet_system_loader
+
+    # Remove and preserve existing entry. A `nil` is also preserved to indicate
+    # an override that didn't replace a loaded function.
+    entry = loader.get_entry(typed_name)
+    existing = entry.nil? ? nil : entry.value
+    loader.remove_entry(typed_name) unless existing.nil?
+    @overridden_functions[typed_name] = existing
+
+    # Add the override to the loader
+    loader.set_entry(typed_name, override)
+  end
+
+  def remove_function_overrides
+    loader = loaders.puppet_system_loader
+    @overridden_functions.each_pair do |typed_name, overridden|
+      loader.remove_entry(typed_name)
+      loader.set_entry(typed_name, overridden) unless overridden.nil?
+    end
   end
 
   def add_catalog_validators
@@ -32,38 +54,43 @@ class Puppet::Parser::EnvironmentCompiler < Puppet::Parser::Compiler
   end
 
   def compile
-    Puppet.override(@context_overrides, "For compiling environment catalog #{environment.name}") do
-      @catalog.environment_instance = environment
+    add_function_overrides
+    begin
+      Puppet.override(@context_overrides, "For compiling environment catalog #{environment.name}") do
+        @catalog.environment_instance = environment
 
-      Puppet::Util::Profiler.profile("Env Compile: Created settings scope", [:compiler, :create_settings_scope]) { create_settings_scope }
+        Puppet::Util::Profiler.profile("Env Compile: Created settings scope", [:compiler, :create_settings_scope]) { create_settings_scope }
 
-      activate_binder
+        activate_binder
 
-      Puppet::Util::Profiler.profile("Env Compile: Evaluated main", [:compiler, :evaluate_main]) { evaluate_main }
+        Puppet::Util::Profiler.profile("Env Compile: Evaluated main", [:compiler, :evaluate_main]) { evaluate_main }
 
-      Puppet::Util::Profiler.profile("Env Compile: Evaluated site", [:compiler, :evaluate_site]) { evaluate_site }
+        Puppet::Util::Profiler.profile("Env Compile: Evaluated site", [:compiler, :evaluate_site]) { evaluate_site }
 
-      Puppet::Util::Profiler.profile("Env Compile: Evaluated application instances", [:compiler, :evaluate_applications]) { evaluate_applications }
+        Puppet::Util::Profiler.profile("Env Compile: Evaluated application instances", [:compiler, :evaluate_applications]) { evaluate_applications }
 
-      Puppet::Util::Profiler.profile("Env Compile: Prune", [:compiler, :prune_catalog]) { prune_catalog }
+        Puppet::Util::Profiler.profile("Env Compile: Prune", [:compiler, :prune_catalog]) { prune_catalog }
 
-      Puppet::Util::Profiler.profile("Env Compile: Validate Catalog pre-finish", [:compiler, :validate_pre_finish]) do
-        validate_catalog(CatalogValidator::PRE_FINISH)
-      end
+        Puppet::Util::Profiler.profile("Env Compile: Validate Catalog pre-finish", [:compiler, :validate_pre_finish]) do
+          validate_catalog(CatalogValidator::PRE_FINISH)
+        end
 
-      Puppet::Util::Profiler.profile("Env Compile: Finished catalog", [:compiler, :finish_catalog]) { finish }
+        Puppet::Util::Profiler.profile("Env Compile: Finished catalog", [:compiler, :finish_catalog]) { finish }
 
-      fail_on_unevaluated
+        fail_on_unevaluated
 
-      Puppet::Util::Profiler.profile("Env Compile: Validate Catalog final", [:compiler, :validate_final]) do
-        validate_catalog(CatalogValidator::FINAL)
-      end
+        Puppet::Util::Profiler.profile("Env Compile: Validate Catalog final", [:compiler, :validate_final]) do
+          validate_catalog(CatalogValidator::FINAL)
+        end
 
-      if block_given?
-        yield @catalog
-      else
-        @catalog
+        if block_given?
+          yield @catalog
+        else
+          @catalog
+        end
       end
+    ensure
+      remove_function_overrides
     end
   end
 

data/lib/puppet/parser/resource.rb

@@ -77,7 +77,7 @@ class Puppet::Parser::Resource < Puppet::Resource
       elsif resource_type.nil?
         self.fail "Cannot find definition #{type}"
       else
-        finish(false) # Call finish but do not validate
+        finish_evaluation() # do not finish completely (as that destroys Sensitive data)
         resource_type.evaluate_code(self)
       end
     end
@@ -94,8 +94,18 @@ class Puppet::Parser::Resource < Puppet::Resource
     end
   end
 
-  # Do any finishing work on this object, called before evaluation or
-  # before storage/translation. The method does nothing the second time
+  # Finish the evaluation by assigning defaults and scope tags
+  # @api private
+  #
+  def finish_evaluation
+    return if @evaluation_finished
+    add_defaults
+    add_scope_tags
+    @evaluation_finished = true
+  end
+
+  # Do any finishing work on this object, called before
+  # storage/translation. The method does nothing the second time
   # it is called on the same resource.
   #
   # @param do_validate [Boolean] true if validation should be performed
@@ -104,8 +114,7 @@ class Puppet::Parser::Resource < Puppet::Resource
   def finish(do_validate = true)
     return if finished?
     @finished = true
-    add_defaults
-    add_scope_tags
+    finish_evaluation
     replace_sensitive_data
     validate if do_validate
   end

data/lib/puppet/pops/evaluator/closure.rb

@@ -41,8 +41,8 @@ class Closure < CallableSignature
 
   # Call closure with argument assignment by name
   def call_by_name(args_hash, enforce_parameters)
+    closure_scope = enclosing_scope
     if enforce_parameters
-      closure_scope = enclosing_scope
       # Push a temporary parameter scope used while resolving the parameter defaults
       closure_scope.with_parameter_scope(closure_name, parameter_names) do |param_scope|
         # Assign all non-nil values, even those that represent non-existent paramaters.
@@ -65,7 +65,7 @@ class Closure < CallableSignature
       Types::TypeMismatchDescriber.validate_parameters(closure_name, params_struct, args_hash)
     end
 
-    @evaluator.evaluate_block_with_bindings(enclosing_scope, args_hash, @model.body)
+    @evaluator.evaluate_block_with_bindings(closure_scope, args_hash, @model.body)
   end
 
   def parameters

data/lib/puppet/pops/evaluator/collectors/exported_collector.rb

@@ -44,7 +44,7 @@ class Puppet::Pops::Evaluator::Collectors::ExportedCollector < Puppet::Pops::Eva
       found_resources = found.map {|x| x.is_a?(Puppet::Parser::Resource) ? x : x.to_resource(@scope)}
 
       found_resources.each do |item|
-        if existing = @scope.findresource(item.type, item.title)
+        if existing = @scope.findresource(item.resource_type, item.title)
           unless existing.collector_id == item.collector_id
             raise Puppet::ParseError,
               "A duplicate resource was found while collecting exported resources, with the type and title #{item.ref}"

data/lib/puppet/pops/evaluator/runtime3_converter.rb

@@ -138,8 +138,9 @@ class Runtime3Converter
     # due to Puppet::Resource's idiosyncratic behavior where some references must be
     # absolute and others cannot be.
     # Thus there is no need to call scope.resolve_type_and_titles to do dynamic lookup.
-
-    Puppet::Resource.new(*catalog_type_to_split_type_title(o))
+    t, title = catalog_type_to_split_type_title(o)
+    t = Runtime3ResourceSupport.find_resource_type(scope, t) unless t == 'class' || t == 'node'
+    Puppet::Resource.new(t, title)
   end
   alias :convert2_PCatalogEntryType :convert_PCatalogEntryType
 

data/lib/puppet/pops/evaluator/runtime3_support.rb

@@ -203,6 +203,7 @@ module Runtime3Support
     else
       # transform into the wonderful String representation in 3x
       type, title = Runtime3Converter.instance.catalog_type_to_split_type_title(source)
+      type = Runtime3ResourceSupport.find_resource_type(scope, type) unless type == 'class' || type == 'node'
       source_resource = Puppet::Resource.new(type, title)
     end
     if target.is_a?(Collectors::AbstractCollector)
@@ -211,6 +212,7 @@ module Runtime3Support
     else
       # transform into the wonderful String representation in 3x
       type, title = Runtime3Converter.instance.catalog_type_to_split_type_title(target)
+      type = Runtime3ResourceSupport.find_resource_type(scope, type) unless type == 'class' || type == 'node'
       target_resource = Puppet::Resource.new(type, title)
     end
     # Add the relationship to the compiler for later evaluation.
@@ -343,8 +345,9 @@ module Runtime3Support
       unless r.is_a?(Types::PResourceType) && r.type_name != 'class'
         fail(Issues::ILLEGAL_OVERRIDEN_TYPE, o, {:actual => r} )
       end
+      t = Runtime3ResourceSupport.find_resource_type(scope, r.type_name)
       resource = Puppet::Parser::Resource.new(
-      r.type_name, r.title,
+        t, r.title,
         :parameters => evaluated_parameters,
         :file => file,
         :line => line,

data/lib/puppet/pops/loader/base_loader.rb

@@ -82,6 +82,14 @@ class BaseLoader < Loader
     set_entry(TypedName.new(type, name), value, origin)
   end
 
+  # @api private
+  #
+  def remove_entry(typed_name)
+    unless @named_values.delete(typed_name).nil?
+      @last_result = nil unless @last_result.nil? || typed_name != @last_result.typed_name
+    end
+  end
+
   # Promotes an already created entry (typically from another loader) to this loader
   #
   # @api private

data/lib/puppet/pops/loader/runtime3_type_loader.rb

@@ -63,7 +63,7 @@ class Runtime3TypeLoader < BaseLoader
   #
   def find_impl(typed_name)
     name = typed_name.name
-    te = StaticLoader::BUILTIN_TYPE_NAMES_LC.include?(name) ? nil : @resource_3x_loader.find(typed_name)
+    te = StaticLoader::BUILTIN_TYPE_NAMES_LC.include?(name) ? nil : @resource_3x_loader.load_typed(typed_name)
     if te.nil? || te.value.nil?
       # Look for Puppet::Type
       value = Puppet::Type.type(name) unless typed_name.qualified?

data/lib/puppet/pops/resource/resource_type_impl.rb

@@ -53,6 +53,11 @@ class ResourceTypeImpl
     )
   end
 
+  def eql?(other)
+    other.is_a?(Puppet::CompilableResourceType) && @name == other.name
+  end
+  alias == eql?
+
   # Compares this type against the given _other_ (type) and returns -1, 0, or +1 depending on the order.
   # @param other [Object] the object to compare against (produces nil, if not kind of Type}
   # @return [-1, 0, +1, nil] produces -1 if this type is before the given _other_ type, 0 if equals, and 1 if after.
@@ -138,7 +143,7 @@ class ResourceTypeImpl
       when 0
         # TechDebt: The case of specifying title patterns when having no name vars is unspecified behavior in puppet
         # Here it is silently ignored.
-        []
+        nil
       when 1
         if @title_pattners_hash.nil?
           [ [ /(.*)/m, [ [@key_attributes.first] ] ] ]
@@ -166,6 +171,10 @@ class ResourceTypeImpl
     false
   end
 
+  def is_capability?
+    false
+  end
+
   # Answers if the parameter name is a parameter/attribute of this type
   # This is part of the Puppet::Type API
   # Check if used when compiling (it is triggered in an apply)

data/lib/puppet/property.rb

@@ -367,7 +367,8 @@ class Puppet::Property < Puppet::Parameter
     rescue => detail
       # Certain operations may fail, but we don't want to fail the transaction if we can
       # avoid it
-      Puppet.log_exception(detail, "Unknown failure comparing values #{should} and #{is} using insync? on type: #{self.resource.ref} property: #{self.name}", { :level => :info })
+      msg = "Unknown failure using insync_values? on type: #{self.resource.ref} / property: #{self.name} to compare values #{should} and #{is}"
+      Puppet.info(msg)
 
       # Return nil, ie. unknown
       nil

data/lib/puppet/resource.rb

@@ -226,12 +226,12 @@ class Puppet::Resource
 
       src.to_hash.each do |p, v|
         if v.is_a?(Puppet::Resource)
-          v = Puppet::Resource.new(v.type, v.title)
+          v = v.copy_as_resource
         elsif v.is_a?(Array)
           # flatten resource references arrays
           v = v.flatten if v.flatten.find { |av| av.is_a?(Puppet::Resource) }
           v = v.collect do |av|
-            av = Puppet::Resource.new(av.type, av.title) if av.is_a?(Puppet::Resource)
+            av = av.copy_as_resource if av.is_a?(Puppet::Resource)
             av
           end
         end
@@ -258,7 +258,7 @@ class Puppet::Resource
       #
       # TODO: Further optimizations should be possible as the "type juggling" is
       # not needed when the type implementation is known.
-      # 
+      #
       if type.is_a?(Puppet::CompilableResourceType) || type.is_a?(Puppet::Resource::Type)
         # set the resource type implementation
         self.resource_type = type
@@ -274,25 +274,27 @@ class Puppet::Resource
 
       @type, @title = self.class.type_and_title(type, title)
 
-      if params = attributes[:parameters]
-        extract_parameters(params)
+      rt = resource_type
+
+      if strict? && rt.nil?
+        if self.class?
+          raise ArgumentError, "Could not find declared class #{title}"
+        else
+          raise ArgumentError, "Invalid resource type #{type}"
+        end
       end
 
-      if resource_type && resource_type.respond_to?(:deprecate_params)
-        resource_type.deprecate_params(title, attributes[:parameters])
+      params = attributes[:parameters]
+      unless params.nil? || params.empty?
+        extract_parameters(params)
+        if rt && rt.respond_to?(:deprecate_params)
+          rt.deprecate_params(title, params)
+        end
       end
 
       tag(self.type)
       tag_if_valid(self.title)
     end
-
-    if strict? and ! resource_type
-      if self.class?
-        raise ArgumentError, "Could not find declared class #{title}"
-      else
-        raise ArgumentError, "Invalid resource type #{type}"
-      end
-    end
   end
 
   def ref

data/lib/puppet/resource/catalog.rb

@@ -350,15 +350,18 @@ class Puppet::Resource::Catalog < Puppet::Graph::SimpleGraph
 
   # Look a resource up by its reference (e.g., File[/etc/passwd]).
   def resource(type, title = nil)
-    type, title = Puppet::Resource.type_and_title(type, title)
-    title_key   = [type, title.to_s]
+    # Retain type if it's a type
+    type_name = type.is_a?(Puppet::CompilableResourceType) || type.is_a?(Puppet::Resource::Type) ? type.name : type
+    type_name, title = Puppet::Resource.type_and_title(type_name, title)
+    type = type_name if type.is_a?(String)
+    title_key   = [type_name, title.to_s]
     result = @resource_table[title_key]
     if result.nil?
       # an instance has to be created in order to construct the unique key used when
       # searching for aliases.
       unless @aliases.empty? && !Puppet[:app_management]
         res = Puppet::Resource.new(type, title, { :environment => @environment_instance })
-        result = @resource_table[[type, res.uniqueness_key].flatten]
+        result = @resource_table[[type_name, res.uniqueness_key].flatten]
       end
 
       if result.nil? && Puppet[:app_management]

data/lib/puppet/resource/type.rb

@@ -427,7 +427,15 @@ class Puppet::Resource::Type
   # Validate that all parameters given to the resource are correct
   # @param resource [Puppet::Resource] the resource to validate
   def validate_resource(resource)
-    validate_resource_hash(resource, Hash[resource.parameters.map { |name, value| [name.to_s, value.value] }])
+    # Since Sensitive values have special encoding (in a separate parameter) an unwrapped sensitive value must be
+    # recreated as a Sensitive in order to perform correct type checking.
+    sensitives = Set.new(resource.sensitive_parameters)
+    validate_resource_hash(resource,
+      Hash[resource.parameters.map do |name, value|
+        value_to_validate = sensitives.include?(name) ? Puppet::Pops::Types::PSensitiveType::Sensitive.new(value.value) : value.value
+        [name.to_s, value_to_validate]
+      end
+    ])
   end
 
   # Check whether a given argument is valid.

data/lib/puppet/type/component.rb

@@ -71,6 +71,17 @@ Puppet::Type.newtype(:component) do
     reference.to_s
   end
 
+  # Overrides the default implementation to do nothing.
+  # This type contains data from class/define parameters, but does
+  # not have actual parameters or properties at the Type level. We can
+  # simply ignore anything flagged as sensitive here, since any
+  # contained resources will handle that sensitivity themselves. There
+  # is no risk of this information leaking into reports, since no
+  # Component instances survive the graph transmutation.
+  #
+  def set_sensitive_parameters(sensitive_parameters)
+  end
+
   private
 
   attr_reader :reference

data/lib/puppet/version.rb

@@ -7,7 +7,7 @@
 
 
 module Puppet
-  PUPPETVERSION = '4.6.1'
+  PUPPETVERSION = '4.6.2'
 
   ##
   # version is a public API method intended to always provide a fast and

data/spec/integration/application/apply_spec.rb

@@ -1,5 +1,6 @@
 require 'spec_helper'
 require 'puppet_spec/files'
+require 'puppet_spec/compiler'
 
 describe "apply" do
   include PuppetSpec::Files
@@ -25,6 +26,112 @@ describe "apply" do
       expect(Puppet::FileSystem.exist?(file_to_create)).to be_truthy
       expect(File.read(file_to_create)).to eq("my stuff")
     end
+
+    context 'from environment with a pcore defined resource type' do
+      include PuppetSpec::Compiler
+
+      let!(:envdir) { tmpdir('environments') }
+      let(:env_name) { 'spec' }
+      let(:dir_structure) {
+        {
+          '.resource_types' => {
+            'applytest.pp' => <<-CODE
+            Puppet::Resource::ResourceType3.new(
+              'applytest',
+              [Puppet::Resource::Param.new(String, 'message')],
+              [Puppet::Resource::Param.new(String, 'name', true)])
+          CODE
+          },
+          'modules' => {
+            'amod' => {
+              'lib' => {
+                'puppet' => {
+                  'type' => { 'applytest.rb' => <<-CODE
+Puppet::Type.newtype(:applytest) do
+newproperty(:message) do
+  def sync
+    Puppet.send(@resource[:loglevel], self.should)
+  end
+
+  def retrieve
+    :absent
+  end
+
+  def insync?(is)
+    false
+  end
+
+  defaultto { @resource[:name] }
+end
+
+newparam(:name) do
+  desc "An arbitrary tag for your own reference; the name of the message."
+  Puppet.notice('the Puppet::Type says hello')
+  isnamevar
+end
+end
+                  CODE
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+
+      let(:environments) { Puppet::Environments::Directories.new(envdir, []) }
+      let(:env) { Puppet::Node::Environment.create(:'spec', [File.join(envdir, 'spec', 'modules')]) }
+      let(:node) { Puppet::Node.new('test', :environment => env) }
+      around(:each) do |example|
+        Puppet::Type.rmtype(:applytest)
+        Puppet[:environment] = env_name
+        dir_contained_in(envdir, env_name => dir_structure)
+        Puppet.override(:environments => environments, :current_environment => env) do
+          example.run
+        end
+      end
+
+      it 'does not load the pcore type' do
+        catalog = compile_to_catalog('applytest { "applytest was here":}', node)
+        apply = Puppet::Application[:apply]
+        apply.options[:catalog] = file_containing('manifest', catalog.to_pson)
+
+        Puppet[:environmentpath] = envdir
+        Puppet::Pops::Loader::Runtime3TypeLoader.any_instance.expects(:find).never
+        expect { apply.run }.to have_printed(/the Puppet::Type says hello.*applytest was here/m)
+      end
+
+      # Test just to verify that the Pcore Resource Type and not the Ruby one is produced when the catalog is produced
+      it 'loads pcore resource type instead of ruby resource type during compile' do
+        Puppet[:code] = 'applytest { "applytest was here": }'
+        compiler = Puppet::Parser::Compiler.new(node)
+        tn = Puppet::Pops::Loader::TypedName.new(:resource_type_pp, 'applytest')
+        rt = Puppet::Pops::Resource::ResourceTypeImpl.new('applytest', [Puppet::Pops::Resource::Param.new(String, 'message')], [Puppet::Pops::Resource::Param.new(String, 'name', true)])
+
+        compiler.loaders.runtime3_type_loader.instance_variable_get(:@resource_3x_loader).expects(:set_entry).once.with(tn, rt, is_a(String))
+          .returns(Puppet::Pops::Loader::Loader::NamedEntry.new(tn, rt, nil))
+        expect { compiler.compile }.not_to have_printed(/the Puppet::Type says hello/)
+      end
+
+      it "does not fail when pcore type is loaded twice" do
+        Puppet[:code] = 'applytest { xyz: alias => aptest }; Resource[applytest]'
+        compiler = Puppet::Parser::Compiler.new(node)
+        expect { compiler.compile }.not_to raise_error
+      end
+
+      it "does not load the ruby type when using function 'defined()' on a loaded resource that is missing from the catalog" do
+        # Ensure that the Resource[applytest,foo] is loaded'
+        eval_and_collect_notices('applytest { xyz: }', node)
+
+        # Ensure that:
+        # a) The catalog contains aliases (using a name for the abc resource ensures this)
+        # b) That Resource[applytest,xyz] is not defined in the catalog (although it's loaded)
+        # c) That this doesn't trigger a load of the Puppet::Type
+        notices = eval_and_collect_notices('applytest { abc: name => some_alias }; notice(defined(Resource[applytest,xyz]))', node)
+        expect(notices).to include('false')
+        expect(notices).not_to include('the Puppet::Type says hello')
+      end
+    end
   end
 
   it "applies a given file even when a directory environment is specified" do