puppet 6.13.0-universal-darwin → 6.14.0-universal-darwin

data/lib/puppet/http/service/ca.rb

@@ -2,9 +2,9 @@ class Puppet::HTTP::Service::Ca < Puppet::HTTP::Service
   HEADERS = { 'Accept' => 'text/plain' }.freeze
   API = '/puppet-ca/v1'.freeze
 
-  def initialize(client, server, port)
+  def initialize(client, session, server, port)
     url = build_url(API, server || Puppet[:ca_server], port || Puppet[:ca_port])
-    super(client, url)
+    super(client, session, url)
   end
 
   def get_certificate(name, ssl_context: nil)
@@ -14,9 +14,9 @@ class Puppet::HTTP::Service::Ca < Puppet::HTTP::Service
       ssl_context: ssl_context
     )
 
-    return response.body.to_s if response.success?
+    process_response(response)
 
-    raise Puppet::HTTP::ResponseError.new(response)
+    response.body.to_s
   end
 
   def get_certificate_revocation_list(if_modified_since: nil, ssl_context: nil)
@@ -29,9 +29,9 @@ class Puppet::HTTP::Service::Ca < Puppet::HTTP::Service
       ssl_context: ssl_context
     )
 
-    return response.body.to_s if response.success?
+    process_response(response)
 
-    raise Puppet::HTTP::ResponseError.new(response)
+    response.body.to_s
   end
 
   def put_certificate_request(name, csr, ssl_context: nil)
@@ -43,8 +43,8 @@ class Puppet::HTTP::Service::Ca < Puppet::HTTP::Service
       ssl_context: ssl_context
     )
 
-    return response.body.to_s if response.success?
+    process_response(response)
 
-    raise Puppet::HTTP::ResponseError.new(response)
+    response.body.to_s
   end
 end

data/lib/puppet/http/service/compiler.rb

@@ -1,9 +1,9 @@
 class Puppet::HTTP::Service::Compiler < Puppet::HTTP::Service
   API = '/puppet/v3'.freeze
 
-  def initialize(client, server, port)
+  def initialize(client, session, server, port)
     url = build_url(API, server || Puppet[:server], port || Puppet[:masterport])
-    super(client, url)
+    super(client, session, url)
   end
 
   def get_node(name, environment:, configured_environment: nil, transaction_uuid: nil)
@@ -16,15 +16,15 @@ class Puppet::HTTP::Service::Compiler < Puppet::HTTP::Service
         environment: environment,
         configured_environment: configured_environment || environment,
         transaction_uuid: transaction_uuid,
-      },
+      }
     )
 
-    return deserialize(response, Puppet::Node) if response.success?
+    process_response(response)
 
-    raise Puppet::HTTP::ResponseError.new(response)
+    deserialize(response, Puppet::Node)
   end
 
-  def get_catalog(name, facts:, environment:, configured_environment: nil, transaction_uuid: nil, job_uuid: nil, static_catalog: true, checksum_type: Puppet[:supported_checksum_types])
+  def post_catalog(name, facts:, environment:, configured_environment: nil, transaction_uuid: nil, job_uuid: nil, static_catalog: true, checksum_type: Puppet[:supported_checksum_types])
     if Puppet[:preferred_serialization_format] == "pson"
       formatter = Puppet::Network::FormatHandler.format_for(:pson)
       # must use 'pson' instead of 'text/pson'
@@ -61,9 +61,23 @@ class Puppet::HTTP::Service::Compiler < Puppet::HTTP::Service
       body: body,
     )
 
-    return deserialize(response, Puppet::Resource::Catalog) if response.success?
+    process_response(response)
+
+    deserialize(response, Puppet::Resource::Catalog)
+  end
+
+  def get_facts(name, environment:)
+    headers = add_puppet_headers('Accept' => get_mime_types(Puppet::Node::Facts).join(', '))
+
+    response = @client.get(
+      with_base_url("/facts/#{name}"),
+      headers: headers,
+      params: { environment: environment }
+    )
+
+    process_response(response)
 
-    raise Puppet::HTTP::ResponseError.new(response)
+    deserialize(response, Puppet::Node::Facts)
   end
 
   def put_facts(name, environment:, facts:)
@@ -79,8 +93,25 @@ class Puppet::HTTP::Service::Compiler < Puppet::HTTP::Service
       body: serialize(formatter, facts),
     )
 
-    return true if response.success?
+    process_response(response)
+
+    true
+  end
+
+  def get_status(name)
+    headers = add_puppet_headers('Accept' => get_mime_types(Puppet::Status).join(', '))
+
+    response = @client.get(
+      with_base_url("/status/#{name}"),
+      headers: headers,
+      params: {
+        # environment is required, but meaningless, default to production
+        environment: 'production'
+      },
+    )
+
+    process_response(response)
 
-    raise Puppet::HTTP::ResponseError.new(response)
+    deserialize(response, Puppet::Status)
   end
 end

data/lib/puppet/http/service/file_server.rb

@@ -4,15 +4,15 @@ class Puppet::HTTP::Service::FileServer < Puppet::HTTP::Service
   API = '/puppet/v3'.freeze
   PATH_REGEX = /^\//
 
-  def initialize(client, server, port)
+  def initialize(client, session, server, port)
     url = build_url(API, server || Puppet[:server], port || Puppet[:masterport])
-    super(client, url)
+    super(client, session, url)
   end
 
-  def get_file_metadata(path:, environment:, links: :manage, checksum_type: Puppet[:digest_algorithm], source_permissions: :ignore, ssl_context: nil)
+  def get_file_metadata(path:, environment:, links: :manage, checksum_type: Puppet[:digest_algorithm], source_permissions: :ignore)
     validate_path(path)
 
-    headers = add_puppet_headers({ 'Accept' => get_mime_types(Puppet::FileServing::Metadata).join(', ') })
+    headers = add_puppet_headers('Accept' => get_mime_types(Puppet::FileServing::Metadata).join(', '))
 
     response = @client.get(
       with_base_url("/file_metadata#{path}"),
@@ -22,19 +22,18 @@ class Puppet::HTTP::Service::FileServer < Puppet::HTTP::Service
         checksum_type: checksum_type,
         source_permissions: source_permissions,
         environment: environment
-      },
-      ssl_context: ssl_context
+      }
     )
 
-    return deserialize(response, Puppet::FileServing::Metadata) if response.success?
+    process_response(response)
 
-    raise Puppet::HTTP::ResponseError.new(response)
+    deserialize(response, Puppet::FileServing::Metadata)
   end
 
-  def get_file_metadatas(path: nil, environment:, recurse: :false, recurselimit: nil, ignore: nil, links: :manage, checksum_type: Puppet[:digest_algorithm], source_permissions: :ignore, ssl_context: nil)
+  def get_file_metadatas(path: nil, environment:, recurse: :false, recurselimit: nil, ignore: nil, links: :manage, checksum_type: Puppet[:digest_algorithm], source_permissions: :ignore)
     validate_path(path)
 
-    headers = add_puppet_headers({ 'Accept' => get_mime_types(Puppet::FileServing::Metadata).join(', ') })
+    headers = add_puppet_headers('Accept' => get_mime_types(Puppet::FileServing::Metadata).join(', '))
 
     response = @client.get(
       with_base_url("/file_metadatas#{path}"),
@@ -47,36 +46,57 @@ class Puppet::HTTP::Service::FileServer < Puppet::HTTP::Service
         checksum_type: checksum_type,
         source_permissions: source_permissions,
         environment: environment,
-      },
-      ssl_context: ssl_context
+      }
     )
 
-    return deserialize_multiple(response, Puppet::FileServing::Metadata) if response.success?
+    process_response(response)
 
-    raise Puppet::HTTP::ResponseError.new(response)
+    deserialize_multiple(response, Puppet::FileServing::Metadata)
   end
 
-  def get_file_content(path:, environment:, ssl_context: nil, &block)
+  def get_file_content(path:, environment:, &block)
     validate_path(path)
 
-    headers = add_puppet_headers({'Accept' => 'application/octet-stream' })
+    headers = add_puppet_headers('Accept' => 'application/octet-stream')
     response = @client.get(
       with_base_url("/file_content#{path}"),
       headers: headers,
       params: {
         environment: environment
-      },
-      ssl_context: ssl_context
+      }
     ) do |res|
       if res.success?
         res.read_body(&block)
       end
     end
 
-    return nil if response.success?
+    process_response(response)
 
-    raise Puppet::HTTP::ResponseError.new(response)
+    nil
   end
+
+  def get_static_file_content(path:, environment:, code_id:, &block)
+    validate_path(path)
+
+    headers = add_puppet_headers('Accept' => 'application/octet-stream')
+    response = @client.get(
+      with_base_url("/static_file_content#{path}"),
+      headers: headers,
+      params: {
+        environment: environment,
+        code_id: code_id,
+      }
+    ) do |res|
+      if res.success?
+        res.read_body(&block)
+      end
+    end
+
+    process_response(response)
+
+    nil
+  end
+
   private
 
   def validate_path(path)

data/lib/puppet/http/service/report.rb

@@ -1,15 +1,12 @@
 class Puppet::HTTP::Service::Report < Puppet::HTTP::Service
   API = '/puppet/v3'.freeze
 
-  # puppet major version where JSON is enabled by default
-  MAJOR_VERSION_JSON_DEFAULT = 5
-
-  def initialize(client, server, port)
+  def initialize(client, session, server, port)
     url = build_url(API, server || Puppet[:report_server], port || Puppet[:report_port])
-    super(client, url)
+    super(client, session, url)
   end
 
-  def put_report(name, report, environment:, ssl_context: nil)
+  def put_report(name, report, environment:)
     formatter = Puppet::Network::FormatHandler.format_for(Puppet[:preferred_serialization_format])
     headers = add_puppet_headers('Accept' => get_mime_types(Puppet::Transaction::Report).join(', '))
 
@@ -18,19 +15,19 @@ class Puppet::HTTP::Service::Report < Puppet::HTTP::Service
       headers: headers,
       params: { environment: environment },
       content_type: formatter.mime,
-      body: serialize(formatter, report),
-      ssl_context: ssl_context
+      body: serialize(formatter, report)
     )
 
-    return response.body.to_s if response.success?
+    # override parent's process_response handling
+    @session.process_response(response)
 
-    server_version = response[Puppet::Network::HTTP::HEADER_PUPPET_VERSION]
-    if server_version && SemanticPuppet::Version.parse(server_version).major < MAJOR_VERSION_JSON_DEFAULT &&
-        Puppet[:preferred_serialization_format] != 'pson'
+    if response.success?
+      response
+    elsif !@session.supports?(:report, 'json') && Puppet[:preferred_serialization_format] != 'pson'
       #TRANSLATORS "pson", "preferred_serialization_format", and "puppetserver" should not be translated
-      raise Puppet::HTTP::ProtocolError.new(_("To submit reports to a server running puppetserver %{server_version}, set preferred_serialization_format to pson") % { server_version: server_version })
+      raise Puppet::HTTP::ProtocolError.new(_("To submit reports to a server running puppetserver %{server_version}, set preferred_serialization_format to pson") % { server_version: response[Puppet::HTTP::HEADER_PUPPET_VERSION]})
+    else
+      raise Puppet::HTTP::ResponseError.new(response)
     end
-
-    raise Puppet::HTTP::ResponseError.new(response)
   end
 end

data/lib/puppet/http/session.rb

@@ -1,9 +1,20 @@
 class Puppet::HTTP::Session
+  # capabilities for a site
+  CAP_LOCALES = 'locales'.freeze
+  CAP_JSON = 'json'.freeze
+
+  # puppet version where locales mount was added
+  SUPPORTED_LOCALES_MOUNT_AGENT_VERSION = Gem::Version.new("5.3.4")
+
+  # puppet version where JSON was enabled by default
+  SUPPORTED_JSON_DEFAULT = Gem::Version.new("5.0.0")
+
   def initialize(client, resolvers)
     @client = client
     @resolvers = resolvers
     @resolved_services = {}
     @resolution_exceptions = []
+    @server_versions = {}
   end
 
   def route_to(name, url: nil, ssl_context: nil)
@@ -11,7 +22,7 @@ class Puppet::HTTP::Session
 
     # short circuit if explicit URL host & port given
     if url && url.host != nil && !url.host.empty?
-      service = Puppet::HTTP::Service.create_service(@client, name, url.host, url.port)
+      service = Puppet::HTTP::Service.create_service(@client, self, name, url.host, url.port)
       service.connect(ssl_context: ssl_context)
       return service
     end
@@ -38,4 +49,31 @@ class Puppet::HTTP::Session
   def add_exception(exception)
     @resolution_exceptions << exception
   end
+
+  def process_response(response)
+    version = response[Puppet::HTTP::HEADER_PUPPET_VERSION]
+    if version
+      site = Puppet::Network::HTTP::Site.from_uri(response.url)
+      @server_versions[site] = version
+    end
+  end
+
+  def supports?(name, capability)
+    raise ArgumentError, "Unknown service #{name}" unless Puppet::HTTP::Service.valid_name?(name)
+
+    service = @resolved_services[name]
+    return false unless service
+
+    site = Puppet::Network::HTTP::Site.from_uri(service.url)
+    server_version = @server_versions[site]
+
+    case capability
+    when CAP_LOCALES
+      !server_version.nil? && Gem::Version.new(server_version) >= SUPPORTED_LOCALES_MOUNT_AGENT_VERSION
+    when CAP_JSON
+      server_version.nil? || Gem::Version.new(server_version) >= SUPPORTED_JSON_DEFAULT
+    else
+      false
+    end
+  end
 end

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

@@ -3,4 +3,37 @@ 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)
+    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
+    )
+  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,50 @@ 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)
+    api.get_facts(
+      request.key,
+      environment: request.environment.to_s
+    )
+  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_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