puppet 6.17.0-x64-mingw32 → 7.1.0-x64-mingw32

data/lib/puppet/http/resolver.rb

@@ -1,26 +1,17 @@
-#
-# @api private
-#
 # Resolver base class. Each resolver represents a different strategy for
 # resolving a service name into a list of candidate servers and ports.
 #
 # @abstract Subclass and override {#resolve} to create a new resolver.
-#
+# @api public
 class Puppet::HTTP::Resolver
   #
-  # @api private
-  #
-  # Create a new resolver
+  # Create a new resolver.
   #
   # @param [Puppet::HTTP::Client] client
-  #
   def initialize(client)
     @client = client
   end
 
-  #
-  # @api private
-  #
   # Return a working server/port for the resolver. This is the base
   # implementation and is meant to be a placeholder.
   #
@@ -28,34 +19,30 @@ class Puppet::HTTP::Resolver
   # @param [Symbol] name the service to resolve
   # @param [Puppet::SSL::SSLContext] ssl_context (nil) optional ssl context to
   #   use when creating a connection
-  # @param [Proc] error_handler (nil) optional callback for each error
-  #   encountered while resolving a route.
+  # @param [Proc] canceled_handler (nil) optional callback allowing a resolver
+  #   to cancel resolution.
   #
   # @raise [NotImplementedError] this base class is not implemented
   #
-  def resolve(session, name, ssl_context: nil, error_handler: nil)
+  # @api public
+  def resolve(session, name, ssl_context: nil, canceled_handler: nil)
     raise NotImplementedError
   end
 
-  #
-  # @api private
-  #
-  # Check a given connection to establish if it can be relied on for future use
+  # Check a given connection to establish if it can be relied on for future use.
   #
   # @param [Puppet::HTTP::Session] session
   # @param [Puppet::HTTP::Service] service
   # @param [Puppet::SSL::SSLContext] ssl_context
-  # @param [Proc] error_handler (nil) optional callback for each error
-  #   encountered while resolving a route.
   #
   # @return [Boolean] Returns true if a connection is successful, false otherwise
   #
-  def check_connection?(session, service, ssl_context: nil, error_handler: nil)
+  # @api public
+  def check_connection?(session, service, ssl_context: nil)
     service.connect(ssl_context: ssl_context)
     return true
   rescue Puppet::HTTP::ConnectionError => e
-    error_handler.call(e) if error_handler
-    Puppet.debug("Connection to #{service.url} failed, trying next route: #{e.message}")
+    Puppet.log_exception(e, "Connection to #{service.url} failed, trying next route: #{e.message}")
     return false
   end
 end

data/lib/puppet/http/resolver/server_list.rb

@@ -1,12 +1,10 @@
-#
-# @api private
-#
 # Use the server_list setting to resolve a service. This resolver is only used
 # if server_list is set either on the command line or in the configuration file.
 #
+# @api public
 class Puppet::HTTP::Resolver::ServerList < Puppet::HTTP::Resolver
-  #
-  # @api private
+
+  # Create a server list resolver.
   #
   # @param [Puppet::HTTP::Client] client
   # @param [Array<String>] server_list_setting array of servers set via the
@@ -22,19 +20,15 @@ class Puppet::HTTP::Resolver::ServerList < Puppet::HTTP::Resolver
     @server_list_setting = server_list_setting
     @default_port = default_port
     @services = services
-    @resolved_url = nil
   end
 
-  #
-  # @api private
-  #
   # Walk the server_list to find a server and port that will connect successfully.
   #
-  # @param [Puppet::HTTP::Session] session <description>
+  # @param [Puppet::HTTP::Session] session
   # @param [Symbol] name the name of the service being resolved
   # @param [Puppet::SSL::SSLContext] ssl_context
-  # @param [Proc] error_handler (nil) optional callback for each error
-  #   encountered while resolving a route.
+  # @param [Proc] canceled_handler optional callback allowing a resolver
+  #   to cancel resolution.
   #
   # @return [nil] return nil if the service to be resolved does not support
   #   server_list
@@ -44,7 +38,8 @@ class Puppet::HTTP::Resolver::ServerList < Puppet::HTTP::Resolver
   # @raise [Puppet::Error] raise if none of the servers defined in server_list
   #   are available
   #
-  def resolve(session, name, ssl_context: nil, error_handler: nil)
+  # @api public
+  def resolve(session, name, ssl_context: nil, canceled_handler: nil)
     # If we're configured to use an explicit service host, e.g. report_server
     # then don't use server_list to resolve the `:report` service.
     return nil unless @services.include?(name)
@@ -58,41 +53,24 @@ class Puppet::HTTP::Resolver::ServerList < Puppet::HTTP::Resolver
     @server_list_setting.value.each do |server|
       host = server[0]
       port = server[1] || @default_port
-      uri = URI("https://#{host}:#{port}/status/v1/simple/master")
-      if get_success?(uri, session, ssl_context: ssl_context, error_handler: error_handler)
-        @resolved_url = uri
-        return Puppet::HTTP::Service.create_service(@client, session, name, host, port)
+
+      service = Puppet::HTTP::Service.create_service(@client, session, :puppetserver, host, port)
+      begin
+        service.get_simple_status(ssl_context: ssl_context)
+        @resolved_url = service.url
+        return Puppet::HTTP::Service.create_service(@client, session, name, @resolved_url.host, @resolved_url.port)
+      rescue Puppet::HTTP::ResponseError => detail
+        Puppet.log_exception(detail, _("Puppet server %{host}:%{port} is unavailable: %{code} %{reason}") %
+                             { host: service.url.host, port: service.url.port, code: detail.response.code, reason: detail.response.reason })
+      rescue Puppet::HTTP::HTTPError => detail
+        Puppet.log_exception(detail, _("Unable to connect to server from server_list setting: %{detail}") % {detail: detail})
       end
     end
 
-    raise Puppet::Error, _("Could not select a functional puppet master from server_list: '%{server_list}'") % { server_list: @server_list_setting.print(@server_list_setting.value) }
-  end
-
-  #
-  # @api private
-  #
-  # Check if a server and port is available
-  #
-  # @param [URI] uri A URI created from the server and port to test
-  # @param [Puppet::HTTP::Session] session
-  # @param [Puppet::SSL::SSLContext] ssl_context
-  # @param [Proc] error_handler (nil) optional callback for each error
-  #   encountered while resolving a route.
-  #
-  # @return [Boolean] true if a successful response is returned by the server,
-  #   false otherwise
-  #
-  def get_success?(uri, session, ssl_context: nil, error_handler: nil)
-    response = @client.get(uri, options: {ssl_context: ssl_context})
-    return true if response.success?
+    # don't fallback to other resolvers
+    canceled_handler.call(true) if canceled_handler
 
-    Puppet.debug(_("Puppet server %{host}:%{port} is unavailable: %{code} %{reason}") %
-                 { host: uri.host, port: uri.port, code: response.code, reason: response.reason })
-    return false
-  rescue => detail
-    error_handler.call(detail) if error_handler
-    #TRANSLATORS 'server_list' is the name of a setting and should not be translated
-    Puppet.debug _("Unable to connect to server from server_list setting: %{detail}") % {detail: detail}
-    return false
+    # not found
+    nil
   end
 end

data/lib/puppet/http/resolver/settings.rb

@@ -1,26 +1,23 @@
-#
-# @api private
-#
 # Resolve a service using settings. This is the default resolver if none of the
 # other resolvers find a functional connection.
 #
+# @api public
 class Puppet::HTTP::Resolver::Settings < Puppet::HTTP::Resolver
-  #
-  # @api private
-  #
+
   # Resolve a service using the default server and port settings for this service.
   #
   # @param [Puppet::HTTP::Session] session
   # @param [Symbol] name the name of the service to be resolved
   # @param [Puppet::SSL::SSLContext] ssl_context
-  # @param [Proc] error_handler (nil) optional callback for each error
-  #   encountered while resolving a route.
+  # @param [Proc] canceled_handler optional callback allowing a resolver
+  #   to cancel resolution.
   #
   # @return [Puppet::HTTP::Service] if the service successfully connects,
   #   return it. Otherwise, return nil.
   #
-  def resolve(session, name, ssl_context: nil, error_handler: nil)
+  # @api public
+  def resolve(session, name, ssl_context: nil, canceled_handler: nil)
     service = Puppet::HTTP::Service.create_service(@client, session, name)
-    check_connection?(session, service, ssl_context: ssl_context, error_handler: error_handler) ? service : nil
+    check_connection?(session, service, ssl_context: ssl_context) ? service : nil
   end
 end

data/lib/puppet/http/resolver/srv.rb

@@ -1,11 +1,9 @@
+# Resolve a service using DNS SRV records.
 #
-# @api private
-#
-# Resolve a service using SRV
-#
+# @api public
 class Puppet::HTTP::Resolver::SRV < Puppet::HTTP::Resolver
-  #
-  # @api private
+
+  # Create an DNS SRV resolver.
   #
   # @param [Puppet::HTTP::Client] client
   # @param [String] domain srv domain
@@ -14,32 +12,30 @@ class Puppet::HTTP::Resolver::SRV < Puppet::HTTP::Resolver
   def initialize(client, domain:, dns: Resolv::DNS.new)
     @client = client
     @srv_domain = domain
-    @delegate = Puppet::Network::Resolver.new(dns)
+    @delegate = Puppet::HTTP::DNS.new(dns)
   end
 
-  #
-  # @api private
-  #
   # Walk the available srv records and return the first that successfully connects
   #
   # @param [Puppet::HTTP::Session] session
   # @param [Symbol] name the service being resolved
   # @param [Puppet::SSL::SSLContext] ssl_context
-  # @param [Proc] error_handler (nil) optional callback for each error
-  #   encountered while resolving a route.
+  # @param [Proc] canceled_handler optional callback allowing a resolver
+  #   to cancel resolution.
   #
   # @return [Puppet::HTTP::Service] if an available service is found, return
   #   it. Return nil otherwise.
   #
-  def resolve(session, name, ssl_context: nil, error_handler: nil)
+  # @api public
+  def resolve(session, name, ssl_context: nil, canceled_handler: nil)
     # Here we pass our HTTP service name as the DNS SRV service name
     # This is fine for :ca, but note that :puppet and :file are handled
     # specially in `each_srv_record`.
     @delegate.each_srv_record(@srv_domain, name) do |server, port|
       service = Puppet::HTTP::Service.create_service(@client, session, name, server, port)
-      return service if check_connection?(session, service, ssl_context: ssl_context, error_handler: error_handler)
+      return service if check_connection?(session, service, ssl_context: ssl_context)
     end
 
-    return nil
+    nil
   end
 end

data/lib/puppet/http/response.rb

@@ -1,118 +1,100 @@
+# Represents the response returned from the server from an HTTP request.
 #
-# @api private
-#
-# Represents the response returned from the server from an HTTP request
-#
+# @api abstract
+# @api public
 class Puppet::HTTP::Response
-  # @api private
-  # @return [Net::HTTP] the Net::HTTP response
-  attr_reader :nethttp
-
-  # @api private
-  # @return [URI] the response uri
+  # @return [URI] the response url
   attr_reader :url
 
+  # Create a response associated with the URL.
   #
-  # @api private
-  #
-  # Object to represent the response returned from an HTTP request
-  #
-  # @param [Net::HTTP] nethttp the request response
   # @param [URI] url
-  #
-  def initialize(nethttp, url)
-    @nethttp = nethttp
+  # @param [Integer] HTTP status
+  # @param [String] HTTP reason
+  def initialize(url, code, reason)
     @url = url
+    @code = code
+    @reason = reason
   end
 
-  #
-  # @api private
-  #
-  # Extract the response code
+  # Return the response code.
   #
   # @return [Integer] Response code for the request
   #
+  # @api public
   def code
-    @nethttp.code.to_i
+    @code
   end
 
-  #
-  # @api private
-  #
-  # Extract the response message
+  # Return the response message.
   #
   # @return [String] Response message for the request
   #
+  # @api public
   def reason
-    @nethttp.message
+    @reason
   end
 
-  #
-  # @api private
-  #
   # Returns the entire response body. Can be used instead of
-  #   Puppet::HTTP::Response.read_body, but both methods cannot be used for the
+  #   `Puppet::HTTP::Response.read_body`, but both methods cannot be used for the
   #   same response.
   #
   # @return [String] Response body for the request
   #
+  # @api public
   def body
-    @nethttp.body
+    raise NotImplementedError
   end
 
-  #
-  # @api private
-  #
   # Streams the response body to the caller in chunks. Can be used instead of
-  #   Puppet::HTTP::Response.body, but both methods cannot be used for the same
+  #   `Puppet::HTTP::Response.body`, but both methods cannot be used for the same
   #   response.
   #
   # @yield [String] Streams the response body in chunks
   #
   # @raise [ArgumentError] raise if a block is not given
   #
+  # @api public
   def read_body(&block)
-    raise ArgumentError, "A block is required" unless block_given?
-
-    @nethttp.read_body(&block)
+    raise NotImplementedError
   end
 
-  #
-  # @api private
-  #
-  # Check if the request received a response of success
+  # Check if the request received a response of success (HTTP 2xx).
   #
   # @return [Boolean] Returns true if the response indicates success
   #
+  # @api public
   def success?
-    @nethttp.is_a?(Net::HTTPSuccess)
+    200 <= @code && @code < 300
   end
 
-  # @api private
-  #
   # Get a header case-insensitively.
+  #
   # @param [String] name The header name
   # @return [String] The header value
   #
+  # @api public
   def [](name)
-    @nethttp[name]
+    raise NotImplementedError
   end
 
-  # @api private
-  #
   # Yield each header name and value. Returns an enumerator if no block is given.
   #
   # @yieldparam [String] header name
   # @yieldparam [String] header value
   #
+  # @api public
   def each_header(&block)
-    @nethttp.each_header(&block)
+    raise NotImplementedError
   end
 
-  # @api private
-  #
-  # Drain the response body.
+  # Ensure the response body is fully read so that the server is not blocked
+  # waiting for us to read data from the socket. Also if the caller streamed
+  # the response, but didn't read the data, we need a way to drain the socket
+  # before adding the connection back to the connection pool, otherwise the
+  # unread response data would "leak" into the next HTTP request/response.
   #
+  # @api public
   def drain
     body
     true

data/lib/puppet/http/response_converter.rb

@@ -0,0 +1,24 @@
+module Puppet::HTTP::ResponseConverter
+  module_function
+
+  # Borrowed from puppetserver, see https://github.com/puppetlabs/puppetserver/commit/a1ebeaaa5af590003ccd23c89f808ba4f0c89609
+  def to_ruby_response(response)
+    str_code = response.code.to_s
+
+    # Copied from Net::HTTPResponse because it is private there.
+    clazz = Net::HTTPResponse::CODE_TO_OBJ[str_code] or
+      Net::HTTPResponse::CODE_CLASS_TO_OBJ[str_code[0,1]] or
+      Net::HTTPUnknownResponse
+    result = clazz.new(nil, str_code, nil)
+    result.body = response.body
+    # This is nasty, nasty.  But apparently there is no way to create
+    # an instance of Net::HttpResponse from outside of the library and have
+    # the body be readable, unless you do stupid things like this.
+    result.instance_variable_set(:@read, true)
+    response.each_header do |k,v|
+      result[k] = v
+    end
+    result
+  end
+end
+

data/lib/puppet/http/response_net_http.rb

@@ -0,0 +1,42 @@
+# Adapts Net::HTTPResponse to Puppet::HTTP::Response
+#
+# @api public
+class Puppet::HTTP::ResponseNetHTTP < Puppet::HTTP::Response
+
+  # Create a response associated with the URL.
+  #
+  # @param [URI] url
+  # @param [Net::HTTPResponse] nethttp The response
+  def initialize(url, nethttp)
+    super(url, nethttp.code.to_i, nethttp.message)
+
+    @nethttp = nethttp
+  end
+
+  # (see Puppet::HTTP::Response#body)
+  def body
+    @nethttp.body
+  end
+
+  # (see Puppet::HTTP::Response#read_body)
+  def read_body(&block)
+    raise ArgumentError, "A block is required" unless block_given?
+
+    @nethttp.read_body(&block)
+  end
+
+  # (see Puppet::HTTP::Response#success?)
+  def success?
+    @nethttp.is_a?(Net::HTTPSuccess)
+  end
+
+  # (see Puppet::HTTP::Response#[])
+  def [](name)
+    @nethttp[name]
+  end
+
+  # (see Puppet::HTTP::Response#each_header)
+  def each_header(&block)
+    @nethttp.each_header(&block)
+  end
+end