puppet 5.0.0 → 6.0.0

data/lib/puppet/parser/script_compiler.rb

@@ -0,0 +1,123 @@
+require 'puppet/loaders'
+require 'puppet/pops'
+
+# A Script "compiler" that does not support catalog operations
+#
+# The Script compiler is "one shot" - it does not support rechecking if underlying source has changed or
+# deal with possible errors in a cached environment.
+#
+class Puppet::Parser::ScriptCompiler
+  # Allows the ScriptCompiler to use the 3.x Scope class without being an actual "Compiler"
+  #
+  include Puppet::Parser::AbstractCompiler
+
+  # @api private
+  attr_reader :topscope
+
+  # @api private
+  attr_reader :qualified_variables
+
+  # Access to the configured loaders for 4x
+  # @return [Puppet::Pops::Loader::Loaders] the configured loaders
+  # @api private
+  attr_reader :loaders
+
+  # @api private
+  attr_reader :environment
+
+  # @api private
+  attr_reader :node_name
+
+  def with_context_overrides(description = '', &block)
+    Puppet.override( @context_overrides , description, &block)
+  end
+
+  # Evaluates the configured setup for a script + code in an environment with modules
+  #
+  def compile
+    Puppet[:strict_variables] = true
+    Puppet[:strict] = :error
+
+    # TRANSLATORS, "For running script" is not user facing
+    Puppet.override( @context_overrides , "For running script") do
+
+      #TRANSLATORS "main" is a function name and should not be translated
+      result = Puppet::Util::Profiler.profile(_("Script: Evaluated main"), [:script, :evaluate_main]) { evaluate_main }
+      if block_given?
+        yield self
+      else
+        result
+      end
+    end
+
+  rescue Puppet::ParseErrorWithIssue => detail
+    detail.node = node_name
+    Puppet.log_exception(detail)
+    raise
+  rescue => detail
+    message = "#{detail} on node #{node_name}"
+    Puppet.log_exception(detail, message)
+    raise Puppet::Error, message, detail.backtrace
+  end
+
+  # Constructs the overrides for the context
+  def context_overrides()
+    {
+      :current_environment => environment,
+      :global_scope => @topscope,             # 4x placeholder for new global scope
+      :loaders  => @loaders,                  # 4x loaders
+      :rich_data => true,
+    }
+  end
+
+  # Create a script compiler for the given environment where errors are logged as coming
+  # from the given node_name
+  #
+  def initialize(environment, node_name, for_agent=false)
+    @environment = environment
+    @node_name = node_name
+
+    # Create the initial scope, it is needed early
+    @topscope = Puppet::Parser::Scope.new(self)
+
+    # Initialize loaders and Pcore
+    if for_agent
+      @loaders = Puppet::Pops::Loaders.new(environment, true)
+    else
+      @loaders = Puppet::Pops::Loaders.new(environment)
+    end
+
+    # Need to compute overrides here, and remember them, because we are about to
+    # Expensive entries in the context are bound lazily.
+    @context_overrides = context_overrides()
+
+    # Resolutions of fully qualified variable names
+    @qualified_variables = {}
+  end
+
+  # Having multiple named scopes hanging from top scope is not supported when scripting
+  # in the regular compiler this is used to create one named scope per class.
+  # When scripting, the "main class" is just a container of the top level code to evaluate
+  # and it is not evaluated as a class added to a catalog. Since classes are not supported
+  # there is no need to support the concept of "named scopes" as all variables are local
+  # or in the top scope itself (notably, the $settings:: namespace is initialized
+  # as just a set of variables in that namespace - there is no named scope for 'settings'
+  # when scripting.
+  # 
+  # Keeping this method here to get specific error as being unsure if there are functions/logic
+  # that will call this. The AbstractCompiler defines this method, but maybe it does not
+  # have to (TODO).
+  #
+  def newscope(parent, options = {})
+     raise _('having multiple named scopes is not supported when scripting')
+  end
+
+  private
+
+  # Find and evaluate the top level code.
+  def evaluate_main
+    @loaders.pre_load
+    program = @loaders.load_main_manifest
+    return program.nil? ? nil : Puppet::Pops::Parser::EvaluatingParser.singleton.evaluator.evaluate(program, @topscope)
+  end
+end

data/lib/puppet/parser/templatewrapper.rb

@@ -62,7 +62,7 @@ class Puppet::Parser::TemplateWrapper
   # @api private
   def file=(filename)
     unless @__file__ = Puppet::Parser::Files.find_template(filename, scope.compiler.environment)
-      raise Puppet::ParseError, "Could not find template '#{filename}'"
+      raise Puppet::ParseError, _("Could not find template '%{filename}'") % { filename: filename }
     end
   end
 
@@ -78,7 +78,8 @@ class Puppet::Parser::TemplateWrapper
     # Expose all the variables in our scope as instance variables of the
     # current object, making it possible to access them without conflict
     # to the regular methods.
-    benchmark(:debug, _("Bound template variables for %{template_source}") % { template_source: template_source }) do
+    escaped_template_source = template_source.gsub(/%/, '%%')
+    benchmark(:debug, _("Bound template variables for %{template_source} in %%{seconds} seconds") % { template_source: escaped_template_source }) do
       scope.to_hash.each do |name, value|
         realname = name.gsub(/[^\w]/, "_")
         instance_variable_set("@#{realname}", value)
@@ -86,7 +87,7 @@ class Puppet::Parser::TemplateWrapper
     end
 
     result = nil
-    benchmark(:debug, _("Interpolated template %{template_source}") % { template_source: template_source }) do
+    benchmark(:debug, _("Interpolated template %{template_source} in %%{seconds} seconds") % { template_source: escaped_template_source }) do
       template = ERB.new(string, 0, "-")
       template.filename = @__file__
       result = template.result(binding)

data/lib/puppet/parser/type_loader.rb

@@ -70,7 +70,7 @@ class Puppet::Parser::TypeLoader
           Puppet.debug {"Automatically imported #{fqname} from #{filename} into #{environment}"}
           return result
         end
-      rescue TypeLoaderError => detail
+      rescue TypeLoaderError
         # I'm not convinced we should just drop these errors, but this
         # preserves existing behaviours.
       end
@@ -110,20 +110,20 @@ class Puppet::Parser::TypeLoader
     # There is currently one user in indirector/resourcetype/parser
     #
     if Puppet.lookup(:squelch_parse_errors) {|| false }
-        begin
-          loaded_asts << parse_file(file)
-        rescue => e
-          # Resume from errors so that all parseable files may
-          # 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}")
-        end
-      else
+      begin
         loaded_asts << parse_file(file)
+      rescue => e
+        # Resume from errors so that all parseable files may
+        # 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}")
       end
+    else
+      loaded_asts << parse_file(file)
+    end
 
-      @loaded[file] = true
+    @loaded[file] = true
     end
 
     loaded_asts.collect do |ast|

data/lib/puppet/parser.rb

@@ -2,6 +2,7 @@
 module Puppet::Parser; end
 
 require 'puppet/parser/ast'
+require 'puppet/parser/abstract_compiler'
 require 'puppet/parser/compiler'
 require 'puppet/parser/compiler/catalog_validator'
 require 'puppet/resource/type_collection'

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).

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

@@ -27,6 +27,11 @@ class AccessOperator
   protected
 
   def access_Object(o, scope, keys)
+    type = Puppet::Pops::Types::TypeCalculator.infer(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
 
@@ -347,18 +381,25 @@ class AccessOperator
     end
   end
 
-  def access_PType(o, scope, keys)
+  def access_PTypeType(o, scope, keys)
     keys.flatten!
     if keys.size == 1
       unless keys[0].is_a?(Types::PAnyType)
         fail(Issues::BAD_TYPE_SLICE_TYPE, @semantic.keys[0], {:base_type => 'Type-Type', :actual => keys[0].class})
       end
-      Types::PType.new(keys[0])
+      Types::PTypeType.new(keys[0])
     else
       fail(Issues::BAD_TYPE_SLICE_ARITY, @semantic, {:base_type => 'Type-Type', :min => 1, :actual => keys.size})
     end
   end
 
+  def access_PInitType(o, scope, keys)
+    unless keys[0].is_a?(Types::PAnyType)
+      fail(Issues::BAD_TYPE_SLICE_TYPE, @semantic.keys[0], {:base_type => 'Init-Type', :actual => keys[0].class})
+    end
+    Types::TypeFactory.init(*keys)
+  end
+
   def access_PIterableType(o, scope, keys)
     keys.flatten!
     if keys.size == 1
@@ -618,7 +659,7 @@ class AccessOperator
 
   NS = '::'.freeze
 
-  def access_PHostClassType(o, scope, keys)
+  def access_PClassType(o, scope, keys)
     blamed = keys.size == 0 ? @semantic : @semantic.keys[0]
     keys_orig_size = keys.size
 
@@ -651,7 +692,7 @@ class AccessOperator
         name = name[2..-1] if name[0,2] == NS
 
         fail(Issues::ILLEGAL_NAME, @semantic.keys[i], {:name=>c}) unless name =~ Patterns::NAME
-        Types::PHostClassType.new(name)
+        Types::PClassType.new(name)
       end
     else
       # lookup class resource and return one or more parameter values

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
@@ -310,7 +318,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

@@ -10,7 +10,8 @@ class CollectorTransformer
   end
 
   def transform(o, scope)
-    raise ArgumentError, "Expected CollectExpression" unless o.is_a? Model::CollectExpression
+    #TRANSLATORS 'CollectExpression' is a class name and should not be translated
+    raise ArgumentError, _("Expected CollectExpression") unless o.is_a? Model::CollectExpression
 
     raise "LHS is not a type" unless o.type_expr.is_a? Model::QualifiedReference
     type = o.type_expr.value().downcase()
@@ -27,7 +28,7 @@ class CollectorTransformer
       overrides = {
         :parameters => o.operations.map{ |x| @@evaluator.evaluate(x, scope)}.flatten,
         :file       => o.file,
-        :line       => [o.line, o.pos],
+        :line       => o.line,
         :source     => scope.source,
         :scope      => scope
       }
@@ -123,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

@@ -27,7 +27,7 @@ class Puppet::Pops::Evaluator::Collectors::AbstractCollector
     @scope = scope
 
     if !(overrides.nil? || overrides[:parameters])
-      raise ArgumentError, "Exported resource try to override without parameters"
+      raise ArgumentError, _("Exported resource try to override without parameters")
     end
 
     @overrides = overrides

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,127 @@
+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
+  # @return [nil] does not return anything - the catalog is modified as a side effect
+  #
+  def self.resolve_and_replace(facts, catalog)
+    compiler = Puppet::Parser::ScriptCompiler.new(catalog.environment_instance, 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))
+    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