puppet 5.3.4 → 6.29.0

data/lib/puppet/pal/script_compiler.rb

@@ -0,0 +1,73 @@
+module Puppet
+module Pal
+
+  class ScriptCompiler < Compiler
+    # Returns the signature of the given plan name
+    # @param plan_name [String] the name of the plan to get the signature of
+    # @return [Puppet::Pal::PlanSignature, nil] returns a PlanSignature, or nil if plan is not found
+    #
+    def plan_signature(plan_name)
+      loader = internal_compiler.loaders.private_environment_loader
+      func = loader.load(:plan, plan_name)
+      if func
+        return PlanSignature.new(func)
+      end
+      # Could not find plan
+      nil
+    end
+
+    # Returns an array of TypedName objects for all plans, optionally filtered by a regular expression.
+    # The returned array has more information than just the leaf name - the typical thing is to just get
+    # the name as showing the following example.
+    #
+    # Errors that occur during plan discovery will either be logged as warnings or collected by the optional
+    # `error_collector` array. When provided, it will receive {Puppet::DataTypes::Error} instances describing
+    # each error in detail and no warnings will be logged.
+    #
+    # @example getting the names of all plans
+    #   compiler.list_plans.map {|tn| tn.name }
+    #
+    # @param filter_regex [Regexp] an optional regexp that filters based on name (matching names are included in the result)
+    # @param error_collector [Array<Puppet::DataTypes::Error>] an optional array that will receive errors during load
+    # @return [Array<Puppet::Pops::Loader::TypedName>] an array of typed names
+    #
+    def list_plans(filter_regex = nil, error_collector = nil)
+      list_loadable_kind(:plan, filter_regex, error_collector)
+    end
+
+    # Returns the signature callable of the given task (the arguments it accepts, and the data type it returns)
+    # @param task_name [String] the name of the task to get the signature of
+    # @return [Puppet::Pal::TaskSignature, nil] returns a TaskSignature, or nil if task is not found
+    #
+    def task_signature(task_name)
+      loader = internal_compiler.loaders.private_environment_loader
+      task = loader.load(:task, task_name)
+      if task
+        return TaskSignature.new(task)
+      end
+      # Could not find task
+      nil
+    end
+
+    # Returns an array of TypedName objects for all tasks, optionally filtered by a regular expression.
+    # The returned array has more information than just the leaf name - the typical thing is to just get
+    # the name as showing the following example.
+    #
+    # @example getting the names of all tasks
+    #   compiler.list_tasks.map {|tn| tn.name }
+    #
+    # Errors that occur during task discovery will either be logged as warnings or collected by the optional
+    # `error_collector` array. When provided, it will receive {Puppet::DataTypes::Error} instances describing
+    # each error in detail and no warnings will be logged.
+    #
+    # @param filter_regex [Regexp] an optional regexp that filters based on name (matching names are included in the result)
+    # @param error_collector [Array<Puppet::DataTypes::Error>] an optional array that will receive errors during load
+    # @return [Array<Puppet::Pops::Loader::TypedName>] an array of typed names
+    #
+    def list_tasks(filter_regex = nil, error_collector = nil)
+      list_loadable_kind(:task, filter_regex, error_collector)
+    end
+  end
+
+end
+end

data/lib/puppet/pal/task_signature.rb

@@ -0,0 +1,58 @@
+module Puppet
+module Pal
+  # A TaskSignature is returned from `task_signature`. Its purpose is to answer questions about the task's parameters
+  # and if it can be run/called with a hash of named parameters.
+  #
+  class TaskSignature
+    def initialize(task)
+      @task = task
+    end
+
+    # Returns whether or not the given arguments are acceptable when running the task.
+    # In addition to returning the boolean outcome, if a block is given, it is called with a string of formatted
+    # error messages that describes the difference between what was given and what is expected. The error message may
+    # have multiple lines of text, and each line is indented one space.
+    #
+    # @param args_hash [Hash] a hash mapping parameter names to argument values
+    # @yieldparam [String] a formatted error message if a type mismatch occurs that explains the mismatch
+    # @return [Boolean] if the given arguments are acceptable when running the task
+    #
+    def runnable_with?(args_hash)
+      params = @task.parameters
+      params_type = if params.nil?
+        T_GENERIC_TASK_HASH
+      else
+        Puppet::Pops::Types::TypeFactory.struct(params)
+      end
+      return true if params_type.instance?(args_hash)
+
+      if block_given?
+        tm = Puppet::Pops::Types::TypeMismatchDescriber.singleton
+        error = if params.nil?
+          tm.describe_mismatch('', params_type, Puppet::Pops::Types::TypeCalculator.infer_set(args_hash))
+        else
+          tm.describe_struct_signature(params_type, args_hash).flatten.map {|e| e.format }.join("\n")
+        end
+        yield "Task #{@task.name}:\n#{error}"
+      end
+      false
+    end
+
+    # Returns the Task instance as a hash
+    #
+    # @return [Hash{String=>Object}] the hash representation of the task
+    def task_hash
+      @task._pcore_init_hash
+    end
+
+    # Returns the Task instance which can be further explored. It contains all meta-data defined for
+    # the task such as the description, parameters, output, etc.
+    #
+    # @return [Puppet::Pops::Types::PuppetObject] An instance of a dynamically created Task class
+    def task
+      @task
+    end
+  end
+
+end
+end

data/lib/puppet/parameter/boolean.rb

@@ -1,7 +1,7 @@
 require 'puppet/coercion'
 
 # This specialized {Puppet::Parameter} handles Boolean options, accepting lots
-# of strings and symbols for both truthiness and falsehood.
+# of strings and symbols for both truth and falsehood.
 #
 class Puppet::Parameter::Boolean < Puppet::Parameter
   def unsafe_munge(value)

data/lib/puppet/parameter/value_collection.rb

@@ -18,9 +18,8 @@ class Puppet::Parameter::ValueCollection
   #
   def aliasvalue(name, other)
     other = other.to_sym
-    unless value = match?(other)
-      raise Puppet::DevError, _("Cannot alias nonexistent value %{value}") % { value: other }
-    end
+    value = match?(other)
+    raise Puppet::DevError, _("Cannot alias nonexistent value %{value}") % { value: other } unless value
 
     value.alias(name)
   end
@@ -35,7 +34,8 @@ class Puppet::Parameter::ValueCollection
       unless values.empty?
         @doc << "Valid values are "
         @doc << @strings.collect do |value|
-          if aliases = value.aliases and ! aliases.empty?
+          aliases = value.aliases
+          if aliases && ! aliases.empty?
             "`#{value.name}` (also called `#{aliases.join(", ")}`)"
           else
             "`#{value.name}`"
@@ -81,9 +81,8 @@ class Puppet::Parameter::ValueCollection
   #
   def match?(test_value)
     # First look for normal values
-    if value = @strings.find { |v| v.match?(test_value) }
-      return value
-    end
+    value = @strings.find { |v| v.match?(test_value) }
+    return value if value
 
     # Then look for a regex match
     @regexes.find { |v| v.match?(test_value) }
@@ -100,7 +99,8 @@ class Puppet::Parameter::ValueCollection
   def munge(value)
     return value if empty?
 
-    if instance = match?(value)
+    instance = match?(value)
+    if instance
       if instance.regex?
         return value
       else

data/lib/puppet/parameter.rb

@@ -1,4 +1,3 @@
-require 'puppet/util/methodhelper'
 require 'puppet/util/logging'
 require 'puppet/util/docs'
 
@@ -22,7 +21,6 @@ class Puppet::Parameter
   include Puppet::Util
   include Puppet::Util::Errors
   include Puppet::Util::Logging
-  include Puppet::Util::MethodHelper
 
   require 'puppet/parameter/value_collection'
 
@@ -93,6 +91,14 @@ class Puppet::Parameter
       end
     end
 
+    def sensitive(value = nil, &block)
+      if block
+        define_method(:is_sensitive, &block)
+      else
+        define_method(:is_sensitive) do value end
+      end
+    end
+
     # Produces a documentation string.
     # If an enumeration of _valid values_ has been defined, it is appended to the documentation
     # for this parameter specified with the {desc} method.
@@ -104,11 +110,13 @@ class Puppet::Parameter
 
       unless defined?(@addeddocvals)
         @doc = Puppet::Util::Docs.scrub(@doc)
-        if vals = value_collection.doc
+        vals = value_collection.doc
+        if vals
           @doc << "\n\n#{vals}"
         end
 
-        if features = self.required_features
+        features = self.required_features
+        if features
           @doc << "\n\nRequires features #{features.flatten.collect { |f| f.to_s }.join(" ")}."
         end
         @addeddocvals = true
@@ -332,16 +340,15 @@ class Puppet::Parameter
   # @api public
   # @note A parameter should be created via the DSL method {Puppet::Type::newparam}
   #
-  def initialize(options = {})
-    options = symbolize_options(options)
-    if resource = options[:resource]
+  def initialize(resource: nil, value: nil, should: nil)
+    if resource
       self.resource = resource
-      options.delete(:resource)
     else
       raise Puppet::DevError, _("No resource set for %{name}") % { name: self.class.name }
     end
 
-    set_options(options)
+    self.value = value if value
+    self.should = should if should
   end
 
   # Writes the given `msg` to the log with the loglevel indicated by the associated resource's
@@ -422,7 +429,7 @@ class Puppet::Parameter
     begin
       ret = unsafe_munge(value)
     rescue Puppet::Error => detail
-      Puppet.debug "Reraising #{detail}"
+      Puppet.debug { "Reraising #{detail}" }
       raise
     rescue => detail
       raise Puppet::DevError, _("Munging failed for value %{value} in class %{class_name}: %{detail}") % { value: value.inspect, class_name: self.name, detail: detail }, detail.backtrace

data/lib/puppet/parser/abstract_compiler.rb

@@ -0,0 +1,36 @@
+
+module Puppet::Parser::AbstractCompiler
+
+  # Returns the catalog for a compilation. Must return a Puppet::Resource::Catalog or fail with an 
+  # error if the specific compiler does not support catalog operations.
+  #
+  def catalog
+    raise Puppet::DevError("Class '#{self.class}' should have implemented 'catalog'")
+  end
+
+  # Returns the environment for the compilation
+  #
+  def environment
+    raise Puppet::DevError("Class '#{self.class}' should have implemented 'environment'")
+  end
+
+  # Produces a new scope
+  # This method is here if there are functions/logic that will call this for some other purpose than to create
+  # a named scope for a class. It may not have to be here. (TODO)
+  #
+  def newscope(scope, options)
+    raise Puppet::DevError("Class '#{self.class}' should have implemented 'newscope'")
+  end
+
+  # Returns a hash of all externally referenceable qualified variables
+  #
+  def qualified_variables
+    raise Puppet::DevError("Class '#{self.class}' should have implemented 'qualified_variables'")
+  end
+
+  # Returns the top scope instance
+  def topscope
+    raise Puppet::DevError("Class '#{self.class}' should have implemented 'topscope'")
+  end
+
+end

data/lib/puppet/parser/ast/branch.rb

@@ -1,7 +1,7 @@
 # The parent class of all AST objects that contain other AST objects.
 # Everything but the really simple objects descend from this.  It is
 # important to note that Branch objects contain other AST objects only --
-# if you want to contain values, use a descendent of the AST::Leaf class.
+# if you want to contain values, use a descendant of the AST::Leaf class.
 #
 # @api private
 class Puppet::Parser::AST::Branch < Puppet::Parser::AST
@@ -12,8 +12,8 @@ class Puppet::Parser::AST::Branch < Puppet::Parser::AST
     @children.each { |child| yield child }
   end
 
-  def initialize(arghash)
-    super(arghash)
-    @children ||= []
+  def initialize(children: [], **args)
+    @children = children
+    super(**args)
   end
 end

data/lib/puppet/parser/ast/leaf.rb

@@ -16,13 +16,18 @@ class Puppet::Parser::AST::Leaf < Puppet::Parser::AST
   def to_s
     @value.to_s unless @value.nil?
   end
+
+  def initialize(value: nil, file: nil, line: nil, pos: nil)
+    @value = value
+    super(file: file, line: line, pos: pos)
+  end
 end
 
 # Host names, either fully qualified or just the short name, or even a regex
 #
 class Puppet::Parser::AST::HostName < Puppet::Parser::AST::Leaf
-  def initialize(hash)
-    super
+  def initialize(value: nil, file: nil, line: nil, pos: nil)
+    super(value: value, file: file, line: line, pos: pos)
 
     # Note that this is an AST::Regex, not a Regexp
     unless @value.is_a?(Regex)
@@ -45,8 +50,9 @@ class Puppet::Parser::AST::HostName < Puppet::Parser::AST::Leaf
 end
 
 class Puppet::Parser::AST::Regex < Puppet::Parser::AST::Leaf
-  def initialize(hash)
-    super
+  def initialize(value: nil, file: nil, line: nil, pos: nil)
+    super(value: value, file: file, line: line, pos: pos)
+
     # transform value from hash options unless it is already a regular expression
     @value = Regexp.new(@value) unless @value.is_a?(Regexp)
   end

data/lib/puppet/parser/ast/pops_bridge.rb

@@ -13,12 +13,6 @@ class Puppet::Parser::AST::PopsBridge
   # expression.
   #
   class Expression < Puppet::Parser::AST::Leaf
-
-    def initialize args
-      super
-      @@evaluator ||= Puppet::Pops::Parser::EvaluatingParser.new()
-    end
-
     def to_s
       Puppet::Pops::Model::ModelTreeDumper.new.dump(@value)
     end
@@ -29,8 +23,9 @@ class Puppet::Parser::AST::PopsBridge
     end
 
     def evaluate(scope)
-      object = @@evaluator.evaluate(scope, @value)
-      @@evaluator.convert_to_3x(object, scope)
+      evaluator = Puppet::Pops::Parser::EvaluatingParser.singleton
+      object = evaluator.evaluate(scope, @value)
+      evaluator.convert_to_3x(object, scope)
     end
 
     # Adapts to 3x where top level constructs needs to have each to iterate over children. Short circuit this
@@ -62,10 +57,6 @@ class Puppet::Parser::AST::PopsBridge
   end
 
   class ExpressionSupportingReturn < Expression
-    def initialize args
-      super
-    end
-
     def evaluate(scope)
       return catch(:return) do
         return catch(:next) do
@@ -87,7 +78,6 @@ class Puppet::Parser::AST::PopsBridge
       @program_model = program_model
       @context = context
       @ast_transformer ||= Puppet::Pops::Model::AstTransformer.new(@context[:file])
-      @@evaluator ||= Puppet::Pops::Parser::EvaluatingParser.new()
     end
 
     # This is the 3x API, the 3x AST searches through all code to find the instructions that can be instantiated.
@@ -95,7 +85,8 @@ class Puppet::Parser::AST::PopsBridge
     # efficient as it avoids one full scan of all logic via recursive enumeration/yield)
     #
     def instantiate(modname)
-      @program_model.definitions.collect do |d|
+
+      @program_model.definitions.map do |d|
         case d
         when Puppet::Pops::Model::HostClassDefinition
           instantiate_HostClassDefinition(d, modname)
@@ -107,29 +98,21 @@ class Puppet::Parser::AST::PopsBridge
           instantiate_NodeDefinition(d, modname)
         when Puppet::Pops::Model::SiteDefinition
             instantiate_SiteDefinition(d, modname)
-        when Puppet::Pops::Model::FunctionDefinition
-          # The 3x logic calling this will not know what to do with the result, it is compacted away at the end
-          instantiate_FunctionDefinition(d, modname)
-          next
-        when Puppet::Pops::Model::TypeAlias
-          # The 3x logic calling this will not know what to do with the result, it is compacted away at the end
-          instantiate_TypeAlias(d, modname)
-          next
-        when Puppet::Pops::Model::TypeMapping
-          # The 3x logic calling this will not know what to do with the result, it is compacted away at the end
-          instantiate_TypeMapping(d, modname)
-          next
         when Puppet::Pops::Model::Application
           instantiate_ApplicationDefinition(d, modname)
         else
-          raise Puppet::ParseError, _("Internal Error: Unknown type of definition - got '%{name}'") % { name: d.class }
+          loaders = Puppet::Pops::Loaders.loaders
+          loaders.instantiate_definition(d, loaders.find_loader(modname))
+
+          # The 3x logic calling this will not know what to do with the result, it is compacted away at the end
+          nil
         end
       end.flatten().compact() # flatten since node definition may have returned an array
-                              # Compact since functions are not understood by compiler
+                              # Compact since 4x definitions are not understood by compiler
     end
 
     def evaluate(scope)
-      @@evaluator.evaluate(scope, program_model)
+      Puppet::Pops::Parser::EvaluatingParser.singleton.evaluate(scope, program_model)
     end
 
     # Adapts to 3x where top level constructs needs to have each to iterate over children. Short circuit this
@@ -139,8 +122,26 @@ class Puppet::Parser::AST::PopsBridge
       yield self
     end
 
+    # Returns true if this Program only contains definitions
+    def is_definitions_only?
+      is_definition?(program_model)
+    end
+
     private
 
+    def is_definition?(o)
+      case o
+      when Puppet::Pops::Model::Program
+        is_definition?(o.body)
+      when Puppet::Pops::Model::BlockExpression
+        o.statements.all {|s| is_definition?(s) }
+      when Puppet::Pops::Model::Definition
+        true
+      else
+        false
+      end
+    end
+
     def instantiate_Parameter(o)
       # 3x needs parameters as an array of `[name]` or `[name, value_expr]`
       if o.value
@@ -165,9 +166,11 @@ class Puppet::Parser::AST::PopsBridge
       # reused and we may reenter without a scope (which is fine). A debug message is then output in case
       # there is the need to track down the odd corner case. See {#obtain_scope}.
       #
-      if scope = obtain_scope
+      scope = obtain_scope
+      if scope
+        evaluator = Puppet::Pops::Parser::EvaluatingParser.singleton
         typed_parameters.each do |p|
-          result[p.name] =  @@evaluator.evaluate(scope, p.type_expr)
+          result[p.name] = evaluator.evaluate(scope, p.type_expr)
         end
       end
       result
@@ -261,43 +264,6 @@ class Puppet::Parser::AST::PopsBridge
       Puppet::Resource::Type.new(:site, 'site', @context.merge(args))
     end
 
-    # Propagates a found Function to the appropriate loader.
-    # This is for 4x evaluator/loader
-    #
-    def instantiate_FunctionDefinition(function_definition, modname)
-      loader = Puppet::Pops::Loaders.find_loader(modname)
-
-      # Instantiate Function, and store it in the loader
-      typed_name, f = Puppet::Pops::Loader::PuppetFunctionInstantiator.create_from_model(function_definition, loader)
-      loader.set_entry(typed_name, f, function_definition.locator.to_uri(function_definition))
-
-      nil # do not want the function to inadvertently leak into 3x
-    end
-
-    # Propagates a found TypeAlias to the appropriate loader.
-    # This is for 4x evaluator/loader
-    #
-    def instantiate_TypeAlias(type_alias, modname)
-      loader = Puppet::Pops::Loaders.find_loader(modname)
-
-      # Bind the type alias to the loader using the alias
-      Puppet::Pops::Loader::TypeDefinitionInstantiator.create_from_model(type_alias, loader)
-
-      nil # do not want the type alias to inadvertently leak into 3x
-    end
-
-    # Adds the TypeMapping to the ImplementationRegistry
-    # This is for 4x evaluator/loader
-    #
-    def instantiate_TypeMapping(type_mapping, modname)
-      loader = Puppet::Pops::Loaders.find_loader(modname)
-      tf = Puppet::Pops::Types::TypeParser.singleton
-      lhs = tf.interpret(type_mapping.type_expr, loader)
-      rhs = tf.interpret_any(type_mapping.mapping_expr, loader)
-      Puppet::Pops::Loaders.implementation_registry.register_type_mapping(lhs, rhs, loader)
-      nil
-    end
-
     def code()
       Expression.new(:value => @value)
     end

data/lib/puppet/parser/ast/resourceparam.rb

@@ -26,6 +26,6 @@ class Puppet::Parser::AST::ResourceParam < Puppet::Parser::AST::Branch
   end
 
   def to_s
-    "#{@param} => #{@value.to_s}"
+    "#{@param} => #{@value}"
   end
 end

data/lib/puppet/parser/ast.rb

@@ -7,12 +7,11 @@ class Puppet::Parser::AST
   AST = Puppet::Parser::AST
 
   include Puppet::Util::Errors
-  include Puppet::Util::MethodHelper
 
   attr_accessor :parent, :scope, :file, :line, :pos
 
   def inspect
-    "( #{self.class} #{self.to_s} #{@children.inspect} )"
+    "( #{self.class} #{self} #{@children.inspect} )"
   end
 
   # Evaluate the current object.  Just a stub method, since the subclass
@@ -44,14 +43,11 @@ class Puppet::Parser::AST
     end
   end
 
-  # Initialize the object.  Requires a hash as the argument, and
-  # takes each of the parameters of the hash and calls the setter
-  # method for them.  This is probably pretty inefficient and should
-  # likely be changed at some point.
-  def initialize(args)
-    set_options(args)
+  def initialize(file: nil, line: nil, pos: nil)
+    @file = file
+    @line = line
+    @pos = pos
   end
-
 end
 
 # And include all of the AST subclasses.

data/lib/puppet/parser/catalog_compiler.rb

@@ -0,0 +1,56 @@
+require 'puppet/loaders'
+require 'puppet/pops'
+
+# A Catalog "compiler" that is like the regular compiler but with an API
+# that is harmonized with the ScriptCompiler
+#
+# 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::CatalogCompiler < Puppet::Parser::Compiler
+
+  # Evaluates the configured setup for a script + code in an environment with modules
+  #
+  def compile
+    Puppet[:strict_variables] = true
+    Puppet[:strict] = :error
+
+    Puppet.override(rich_data: true) do
+      super
+    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
+
+  # Evaluates all added constructs, and validates the resulting catalog.
+  # This can be called whenever a series of evaluation of puppet code strings
+  # have reached a stable state (essentially that there are no relationships to
+  # non-existing resources).
+  #
+  # Raises an error if validation fails.
+  #
+  def compile_additions
+    evaluate_additions
+    validate
+  end
+
+  # Evaluates added constructs that are lazily evaluated until all of them have been evaluated.
+  # 
+  def evaluate_additions
+    evaluate_generators
+    finish
+  end
+
+  # Validates the current state of the catalog.
+  # Does not cause evaluation of lazy constructs.
+  def validate
+    validate_catalog(CatalogValidator::FINAL)
+  end
+end

data/lib/puppet/parser/compiler/catalog_validator/env_relationship_validator.rb

@@ -1,7 +1,9 @@
 class Puppet::Parser::Compiler
   # Validator that asserts that all capability resources that are referenced by 'consume' or 'require' has
   # been exported by some other resource in the environment
- class CatalogValidator::EnvironmentRelationshipValidator < CatalogValidator
+  #
+  # @deprecated application orchestration will be removed in puppet 7
+  class CatalogValidator::EnvironmentRelationshipValidator < CatalogValidator
 
     def validate
       assumed_exports = {}

data/lib/puppet/parser/compiler/catalog_validator/relationship_validator.rb

@@ -32,8 +32,15 @@ class Puppet::Parser::Compiler
         refs = param.value.is_a?(Array) ? param.value.flatten : [param.value]
         refs.each do |r|
           next if r.nil? || r == :undef
-          unless catalog.resource(r.to_s)
-            msg = _("Could not find resource '%{res}' in parameter '%{param}'") % { res: r.to_s, param: param.name.to_s }
+          res = r.to_s
+          begin
+            found = catalog.resource(res)
+          rescue ArgumentError => e
+            # Raise again but with file and line information
+            raise CatalogValidationError.new(e.message, param.file, param.line)
+          end
+          unless found
+            msg = _("Could not find resource '%{res}' in parameter '%{param}'") % { res: res, param: param.name.to_s }
             raise CatalogValidationError.new(msg, param.file, param.line)
           end
         end

data/lib/puppet/parser/compiler/catalog_validator/site_validator.rb

@@ -1,5 +1,7 @@
 class Puppet::Parser::Compiler
   # Validator that asserts that only application components can appear inside a site.
+  #
+  # @deprecated application orchestration will be removed in puppet 7
   class CatalogValidator::SiteValidator < CatalogValidator
     def self.validation_stage?(stage)
       PRE_FINISH.equal?(stage)