puppet 6.17.0-x86-mingw32 → 7.1.0-x86-mingw32

data/lib/puppet/parser/compiler.rb

@@ -72,22 +72,6 @@ class Puppet::Parser::Compiler
   end
 
   def add_resource(scope, resource)
-    type = resource.resource_type
-    if type.is_a?(Puppet::Resource::Type) && type.application?
-      @applications << resource
-      assert_app_in_site(scope, resource)
-      return
-    end
-
-    if @current_app
-      # We are in the process of pulling application components out that
-      # apply to this node
-      Puppet.notice "Check #{resource}"
-      return unless @current_components.any? do |comp|
-        comp.type == resource.type && comp.title == resource.title
-      end
-    end
-
     @resources << resource
 
     # Note that this will fail if the resource is not unique.
@@ -110,22 +94,6 @@ class Puppet::Parser::Compiler
     end
   end
 
-  def assert_app_in_site(scope, resource)
-    if resource.type == 'App'
-      if scope.resource
-        # directly contained in a Site
-        return if scope.resource.type == 'Site'
-        # contained in something that may be contained in Site
-        upstream = @catalog.upstream_from_vertex(scope.resource)
-        if upstream
-          return if upstream.keys.map(&:type).include?('Site')
-        end
-      end
-      #TRANSLATORS "Site" is a puppet keyword and should not be translated
-      raise ArgumentError, _("Application instances like '%{resource}' can only be contained within a Site") % { resource: resource }
-    end
-  end
-
   # Store the fact that we've evaluated a class
   def add_class(name)
     @catalog.add_class(name) unless name == ""
@@ -160,22 +128,13 @@ class Puppet::Parser::Compiler
 
       Puppet::Util::Profiler.profile(_("Compile: Created settings scope"), [:compiler, :create_settings_scope]) { create_settings_scope }
 
-      Puppet::Util::Profiler.profile(_("Compile: Evaluated capability mappings"), [:compiler, :evaluate_capability_mappings]) { evaluate_capability_mappings }
-
       #TRANSLATORS "main" is a function name and should not be translated
       Puppet::Util::Profiler.profile(_("Compile: Evaluated main"), [:compiler, :evaluate_main]) { evaluate_main }
 
-      Puppet::Util::Profiler.profile(_("Compile: Evaluated site"), [:compiler, :evaluate_site]) { evaluate_site }
-
       Puppet::Util::Profiler.profile(_("Compile: Evaluated AST node"), [:compiler, :evaluate_ast_node]) { evaluate_ast_node }
 
       Puppet::Util::Profiler.profile(_("Compile: Evaluated node classes"), [:compiler, :evaluate_node_classes]) { evaluate_node_classes }
 
-      Puppet::Util::Profiler.profile(_("Compile: Evaluated application instances"), [:compiler, :evaluate_applications]) { evaluate_applications }
-
-      # New capability mappings may have been defined when the site was evaluated
-      Puppet::Util::Profiler.profile(_("Compile: Evaluated site capability mappings"), [:compiler, :evaluate_capability_mappings]) { evaluate_capability_mappings }
-
       Puppet::Util::Profiler.profile(_("Compile: Evaluated generators"), [:compiler, :evaluate_generators]) { evaluate_generators }
 
       Puppet::Util::Profiler.profile(_("Compile: Validate Catalog pre-finish"), [:compiler, :validate_pre_finish]) do
@@ -184,8 +143,6 @@ class Puppet::Parser::Compiler
 
       Puppet::Util::Profiler.profile(_("Compile: Finished catalog"), [:compiler, :finish_catalog]) { finish }
 
-      Puppet::Util::Profiler.profile(_("Compile: Prune"), [:compiler, :prune_catalog]) { prune_catalog }
-
       fail_on_unevaluated
 
       Puppet::Util::Profiler.profile(_("Compile: Validate Catalog final"), [:compiler, :validate_final]) do
@@ -243,112 +200,6 @@ class Puppet::Parser::Compiler
     evaluate_classes(classes_without_params, @node_scope || topscope)
   end
 
-  # Evaluates the site - the top container for an environment catalog
-  # The site contain behaves analogous to a node - for the environment catalog, node expressions are ignored
-  # as the result is cross node. The site expression serves as a container for everything that is across
-  # all nodes.
-  #
-  # @api private
-  #
-  def evaluate_site
-    # Has a site been defined? If not, do nothing but issue a warning.
-    #
-    site = environment.known_resource_types.find_site()
-    unless site
-      on_empty_site()
-      return
-    end
-
-    # Create a resource to model this site and add it to catalog
-    resource = site.ensure_in_catalog(topscope)
-
-    # The site sets node scope to be able to shadow what is in top scope
-    @node_scope = topscope.class_scope(site)
-
-    # Evaluates the logic contain in the site expression
-    resource.evaluate
-  end
-
-  # @api private
-  def on_empty_site
-    # do nothing
-  end
-
-  # Prunes the catalog by dropping all resources are contained under the Site (if a site expression is used).
-  # As a consequence all edges to/from dropped resources are also dropped.
-  # Once the pruning is performed, this compiler returns the pruned list when calling the #resources method.
-  # The pruning does not alter the order of resources in the resources list.
-  #
-  # @api private
-  def prune_catalog
-    prune_node_catalog
-  end
-
-  def prune_node_catalog
-    # Everything under Site[site] should be pruned as that is for the environment catalog, not a node
-    #
-    the_site_resource = @catalog.resource('Site', 'site')
-
-    if the_site_resource
-      # Get downstream vertexes returns a hash where the keys are the resources and values nesting level
-      to_be_removed = @catalog.downstream_from_vertex(the_site_resource).keys
-
-      # Drop the Site[site] resource if it has no content
-      if to_be_removed.empty?
-        to_be_removed << the_site_resource
-      end
-    else
-      to_be_removed = []
-    end
-
-    # keep_from_site is populated with any App resources.
-    application_resources = @resources.select {|r| r.type == 'App' }
-    # keep all applications plus what is directly referenced from applications
-    keep_from_site = application_resources
-    keep_from_site += application_resources.map {|app| @catalog.direct_dependents_of(app) }.flatten
-
-    to_be_removed -= keep_from_site
-    @catalog.remove_resource(*to_be_removed)
-    # set the pruned result
-    @resources = @catalog.resources
-  end
-
-  # @api private
-  def evaluate_applications
-    @applications.each do |app|
-      components = []
-      mapping = app.parameters[:nodes] ? app.parameters[:nodes].value : {}
-      raise Puppet::Error, _("Invalid node mapping in %{app}: Mapping must be a hash") % { app: app.ref } unless mapping.is_a?(Hash)
-      all_mapped = Set.new
-      mapping.each do |k,v|
-        raise Puppet::Error, _("Invalid node mapping in %{app}: Key %{k} is not a Node") % { app: app.ref, k: k } unless k.is_a?(Puppet::Resource) && k.type == 'Node'
-        v = [v] unless v.is_a?(Array)
-        v.each do |res|
-          raise Puppet::Error, _("Invalid node mapping in %{app}: Value %{res} is not a resource") % { app: app.ref, res: res } unless res.is_a?(Puppet::Resource)
-          raise Puppet::Error, _("Application %{app} maps component %{res} to multiple nodes") % { app: app.ref, res: res } if all_mapped.add?(res.ref).nil?
-          components << res if k.title == node.name
-        end
-      end
-      begin
-        @current_app = app
-        @current_components = components
-        unless @current_components.empty?
-          Puppet.notice "EVAL APP #{app} #{components.inspect}"
-          # Add the app itself since components mapped to the current node
-          # will have a containment edge for it
-          # @todo lutter 2015-01-28: the node mapping winds up in the
-          # catalog, but probably shouldn't
-          @catalog.add_resource(@current_app)
-          @current_app.evaluate
-        end
-      ensure
-        @current_app = nil
-        @current_components = nil
-      end
-    end
-  end
-
-
   # If ast nodes are enabled, then see if we can find and evaluate one.
   #
   # @api private
@@ -391,12 +242,6 @@ class Puppet::Parser::Compiler
       classes = classes.keys
     end
 
-    unless @current_components.nil?
-      classes = classes.select do |title|
-        @current_components.any? { |comp| comp.class? && comp.title == title }
-      end
-    end
-
     hostclasses = classes.collect do |name|
       environment.known_resource_types.find_hostclass(name) or raise Puppet::Error, _("Could not find class %{name} for %{node}") % { name: name, node: node.name }
     end
@@ -427,16 +272,6 @@ class Puppet::Parser::Compiler
 
   def initialize(node, code_id: nil)
     @node = sanitize_node(node)
-    # Array of resources representing all application instances we've found
-    @applications = []
-    # We use @current_app and @current_components to signal to the
-    # evaluator that we are in the middle of evaluating an
-    # application. They are set in evaluate_applications to the application
-    # instance, resp. to an array of the components of that application
-    # that is mapped to the current node. They are only non-nil when we are
-    # in the middle of executing evaluate_applications
-    @current_app = nil
-    @current_components = nil
     @code_id = code_id
     initvars
     add_catalog_validators
@@ -481,39 +316,6 @@ class Puppet::Parser::Compiler
     [already_included, newly_included]
   end
 
-  def evaluate_capability_mappings
-    krt = environment.known_resource_types
-    krt.capability_mappings.each_value do |capability_mapping|
-      args = capability_mapping.arguments
-      component_ref = args['component']
-      kind = args['kind']
-
-      # That component_ref is either a QREF or a Class['literal'|QREF] is asserted during validation so no
-      # need to check that here
-      if component_ref.is_a?(Puppet::Pops::Model::QualifiedReference)
-        component_name = component_ref.cased_value
-        component_type = 'type'
-        component = krt.find_definition(component_name)
-      else
-        component_name = component_ref.keys[0].value
-        component_type = 'class'
-        component = krt.find_hostclass(component_name)
-      end
-      if component.nil?
-        raise Puppet::ParseError, _("Capability mapping error: %{kind} clause references nonexistent %{component_type} %{component_name}") %
-            { kind: kind, component_type: component_type, component_name: component_name }
-      end
-
-      blueprint = args['blueprint']
-      if kind == 'produces'
-        component.add_produces(blueprint)
-      else
-        component.add_consumes(blueprint)
-      end
-    end
-    krt.capability_mappings.clear # No longer needed
-  end
-
   # Evaluate our collections and return true if anything returned an object.
   # The 'true' is used to continue a loop, so it's important.
   def evaluate_collections

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

@@ -1,6 +1,5 @@
 class Puppet::Parser::Compiler
-  # Validator that asserts that only 'require', 'consume', and 'export' is used when declaring relationships
-  # to capability resources.
+  # Validator that asserts relationship metaparameters refer to valid resources
   class CatalogValidator::RelationshipValidator < CatalogValidator
     def validate
       catalog.resources.each do |resource|
@@ -16,48 +15,24 @@ class Puppet::Parser::Compiler
 
     private
 
-    # A hash lookup is 6x avg times faster than find among 3 values.
-    CAPABILITY_ACCEPTED_METAPARAMS = {:require => true, :consume => true, :export => true}.freeze
-
     def validate_relationship(param)
-      # when relationship is to a capability
-      if has_capability?(param.value)
-        unless CAPABILITY_ACCEPTED_METAPARAMS[param.name]
-          raise CatalogValidationError.new(
-            _("'%{param}' is not a valid relationship to a capability") % { param: param.name },
-              param.file, param.line)
+      # the referenced resource must exist
+      refs = param.value.is_a?(Array) ? param.value.flatten : [param.value]
+      refs.each do |r|
+        next if r.nil? || r == :undef
+        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
-      else
-        # all other relationships requires the referenced resource to exist
-        refs = param.value.is_a?(Array) ? param.value.flatten : [param.value]
-        refs.each do |r|
-          next if r.nil? || r == :undef
-          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
+        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
     end
-
-    def has_capability?(value)
-      case value
-      when Array
-        value.find { |v| has_capability?(v) }
-      when Puppet::Resource
-        rt = value.resource_type
-        !rt.nil? && rt.is_capability?
-      else
-        false
-      end
-    end
   end
 end
 

data/lib/puppet/parser/functions.rb

@@ -77,6 +77,26 @@ module Puppet::Parser::Functions
   # @api private
   class AnonymousModuleAdapter < Puppet::Pops::Adaptable::Adapter
     attr_accessor :module
+
+    def self.create_adapter(env)
+      adapter = super(env)
+      adapter.module = Module.new do
+        @metadata = {}
+
+        def self.all_function_info
+          @metadata
+        end
+
+        def self.get_function_info(name)
+          @metadata[name]
+        end
+
+        def self.add_function_info(name, info)
+          @metadata[name] = info
+        end
+      end
+      adapter
+    end
   end
 
   @environment_module_lock = Puppet::Concurrent::Lock.new
@@ -87,23 +107,7 @@ module Puppet::Parser::Functions
   # @api private
   def self.environment_module(env)
     @environment_module_lock.synchronize do
-      AnonymousModuleAdapter.adapt(env) do |a|
-        a.module ||= Module.new do
-          @metadata = {}
-
-          def self.all_function_info
-            @metadata
-          end
-
-          def self.get_function_info(name)
-            @metadata[name]
-          end
-
-          def self.add_function_info(name, info)
-            @metadata[name] = info
-          end
-        end
-      end.module
+      AnonymousModuleAdapter.adapt(env).module
     end
   end
 

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