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

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

@@ -3,4 +3,38 @@ require 'puppet/indirector/rest'
 
 class Puppet::Resource::Catalog::Rest < Puppet::Indirector::REST
   desc "Find resource catalogs over HTTP via REST."
+
+  def find(request)
+    return super unless use_http_client?
+
+    checksum_type = if request.options[:checksum_type]
+                      request.options[:checksum_type].split('.')
+                    else
+                      Puppet[:supported_checksum_types]
+                    end
+
+    session = Puppet.lookup(:http_session)
+    api = session.route_to(:puppet)
+    _, catalog = api.post_catalog(
+      request.key,
+      facts: request.options[:facts_for_catalog],
+      environment: request.environment.to_s,
+      configured_environment: request.options[:configured_environment],
+      transaction_uuid: request.options[:transaction_uuid],
+      job_uuid: request.options[:job_id],
+      static_catalog: request.options[:static_catalog],
+      checksum_type: checksum_type
+    )
+    catalog
+  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/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/file.rb

@@ -250,7 +250,7 @@ module Puppet::FileBucketFile
     # @return [void]
     # @api private
     def copy_bucket_file_to_contents_file(contents_file, bucket_file)
-      Puppet::Util.replace_file(contents_file, 0440) do |of|
+      Puppet::FileSystem.replace_file(contents_file, 0440) do |of|
         # PUP-1044 writes all of the contents
         bucket_file.stream() do |src|
           FileUtils.copy_stream(src, of)

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: 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,12 +8,12 @@ class Puppet::Indirector::FileMetadata::Http < Puppet::Indirector::GenericHttp
 
   include Puppet::FileServing::TerminusHelper
 
-  @http_method = :head
-
   def find(request)
-    head = super
+    uri = URI(request.uri)
+    client = Puppet.runtime[:http]
+    head = client.head(uri, options: {include_system_store: true})
 
-    if head.is_a?(Net::HTTPSuccess)
+    if head.success?
       metadata = Puppet::FileServing::HttpMetadata.new(head)
       metadata.checksum_type = request.options[:checksum_type] if request.options[:checksum_type]
       metadata.collect

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: 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: 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/json.rb

@@ -14,7 +14,7 @@ class Puppet::Indirector::JSON < Puppet::Indirector::Terminus
     filename = path(request.key)
     FileUtils.mkdir_p(File.dirname(filename))
 
-    Puppet::Util.replace_file(filename, 0660) {|f| f.print to_json(request.instance).force_encoding(Encoding::BINARY) }
+    Puppet::FileSystem.replace_file(filename, 0660) {|f| f.print to_json(request.instance).force_encoding(Encoding::BINARY) }
   rescue TypeError => detail
     Puppet.log_exception(detail, _("Could not save %{json} %{request}: %{detail}") % { json: self.name, request: request.key, detail: detail })
   end

data/lib/puppet/indirector/msgpack.rb

@@ -21,7 +21,7 @@ class Puppet::Indirector::Msgpack < Puppet::Indirector::Terminus
     filename = path(request.key)
     FileUtils.mkdir_p(File.dirname(filename))
 
-    Puppet::Util.replace_file(filename, 0660) {|f| f.print to_msgpack(request.instance) }
+    Puppet::FileSystem.replace_file(filename, 0660) {|f| f.print to_msgpack(request.instance) }
   rescue TypeError => detail
     Puppet.log_exception(detail, _("Could not save %{name} %{request}: %{detail}") % { name: self.name, request: request.key, detail: detail })
   end

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/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/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|

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

@@ -6,4 +6,22 @@ class Puppet::Indirector::Status::Rest < Puppet::Indirector::REST
   desc "Get puppet master's status via REST. Useful because it tests the health
     of both the web server and the indirector."
 
+  def find(request)
+    return super unless use_http_client?
+
+    session = Puppet.lookup(:http_session)
+    api = session.route_to(:puppet)
+    _, status = api.get_status(request.key)
+    status
+  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