puppet 6.16.0-x64-mingw32 → 7.0.0-x64-mingw32

data/lib/puppet/parser/functions/create_resources.rb

@@ -1,5 +1,9 @@
 Puppet::Parser::Functions::newfunction(:create_resources, :arity => -3, :doc => <<-'ENDHEREDOC') do |args|
     Converts a hash into a set of resources and adds them to the catalog.
+    
+    **Note**: Use this function selectively. It's generally better to write resources in
+     [Puppet](https://puppet.com/docs/puppet/latest/lang_resources.html), as
+     resources created with `create_resource` are difficult to read and troubleshoot.
 
     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} }`:
@@ -33,7 +37,7 @@ Puppet::Parser::Functions::newfunction(:create_resources, :arity => -3, :doc =>
     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
+    with @ or @@ respectively. For example, the $myusers hash may be exported
     in the following manner:
 
         create_resources("@@user", $myusers)
@@ -42,9 +46,9 @@ Puppet::Parser::Functions::newfunction(:create_resources, :arity => -3, :doc =>
 
         create_resources("@user", $myusers)
 
-    Note that `create_resources` will filter out parameter values that are `undef` so that normal
-    data binding and puppet default value expressions are considered (in that order) for the
-    final value of a parameter (just as when setting a parameter to `undef` in a puppet language
+    Note that `create_resources` filters out parameter values that are `undef` so that normal
+    data binding and Puppet default value expressions are considered (in that order) for the
+    final value of a parameter (just as when setting a parameter to `undef` in a Puppet language
     resource declaration).
   ENDHEREDOC
   if Puppet[:tasks]
@@ -63,9 +67,9 @@ Puppet::Parser::Functions::newfunction(:create_resources, :arity => -3, :doc =>
   defaults ||= {}
   type_name = type.sub(/^@{1,2}/, '').downcase
 
-  # Get file/line information from the puppet stack (where call comes from in puppet source)
-  # If relayed via other puppet functions in ruby that do not nest their calls, the source position
-  # will be in the original puppet source.
+  # Get file/line information from the Puppet stack (where call comes from in Puppet source)
+  # If relayed via other Puppet functions in ruby that do not nest their calls, the source position
+  # will be in the original Puppet source.
   #
   file, line = Puppet::Pops::PuppetStack.top_of_stack
 

data/lib/puppet/parser/resource.rb

@@ -150,15 +150,6 @@ class Puppet::Parser::Resource < Puppet::Resource
     end
   end
 
-  def is_unevaluated_consumer?
-    # We don't declare a new variable here just to test. Saves memory
-    instance_variable_defined?(:@unevaluated_consumer)
-  end
-
-  def mark_unevaluated_consumer
-    @unevaluated_consumer = true
-  end
-
   # Merge an override resource in.  This will throw exceptions if
   # any overrides aren't allowed.
   def merge(resource)
@@ -260,66 +251,6 @@ class Puppet::Parser::Resource < Puppet::Resource
     super || ((scope_resource = scope.resource) && !scope_resource.equal?(self) && scope_resource.raw_tagged?(tag_array))
   end
 
-  # Fills resource params from a capability
-  #
-  # This backs 'consumes => Sql[one]'
-  # @api private
-  def add_parameters_from_consume
-    return if self[:consume].nil?
-
-    map = {}
-    [ self[:consume] ].flatten.map do |ref|
-      # Assert that the ref really is a resource reference
-      raise Puppet::Error, _("Invalid consume in %{value0}: %{ref} is not a resource") % { value0: self.ref, ref: ref } unless ref.is_a?(Puppet::Resource)
-
-      # Resolve references
-      t = ref.type
-      t = Puppet::Pops::Evaluator::Runtime3ResourceSupport.find_resource_type(scope, t) unless t == 'class' || t == 'node'
-      cap = catalog.resource(t, ref.title)
-      if cap.nil?
-        raise Puppet::Error, _("Resource %{ref} could not be found; it might not have been produced yet") % { ref: ref }
-      end
-
-      # Ensure that the found resource is a capability resource
-      raise Puppet::Error, _("Invalid consume in %{ref}: %{cap} is not a capability resource") % { ref: ref, cap: cap } unless cap.resource_type.is_capability?
-      cap
-    end.each do |cns|
-      # Establish mappings
-      blueprint = resource_type.consumes.find do |bp|
-        bp[:capability] == cns.type
-      end
-      # @todo lutter 2015-08-03: catch this earlier, can we do this during
-      # static analysis ?
-      raise _("Resource %{res} tries to consume %{cns} but no 'consumes' mapping exists for %{resource_type} and %{cns_type}") % { res: self, cns: cns, resource_type: self.resource_type, cns_type: cns.type } unless blueprint
-
-      # setup scope that has, for each attr of cns, a binding to cns[attr]
-      scope.with_global_scope do |global_scope|
-        cns_scope = global_scope.newscope(:source => self, :resource => self)
-        cns.to_hash.each { |name, value| cns_scope[name.to_s] = value }
-
-        # evaluate mappings in that scope
-        resource_type.arguments.keys.each do |name|
-          expr = blueprint[:mappings][name]
-          if expr
-            # Explicit mapping
-            value = expr.safeevaluate(cns_scope)
-          else
-            value = cns[name]
-          end
-          unless value.nil?
-            # @todo lutter 2015-07-01: this should be caught by the checker
-            # much earlier. We consume several capres, at least two of which
-            # want to map to the same parameter (PUP-5080)
-            raise _("Attempt to reassign attribute '%{name}' in '%{resource}' caused by multiple consumed mappings to the same attribute") % { name: name, resource: self } if map[name]
-            map[name] = value
-          end
-        end
-      end
-    end
-
-    map.each { |name, value| self[name] = value if self[name].nil? }
-  end
-
   def offset
     nil
   end
@@ -338,10 +269,11 @@ class Puppet::Parser::Resource < Puppet::Resource
   end
 
   def replace_sensitive_data
-    parameters.each_pair do |name, param|
+    parameters.keys.each do |name|
+      param = parameters[name]
       if param.value.is_a?(Puppet::Pops::Types::PSensitiveType::Sensitive)
         @sensitive_parameters << name
-        param.value = param.value.unwrap
+        parameters[name] = Puppet::Parser::Resource::Param.from_param(param, param.value.unwrap)
       end
     end
   end

data/lib/puppet/parser/resource/param.rb

@@ -26,4 +26,10 @@ class Puppet::Parser::Resource::Param
   def to_s
     "#{self.name} => #{self.value}"
   end
+
+  def self.from_param(param, value)
+    new_param = param.dup
+    new_param.value = value
+    return new_param
+  end
 end

data/lib/puppet/parser/type_loader.rb

@@ -81,7 +81,7 @@ class Puppet::Parser::TypeLoader
   end
 
   def parse_file(file)
-    Puppet.debug("importing '#{file}' in environment #{environment}")
+    Puppet.debug { "importing '#{file}' in environment #{environment}" }
     parser = Puppet::Parser::ParserFactory.parser
     parser.file = file
     return parser.parse
@@ -118,7 +118,7 @@ class Puppet::Parser::TypeLoader
         # still be parsed. Mark this file as loaded so that
         # it would not be parsed next time (handle it as if
         # it was successfully parsed).
-        Puppet.debug("Unable to parse '#{file}': #{e.message}")
+        Puppet.debug { "Unable to parse '#{file}': #{e.message}" }
       end
     else
       loaded_asts << parse_file(file)

data/lib/puppet/pops/adaptable.rb

@@ -69,11 +69,7 @@ module Adaptable
     #
     def self.get(o)
       attr_name = self_attr_name
-      if o.instance_variable_defined?(attr_name)
-        o.instance_variable_get(attr_name)
-      else
-        nil
-      end
+      o.instance_variable_get(attr_name)
     end
 
     # Returns an existing adapter for the given object, or creates a new adapter if the
@@ -94,14 +90,13 @@ module Adaptable
     #
     def self.adapt(o, &block)
       attr_name = self_attr_name
-      value = o.instance_variable_get(attr_name) if o.instance_variable_defined?(attr_name)
+      value = o.instance_variable_get(attr_name)
       adapter = value || associate_adapter(create_adapter(o), o)
       if block_given?
-        case block.arity
-          when 1
-            block.call(adapter)
-          else
-            block.call(adapter, o)
+        if block.arity == 1
+          block.call(adapter)
+        else
+          block.call(adapter, o)
         end
       end
       adapter
@@ -127,8 +122,7 @@ module Adaptable
     def self.adapt_new(o, &block)
       adapter = associate_adapter(create_adapter(o), o)
       if block_given?
-        case block.arity
-        when 1
+        if block.arity == 1
           block.call(adapter)
         else
           block.call(adapter, o)

data/lib/puppet/pops/adapters.rb

@@ -99,6 +99,13 @@ module Adapters
 
     class PathsAndNameCacheAdapter < Puppet::Pops::Adaptable::Adapter
       attr_accessor :cache, :paths
+
+      def self.create_adapter(env)
+        adapter = super(env)
+        adapter.paths = env.modulepath.map { |p| Pathname.new(p) }
+        adapter.cache = {}
+        adapter
+      end
     end
 
     # Attempts to find the module that `instance` originates from by looking at it's {SourcePosAdapter} and
@@ -117,10 +124,7 @@ module Adapters
     def self.loader_name_by_source(environment, instance, file)
       file = instance.file if file.nil?
       return nil if file.nil? || EMPTY_STRING == file
-      pn_adapter = PathsAndNameCacheAdapter.adapt(environment) do |a|
-        a.paths ||= environment.modulepath.map { |p| Pathname.new(p) }
-        a.cache ||= {}
-      end
+      pn_adapter = PathsAndNameCacheAdapter.adapt(environment)
       dir = File.dirname(file)
       pn_adapter.cache.fetch(dir) do |key|
         mod = find_module_for_dir(environment, pn_adapter.paths, dir)

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

@@ -45,9 +45,7 @@ class Puppet::Pops::Evaluator::Collectors::AbstractCollector
     return false if objects.empty?
 
     if @overrides and !objects.empty?
-      overrides[:source].meta_def(:child_of?) do |klass|
-        true
-      end
+      overrides[:source].override = true
 
       objects.each do |res|
         unless @collected.include?(res.ref)

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

@@ -462,10 +462,24 @@ class EvaluatorImpl
   end
 
   def eval_EppExpression(o, scope)
+    contains_sensitive = false
+
     scope["@epp"] = []
     evaluate(o.body, scope)
-    result = scope["@epp"].join
-    result
+    result = scope["@epp"].map do |r|
+      if r.instance_of?(Puppet::Pops::Types::PSensitiveType::Sensitive)
+        contains_sensitive = true
+        string(r.unwrap, scope)
+      else
+        r
+      end
+    end.join
+
+    if contains_sensitive
+      Puppet::Pops::Types::PSensitiveType::Sensitive.new(result)
+    else
+      result
+    end
   end
 
   def eval_RenderStringExpression(o, scope)
@@ -474,7 +488,12 @@ class EvaluatorImpl
   end
 
   def eval_RenderExpression(o, scope)
-    scope["@epp"] << string(evaluate(o.expr, scope), scope)
+    result = evaluate(o.expr, scope)
+    if result.instance_of?(Puppet::Pops::Types::PSensitiveType::Sensitive)
+      scope["@epp"] << result
+    else
+      scope["@epp"] << string(result, scope)
+    end
     nil
   end
 
@@ -876,11 +895,11 @@ class EvaluatorImpl
   def eval_ApplyExpression(o, scope)
     # All expressions are wrapped in an ApplyBlockExpression so we can identify the contents of
     # that block. However we don't want to serialize the block expression, so unwrap here.
-    body = if o.body.statements.count > 1
-      Model::BlockExpression.from_asserted_hash(o.body._pcore_init_hash)
-    else
-      o.body.statements[0]
-    end
+    body = if o.body.statements.count == 1
+             o.body.statements[0]
+           else
+             Model::BlockExpression.from_asserted_hash(o.body._pcore_init_hash)
+           end
 
     Puppet.lookup(:apply_executor).apply(unfold([], o.arguments, scope), body, scope)
   end
@@ -1021,11 +1040,6 @@ class EvaluatorImpl
     end
   end
 
-  # SubLocatable is simply an expression that holds location information
-  def eval_SubLocatedExpression o, scope
-    evaluate(o.expr, scope)
-  end
-
   # Evaluates Puppet DSL Heredoc
   def eval_HeredocExpression o, scope
     expr = o.text_expr

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

@@ -79,9 +79,9 @@ class Runtime3Converter
 
   def convert_String(o, scope, undef_value)
     # Although wasteful, a dup is needed because user code may mutate these strings when applying
-    # Resources. This does not happen when in master mode since it only uses Resources that are
+    # Resources. This does not happen when in server mode since it only uses Resources that are
     # in puppet core and those are all safe.
-    o.frozen? && !Puppet.run_mode.master? ? o.dup : o
+    o.frozen? && !Puppet.run_mode.server? ? o.dup : o
   end
 
   def convert_Object(o, scope, undef_value)

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

@@ -19,7 +19,7 @@ module Runtime3ResourceSupport
       # resolved type is just the string CLASS
       resolved_type = CLASS_STRING
     else
-      # resolve a resource type - pcore based, ruby impl, user defined, or application
+      # resolve a resource type - pcore based, ruby impl or user defined
       resolved_type = find_resource_type(scope, type_name)
     end
 
@@ -109,10 +109,10 @@ module Runtime3ResourceSupport
 
   def self.find_defined_resource_type(scope, type_name)
     krt = scope.environment.known_resource_types
-    krt.find_definition(type_name) || krt.application(type_name)
+    krt.find_definition(type_name)
   end
   private_class_method :find_defined_resource_type
 
 end
 end
-end
+end

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

@@ -505,7 +505,7 @@ module Runtime3Support
       # Store config issues, ignore or warning
       p[Issues::RT_NO_STORECONFIGS_EXPORT]    = Puppet[:storeconfigs] ? :ignore : :warning
       p[Issues::RT_NO_STORECONFIGS]           = Puppet[:storeconfigs] ? :ignore : :warning
-      p[Issues::CLASS_NOT_VIRTUALIZABLE]      = Puppet[:strict] == :off ? :warning : Puppet[:strict]
+      p[Issues::CLASS_NOT_VIRTUALIZABLE]      = :error
       p[Issues::NUMERIC_COERCION]             = Puppet[:strict] == :off ? :ignore : Puppet[:strict]
       p[Issues::SERIALIZATION_DEFAULT_CONVERTED_TO_STRING] = Puppet[:strict] == :off ? :warning : Puppet[:strict]
       p[Issues::SERIALIZATION_UNKNOWN_CONVERTED_TO_STRING] = Puppet[:strict] == :off ? :warning : Puppet[:strict]

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

@@ -16,13 +16,11 @@ class Puppet::Pops::Loader::RubyLegacyFunctionInstantiator
   # @return [Puppet::Pops::Functions.Function] - an instantiated function with global scope closure associated with the given loader
   #
   def self.create(loader, typed_name, source_ref, ruby_code_string)
-    # When func3x turned on, assert content by parsing, when turned off continue with (legacy) undefined behavior
-    if Puppet[:func3x_check]
-      assertion_result = []
-      if assert_code(ruby_code_string, assertion_result)
-        unless ruby_code_string.is_a?(String) && assertion_result.include?(:found_newfunction)
-          raise ArgumentError, _("The code loaded from %{source_ref} does not seem to be a Puppet 3x API function - no 'newfunction' call.") % { source_ref: source_ref }
-        end
+    # Assert content of 3x function by parsing
+    assertion_result = []
+    if assert_code(ruby_code_string, assertion_result)
+      unless ruby_code_string.is_a?(String) && assertion_result.include?(:found_newfunction)
+        raise ArgumentError, _("The code loaded from %{source_ref} does not seem to be a Puppet 3x API function - no 'newfunction' call.") % { source_ref: source_ref }
       end
     end
 
@@ -91,7 +89,7 @@ class Puppet::Pops::Loader::RubyLegacyFunctionInstantiator
     when :def, :defs
       # There should not be any calls to def in a 3x function
       mname, mline = extract_name_line(find_identity(x))
-      raise SecurityError, _("Illegal method definition of method '%{method_name}' on line %{line}' in legacy function. See %{url} for more information") % { 
+      raise SecurityError, _("Illegal method definition of method '%{method_name}' on line %{line} in legacy function. See %{url} for more information") % { 
         method_name: mname,
         line: mline,
         url: "https://puppet.com/docs/puppet/latest/functions_refactor_legacy.html"

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

@@ -7,10 +7,12 @@ module Loader
 #
 # @api private
 class Runtime3TypeLoader < BaseLoader
-  def initialize(parent_loader, loaders, environment, env_path)
+  attr_reader :resource_3x_loader
+
+  def initialize(parent_loader, loaders, environment, resource_3x_loader)
     super(parent_loader, environment.name)
     @environment = environment
-    @resource_3x_loader = env_path.nil? ? nil : ModuleLoaders.pcore_resource_type_loader_from(parent_loader, loaders, env_path)
+    @resource_3x_loader = resource_3x_loader
   end
 
   def discover(type, error_collector = nil, name_authority = Pcore::RUNTIME_NAME_AUTHORITY, &block)

data/lib/puppet/pops/loaders.rb

@@ -18,18 +18,18 @@ class Loaders
   attr_reader :private_environment_loader
   attr_reader :environment
 
-  def self.new(environment, for_agent = false)
+  def self.new(environment, for_agent = false, load_from_pcore = true)
     environment.lock.synchronize do
       obj = environment.loaders
       if obj.nil?
         obj = self.allocate
-        obj.send(:initialize, environment, for_agent)
+        obj.send(:initialize, environment, for_agent, load_from_pcore)
       end
       obj
     end
   end
 
-  def initialize(environment, for_agent)
+  def initialize(environment, for_agent, load_from_pcore = true)
     # Protect against environment havoc
     raise ArgumentError.new(_("Attempt to redefine already initialized loaders for environment")) unless environment.loaders.nil?
     environment.loaders = self
@@ -51,12 +51,13 @@ class Loaders
     #    TODO: loaders need to work when also running in an agent doing catalog application. There is no
     #    concept of environment the same way as when running as a master (except when doing apply).
     #    The creation mechanisms should probably differ between the two.
-    @private_environment_loader = if for_agent
-      @puppet_cache_loader = create_puppet_cache_loader()
-      create_environment_loader(environment, @puppet_cache_loader)
-    else
-      create_environment_loader(environment, @puppet_system_loader)
-    end
+    @private_environment_loader =
+      if for_agent
+        @puppet_cache_loader = create_puppet_cache_loader
+        create_environment_loader(environment, @puppet_cache_loader, load_from_pcore)
+      else
+        create_environment_loader(environment, @puppet_system_loader, load_from_pcore)
+      end
 
     Pcore.init_env(@private_environment_loader)
 
@@ -362,7 +363,7 @@ class Loaders
     Loader::ModuleLoaders.cached_loader_from(puppet_system_loader, self)
   end
 
-  def create_environment_loader(environment, parent_loader)
+  def create_environment_loader(environment, parent_loader, load_from_pcore = true)
     # This defines where to start parsing/evaluating - the "initial import" (to use 3x terminology)
     # Is either a reference to a single .pp file, or a directory of manifests. If the environment becomes
     # a module and can hold functions, types etc. then these are available across all other modules without
@@ -387,7 +388,13 @@ class Loaders
     else
       # Create the 3.x resource type loader
       static_loader.runtime_3_init
-      @runtime3_type_loader = add_loader_by_name(Loader::Runtime3TypeLoader.new(parent_loader, self, environment, env_conf.nil? ? nil : env_path))
+      # Create pcore resource type loader, if applicable
+      pcore_resource_type_loader = if load_from_pcore && env_path
+                                     Loader::ModuleLoaders.pcore_resource_type_loader_from(parent_loader, self, env_path)
+                                   else
+                                     nil
+                                   end
+      @runtime3_type_loader = add_loader_by_name(Loader::Runtime3TypeLoader.new(parent_loader, self, environment, pcore_resource_type_loader))
 
       if env_path.nil?
         # Not a real directory environment, cannot work as a module TODO: Drop when legacy env are dropped?