puppet 6.15.0-x86-mingw32 → 6.19.1-x86-mingw32

data/lib/puppet/network/http/api/indirected_routes.rb

@@ -218,7 +218,7 @@ class Puppet::Network::HTTP::API::IndirectedRoutes
     return formatter if formatter
 
     raise Puppet::Network::HTTP::Error::HTTPNotAcceptableError.new(
-            _("No supported formats are acceptable (Accept: %{accepted_formats})") % { accepted_formats: formats },
+            _("No supported formats are acceptable (Accept: %{accepted_formats})") % { accepted_formats: formats.map(&:mime).join(', ') },
             Puppet::Network::HTTP::Issues::UNSUPPORTED_FORMAT)
   end
 

data/lib/puppet/network/http/api/master/v3/environment.rb

@@ -1,8 +1,11 @@
 require 'puppet/util/json'
 require 'puppet/parser/environment_compiler'
 
+# @deprecated application orchestration will be removed in puppet 7
 class Puppet::Network::HTTP::API::Master::V3::Environment
   def call(request, response)
+    Puppet.deprecation_warning("Application orchestration is deprecated. See https://puppet.com/docs/puppet/5.5/deprecated_language.html")
+
     env_name = request.routing_path.split('/').last
     env = Puppet.lookup(:environments).get(env_name)
     code_id = request.params[:code_id]

data/lib/puppet/network/http/api/master/v3/environments.rb

@@ -31,5 +31,4 @@ class Puppet::Network::HTTP::API::Master::V3::Environments
       ttl
     end
   end
-
 end

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

@@ -20,9 +20,11 @@ module Puppet::Network::HTTP::Compression
     def uncompress_body(response)
       case response['content-encoding']
       when 'gzip'
+        Puppet.deprecation_warning(_('Puppet::Network::HTTP::Compression::Active#uncompress_body is deprecated.'))
         # ZLib::GzipReader has an associated encoding, by default Encoding.default_external
         return Zlib::GzipReader.new(StringIO.new(response.body), :encoding => Encoding::BINARY).read
       when 'deflate'
+        Puppet.deprecation_warning(_('Puppet::Network::HTTP::Compression::Active#uncompress_body is deprecated.'))
         return Zlib::Inflate.new.inflate(response.body)
       when nil, 'identity'
         return response.body
@@ -32,6 +34,7 @@ module Puppet::Network::HTTP::Compression
     end
 
     def uncompress(response)
+      Puppet.deprecation_warning(_('Puppet::Network::HTTP::Compression::Active#uncompress is deprecated.'))
       raise Net::HTTPError.new("No block passed", response) unless block_given?
 
       case response['content-encoding']
@@ -71,6 +74,7 @@ module Puppet::Network::HTTP::Compression
       end
 
       def uncompress(chunk)
+        Puppet.deprecation_warning(_('Puppet::Network::HTTP::Compression::ZlibAdapter#uncompress is deprecated.'))
         out = @uncompressor.inflate(chunk)
         @first = false
         return out
@@ -97,6 +101,7 @@ module Puppet::Network::HTTP::Compression
 
   module None
     def uncompress_body(response)
+      Puppet.deprecation_warning(_('Puppet::Network::HTTP::Compression::None#uncompress_body is deprecated.'))
       response.body
     end
 
@@ -105,12 +110,14 @@ module Puppet::Network::HTTP::Compression
     end
 
     def uncompress(response)
+      Puppet.deprecation_warning(_('Puppet::Network::HTTP::Compression::None#uncompress is deprecated.'))
       yield IdentityAdapter.new
     end
   end
 
   class IdentityAdapter
     def uncompress(chunk)
+      Puppet.deprecation_warning(_('Puppet::Network::HTTP::Compression::IdentityAdapter#uncompress is deprecated.'))
       chunk
     end
 

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

@@ -343,6 +343,8 @@ module Puppet::Network::HTTP
     end
 
     def with_connection(site, &block)
+      Puppet.deprecation_warning(_('Puppet::Network::HTTP::Connection is deprecated. Please use Puppet::Network::HTTP::ConnectionAdapter instead.'))
+
       response = nil
       @pool.with_connection(site, @verifier) do |conn|
         response = yield conn

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

@@ -0,0 +1,184 @@
+class Puppet::Network::HTTP::ConnectionAdapter < Puppet::Network::HTTP::Connection
+  def initialize(host, port, options = {})
+    super(host, port, options)
+
+    @client = Puppet.runtime[:http]
+  end
+
+  def get(path, headers = {}, options = {})
+    headers ||= {}
+    options[:ssl_context] ||= resolve_ssl_context
+    options[:redirect_limit] ||= @redirect_limit
+
+    with_error_handling do
+      resp = @client.get(to_url(path), headers: headers, options: options)
+      resp.nethttp
+    end
+  end
+
+  def post(path, data, headers = nil, options = {})
+    headers ||= {}
+    headers['Content-Type'] ||= "application/x-www-form-urlencoded"
+    data ||= ''
+    options[:ssl_context] ||= resolve_ssl_context
+    options[:redirect_limit] ||= @redirect_limit
+
+    with_error_handling do
+      resp = @client.post(to_url(path), data, headers: headers, options: options)
+      resp.nethttp
+    end
+  end
+
+  def head(path, headers = {}, options = {})
+    headers ||= {}
+    options[:ssl_context] ||= resolve_ssl_context
+    options[:redirect_limit] ||= @redirect_limit
+
+    with_error_handling do
+      resp = @client.head(to_url(path), headers: headers, options: options)
+      resp.nethttp
+    end
+  end
+
+  def delete(path, headers = {'Depth' => 'Infinity'}, options = {})
+    headers ||= {}
+    options[:ssl_context] ||= resolve_ssl_context
+    options[:redirect_limit] ||= @redirect_limit
+
+    with_error_handling do
+      resp = @client.delete(to_url(path), headers: headers, options: options)
+      resp.nethttp
+    end
+  end
+
+  def put(path, data, headers = nil, options = {})
+    headers ||= {}
+    headers['Content-Type'] ||= "application/x-www-form-urlencoded"
+    data ||= ''
+    options[:ssl_context] ||= resolve_ssl_context
+    options[:redirect_limit] ||= @redirect_limit
+
+    with_error_handling do
+      resp = @client.put(to_url(path), data, headers: headers, options: options)
+      resp.nethttp
+    end
+  end
+
+  def request_get(*args, &block)
+    path, headers = *args
+    headers ||= {}
+    options = {
+      ssl_context: resolve_ssl_context,
+      redirect_limit: @redirect_limit
+    }
+
+    resp = @client.get(to_url(path), headers: headers, options: options) do |response|
+      yield response.nethttp if block_given?
+    end
+    resp.nethttp
+  end
+
+  def request_head(*args, &block)
+    path, headers = *args
+    headers ||= {}
+    options = {
+      ssl_context: resolve_ssl_context,
+      redirect_limit: @redirect_limit
+    }
+
+    response = @client.head(to_url(path), headers: headers, options: options)
+    yield response.nethttp if block_given?
+    response.nethttp
+  end
+
+  def request_post(*args, &block)
+    path, data, headers = *args
+    headers ||= {}
+    headers['Content-Type'] ||= "application/x-www-form-urlencoded"
+    options = {
+      ssl_context: resolve_ssl_context,
+      redirect_limit: @redirect_limit
+    }
+
+    resp = @client.post(to_url(path), data, headers: headers, options: options) do |response|
+      yield response.nethttp if block_given?
+    end
+    resp.nethttp
+  end
+
+  private
+
+  # The old Connection class ignores the ssl_context on the Puppet stack,
+  # and always loads certs/keys based on what is currently in the filesystem.
+  # If the files are missing, it would attempt to bootstrap the certs/keys
+  # while in the process of making a network request, due to the call to
+  # Puppet.lookup(:ssl_host) in Puppet::SSL::Validator::DefaultValidator#setup_connection.
+  # This class doesn't preserve the boostrap behavior because that is handled
+  # outside of this class, and can only be triggered by running `puppet ssl` or
+  # `puppet agent`.
+  def resolve_ssl_context
+    # don't need an ssl context for http connections
+    return nil unless @site.use_ssl?
+
+    # if our verifier has an ssl_context, use that
+    ctx = @verifier.ssl_context
+    return ctx if ctx
+
+    # load available certs
+    cert = Puppet::X509::CertProvider.new
+    ssl = Puppet::SSL::SSLProvider.new
+    begin
+      password = cert.load_private_key_password
+      ssl.load_context(certname: Puppet[:certname], password: password)
+    rescue Puppet::SSL::SSLError => e
+      Puppet.log_exception(e)
+
+      # if we don't have cacerts, then create a root context that doesn't
+      # trust anything. The old code used to fallback to VERIFY_NONE,
+      # which we don't want to emulate.
+      ssl.create_root_context(cacerts: [])
+    end
+  end
+
+  def to_url(path)
+    if path =~ /^https?:\/\//
+      # The old Connection class accepts a URL as the request path, and sends
+      # it in "absolute-form" in the request line, e.g. GET https://puppet:8140/.
+      # See https://httpwg.org/specs/rfc7230.html#absolute-form. It just so happens
+      # to work because HTTP 1.1 servers are required to accept absolute-form even
+      # though clients are only supposed to send them to proxies, so the proxy knows
+      # what upstream server to CONNECT to. This method creates a URL using the
+      # scheme/host/port that the connection was created with, and appends the path
+      # and query portions of the absolute-form. The resulting request will use "origin-form"
+      # as it should have done all along.
+      abs_form = URI(path)
+      url = URI("#{@site.addr}/#{normalize_path(abs_form.path)}")
+      url.query = abs_form.query if abs_form.query
+      url
+    else
+      URI("#{@site.addr}/#{normalize_path(path)}")
+    end
+  end
+
+  def normalize_path(path)
+    if path[0] == '/'
+      path[1..-1]
+    else
+      path
+    end
+  end
+
+  def with_error_handling(&block)
+    yield
+  rescue Puppet::HTTP::TooManyRedirects => e
+    raise Puppet::Network::HTTP::RedirectionLimitExceededException.new(_("Too many HTTP redirections for %{host}:%{port}") % { host: @host, port: @port }, e)
+  rescue Puppet::HTTP::HTTPError => e
+    Puppet.log_exception(e, e.message)
+    case e.cause
+    when Net::OpenTimeout, Net::ReadTimeout, Net::HTTPError, EOFError
+      raise e.cause
+    else
+      raise e
+    end
+  end
+end

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/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,14 +13,13 @@ 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
   end
   def self.http_client_class=(klass)
     @http_client_class = klass
-    Puppet.runtime['http'] = Puppet::HTTP::ExternalClient.new(klass)
   end
 
   # Retrieve a connection for the given host and port.

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/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|
@@ -424,7 +432,6 @@ module Pal
       begin
         node.sanitize()
         compiler = create_internal_compiler(internal_compiler_class, node)
-        add_variables(compiler.topscope, pal_variables)
 
         case internal_compiler_class
         when :script
@@ -435,11 +442,31 @@ 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
+            # 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)