puppet 6.11.1-universal-darwin → 6.16.0-universal-darwin

data/lib/puppet/network/http/nocache_pool.rb

@@ -3,6 +3,7 @@
 # @api private
 class Puppet::Network::HTTP::NoCachePool < Puppet::Network::HTTP::BasePool
   def initialize(factory = Puppet::Network::HTTP::Factory.new)
+    Puppet.deprecation_warning(_('Puppet::Network::HTTP::NoCachePool is deprecated.'))
     @factory = factory
   end
 
@@ -15,6 +16,7 @@ class Puppet::Network::HTTP::NoCachePool < Puppet::Network::HTTP::BasePool
     begin
       yield http
     ensure
+      return unless http.started?
       Puppet.debug("Closing connection for #{site}")
       http.finish
     end

data/lib/puppet/network/http/pool.rb

@@ -9,11 +9,9 @@
 # @api private
 #
 class Puppet::Network::HTTP::Pool < Puppet::Network::HTTP::BasePool
-  FIFTEEN_SECONDS = 15
+  attr_reader :factory, :keepalive_timeout
 
-  attr_reader :factory
-
-  def initialize(keepalive_timeout = FIFTEEN_SECONDS)
+  def initialize(keepalive_timeout)
     @pool = {}
     @factory = Puppet::Network::HTTP::Factory.new
     @keepalive_timeout = keepalive_timeout
@@ -33,7 +31,7 @@ class Puppet::Network::HTTP::Pool < Puppet::Network::HTTP::BasePool
       reuse = false
       raise detail
     ensure
-      if reuse
+      if reuse && http.started?
         release(site, verifier, http)
       else
         close_connection(site, http)
@@ -56,13 +54,17 @@ class Puppet::Network::HTTP::Pool < Puppet::Network::HTTP::BasePool
   end
 
   # Safely close a persistent connection.
+  # Don't try to close a connection that's already closed.
   #
   # @api private
   def close_connection(site, http)
+    return false unless http.started?
     Puppet.debug("Closing connection for #{site}")
     http.finish
+    true
   rescue => detail
     Puppet.log_exception(detail, _("Failed to close connection for %{site}: %{detail}") % { site: site, detail: detail })
+    nil
   end
 
   # Borrow and take ownership of a persistent connection. If a new
@@ -71,9 +73,14 @@ class Puppet::Network::HTTP::Pool < Puppet::Network::HTTP::BasePool
   # @api private
   def borrow(site, verifier)
     @pool[site] = active_sessions(site)
-    index = @pool[site].index { |session| verifier.reusable?(session.verifier) }
+    index = @pool[site].index do |session|
+      (verifier.nil? && session.verifier.nil?) ||
+        (!verifier.nil? && verifier.reusable?(session.verifier))
+    end
     session = index ? @pool[site].delete_at(index) : nil
     if session
+      @pool.delete(site) if @pool[site].empty?
+
       Puppet.debug("Using cached connection for #{site}")
       session.connection
     else

data/lib/puppet/network/http_pool.rb

@@ -1,4 +1,5 @@
 require 'puppet/network/http/connection'
+require 'puppet/network/http/connection_adapter'
 require 'puppet/util/platform'
 
 module Puppet::Network; end
@@ -12,7 +13,7 @@ module Puppet::Network; end
 #
 module Puppet::Network::HttpPool
 
-  @http_client_class = Puppet::Network::HTTP::Connection
+  @http_client_class = Puppet::Network::HTTP::ConnectionAdapter
 
   def self.http_client_class
     @http_client_class

data/lib/puppet/node/environment.rb

@@ -1,6 +1,7 @@
 require 'puppet/util'
 require 'monitor'
 require 'puppet/parser/parser_factory'
+require 'puppet/concurrent/lock'
 
 # Just define it, so this class has fewer load dependencies.
 class Puppet::Node
@@ -70,6 +71,7 @@ class Puppet::Node::Environment
   #
   # @param name [Symbol] The environment name
   def initialize(name, modulepath, manifest, config_version)
+    @lock = Puppet::Concurrent::Lock.new
     @name = name.intern
     @modulepath = self.class.expand_dirs(self.class.extralibs() + modulepath)
     @manifest = manifest == NO_MANIFEST ? manifest : Puppet::FileSystem.expand_path(manifest)
@@ -160,6 +162,10 @@ class Puppet::Node::Environment
   # @api private
   attr_accessor :loaders
 
+  # Lock for compilation that needs exclusive access to the environment
+  # @api private
+  attr_reader :lock
+
   # Checks to make sure that this environment did not have a manifest set in
   # its original environment.conf if Puppet is configured with
   # +disable_per_environment_manifest+ set true.  If it did, the environment's
@@ -232,11 +238,13 @@ class Puppet::Node::Environment
   # @api public
   # @return [Puppet::Resource::TypeCollection] The current global TypeCollection
   def known_resource_types
-    if @known_resource_types.nil?
-      @known_resource_types = Puppet::Resource::TypeCollection.new(self)
-      @known_resource_types.import_ast(perform_initial_import(), '')
+    @lock.synchronize do
+      if @known_resource_types.nil?
+        @known_resource_types = Puppet::Resource::TypeCollection.new(self)
+        @known_resource_types.import_ast(perform_initial_import(), '')
+      end
+      @known_resource_types
     end
-    @known_resource_types
   end
 
   # Yields each modules' plugin directory if the plugin directory (modulename/lib)
@@ -289,7 +297,13 @@ class Puppet::Node::Environment
   def modules
     if @modules.nil?
       module_references = []
-      seen_modules = {}
+      project = Puppet.lookup(:bolt_project) { nil }
+      seen_modules = if project
+                       module_references << project.to_h
+                       { project.name => true }
+                     else
+                       {}
+                     end
       modulepath.each do |path|
         Dir.entries(path).each do |name|
           next unless Puppet::Module.is_module_directory?(name, path)
@@ -429,9 +443,11 @@ class Puppet::Node::Environment
   # Checks if a reparse is required (cache of files is stale).
   #
   def check_for_reparse
-    if (Puppet[:code] != @parsed_code || @known_resource_types.parse_failed?)
-      @parsed_code = nil
-      @known_resource_types = nil
+    @lock.synchronize do
+      if (Puppet[:code] != @parsed_code || @known_resource_types.parse_failed?)
+        @parsed_code = nil
+        @known_resource_types = nil
+      end
     end
   end
 

data/lib/puppet/pal/catalog_compiler.rb

@@ -97,6 +97,11 @@ module Pal
       internal_compiler.evaluate_additions
     end
 
+    # Attempts to evaluate AST for node defnintions https://puppet.com/docs/puppet/latest/lang_node_definitions.html
+    # if there are any.
+    def evaluate_ast_node
+      internal_compiler.evaluate_ast_node
+    end
   end
 
 end

data/lib/puppet/pal/pal_impl.rb

@@ -83,6 +83,8 @@ module Pal
       end
     end
 
+    previous_tasks_value = Puppet[:tasks]
+    previous_code_value = Puppet[:code]
     Puppet[:tasks] = true
     # After the assertions, if code_string is non nil - it has the highest precedence
     Puppet[:code] = code_string unless code_string.nil?
@@ -90,6 +92,9 @@ module Pal
     # If manifest_file is nil, the #main method will use the env configured manifest
     # to do things in the block while a Script Compiler is in effect
     main(manifest_file, facts, variables, :script, &block)
+  ensure
+    Puppet[:tasks] = previous_tasks_value
+    Puppet[:code] = previous_code_value
   end
 
   # Evaluates a Puppet Language script string.
@@ -417,37 +422,8 @@ module Pal
     # TRANSLATORS, the string "For puppet PAL" is not user facing
     Puppet.override({:current_environment => apply_environment}, "For puppet PAL") do
       begin
-        # support the following features when evaluating puppet code
-        # * $facts with facts from host running the script
-        # * $settings with 'settings::*' namespace populated, and '$settings::all_local' hash
-        # * $trusted as setup when using puppet apply
-        # * an environment
-        #
-
-        # fixup trusted information
         node.sanitize()
-
         compiler = create_internal_compiler(internal_compiler_class, node)
-        # compiler = Puppet::Parser::ScriptCompiler.new(node.environment, node.name)
-        topscope = compiler.topscope
-
-        # When scripting the trusted data are always local, but set them anyway
-        # When compiling for a catalog, the catalog compiler does this
-        unless internal_compiler_class == :catalog
-          topscope.set_trusted(node.trusted_data)
-
-          # Server facts are always about the local node's version etc.
-          topscope.set_server_facts(node.server_facts)
-
-          # Set $facts for the node running the script
-          facts_hash = node.facts.nil? ? {} : node.facts.values
-          topscope.set_facts(facts_hash)
-
-          # create the $settings:: variables
-          topscope.merge_settings(node.environment.name, false)
-        end
-
-        add_variables(topscope, pal_variables)
 
         case internal_compiler_class
         when :script
@@ -463,6 +439,10 @@ module Pal
         # TRANSLATORS: Do not translate, symbolic name
         Puppet.override(overrides, "PAL::with_#{internal_compiler_class}_compiler") do
           compiler.compile do | compiler_yield |
+            # In case the varaibles passed to the compiler are PCore types defined in modules, they
+            # need to be deserialized and added from within the this scope, so that loaders are
+            # available during deserizlization.
+            add_variables(compiler.topscope, Puppet::Pops::Serialization::FromDataConverter.convert(pal_variables))
             # wrap the internal compiler to prevent it from leaking in the PAL API
             if block_given?
               yield(pal_compiler)

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
@@ -87,7 +82,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.
@@ -122,7 +116,7 @@ class Puppet::Parser::AST::PopsBridge
     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
@@ -178,8 +172,9 @@ class Puppet::Parser::AST::PopsBridge
       #
       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

data/lib/puppet/parser/compiler.rb

@@ -348,6 +348,34 @@ class Puppet::Parser::Compiler
     end
   end
 
+
+  # If ast nodes are enabled, then see if we can find and evaluate one.
+  #
+  # @api private
+  def evaluate_ast_node
+    krt = environment.known_resource_types
+    return unless krt.nodes? #ast_nodes?
+
+    # Now see if we can find the node.
+    astnode = nil
+    @node.names.each do |name|
+      astnode = krt.node(name.to_s.downcase)
+      break if astnode
+    end
+
+    unless (astnode ||= krt.node("default"))
+      raise Puppet::ParseError, _("Could not find node statement with name 'default' or '%{names}'") % { names: node.names.join(", ") }
+    end
+
+    # Create a resource to model this node, and then add it to the list
+    # of resources.
+    resource = astnode.ensure_in_catalog(topscope)
+
+    resource.evaluate
+
+    @node_scope = topscope.class_scope(astnode)
+  end
+
   # Evaluates each specified class in turn. If there are any classes that
   # can't be found, an error is raised. This method really just creates resource objects
   # that point back to the classes, and then the resources are themselves
@@ -486,31 +514,6 @@ class Puppet::Parser::Compiler
     krt.capability_mappings.clear # No longer needed
   end
 
-  # If ast nodes are enabled, then see if we can find and evaluate one.
-  def evaluate_ast_node
-    krt = environment.known_resource_types
-    return unless krt.nodes? #ast_nodes?
-
-    # Now see if we can find the node.
-    astnode = nil
-    @node.names.each do |name|
-      astnode = krt.node(name.to_s.downcase)
-      break if astnode
-    end
-
-    unless (astnode ||= krt.node("default"))
-      raise Puppet::ParseError, _("Could not find node statement with name 'default' or '%{names}'") % { names: node.names.join(", ") }
-    end
-
-    # Create a resource to model this node, and then add it to the list
-    # of resources.
-    resource = astnode.ensure_in_catalog(topscope)
-
-    resource.evaluate
-
-    @node_scope = topscope.class_scope(astnode)
-  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
@@ -777,13 +780,7 @@ class Puppet::Parser::Compiler
   SETTINGS = 'settings'.freeze
 
   def create_settings_scope
-    resource_types = environment.known_resource_types
-    settings_type = resource_types.hostclass(SETTINGS)
-    if settings_type.nil?
-      settings_type = Puppet::Resource::Type.new(:hostclass, SETTINGS)
-      resource_types.add(settings_type)
-    end
-
+    settings_type = create_settings_type
     settings_resource = Puppet::Parser::Resource.new('class', SETTINGS, :scope => @topscope)
 
     @catalog.add_resource(settings_resource)
@@ -794,6 +791,19 @@ class Puppet::Parser::Compiler
     scope.merge_settings(environment.name)
   end
 
+  def create_settings_type
+    environment.lock.synchronize do
+      resource_types = environment.known_resource_types
+      settings_type = resource_types.hostclass(SETTINGS)
+      if settings_type.nil?
+        settings_type = Puppet::Resource::Type.new(:hostclass, SETTINGS)
+        resource_types.add(settings_type)
+      end
+
+      settings_type
+    end
+  end
+
   # Return an array of all of the unevaluated resources.  These will be definitions,
   # which need to get evaluated into native resources.
   def unevaluated_resources

data/lib/puppet/parser/functions.rb

@@ -1,6 +1,7 @@
 require 'puppet/util/autoload'
 require 'puppet/parser/scope'
 require 'puppet/pops/adaptable'
+require 'puppet/concurrent/lock'
 
 # A module for managing parser functions.  Each specified function
 # is added to a central module that then gets included into the Scope
@@ -78,28 +79,32 @@ module Puppet::Parser::Functions
     attr_accessor :module
   end
 
+  @environment_module_lock = Puppet::Concurrent::Lock.new
+
   # Get the module that functions are mixed into corresponding to an
   # environment
   #
   # @api private
   def self.environment_module(env)
-    AnonymousModuleAdapter.adapt(env) do |a|
-      a.module ||= Module.new do
-        @metadata = {}
+    @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.all_function_info
+            @metadata
+          end
 
-        def self.get_function_info(name)
-          @metadata[name]
-        end
+          def self.get_function_info(name)
+            @metadata[name]
+          end
 
-        def self.add_function_info(name, info)
-          @metadata[name] = info
+          def self.add_function_info(name, info)
+            @metadata[name] = info
+          end
         end
-      end
-    end.module
+      end.module
+    end
   end
 
   # Create a new Puppet DSL function.

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

@@ -7,12 +7,12 @@ result as a String.
 The first argument to this function should be a `<MODULE NAME>/<TEMPLATE FILE>`
 reference, which loads `<TEMPLATE FILE>` from `<MODULE NAME>`'s `templates`
 directory. In most cases, the last argument is optional; if used, it should be a
-[hash](/puppet/latest/reference/lang_data_hash.html) that contains parameters to
+[hash](https://puppet.com/docs/puppet/latest/lang_data_hash.html) that contains parameters to
 pass to the template.
 
-- See the [template](/puppet/latest/reference/lang_template.html) documentation
+- See the [template](https://puppet.com/docs/puppet/latest/lang_template.html) documentation
 for general template usage information.
-- See the [EPP syntax](/puppet/latest/reference/lang_template_epp.html)
+- See the [EPP syntax](https://puppet.com/docs/puppet/latest/lang_template_epp.html)
 documentation for examples of EPP.
 
 For example, to call the apache module's `templates/vhost/_docroot.epp`