puppet 5.3.4 → 6.29.0

data/lib/puppet/plugins/configuration.rb

@@ -10,6 +10,8 @@ module Puppet::Plugins
     require 'puppet/plugins/syntax_checkers'
     require 'puppet/syntax_checkers/base64'
     require 'puppet/syntax_checkers/json'
+    require 'puppet/syntax_checkers/pp'
+    require 'puppet/syntax_checkers/epp'
 
     def self.load_plugins
       # Register extensions
@@ -17,7 +19,9 @@ module Puppet::Plugins
       {
         SyntaxCheckers::SYNTAX_CHECKERS_KEY => {
           'json' => Puppet::SyntaxCheckers::Json.new,
-          'base64' => Puppet::SyntaxCheckers::Base64.new
+          'base64' => Puppet::SyntaxCheckers::Base64.new,
+          'pp' => Puppet::SyntaxCheckers::PP.new,
+          'epp' => Puppet::SyntaxCheckers::EPP.new
         }
       }
     end

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,17 +90,13 @@ module Adaptable
     #
     def self.adapt(o, &block)
       attr_name = self_attr_name
-      adapter = if o.instance_variable_defined?(attr_name) && value = o.instance_variable_get(attr_name)
-        value
-      else
-        associate_adapter(create_adapter(o), o)
-      end
+      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
@@ -130,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

@@ -2,6 +2,20 @@
 #
 module Puppet::Pops
 module Adapters
+
+  class ObjectIdCacheAdapter < Puppet::Pops::Adaptable::Adapter
+    attr_accessor :cache
+
+    def initialize
+      @cache = {}
+    end
+
+    # Retrieves a mutable hash with all stored values
+    def retrieve(o)
+      @cache[o.__id__] ||= {}
+    end
+  end
+
   # A documentation adapter adapts an object with a documentation string.
   # (The intended use is for a source text parser to extract documentation and store this
   # in DocumentationAdapter instances).
@@ -85,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
@@ -103,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/access_operator.rb

@@ -20,13 +20,18 @@ class AccessOperator
     @semantic = access_expression
   end
 
-  def access (o, scope, *keys)
+  def access(o, scope, *keys)
     @@access_visitor.visit_this_2(self, o, scope, keys)
   end
 
   protected
 
   def access_Object(o, scope, keys)
+    type = Puppet::Pops::Types::TypeCalculator.infer_callable_methods_t(o)
+    if type.is_a?(Puppet::Pops::Types::TypeWithMembers)
+      access_func = type['[]']
+      return access_func.invoke(o, scope, keys) unless access_func.nil?
+    end
     fail(Issues::OPERATOR_NOT_APPLICABLE, @semantic.left_expr, :operator=>'[]', :left_value => o)
   end
 
@@ -144,10 +149,22 @@ class AccessOperator
     end
   end
 
+  def access_PBooleanType(o, scope, keys)
+    keys.flatten!
+    assert_keys(keys, o, 1, 1, TrueClass, FalseClass)
+    Types::TypeFactory.boolean(keys[0])
+  end
+
   def access_PEnumType(o, scope, keys)
     keys.flatten!
+    last = keys.last
+    case_insensitive = false
+    if last == true || last == false
+      keys = keys[0...-1]
+      case_insensitive = last
+    end
     assert_keys(keys, o, 1, Float::INFINITY, String)
-    Types::TypeFactory.enum(*keys)
+    Types::PEnumType.new(keys, case_insensitive)
   end
 
   def access_PVariantType(o, scope, keys)
@@ -278,6 +295,19 @@ class AccessOperator
     Types::TypeFactory.pattern(*keys)
   end
 
+  def access_PURIType(o, scope, keys)
+    keys.flatten!
+    if keys.size == 1
+      param = keys[0]
+      unless Types::PURIType::TYPE_URI_PARAM_TYPE.instance?(param)
+        fail(Issues::BAD_TYPE_SLICE_TYPE, @semantic.keys[0], {:base_type => 'URI-Type', :actual => param.class})
+      end
+      Types::PURIType.new(param)
+    else
+      fail(Issues::BAD_TYPE_SLICE_ARITY, @semantic, {:base_type => 'URI-Type', :min => 1, :actual => keys.size})
+    end
+  end
+
   def access_POptionalType(o, scope, keys)
     keys.flatten!
     if keys.size == 1
@@ -310,10 +340,14 @@ class AccessOperator
 
   def access_PObjectType(o, scope, keys)
     keys.flatten!
-    if keys.size == 1
-      Types::TypeFactory.object(keys[0])
+    if o.resolved? && !o.name.nil?
+      Types::PObjectTypeExtension.create(o, keys)
     else
-      fail(Issues::BAD_TYPE_SLICE_ARITY, @semantic, {:base_type => 'Object-Type', :min => 1, :actual => keys.size})
+      if keys.size == 1
+        Types::TypeFactory.object(keys[0])
+      else
+        fail(Issues::BAD_TYPE_SLICE_ARITY, @semantic, {:base_type => 'Object-Type', :min => 1, :actual => keys.size})
+      end
     end
   end
 

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

@@ -78,13 +78,20 @@ class Closure < CallableSignature
     end
   end
 
-  # Call closure with argument assignment by name
+  def call_by_name_with_scope(scope, args_hash, enforce_parameters)
+    call_by_name_internal(scope, args_hash, enforce_parameters)
+  end
+
   def call_by_name(args_hash, enforce_parameters)
-    closure_scope = enclosing_scope
+    call_by_name_internal(enclosing_scope, args_hash, enforce_parameters)
+  end
+
+  # Call closure with argument assignment by name
+  def call_by_name_internal(closure_scope, args_hash, enforce_parameters)
     if enforce_parameters
       # 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.
+        # Assign all non-nil values, even those that represent non-existent parameters.
         args_hash.each { |k, v| param_scope[k] = v unless v.nil? }
         parameters.each do |p|
           name = p.name
@@ -112,6 +119,7 @@ class Closure < CallableSignature
       @evaluator.evaluate_block_with_bindings(closure_scope, args_hash, @model.body)
     end
   end
+  private :call_by_name_internal
 
   def parameters
     @model.parameters
@@ -211,16 +219,15 @@ class Closure < CallableSignature
   def call_with_scope(scope, args)
     variable_bindings = combine_values_with_parameters(scope, args)
 
-    tc = Types::TypeCalculator.singleton
-    final_args = tc.infer_set(parameters.reduce([]) do |tmp_args, param|
+    final_args = parameters.reduce([]) do |tmp_args, param|
       if param.captures_rest
         tmp_args.concat(variable_bindings[param.name])
       else
         tmp_args << variable_bindings[param.name]
       end
-    end)
+    end
 
-    if type.callable?(final_args)
+    if type.callable_with?(final_args, block_type)
       result = catch(:next) do
         @evaluator.evaluate_block_with_bindings(scope, variable_bindings, @model.body)
       end
@@ -228,7 +235,9 @@ class Closure < CallableSignature
         "value returned from #{closure_name}"
       end
     else
-      raise ArgumentError, Types::TypeMismatchDescriber.describe_signatures(closure_name, [self], final_args)
+      tc = Types::TypeCalculator.singleton
+      args_type = tc.infer_set(final_args)
+      raise ArgumentError, Types::TypeMismatchDescriber.describe_signatures(closure_name, [self], args_type)
     end
   end
 
@@ -301,6 +310,7 @@ class Closure < CallableSignature
       to += param_range[1]
     end
     param_types = Types::PTupleType.new(types, Types::PIntegerType.new(from, to))
+    # The block_type for a Closure is always nil for now, see comment in block_name above
     Types::PCallableType.new(param_types, nil, return_type)
   end
 
@@ -310,7 +320,7 @@ class Closure < CallableSignature
     closure_scope = enclosing_scope
 
     parameters.each do |param|
-      arg_type, param_range = create_param_type(param, closure_scope)
+      arg_type, _ = create_param_type(param, closure_scope)
       key_type = type_factory.string(param.name.to_s)
       key_type = type_factory.optional(key_type) unless param.value.nil?
       members[key_type] = arg_type

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

@@ -124,7 +124,7 @@ protected
     end
   end
 
- def query_AccessExpression(o, scope)
+  def query_AccessExpression(o, scope)
     pops_object = @@evaluator.evaluate(o, scope)
 
     # Convert to Puppet 3 style objects since that is how they are represented

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

@@ -45,13 +45,13 @@ 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)
-          newres = Puppet::Parser::Resource.new(res.type, res.title, @overrides)
+          t = res.type
+          t = Puppet::Pops::Evaluator::Runtime3ResourceSupport.find_resource_type(scope, t)
+          newres = Puppet::Parser::Resource.new(t, res.title, @overrides)
           scope.compiler.add_override(newres)
         end
       end

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

@@ -24,6 +24,6 @@ class Puppet::Pops::Evaluator::Collectors::CatalogCollector < Puppet::Pops::Eval
   end
 
   def to_s
-    "Catalog-Collector[#{@type.to_s}]"
+    "Catalog-Collector[#{@type}]"
   end
 end

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

@@ -44,7 +44,8 @@ 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.resource_type, item.title)
+        existing = @scope.findresource(item.resource_type, item.title)
+        if existing
           unless existing.collector_id == item.collector_id
             raise Puppet::ParseError,
               _("A duplicate resource was found while collecting exported resources, with the type and title %{title}") % { title: item.ref }
@@ -64,6 +65,6 @@ class Puppet::Pops::Evaluator::Collectors::ExportedCollector < Puppet::Pops::Eva
   end
 
   def to_s
-    "Exported-Collector[#{@type.to_s}]"
+    "Exported-Collector[#{@type}]"
   end
 end

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

@@ -16,7 +16,8 @@ class Puppet::Pops::Evaluator::Collectors::FixedSetCollector < Puppet::Pops::Eva
   def collect
     resolved = []
     result = @resources.reduce([]) do |memo, ref|
-      if res = @scope.findresource(ref.to_s)
+      res = @scope.findresource(ref.to_s)
+      if res
         res.virtual = false
         memo << res
         resolved << ref

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

@@ -23,7 +23,7 @@ class CompareOperator
     @@include_visitor ||= Visitor.new(self, "include", 2, 2)
   end
 
-  def equals (a, b)
+  def equals(a, b)
     @@equals_visitor.visit_this_1(self, a, b)
   end
 
@@ -34,7 +34,7 @@ class CompareOperator
   end
 
   # Performs a match of a and b, and returns true if b matches a
-  def match(a, b, scope)
+  def match(a, b, scope = nil)
     @@match_visitor.visit_this_2(self, b, a, scope)
   end
 
@@ -59,6 +59,8 @@ class CompareOperator
   def cmp_Numeric(a, b)
     if b.is_a?(Numeric)
       a <=> b
+    elsif b.is_a?(Time::Timespan) || b.is_a?(Time::Timestamp)
+      -(b <=> a) # compare other way and invert result
     else
       raise ArgumentError.new(_("A Numeric is not comparable to non Numeric"))
     end
@@ -133,7 +135,7 @@ class CompareOperator
   def include_String(a, b, scope)
     case b
     when String
-      # subsstring search downcased
+      # substring search downcased
       a.downcase.include?(b.downcase)
     when Regexp
       matched = a.match(b)           # nil, or MatchData
@@ -200,7 +202,7 @@ class CompareOperator
   def match_Regexp(regexp, left, scope)
     return false unless left.is_a? String
     matched = regexp.match(left)
-    set_match_data(matched, scope) # creates or clears ephemeral
+    set_match_data(matched, scope) unless scope.nil? # creates or clears ephemeral
     !!matched # convert to boolean
   end
 
@@ -245,7 +247,7 @@ class CompareOperator
 
   def match_Symbol(symbol, left, scope)
     return true if symbol == :default
-    equals(left, default, scope)
+    equals(left, default)
   end
 end
 end

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

@@ -0,0 +1,132 @@
+require 'puppet/parser/script_compiler'
+
+module Puppet::Pops
+module Evaluator
+
+# Utility class to help resolve instances of Puppet::Pops::Types::PDeferredType::Deferred
+#
+class DeferredResolver
+  DOLLAR = '$'.freeze
+  DIG    = 'dig'.freeze
+
+  # Resolves and replaces all Deferred values in a catalog's resource attributes
+  # found as direct values or nested inside Array, Hash or Sensitive values.
+  # Deferred values inside of custom Object instances are not resolved as this
+  # is expected to be done by such objects.
+  #
+  # @param facts [Puppet::Node::Facts] the facts object for the node
+  # @param catalog [Puppet::Resource::Catalog] the catalog where all deferred values should be replaced
+  # @param environment [Puppet::Node::Environment] the environment whose anonymous module methods
+  #  are to be mixed into the scope
+  # @return [nil] does not return anything - the catalog is modified as a side effect
+  #
+  def self.resolve_and_replace(facts, catalog, environment = catalog.environment_instance)
+    compiler = Puppet::Parser::ScriptCompiler.new(environment, catalog.name, true)
+    resolver = new(compiler)
+    resolver.set_facts_variable(facts)
+    # TODO:
+    #    # When scripting the trusted data are always local, but set them anyway
+    #    @scope.set_trusted(node.trusted_data)
+    #
+    #    # Server facts are always about the local node's version etc.
+    #    @scope.set_server_facts(node.server_facts)
+
+    resolver.resolve_futures(catalog)
+    nil
+  end
+
+  # Resolves a value such that a direct Deferred, or any nested Deferred values
+  # are resolved and used instead of the deferred value.
+  # A direct Deferred value, or nested deferred values inside of Array, Hash or
+  # Sensitive values are resolved and replaced inside of freshly created
+  # containers.
+  #
+  # The resolution takes place in the topscope of the given compiler.
+  # Variable values are supposed to already have been set.
+  #
+  # @param value [Object] the (possibly nested) value to resolve
+  # @param compiler [Puppet::Parser::ScriptCompiler, Puppet::Parser::Compiler] the compiler in effect
+  # @return [Object] the resolved value (a new Array, Hash, or Sensitive if needed), with all deferred values resolved
+  #
+  def self.resolve(value, compiler)
+    resolver = new(compiler)
+    resolver.resolve(value)
+  end
+
+  def initialize(compiler)
+    @compiler = compiler
+    # Always resolve in top scope
+    @scope = @compiler.topscope
+    @deferred_class = Puppet::Pops::Types::TypeFactory.deferred.implementation_class
+  end
+
+  # @param facts [Puppet::Node::Facts] the facts to set in $facts in the compiler's topscope
+  #
+  def set_facts_variable(facts)
+    @scope.set_facts(facts.nil? ? {} : facts.values)
+  end
+
+  def resolve_futures(catalog)
+    catalog.resources.each do |r|
+      overrides = {}
+      r.parameters.each_pair do |k, v|
+        resolved = resolve(v)
+        # If the value is instance of Sensitive - assign the unwrapped value
+        # and mark it as sensitive if not already marked
+        #
+        if resolved.is_a?(Puppet::Pops::Types::PSensitiveType::Sensitive)
+          resolved = resolved.unwrap
+          unless r.sensitive_parameters.include?(k.to_sym)
+            r.sensitive_parameters = (r.sensitive_parameters + [k.to_sym]).freeze
+          end
+        end
+        overrides[ k ] = resolved
+      end
+      r.parameters.merge!(overrides) unless overrides.empty?
+    end
+  end
+
+  def resolve(x)
+    if x.class == @deferred_class
+      resolve_future(x)
+    elsif x.is_a?(Array)
+      x.map {|v| resolve(v) }
+    elsif x.is_a?(Hash)
+      result = {}
+      x.each_pair {|k,v| result[k] = resolve(v) }
+      result
+    elsif x.is_a?(Puppet::Pops::Types::PSensitiveType::Sensitive)
+      # rewrap in a new Sensitive after resolving any nested deferred values
+      Puppet::Pops::Types::PSensitiveType::Sensitive.new(resolve(x.unwrap))
+    elsif x.is_a?(Puppet::Pops::Types::PBinaryType::Binary)
+      # use the ASCII-8BIT string that it wraps
+      x.binary_buffer
+    else
+      x
+    end
+  end
+
+  def resolve_future(f)
+    # If any of the arguments to a future is a future it needs to be resolved first
+    func_name = f.name
+    mapped_arguments = map_arguments(f.arguments)
+    # if name starts with $ then this is a call to dig
+    if func_name[0] == DOLLAR
+      var_name = func_name[1..-1]
+      func_name = DIG
+      mapped_arguments.insert(0, @scope[var_name])
+    end
+
+    # call the function (name in deferred, or 'dig' for a variable)
+    @scope.call_function(func_name, mapped_arguments)
+  end
+
+  def map_arguments(args)
+    return [] if args.nil?
+    args.map {|v| resolve(v) }
+  end
+  private :map_arguments
+
+end
+end
+end

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

@@ -53,8 +53,6 @@ class Puppet::Pops::Evaluator::EppEvaluator
     evaluate(parser, 'epp', scope, true, result, template_args)
   end
 
-  private
-
   def self.evaluate(parser, func_name, scope, use_global_scope_only, parse_result, template_args)
     template_args, template_args_set = handle_template_args(func_name, template_args)
 
@@ -82,6 +80,19 @@ class Puppet::Pops::Evaluator::EppEvaluator
       enforce_parameters = true
     end
 
+    # filter out all qualified names and set them in qualified_variables
+    # only pass unqualified (filtered) variable names to the the template
+    filtered_args = {}
+    template_args.each_pair do |k, v|
+      if k =~ /::/
+        k = k[2..-1] if k.start_with?('::')
+        scope[k] = v
+      else
+        filtered_args[k] = v
+      end
+    end
+    template_args = filtered_args
+
     # inline_epp() logic sees all local variables, epp() all global
     if use_global_scope_only
       scope.with_global_scope do |global_scope|
@@ -91,6 +102,7 @@ class Puppet::Pops::Evaluator::EppEvaluator
       parser.closure(body, scope).call_by_name(template_args, enforce_parameters)
     end
   end
+  private_class_method :evaluate
 
   def self.handle_template_args(func_name, template_args)
     if template_args.nil?
@@ -104,4 +116,5 @@ class Puppet::Pops::Evaluator::EppEvaluator
       [template_args, true]
     end
   end
+  private_class_method :handle_template_args
 end