puppet 6.13.0-x64-mingw32 → 6.18.0-x64-mingw32

data/lib/puppet/indirector/exec.rb

@@ -22,7 +22,7 @@ class Puppet::Indirector::Exec < Puppet::Indirector::Terminus
     end
 
     if output =~ /\A\s*\Z/ # all whitespace
-      Puppet.debug "Empty response for #{name} from #{self.name} terminus"
+      Puppet.debug { "Empty response for #{name} from #{self.name} terminus" }
       return nil
     else
       return output

data/lib/puppet/indirector/facts/facter.rb

@@ -55,7 +55,7 @@ class Puppet::Node::Facts::Facter < Puppet::Indirector::Code
       if Puppet::Util::Log.sendlevel?(:info)
         Puppet.info _("Loading facts")
         Dir.glob("#{dir}/*.rb").each do |file|
-          Puppet.debug "Loading facts from #{file}"
+          Puppet.debug { "Loading facts from #{file}" }
         end
       end
 
@@ -71,7 +71,7 @@ class Puppet::Node::Facts::Facter < Puppet::Indirector::Code
     request.environment.modules.each do |m|
       if m.has_external_facts?
         dir = m.plugin_fact_directory
-        Puppet.debug "Loading external facts from #{dir}"
+        Puppet.debug { "Loading external facts from #{dir}" }
         dirs << dir
       end
     end
@@ -79,7 +79,7 @@ class Puppet::Node::Facts::Facter < Puppet::Indirector::Code
     # Add system external fact directory if it exists
     if FileTest.directory?(Puppet[:pluginfactdest])
       dir = Puppet[:pluginfactdest]
-      Puppet.debug "Loading external facts from #{dir}"
+      Puppet.debug { "Loading external facts from #{dir}" }
       dirs << dir
     end
 

data/lib/puppet/indirector/facts/rest.rb

@@ -4,9 +4,51 @@ require 'puppet/indirector/rest'
 class Puppet::Node::Facts::Rest < Puppet::Indirector::REST
   desc "Find and save facts about nodes over HTTP via REST."
 
+  def find(request)
+    return super unless use_http_client?
+
+    session = Puppet.lookup(:http_session)
+    api = session.route_to(:puppet)
+    _, facts = api.get_facts(
+      request.key,
+      environment: request.environment.to_s
+    )
+    facts
+  rescue Puppet::HTTP::ResponseError => e
+    if e.response.code == 404
+      return nil unless request.options[:fail_on_404]
+
+      _, body = parse_response(e.response.nethttp)
+      msg = _("Find %{uri} resulted in 404 with the message: %{body}") % { uri: elide(e.response.url.path, 100), body: body }
+      raise Puppet::Error, msg
+    else
+      raise convert_to_http_error(e.response.nethttp)
+    end
+  end
+
   def save(request)
     raise ArgumentError, _("PUT does not accept options") unless request.options.empty?
 
+    return legacy_save(request) unless use_http_client?
+
+    session = Puppet.lookup(:http_session)
+    api = session.route_to(:puppet)
+    api.put_facts(
+      request.key,
+      facts: request.instance,
+      environment: request.environment.to_s
+    )
+
+    # preserve existing behavior
+    nil
+  rescue Puppet::HTTP::ResponseError => e
+    # always raise even if fail_on_404 is false
+    raise convert_to_http_error(e.response.nethttp)
+  end
+
+  private
+
+  def legacy_save(request)
     response = do_request(request) do |req|
       http_put(req, IndirectedRoutes.request_to_uri(req), req.instance.render, headers.merge({ "Content-Type" => req.instance.mime }))
     end

data/lib/puppet/indirector/file_bucket_file/rest.rb

@@ -4,5 +4,53 @@ require 'puppet/file_bucket/file'
 module Puppet::FileBucketFile
   class Rest < Puppet::Indirector::REST
     desc "This is a REST based mechanism to send/retrieve file to/from the filebucket"
+
+    def head(request)
+      return super unless use_http_client?
+
+      session = Puppet.lookup(:http_session)
+      api = session.route_to(:puppet)
+      api.head_filebucket_file(
+        request.key,
+        environment: request.environment.to_s,
+        bucket_path: request.options[:bucket_path],
+      )
+    rescue Puppet::HTTP::ResponseError => e
+      return nil if e.response.code == 404
+      raise convert_to_http_error(e.response.nethttp)
+    end
+
+    def find(request)
+      return super unless use_http_client?
+
+      session = Puppet.lookup(:http_session)
+      api = session.route_to(:puppet)
+      _, filebucket_file = api.get_filebucket_file(
+        request.key,
+        environment: request.environment.to_s,
+        bucket_path: request.options[:bucket_path],
+        diff_with: request.options[:diff_with],
+        list_all: request.options[:list_all],
+        fromdate: request.options[:fromdate],
+        todate: request.options[:todate],
+      )
+      filebucket_file
+    rescue Puppet::HTTP::ResponseError => e
+      raise convert_to_http_error(e.response.nethttp)
+    end
+
+    def save(request)
+      return super unless use_http_client?
+
+      session = Puppet.lookup(:http_session)
+      api = session.route_to(:puppet)
+      api.put_filebucket_file(
+        request.key,
+        body: request.instance.render,
+        environment: request.environment.to_s,
+      )
+    rescue Puppet::HTTP::ResponseError => e
+      raise convert_to_http_error(e.response.nethttp)
+    end
   end
 end

data/lib/puppet/indirector/file_content/http.rb

@@ -10,6 +10,11 @@ class Puppet::Indirector::FileContent::Http < Puppet::Indirector::GenericHttp
 
   @http_method = :get
 
+  def initialize
+    Puppet.deprecation_warning(_("Puppet::Indirector::FileContent::Http is deprecated. Use Puppet::HTTP::Client instead."))
+    super
+  end
+
   def find(request)
     response = super
     model.from_binary(uncompress_body(response))

data/lib/puppet/indirector/file_content/rest.rb

@@ -6,4 +6,34 @@ class Puppet::Indirector::FileContent::Rest < Puppet::Indirector::REST
   desc "Retrieve file contents via a REST HTTP interface."
 
   use_srv_service(:fileserver)
+
+  def find(request)
+    return super unless use_http_client?
+
+    content = StringIO.new
+    content.binmode
+
+    url = URI.parse(Puppet::Util.uri_encode(request.uri))
+    session = Puppet.lookup(:http_session)
+    api = session.route_to(:fileserver, url: url)
+
+    api.get_file_content(
+      path: Puppet::Util.uri_unescape(url.path),
+      environment: request.environment.to_s,
+    ) do |data|
+      content << data
+    end
+
+    Puppet::FileServing::Content.from_binary(content.string)
+  rescue Puppet::HTTP::ResponseError => e
+    if e.response.code == 404
+      return nil unless request.options[:fail_on_404]
+
+      _, body = parse_response(e.response.nethttp)
+      msg = _("Find %{uri} resulted in 404 with the message: %{body}") % { uri: elide(e.response.url.path, 100), body: body }
+      raise Puppet::Error, msg
+    else
+      raise convert_to_http_error(e.response.nethttp)
+    end
+  end
 end

data/lib/puppet/indirector/file_metadata/http.rb

@@ -8,20 +8,40 @@ class Puppet::Indirector::FileMetadata::Http < Puppet::Indirector::GenericHttp
 
   include Puppet::FileServing::TerminusHelper
 
-  @http_method = :head
-
   def find(request)
-    head = super
+    checksum_type = request.options[:checksum_type]
+    # See URL encoding comment in Puppet::Type::File::ParamSource#chunk_file_from_source
+    uri = URI(request.uri)
+    client = Puppet.runtime[:http]
+    head = client.head(uri, options: {include_system_store: true})
+
+    return create_httpmetadata(head, checksum_type) if head.success?
 
-    if head.is_a?(Net::HTTPSuccess)
-      metadata = Puppet::FileServing::HttpMetadata.new(head)
-      metadata.checksum_type = request.options[:checksum_type] if request.options[:checksum_type]
-      metadata.collect
-      metadata
+    case head.code
+    when 403, 405
+      # AMZ presigned URL and puppetserver may return 403
+      # instead of 405. Fallback to partial get
+      get = partial_get(client, uri)
+      return create_httpmetadata(get, checksum_type) if get.success?
     end
+
+    nil
   end
 
   def search(request)
     raise Puppet::Error, _("cannot lookup multiple files")
   end
+
+  private
+
+  def partial_get(client, uri)
+    client.get(uri, headers: {'Range' => 'bytes=0-0'}, options: {include_system_store: true})
+  end
+
+  def create_httpmetadata(http_request, checksum_type)
+    metadata = Puppet::FileServing::HttpMetadata.new(http_request)
+    metadata.checksum_type = checksum_type if checksum_type
+    metadata.collect
+    metadata
+  end
 end

data/lib/puppet/indirector/file_metadata/rest.rb

@@ -6,4 +6,56 @@ class Puppet::Indirector::FileMetadata::Rest < Puppet::Indirector::REST
   desc "Retrieve file metadata via a REST HTTP interface."
 
   use_srv_service(:fileserver)
+
+  def find(request)
+    return super unless use_http_client?
+
+    url = URI.parse(Puppet::Util.uri_encode(request.uri))
+    session = Puppet.lookup(:http_session)
+    api = session.route_to(:fileserver, url: url)
+
+    _, file_metadata = api.get_file_metadata(
+      path: Puppet::Util.uri_unescape(url.path),
+      environment: request.environment.to_s,
+      links: request.options[:links],
+      checksum_type: request.options[:checksum_type],
+      source_permissions: request.options[:source_permissions]
+    )
+    file_metadata
+  rescue Puppet::HTTP::ResponseError => e
+    if e.response.code == 404
+      return nil unless request.options[:fail_on_404]
+
+      _, body = parse_response(e.response.nethttp)
+      msg = _("Find %{uri} resulted in 404 with the message: %{body}") % { uri: elide(e.response.url.path, 100), body: body }
+      raise Puppet::Error, msg
+    else
+      raise convert_to_http_error(e.response.nethttp)
+    end
+  end
+
+  def search(request)
+    return super unless use_http_client?
+
+    url = URI.parse(Puppet::Util.uri_encode(request.uri))
+    session = Puppet.lookup(:http_session)
+    api = session.route_to(:fileserver, url: url)
+
+    _, file_metadatas = api.get_file_metadatas(
+      path: Puppet::Util.uri_unescape(url.path),
+      environment: request.environment.to_s,
+      recurse: request.options[:recurse],
+      recurselimit: request.options[:recurselimit],
+      ignore: request.options[:ignore],
+      links: request.options[:links],
+      checksum_type: request.options[:checksum_type],
+      source_permissions: request.options[:source_permissions],
+    )
+    file_metadatas
+  rescue Puppet::HTTP::ResponseError => e
+    # since it's search, return empty array instead of nil
+    return [] if e.response.code == 404
+
+    raise convert_to_http_error(e.response.nethttp)
+  end
 end

data/lib/puppet/indirector/hiera.rb

@@ -1,6 +1,10 @@
 require 'puppet/indirector/terminus'
 require 'hiera/scope'
 
+# This class can't be collapsed into Puppet::Indirector::DataBindings::Hiera
+# because some community plugins rely on this class directly, see PUP-1843.
+# This class is deprecated and will be deleted in a future release.
+# Use `Puppet::DataBinding.indirection.terminus(:hiera)` instead.
 class Puppet::Indirector::Hiera < Puppet::Indirector::Terminus
   def initialize(*args)
     if ! Puppet.features.hiera?

data/lib/puppet/indirector/indirection.rb

@@ -269,7 +269,7 @@ class Puppet::Indirector::Indirection
       return nil
     end
 
-    Puppet.debug "Using cached #{self.name} for #{request.key}"
+    Puppet.debug { "Using cached #{self.name} for #{request.key}" }
     cached
   rescue => detail
     Puppet.log_exception(detail, _("Cached %{indirection} for %{request} failed: %{detail}") % { indirection: self.name, request: request.key, detail: detail })

data/lib/puppet/indirector/node/rest.rb

@@ -4,4 +4,28 @@ require 'puppet/indirector/rest'
 class Puppet::Node::Rest < Puppet::Indirector::REST
   desc "Get a node via REST. Puppet agent uses this to allow the puppet master
     to override its environment."
+
+  def find(request)
+    return super unless use_http_client?
+
+    session = Puppet.lookup(:http_session)
+    api = session.route_to(:puppet)
+    _, node = api.get_node(
+      request.key,
+      environment: request.environment.to_s,
+      configured_environment: request.options[:configured_environment],
+      transaction_uuid: request.options[:transaction_uuid]
+    )
+    node
+  rescue Puppet::HTTP::ResponseError => e
+    if e.response.code == 404
+      return nil unless request.options[:fail_on_404]
+
+      _, body = parse_response(e.response.nethttp)
+      msg = _("Find %{uri} resulted in 404 with the message: %{body}") % { uri: elide(e.response.url.path, 100), body: body }
+      raise Puppet::Error, msg
+    else
+      raise convert_to_http_error(e.response.nethttp)
+    end
+  end
 end

data/lib/puppet/indirector/report/processor.rb

@@ -26,9 +26,9 @@ class Puppet::Transaction::Report::Processor < Puppet::Indirector::Code
   # LAK:NOTE This isn't necessarily the best design, but it's backward
   # compatible and that's good enough for now.
   def process(report)
-    Puppet.debug "Received report to process from #{report.host}"
+    Puppet.debug { "Received report to process from #{report.host}" }
     processors do |mod|
-      Puppet.debug "Processing report from #{report.host} with processor #{mod}"
+      Puppet.debug { "Processing report from #{report.host} with processor #{mod}" }
       # We have to use a dup because we're including a module in the
       # report.
       newrep = report.dup

data/lib/puppet/indirector/report/rest.rb

@@ -7,6 +7,25 @@ class Puppet::Transaction::Report::Rest < Puppet::Indirector::REST
   use_port_setting(:report_port)
   use_srv_service(:report)
 
+  def save(request)
+    return super unless use_http_client?
+
+    session = Puppet.lookup(:http_session)
+    api = session.route_to(:report)
+    response = api.put_report(
+      request.key,
+      request.instance,
+      environment: request.environment.to_s
+    )
+    content_type, body = parse_response(response)
+    deserialize_save(content_type, body)
+  rescue Puppet::HTTP::ResponseError => e
+    return nil if e.response.code == 404
+
+    raise convert_to_http_error(e.response.nethttp)
+  end
+
+  # This is called by the superclass when not using our httpclient.
   def handle_response(request, response)
     if !response.is_a?(Net::HTTPSuccess)
       server_version = response[Puppet::Network::HTTP::HEADER_PUPPET_VERSION]

data/lib/puppet/indirector/report/yaml.rb

@@ -2,10 +2,33 @@ require 'puppet/transaction/report'
 require 'puppet/indirector/yaml'
 
 class Puppet::Transaction::Report::Yaml < Puppet::Indirector::Yaml
+  include Puppet::Util::SymbolicFileMode
+
   desc "Store last report as a flat file, serialized using YAML."
 
   # Force report to be saved there
   def path(name,ext='.yaml')
     Puppet[:lastrunreport]
   end
+
+  def save(request)
+    filename = path(request.key)
+    mode = Puppet.settings.setting(:lastrunreport).mode
+
+    unless valid_symbolic_mode?(mode)
+      raise Puppet::DevError, _("replace_file mode: %{mode} is invalid") % { mode: mode }
+    end
+
+    mode = symbolic_mode_to_int(normalize_symbolic_mode(mode))
+
+    FileUtils.mkdir_p(File.dirname(filename))
+
+    begin
+      Puppet::FileSystem.replace_file(filename, mode) do |fh|
+        fh.print YAML.dump(request.instance)
+      end
+    rescue TypeError => detail
+      Puppet.err _("Could not save %{indirection} %{request}: %{detail}") % { indirection: self.name, request: request.key, detail: detail }
+    end
+  end
 end

data/lib/puppet/indirector/request.rb

@@ -290,6 +290,6 @@ class Puppet::Indirector::Request
       @protocol = uri.scheme
     end
 
-    @key = URI.unescape(uri.path.sub(/^\//, ''))
+    @key = Puppet::Util.uri_unescape(uri.path.sub(/^\//, ''))
   end
 end

data/lib/puppet/indirector/rest.rb

@@ -52,6 +52,13 @@ class Puppet::Indirector::REST < Puppet::Indirector::Terminus
     Puppet::Util::Connection.determine_port(port_setting, server_setting)
   end
 
+  # Should we use puppet's http client to make requests. Will return
+  # false when running in puppetserver
+  def use_http_client?
+    Puppet::Network::HttpPool.http_client_class == Puppet::Network::HTTP::Connection ||
+      Puppet::Network::HttpPool.http_client_class == Puppet::Network::HTTP::ConnectionAdapter
+  end
+
   # Provide appropriate headers.
   def headers
     # yaml is not allowed on the network
@@ -105,6 +112,7 @@ class Puppet::Indirector::REST < Puppet::Indirector::Terminus
   end
 
   def find(request)
+    Puppet.deprecation_warning(_("Puppet::Indirector::Rest#find is deprecated. Use Puppet::HTTP::Client instead."))
     uri, body = IndirectedRoutes.request_to_uri_and_body(request)
     uri_with_query_string = "#{uri}?#{body}"
 
@@ -143,6 +151,7 @@ class Puppet::Indirector::REST < Puppet::Indirector::Terminus
   end
 
   def head(request)
+    Puppet.deprecation_warning(_("Puppet::Indirector::Rest#head is deprecated. Use Puppet::HTTP::Client instead."))
     response = do_request(request) do |req|
       http_head(req, IndirectedRoutes.request_to_uri(req), headers)
     end
@@ -155,6 +164,7 @@ class Puppet::Indirector::REST < Puppet::Indirector::Terminus
   end
 
   def search(request)
+    Puppet.deprecation_warning(_("Puppet::Indirector::Rest#search is deprecated. Use Puppet::HTTP::Client instead."))
     response = do_request(request) do |req|
       http_get(req, IndirectedRoutes.request_to_uri(req), headers)
     end
@@ -168,6 +178,7 @@ class Puppet::Indirector::REST < Puppet::Indirector::Terminus
   end
 
   def destroy(request)
+    Puppet.deprecation_warning(_("Puppet::Indirector::Rest#destroy is deprecated. Use Puppet::HTTP::Client instead."))
     raise ArgumentError, _("DELETE does not accept options") unless request.options.empty?
 
     response = do_request(request) do |req|
@@ -183,6 +194,7 @@ class Puppet::Indirector::REST < Puppet::Indirector::Terminus
   end
 
   def save(request)
+    Puppet.deprecation_warning(_("Puppet::Indirector::Rest#save is deprecated. Use Puppet::HTTP::Client instead."))
     raise ArgumentError, _("PUT does not accept options") unless request.options.empty?
 
     response = do_request(request) do |req|