puppet 6.13.0-x86-mingw32 → 6.18.0-x86-mingw32

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
 

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
@@ -75,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/route.rb

@@ -67,11 +67,11 @@ class Puppet::Network::HTTP::Route
   end
 
   def matches?(request)
-    Puppet.debug("Evaluating match for #{self.inspect}")
+    Puppet.debug { "Evaluating match for #{self.inspect}" }
     if match(request.routing_path)
       return true
     else
-      Puppet.debug("Did not match path (#{request.routing_path.inspect})")
+      Puppet.debug { "Did not match path (#{request.routing_path.inspect})" }
     end
     return false
   end

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

@@ -162,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
@@ -262,7 +266,7 @@ class Puppet::Node::Environment
   # @param name [String] The module name
   # @return [Puppet::Module, nil] The module if found, else nil
   def module(name)
-    modules.find {|mod| mod.name == name}
+    modules_by_name[name]
   end
 
   # Locate a module instance by the full forge name (EG authorname/module)
@@ -293,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 && project.load_as_module?
+                       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)
@@ -317,6 +327,12 @@ class Puppet::Node::Environment
     @modules
   end
 
+  # @api private
+  def modules_by_name
+    @modules_by_name ||= Hash[modules.map { |mod| [mod.name, mod] }]
+  end
+  private :modules_by_name
+
   # Generate a warning if the given directory in a module path entry is named `lib`.
   #
   # @api private
@@ -325,9 +341,10 @@ class Puppet::Node::Environment
   # @param name [String] The directory name
   def warn_about_mistaken_path(path, name)
     if name == "lib"
-      Puppet.debug("Warning: Found directory named 'lib' in module path ('#{path}/lib'); unless " +
-          "you are expecting to load a module named 'lib', your module path may be set " +
-          "incorrectly.")
+      Puppet.debug {
+        "Warning: Found directory named 'lib' in module path ('#{path}/lib'); unless you \
+        are expecting to load a module named 'lib', your module path may be set incorrectly."
+      }
     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

@@ -49,6 +49,7 @@ module Pal
   #   If given at the environment level, the facts given here are merged with higher priority.
   # @param variables [Hash] optional map of fully qualified variable name to value. If given at the environment level, the variables
   #   given here are merged with higher priority.
+  # @param set_local_facts [Boolean] when true, the $facts, $server_facts, and $trusted variables are set for the scope.
   # @param block [Proc] the block performing operations on compiler
   # @return [Object] what the block returns
   # @yieldparam [Puppet::Pal::ScriptCompiler] compiler, a ScriptCompiler to perform operations on.
@@ -59,6 +60,7 @@ module Pal
       code_string:       nil,
       facts:             nil,
       variables:         nil,
+      set_local_facts:   true,
       &block
     )
     # TRANSLATORS: do not translate variable name strings in these assertions
@@ -91,7 +93,7 @@ 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)
+    main(manifest_file, facts, variables, :script, set_local_facts, &block)
   ensure
     Puppet[:tasks] = previous_tasks_value
     Puppet[:code] = previous_code_value
@@ -191,7 +193,7 @@ 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, :catalog, &block)
+    main(manifest_file, facts, variables, :catalog, false, &block)
   ensure
     # Clean up after ourselves
     Puppet[:tasks] = previous_tasks_value
@@ -379,7 +381,13 @@ module Pal
   # Picks up information from the puppet context and configures a script compiler which is given to
   # the provided block
   #
-  def self.main(manifest, facts, variables, internal_compiler_class)
+  def self.main(
+    manifest,
+    facts,
+    variables,
+    internal_compiler_class,
+    set_local_facts
+  )
     # Configure the load path
     env = Puppet.lookup(:pal_env)
     env.each_plugin_directory do |dir|
@@ -422,45 +430,32 @@ 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
+        case internal_compiler_class
+        when :script
+          pal_compiler = ScriptCompiler.new(compiler)
+          overrides[:pal_script_compiler] = overrides[:pal_compiler] = pal_compiler
+        when :catalog
+          pal_compiler = CatalogCompiler.new(compiler)
+          overrides[:pal_catalog_compiler] = overrides[:pal_compiler] = pal_compiler
+        end
+
+        # When scripting the trusted data are always local; default is to set them anyway
         # When compiling for a catalog, the catalog compiler does this
-        unless internal_compiler_class == :catalog
-          topscope.set_trusted(node.trusted_data)
+        if set_local_facts
+          compiler.topscope.set_trusted(node.trusted_data)
 
           # Server facts are always about the local node's version etc.
-          topscope.set_server_facts(node.server_facts)
+          compiler.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)
+          compiler.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
-          pal_compiler = ScriptCompiler.new(compiler)
-          overrides[:pal_script_compiler] = overrides[:pal_compiler] = pal_compiler
-        when :catalog
-          pal_compiler = CatalogCompiler.new(compiler)
-          overrides[:pal_catalog_compiler] = overrides[:pal_compiler] = pal_compiler
+          compiler.topscope.merge_settings(node.environment.name, false)
         end
 
         # Make compiler available to Puppet#lookup and injection in functions
@@ -468,6 +463,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/parameter.rb

@@ -429,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/ast/leaf.rb

@@ -17,17 +17,17 @@ class Puppet::Parser::AST::Leaf < Puppet::Parser::AST
     @value.to_s unless @value.nil?
   end
 
-  def initialize(value: nil, **options)
+  def initialize(value: nil, file: nil, line: nil, pos: nil)
     @value = value
-    super(**options)
+    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)
@@ -51,7 +51,7 @@ end
 
 class Puppet::Parser::AST::Regex < Puppet::Parser::AST::Leaf
   def initialize(hash)
-    super
+    super(**hash)
     # 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

@@ -57,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

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
@@ -420,7 +448,7 @@ class Puppet::Parser::Compiler
   # using the top scope.
   def newscope(parent, options = {})
     parent ||= topscope
-    scope = Puppet::Parser::Scope.new(self, options)
+    scope = Puppet::Parser::Scope.new(self, **options)
     scope.parent = parent
     scope
   end
@@ -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/compiler/catalog_validator/env_relationship_validator.rb

@@ -1,6 +1,8 @@
 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
+  #
+  # @deprecated application orchestration will be removed in puppet 7
   class CatalogValidator::EnvironmentRelationshipValidator < CatalogValidator
 
     def validate

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)

data/lib/puppet/parser/environment_compiler.rb

@@ -1,5 +1,6 @@
 require 'puppet/parser/compiler'
 
+# @deprecated application orchestration will be removed in puppet 7
 class Puppet::Parser::EnvironmentCompiler < Puppet::Parser::Compiler
   def self.compile(env, code_id=nil)
     begin
@@ -16,7 +17,7 @@ class Puppet::Parser::EnvironmentCompiler < Puppet::Parser::Compiler
   end
 
   def initialize(node, options = {})
-    super
+    super(node, **options)
     @overridden_functions = {}
   end
 
@@ -54,6 +55,8 @@ class Puppet::Parser::EnvironmentCompiler < Puppet::Parser::Compiler
   end
 
   def compile
+    Puppet.deprecation_warning("Application orchestration is deprecated. See https://puppet.com/docs/puppet/5.5/deprecated_language.html")
+
     add_function_overrides
     begin
       Puppet.override(@context_overrides, _("For compiling environment catalog %{env}") % { env: environment.name }) do