puppet 6.16.0-x86-mingw32 → 7.0.0-x86-mingw32

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

@@ -2,7 +2,6 @@ module Puppet::Network::HTTP
 end
 
 require 'puppet/network/http'
-require 'puppet/network/rights'
 require 'puppet/util/profiler'
 require 'puppet/util/profiler/aggregate'
 require 'resolv'

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,19 +1,15 @@
 require 'puppet/network/http/connection'
-require 'puppet/network/http/connection_adapter'
-require 'puppet/util/platform'
 
 module Puppet::Network; end
 
-# This module contains the factory methods that should be used for getting a
-# {Puppet::Network::HTTP::Connection} instance. The pool may return a new
-# connection or a persistent cached connection, depending on the underlying
-# pool implementation in use.
+# This module is deprecated.
 #
 # @api public
+# @deprecated Use {Puppet::HTTP::Client} instead.
 #
 module Puppet::Network::HttpPool
 
-  @http_client_class = Puppet::Network::HTTP::ConnectionAdapter
+  @http_client_class = Puppet::Network::HTTP::Connection
 
   def self.http_client_class
     @http_client_class
@@ -30,37 +26,20 @@ module Puppet::Network::HttpPool
   # @param verify_peer [Boolean] Whether to verify the peer credentials, if possible. Verification will not take place if the CA certificate is missing.
   # @return [Puppet::Network::HTTP::Connection]
   #
-  # @deprecated Use {#http_connection} instead.
+  # @deprecated Use {Puppet.runtime[:http]} instead.
   # @api public
   #
   def self.http_instance(host, port, use_ssl = true, verify_peer = true)
-    verifier = if verify_peer
-                 Puppet::SSL::Validator.default_validator()
-               else
-                 Puppet::SSL::Validator.no_validator()
-               end
+    Puppet.warn_once('deprecations', self, "The method 'Puppet::Network::HttpPool.http_instance' is deprecated. Use Puppet.runtime[:http] instead")
 
-    http_client_class.new(host, port,
-                            :use_ssl => use_ssl,
-                            :verify => verifier)
-  end
-
-  # Get an http connection that will be secured with SSL and have the
-  # connection verified with the given verifier
-  #
-  # @param host [String] the DNS name to connect to
-  # @param port [Integer] the port to connect to
-  # @param verifier [#setup_connection, #peer_certs, #verify_errors] An object that will setup the appropriate
-  #   verification on a Net::HTTP instance and report any errors and the certificates used.
-  # @return [Puppet::Network::HTTP::Connection]
-  #
-  # @deprecated Use {#http_connection} instead.
-  # @api public
-  #
-  def self.http_ssl_instance(host, port, verifier = Puppet::SSL::Validator.default_validator())
-    http_client_class.new(host, port,
-                            :use_ssl => true,
-                            :verify => verifier)
+    if verify_peer
+      verifier = Puppet::SSL::Verifier.new(host, nil)
+      http_client_class.new(host, port, use_ssl: use_ssl, verifier: verifier)
+    else
+      ssl = Puppet::SSL::SSLProvider.new
+      verifier = Puppet::SSL::Verifier.new(host, ssl.create_insecure_context)
+      http_client_class.new(host, port, use_ssl: use_ssl, verifier: verifier)
+    end
   end
 
   # Retrieve a connection for the given host and port.
@@ -72,9 +51,12 @@ module Puppet::Network::HttpPool
   #   when making HTTPS connections. Required when `use_ssl` is `true`.
   # @return [Puppet::Network::HTTP::Connection]
   #
+  # @deprecated Use {Puppet.runtime[:http]} instead.
   # @api public
   #
   def self.connection(host, port, use_ssl: true, ssl_context: nil)
+    Puppet.warn_once('deprecations', self, "The method 'Puppet::Network::HttpPool.connection' is deprecated. Use Puppet.runtime[:http] instead")
+
     if use_ssl
       unless ssl_context
         # TRANSLATORS 'ssl_context' is an argument and should not be translated

data/lib/puppet/node.rb

@@ -183,36 +183,7 @@ class Puppet::Node
   # Calculate the list of names we might use for looking
   # up our node.  This is only used for AST nodes.
   def names
-    return [name] if Puppet.settings[:strict_hostname_checking]
-
-    names = []
-
-    names += split_name(name) if name.include?(".")
-
-    # First, get the fqdn
-    fqdn = parameters["fqdn"]
-    unless fqdn
-      if parameters["hostname"] and parameters["domain"]
-        fqdn = parameters["hostname"] + "." + parameters["domain"]
-      else
-        Puppet.warning _("Host is missing hostname and/or domain: %{name}") % { name: name }
-      end
-    end
-
-    # Now that we (might) have the fqdn, add each piece to the name
-    # list to search, in order of longest to shortest.
-    names += split_name(fqdn) if fqdn
-
-    # And make sure the node name is first, since that's the most
-    # likely usage.
-    #   The name is usually the Certificate CN, but it can be
-    # set to the 'facter' hostname instead.
-    if Puppet[:node_name] == 'cert'
-      names.unshift name
-    else
-      names.unshift parameters["hostname"]
-    end
-    names.uniq
+    @names ||= [name]
   end
 
   def split_name(name)

data/lib/puppet/node/environment.rb

@@ -266,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)
@@ -298,7 +298,7 @@ class Puppet::Node::Environment
     if @modules.nil?
       module_references = []
       project = Puppet.lookup(:bolt_project) { nil }
-      seen_modules = if project
+      seen_modules = if project && project.load_as_module?
                        module_references << project.to_h
                        { project.name => true }
                      else
@@ -327,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
@@ -335,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/node/facts.rb

@@ -116,8 +116,25 @@ class Puppet::Node::Facts
     @timestamp = Time.now
   end
 
+  def to_yaml
+    facts_to_display = Psych.parse_stream(YAML.dump(self))
+    quote_special_strings(facts_to_display)
+  end
+
   private
 
+  def quote_special_strings(fact_hash)
+    fact_hash.grep(Psych::Nodes::Scalar).each do |node|
+      next unless node.value =~ /:/
+
+      node.plain  = false
+      node.quoted = true
+      node.style  = Psych::Nodes::Scalar::DOUBLE_QUOTED
+    end
+
+    fact_hash.yaml
+  end
+
   def sanitize_fact(fact)
     if fact.is_a? Hash then
       ret = {}

data/lib/puppet/pal/json_catalog_encoder.rb

@@ -4,6 +4,8 @@
 #
 # @api public
 #
+module Puppet
+module Pal
 class JsonCatalogEncoder
   # Is the resulting Json pretty printed or not.
   attr_reader :pretty
@@ -65,3 +67,5 @@ class JsonCatalogEncoder
   end
   private :possibly_filtered_catalog
 end
+end
+end

data/lib/puppet/pal/pal_impl.rb

@@ -5,6 +5,7 @@ require 'puppet'
 require 'puppet/parser/script_compiler'
 require 'puppet/parser/catalog_compiler'
 
+module Puppet
 # This is the main entry point for "Puppet As a Library" PAL.
 # This file should be required instead of "puppet"
 # Initially, this will require ALL of puppet - over time this will change as the monolithical "puppet" is broken up
@@ -24,7 +25,7 @@ require 'puppet/parser/catalog_compiler'
 #   end
 #   # The result is what 'mymodule::myfunction' returns
 #
-module Puppet
+# @api public
 module Pal
 
   # Defines a context in which multiple operations in an env with a script compiler can be performed in a given block.
@@ -49,6 +50,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.
@@ -57,8 +59,9 @@ module Pal
       configured_by_env: false,
       manifest_file:     nil,
       code_string:       nil,
-      facts:             nil,
-      variables:         nil,
+      facts:             {},
+      variables:         {},
+      set_local_facts:   true,
       &block
     )
     # TRANSLATORS: do not translate variable name strings in these assertions
@@ -91,7 +94,14 @@ 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:                manifest_file,
+      facts:                   facts,
+      variables:               variables,
+      internal_compiler_class: :script,
+      set_local_facts:         set_local_facts,
+      &block
+    )
   ensure
     Puppet[:tasks] = previous_tasks_value
     Puppet[:code] = previous_code_value
@@ -155,8 +165,9 @@ module Pal
     configured_by_env: false,
       manifest_file:     nil,
       code_string:       nil,
-      facts:             nil,
-      variables:         nil,
+      facts:             {},
+      variables:         {},
+      target_variables:  {},
       &block
   )
     # TRANSLATORS: do not translate variable name strings in these assertions
@@ -191,7 +202,15 @@ 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:                manifest_file,
+      facts:                   facts,
+      variables:               variables,
+      target_variables:        target_variables,
+      internal_compiler_class: :catalog,
+      set_local_facts:         false,
+      &block
+    )
   ensure
     # Clean up after ourselves
     Puppet[:tasks] = previous_tasks_value
@@ -256,6 +275,7 @@ module Pal
   # @return [Object] returns what the given block returns
   # @yieldparam [Puppet::Pal] context, a context that responds to Puppet::Pal methods
   #
+  # @api public
   def self.in_environment(env_name,
       modulepath:    nil,
       pre_modulepath: [],
@@ -379,7 +399,14 @@ 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:                nil,
+    facts:                   {},
+    variables:               {},
+    target_variables:        {},
+    internal_compiler_class: nil,
+    set_local_facts:         true
+  )
     # Configure the load path
     env = Puppet.lookup(:pal_env)
     env.each_plugin_directory do |dir|
@@ -395,14 +422,11 @@ module Pal
     pal_variables = Puppet.lookup(:pal_variables)
 
     overrides = {}
+
     unless facts.nil? || facts.empty?
       pal_facts = pal_facts.merge(facts)
       overrides[:pal_facts] = pal_facts
     end
-    unless variables.nil? || variables.empty?
-      pal_variables = pal_variables.merge(variables)
-      overrides[:pal_variables] = pal_variables
-    end
 
     prepare_node_facts(node, pal_facts)
 
@@ -434,15 +458,38 @@ module Pal
           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
+        if set_local_facts
+          compiler.topscope.set_trusted(node.trusted_data)
+
+          # Server facts are always about the local node's version etc.
+          compiler.topscope.set_server_facts(node.server_facts)
+
+          # Set $facts for the node running the script
+          facts_hash = node.facts.nil? ? {} : node.facts.values
+          compiler.topscope.set_facts(facts_hash)
+
+          # create the $settings:: variables
+          compiler.topscope.merge_settings(node.environment.name, false)
+        end
+
         # Make compiler available to Puppet#lookup and injection in functions
         # TODO: The compiler instances should be available under non PAL use as well!
         # 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
+            # In case the variables 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))
+            pal_variables = Puppet::Pops::Serialization::FromDataConverter.convert(pal_variables)
+            variables     = Puppet::Pops::Serialization::FromDataConverter.convert(variables)
+
+            # Merge together target variables and plan variables. This will also shadow any
+            # collisions with facts and emit a warning.
+            topscope_vars = pal_variables.merge(merge_vars(target_variables, variables, node.facts.values))
+
+            add_variables(compiler.topscope, topscope_vars)
             # wrap the internal compiler to prevent it from leaking in the PAL API
             if block_given?
               yield(pal_compiler)
@@ -462,6 +509,38 @@ module Pal
   end
   private_class_method :main
 
+  # Warn and remove variables that will be shadowed by facts of the same
+  # name, which are set in scope earlier.
+  def self.merge_vars(target_vars, vars, facts)
+    # First, shadow plan and target variables by facts of the same name
+    vars        = shadow_vars(facts || {}, vars, 'fact', 'plan variable')
+    target_vars = shadow_vars(facts || {}, target_vars, 'fact', 'target variable')
+    # Then, shadow target variables by plan variables of the same name
+    target_vars = shadow_vars(vars, target_vars, 'plan variable', 'target variable')
+
+    target_vars.merge(vars)
+  end
+  private_class_method :merge_vars
+
+  def self.shadow_vars(vars, other_vars, vars_type, other_vars_type)
+    collisions, valid = other_vars.partition do |k, _|
+      vars.include?(k)
+    end
+
+    if collisions.any?
+      names = collisions.map { |k, _| "$#{k}" }.join(', ')
+      plural = collisions.length == 1 ? '' : 's'
+
+      Puppet.warning(
+        "#{other_vars_type.capitalize}#{plural} #{names} will be overridden by "\
+        "#{vars_type}#{plural} of the same name in the apply block"
+      )
+    end
+
+    valid.to_h
+  end
+  private_class_method :shadow_vars
+
   def self.create_internal_compiler(compiler_class_reference, node)
     case compiler_class_reference
     when :script

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