puppet 6.16.0 → 7.0.0

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

@@ -41,12 +41,16 @@ class Puppet::Indirector::JSON < Puppet::Indirector::Terminus
       raise ArgumentError, _("invalid key")
     end
 
-    base = Puppet.run_mode.master? ? Puppet[:server_datadir] : Puppet[:client_datadir]
+    base = data_dir
     File.join(base, self.class.indirection_name.to_s, name.to_s + ext)
   end
 
   private
 
+  def data_dir()
+    Puppet.run_mode.server? ? Puppet[:server_datadir] : Puppet[:client_datadir]
+  end
+
   def load_json_from_file(file, key)
     json = nil
 

data/lib/puppet/indirector/msgpack.rb

@@ -48,7 +48,7 @@ class Puppet::Indirector::Msgpack < Puppet::Indirector::Terminus
       raise ArgumentError, _("invalid key")
     end
 
-    base = Puppet.run_mode.master? ? Puppet[:server_datadir] : Puppet[:client_datadir]
+    base = Puppet.run_mode.server? ? Puppet[:server_datadir] : Puppet[:client_datadir]
     File.join(base, self.class.indirection_name.to_s, name.to_s + ext)
   end
 

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

@@ -0,0 +1,8 @@
+require 'puppet/node'
+require 'puppet/indirector/json'
+
+class Puppet::Node::Json < Puppet::Indirector::JSON
+  desc "Store node information as flat files, serialized using JSON,
+    or deserialize stored JSON nodes."
+
+end

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

@@ -6,8 +6,6 @@ class Puppet::Node::Rest < Puppet::Indirector::REST
     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(
@@ -21,11 +19,11 @@ class Puppet::Node::Rest < Puppet::Indirector::REST
     if e.response.code == 404
       return nil unless request.options[:fail_on_404]
 
-      _, body = parse_response(e.response.nethttp)
+      _, body = parse_response(e.response)
       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)
+      raise convert_to_http_error(e.response)
     end
   end
 end

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

@@ -0,0 +1,34 @@
+require 'puppet/transaction/report'
+require 'puppet/indirector/json'
+
+class Puppet::Transaction::Report::Json < Puppet::Indirector::JSON
+  include Puppet::Util::SymbolicFileMode
+
+  desc "Store last report as a flat file, serialized using JSON."
+
+  # Force report to be saved there
+  def path(name,ext='.json')
+    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 JSON.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/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

@@ -3,13 +3,8 @@ require 'semantic_puppet'
 
 class Puppet::Transaction::Report::Rest < Puppet::Indirector::REST
   desc "Get server report over HTTP via REST."
-  use_server_setting(:report_server)
-  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(
@@ -22,13 +17,13 @@ class Puppet::Transaction::Report::Rest < Puppet::Indirector::REST
   rescue Puppet::HTTP::ResponseError => e
     return nil if e.response.code == 404
 
-    raise convert_to_http_error(e.response.nethttp)
+    raise convert_to_http_error(e.response)
   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]
+    if !response.success?
+      server_version = response[Puppet::Network::HEADER_PUPPET_VERSION]
       if server_version &&
          SemanticPuppet::Version.parse(server_version).major < Puppet::Indirector::REST::MAJOR_VERSION_JSON_DEFAULT &&
          Puppet[:preferred_serialization_format] != 'pson'

data/lib/puppet/indirector/request.rb

@@ -1,7 +1,6 @@
 require 'cgi'
 require 'uri'
 require 'puppet/indirector'
-require 'puppet/network/resolver'
 require 'puppet/util/psych_support'
 require 'puppet/util/warnings'
 
@@ -109,47 +108,6 @@ class Puppet::Indirector::Request
     method == :search
   end
 
-  # Create the query string, if options are present.
-  def query_string
-    return "" if options.nil? || options.empty?
-    encode_params(expand_into_parameters(options.to_a))
-  end
-
-  def expand_into_parameters(data)
-    data.inject([]) do |params, key_value|
-      key, value = key_value
-
-      expanded_value = case value
-                       when Array
-                         value.collect { |val| [key, val] }
-                       else
-                         [key_value]
-                       end
-
-      params.concat(expand_primitive_types_into_parameters(expanded_value))
-    end
-  end
-
-  def expand_primitive_types_into_parameters(data)
-    data.inject([]) do |params, key_value|
-      key, value = key_value
-      case value
-      when nil
-        params
-      when true, false, String, Symbol, Integer, Float
-        params << [key, value]
-      else
-        raise ArgumentError, _("HTTP REST queries cannot handle values of type '%{klass}'") % { klass: value.class }
-      end
-    end
-  end
-
-  def encode_params(params)
-    params.collect do |key, value|
-      "#{key}=#{Puppet::Util.uri_query_encode(value.to_s)}"
-    end.join("&")
-  end
-
   def initialize_from_hash(hash)
     @indirection_name = hash['indirection_name'].to_sym
     @method = hash['method'].to_sym
@@ -182,65 +140,6 @@ class Puppet::Indirector::Request
     return(uri ? uri : "/#{indirection_name}/#{key}")
   end
 
-  def do_request(srv_service=:puppet, default_server=nil, default_port=nil, &block)
-    # We were given a specific server to use, so just use that one.
-    # This happens if someone does something like specifying a file
-    # source using a puppet:// URI with a specific server.
-    return yield(self) if !self.server.nil?
-
-    if Puppet.settings[:use_srv_records]
-      # We may want to consider not creating a new resolver here
-      # every request eventually, to take advantage of the resolver's
-      # caching behavior.
-      resolver = Puppet::Network::Resolver.new
-      resolver.each_srv_record(Puppet.settings[:srv_domain], srv_service) do |srv_server, srv_port|
-        begin
-          self.server = srv_server
-          self.port   = srv_port
-          return yield(self)
-        rescue SystemCallError => e
-          Puppet.warning _("Error connecting to %{srv_server}:%{srv_port}: %{message}") % { srv_server: srv_server, srv_port: srv_port, message: e.message }
-        end
-      end
-    end
-
-    if default_server
-      self.server = default_server
-    else
-      self.server = Puppet.lookup(:server) do
-        primary_server = Puppet.settings[:server_list][0]
-        if primary_server
-          #TRANSLATORS 'server_list' is the name of a setting and should not be translated
-          debug_once _("Selected server from first entry of the `server_list` setting: %{server}") % {server: primary_server[0]}
-          primary_server[0]
-        else
-          #TRANSLATORS 'server' is the name of a setting and should not be translated
-          debug_once _("Selected server from the `server` setting: %{server}") % {server: Puppet.settings[:server]}
-          Puppet.settings[:server]
-        end
-      end
-    end
-
-    if default_port
-      self.port = default_port
-    else
-      self.port = Puppet.lookup(:serverport) do
-        primary_server = Puppet.settings[:server_list][0]
-        if primary_server
-          #TRANSLATORS 'server_list' is the name of a setting and should not be translated
-          debug_once _("Selected port from the first entry of the `server_list` setting: %{port}") % {port: primary_server[1]}
-          primary_server[1]
-        else
-          #TRANSLATORS 'masterport' is the name of a setting and should not be translated
-          debug_once _("Selected port from the `masterport` setting: %{port}") % {port: Puppet.settings[:masterport]}
-          Puppet.settings[:masterport]
-        end
-      end
-    end
-
-    return yield(self)
-  end
-
   def remote?
     self.node or self.ip
   end
@@ -277,7 +176,7 @@ class Puppet::Indirector::Request
     # If the URI class can look up the scheme, it will provide a port,
     # otherwise it will default to '0'.
     if uri.port.to_i == 0 and uri.scheme == "puppet"
-      @port = Puppet.settings[:masterport].to_i
+      @port = Puppet.settings[:serverport].to_i
     else
       @port = uri.port.to_i
     end
@@ -290,6 +189,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

@@ -1,241 +1,23 @@
-require 'net/http'
-require 'uri'
-require 'puppet/util/json'
-require 'puppet/util/connection'
-require 'semantic_puppet'
-
-require 'puppet/network/http'
-require 'puppet/network/http_pool'
-
 # Access objects via REST
 class Puppet::Indirector::REST < Puppet::Indirector::Terminus
-  include Puppet::Network::HTTP::Compression.module
-
-  IndirectedRoutes = Puppet::Network::HTTP::API::IndirectedRoutes
-  EXCLUDED_FORMATS = [:yaml, :b64_zlib_yaml, :dot]
-
-  # puppet major version where JSON is enabled by default
-  MAJOR_VERSION_JSON_DEFAULT = 5
-
-  class << self
-    attr_reader :server_setting, :port_setting
-  end
-
-  # Specify the setting that we should use to get the server name.
-  def self.use_server_setting(setting)
-    @server_setting = setting
-  end
-
-  # Specify the setting that we should use to get the port.
-  def self.use_port_setting(setting)
-    @port_setting = setting
-  end
-
-  # Specify the service to use when doing SRV record lookup
-  def self.use_srv_service(service)
-    @srv_service = service
-  end
-
-  def self.srv_service
-    @srv_service || :puppet
-  end
-
-  # Select the server to use based on the settings configuration
-  # for this indirection, taking into account the HA server list.
-  def self.server
-    Puppet::Util::Connection.determine_server(server_setting)
-  end
-
-  # Select the port to use based on the settings configuration
-  # for this indirection, taking into account the HA server list.
-  def self.port
-    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
-    network_formats = model.supported_formats - EXCLUDED_FORMATS
-    mime_types = network_formats.map { |f| model.get_format(f).mime }
-    common_headers = {
-      "Accept"                                     => mime_types.join(', '),
-      Puppet::Network::HTTP::HEADER_PUPPET_VERSION => Puppet.version
-    }
-
-    add_accept_encoding(common_headers)
-  end
-
-  def add_profiling_header(headers)
-    if (Puppet[:profile])
-      headers[Puppet::Network::HTTP::HEADER_ENABLE_PROFILING] = "true"
-    end
-    headers
-  end
-
-  def network(request)
-    ssl_context = Puppet.lookup(:ssl_context)
-    Puppet::Network::HttpPool.connection(request.server || self.class.server,
-                                         request.port || self.class.port,
-                                         ssl_context: ssl_context)
-  end
-
-  def http_get(request, path, headers = nil, *args)
-    http_request(:get, request, path, add_profiling_header(headers), *args)
-  end
-
-  def http_post(request, path, data, headers = nil, *args)
-    http_request(:post, request, path, data, add_profiling_header(headers), *args)
-  end
-
-  def http_head(request, path, headers = nil, *args)
-    http_request(:head, request, path, add_profiling_header(headers), *args)
-  end
-
-  def http_delete(request, path, headers = nil, *args)
-    http_request(:delete, request, path, add_profiling_header(headers), *args)
-  end
-
-  def http_put(request, path, data, headers = nil, *args)
-    http_request(:put, request, path, data, add_profiling_header(headers), *args)
-  end
-
-  def http_request(method, request, *args)
-    conn = network(request)
-    conn.send(method, *args)
-  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}"
-
-    response = do_request(request) do |req|
-      # WEBrick in Ruby 1.9.1 only supports up to 1024 character lines in an HTTP request
-      # http://redmine.ruby-lang.org/issues/show/3991
-      if "GET #{uri_with_query_string} HTTP/1.1\r\n".length > 1024
-        uri_with_env = "#{uri}?environment=#{request.environment.name}"
-        http_post(req, uri_with_env, body, headers)
-      else
-        http_get(req, uri_with_query_string, headers)
-      end
-    end
-
-    if is_http_200?(response)
-      content_type, body = parse_response(response)
-      result = deserialize_find(content_type, body)
-      result.name = request.key if result.respond_to?(:name=)
-      result
-
-    elsif is_http_404?(response)
-      return nil unless request.options[:fail_on_404]
-
-      # 404 can get special treatment as the indirector API can not produce a meaningful
-      # reason to why something is not found - it may not be the thing the user is
-      # expecting to find that is missing, but something else (like the environment).
-      # While this way of handling the issue is not perfect, there is at least an error
-      # that makes a user aware of the reason for the failure.
-      #
-      _, body = parse_response(response)
-      msg = _("Find %{uri} resulted in 404 with the message: %{body}") % { uri: elide(uri_with_query_string, 100), body: body }
-      raise Puppet::Error, msg
-    else
-      nil
-    end
+    raise NotImplementedError
   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
-
-    if is_http_200?(response)
-      true
-    else
-      false
-    end
+    raise NotImplementedError
   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
-
-    if is_http_200?(response)
-      content_type, body = parse_response(response)
-      deserialize_search(content_type, body) || []
-    else
-      []
-    end
+    raise NotImplementedError
   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|
-      http_delete(req, IndirectedRoutes.request_to_uri(req), headers)
-    end
-
-    if is_http_200?(response)
-      content_type, body = parse_response(response)
-      deserialize_destroy(content_type, body)
-    else
-      nil
-    end
+    raise NotImplementedError
   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|
-      http_put(req, IndirectedRoutes.request_to_uri(req), req.instance.render, headers.merge({ "Content-Type" => req.instance.mime }))
-    end
-
-    if is_http_200?(response)
-      content_type, body = parse_response(response)
-      deserialize_save(content_type, body)
-    else
-      nil
-    end
-  end
-
-  # Encapsulate call to request.do_request with the arguments from this class
-  # Then yield to the code block that was called in
-  # We certainly could have retained the full request.do_request(...) { |r| ... }
-  # but this makes the code much cleaner and we only then actually make the call
-  # to request.do_request from here, thus if we change what we pass or how we
-  # get it, we only need to change it here.
-  def do_request(request)
-    response = request.do_request(self.class.srv_service, self.class.server, self.class.port) { |req| yield(req) }
-
-    handle_response(request, response) if response
-
-    response
-  end
-
-  def handle_response(request, response)
-    server_version = response[Puppet::Network::HTTP::HEADER_PUPPET_VERSION]
-    if server_version
-      Puppet.lookup(:server_agent_version) do
-        Puppet.push_context(:server_agent_version => server_version)
-      end
-      if SemanticPuppet::Version.parse(server_version).major < MAJOR_VERSION_JSON_DEFAULT &&
-          Puppet[:preferred_serialization_format] != 'pson'
-        #TRANSLATORS "PSON" should not be translated
-        Puppet.warning(_("Downgrading to PSON for future requests"))
-        Puppet[:preferred_serialization_format] = 'pson'
-      end
-    end
+    raise NotImplementedError
   end
 
   def validate_key(request)
@@ -244,67 +26,34 @@ class Puppet::Indirector::REST < Puppet::Indirector::Terminus
 
   private
 
-  def is_http_200?(response)
-    case response.code
-    when "404"
-      false
-    when /^2/
-      true
-    else
-      # Raise the http error if we didn't get a 'success' of some kind.
-      raise convert_to_http_error(response)
-    end
-  end
-
-  def is_http_404?(response)
-    response.code == "404"
-  end
-
   def convert_to_http_error(response)
-    if response.body.to_s.empty? && response.respond_to?(:message)
-      returned_message = response.message
+    if response.body.to_s.empty? && response.reason
+      returned_message = response.reason
     elsif response['content-type'].is_a?(String)
       content_type, body = parse_response(response)
       if content_type =~ /[pj]son/
         returned_message = Puppet::Util::Json.load(body)["message"]
       else
-        returned_message = uncompress_body(response)
+        returned_message = response.body
       end
     else
-      returned_message = uncompress_body(response)
+      returned_message = response.body
     end
 
     message = _("Error %{code} on SERVER: %{returned_message}") % { code: response.code, returned_message: returned_message }
-    Net::HTTPError.new(message, response)
+    Net::HTTPError.new(message, Puppet::HTTP::ResponseConverter.to_ruby_response(response))
   end
 
   # Returns the content_type, stripping any appended charset, and the
-  # body, decompressed if necessary (content-encoding is checked inside
-  # uncompress_body)
+  # body, decompressed if necessary
   def parse_response(response)
     if response['content-type']
-      [ response['content-type'].gsub(/\s*;.*$/,''), uncompress_body(response) ]
+      [ response['content-type'].gsub(/\s*;.*$/,''), response.body ]
     else
       raise _("No content type in http response; cannot parse")
     end
   end
 
-  def deserialize_find(content_type, body)
-    model.convert_from(content_type, body)
-  end
-
-  def deserialize_search(content_type, body)
-    model.convert_from_multiple(content_type, body)
-  end
-
-  def deserialize_destroy(content_type, body)
-    model.convert_from(content_type, body)
-  end
-
-  def deserialize_save(content_type, body)
-    nil
-  end
-
   def elide(string, length)
     if Puppet::Util::Log.level == :debug || string.length <= length
       string