httpx 1.2.6 → 1.4.4

data/lib/httpx/pool.rb

@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 
-require "forwardable"
 require "httpx/selector"
 require "httpx/connection"
 require "httpx/resolver"
@@ -8,110 +7,31 @@ require "httpx/resolver"
 module HTTPX
   class Pool
     using ArrayExtensions::FilterMap
-    extend Forwardable
+    using URIExtensions
 
-    def_delegator :@timers, :after
+    POOL_TIMEOUT = 5
 
-    def initialize
-      @resolvers = {}
-      @timers = Timers.new
-      @selector = Selector.new
-      @connections = []
-    end
-
-    def wrap
-      connections = @connections
+    # Sets up the connection pool with the given +options+, which can be the following:
+    #
+    # :max_connections_per_origin :: the maximum number of connections held in the pool pointing to a given origin.
+    # :pool_timeout :: the number of seconds to wait for a connection to a given origin (before raising HTTPX::PoolTimeoutError)
+    #
+    def initialize(options)
+      @max_connections_per_origin = options.fetch(:max_connections_per_origin, Float::INFINITY)
+      @pool_timeout = options.fetch(:pool_timeout, POOL_TIMEOUT)
+      @resolvers = Hash.new { |hs, resolver_type| hs[resolver_type] = [] }
+      @resolver_mtx = Thread::Mutex.new
       @connections = []
-
-      begin
-        yield self
-      ensure
-        @connections.unshift(*connections)
-      end
-    end
-
-    def empty?
-      @connections.empty?
-    end
-
-    def next_tick
-      catch(:jump_tick) do
-        timeout = next_timeout
-        if timeout && timeout.negative?
-          @timers.fire
-          throw(:jump_tick)
-        end
-
-        begin
-          @selector.select(timeout, &:call)
-          @timers.fire
-        rescue TimeoutError => e
-          @timers.fire(e)
-        end
-      end
-    rescue StandardError => e
-      @connections.each do |connection|
-        connection.emit(:error, e)
-      end
-    rescue Exception # rubocop:disable Lint/RescueException
-      @connections.each(&:force_reset)
-      raise
-    end
-
-    def close(connections = @connections)
-      return if connections.empty?
-
-      connections = connections.reject(&:inflight?)
-      connections.each(&:terminate)
-      next_tick until connections.none? { |c| c.state != :idle && @connections.include?(c) }
-
-      # close resolvers
-      outstanding_connections = @connections
-      resolver_connections = @resolvers.each_value.flat_map(&:connections).compact
-      outstanding_connections -= resolver_connections
-
-      return unless outstanding_connections.empty?
-
-      @resolvers.each_value do |resolver|
-        resolver.close unless resolver.closed?
-      end
-      # for https resolver
-      resolver_connections.each(&:terminate)
-      next_tick until resolver_connections.none? { |c| c.state != :idle && @connections.include?(c) }
-    end
-
-    def init_connection(connection, _options)
-      connection.timers = @timers
-      connection.on(:activate) do
-        select_connection(connection)
-      end
-      connection.on(:exhausted) do
-        case connection.state
-        when :closed
-          connection.idling
-          @connections << connection
-          select_connection(connection)
-        when :closing
-          connection.once(:close) do
-            connection.idling
-            @connections << connection
-            select_connection(connection)
-          end
-        end
-      end
-      connection.on(:close) do
-        unregister_connection(connection)
-      end
-      connection.on(:terminate) do
-        unregister_connection(connection, true)
-      end
-      resolve_connection(connection) unless connection.family
+      @connection_mtx = Thread::Mutex.new
+      @origin_counters = Hash.new(0)
+      @origin_conds = Hash.new { |hs, orig| hs[orig] = ConditionVariable.new }
     end
 
-    def deactivate(connections)
-      connections.each do |connection|
-        connection.deactivate
-        deselect_connection(connection) if connection.state == :inactive
+    def pop_connection
+      @connection_mtx.synchronize do
+        conn = @connections.shift
+        @origin_conds.delete(conn.origin) if conn && (@origin_counters[conn.origin.to_s] -= 1).zero?
+        conn
       end
     end
 
@@ -119,185 +39,94 @@ module HTTPX
     # Many hostnames are reachable through the same IP, so we try to
     # maximize pipelining by opening as few connections as possible.
     #
-    def find_connection(uri, options)
-      conn = @connections.find do |connection|
-        connection.match?(uri, options)
-      end
+    def checkout_connection(uri, options)
+      return checkout_new_connection(uri, options) if options.io
 
-      return unless conn
+      @connection_mtx.synchronize do
+        acquire_connection(uri, options) || begin
+          if @origin_counters[uri.origin] == @max_connections_per_origin
 
-      case conn.state
-      when :closed
-        conn.idling
-        select_connection(conn)
-      when :closing
-        conn.once(:close) do
-          conn.idling
-          select_connection(conn)
-        end
-      end
+            @origin_conds[uri.origin].wait(@connection_mtx, @pool_timeout)
 
-      conn
-    end
-
-    private
-
-    def resolve_connection(connection)
-      @connections << connection unless @connections.include?(connection)
-
-      if connection.addresses || connection.open?
-        #
-        # there are two cases in which we want to activate initialization of
-        # connection immediately:
-        #
-        # 1. when the connection already has addresses, i.e. it doesn't need to
-        #    resolve a name (not the same as name being an IP, yet)
-        # 2. when the connection is initialized with an external already open IO.
-        #
-        connection.once(:connect_error, &connection.method(:handle_error))
-        on_resolver_connection(connection)
-        return
-      end
+            return acquire_connection(uri, options) || raise(PoolTimeoutError.new(uri.origin, @pool_timeout))
+          end
 
-      find_resolver_for(connection) do |resolver|
-        resolver << try_clone_connection(connection, resolver.family)
-        next if resolver.empty?
+          @origin_counters[uri.origin] += 1
 
-        select_connection(resolver)
+          checkout_new_connection(uri, options)
+        end
       end
     end
 
-    def try_clone_connection(connection, family)
-      connection.family ||= family
-
-      return connection if connection.family == family
-
-      new_connection = connection.class.new(connection.origin, connection.options)
-      new_connection.family = family
+    def checkin_connection(connection)
+      return if connection.options.io
 
-      connection.once(:tcp_open) { new_connection.force_reset }
-      connection.once(:connect_error) do |err|
-        if new_connection.connecting?
-          new_connection.merge(connection)
-          connection.emit(:cloned, new_connection)
-          connection.force_reset
-        else
-          connection.__send__(:handle_error, err)
-        end
-      end
+      @connection_mtx.synchronize do
+        @connections << connection
 
-      new_connection.once(:tcp_open) do |new_conn|
-        if new_conn != connection
-          new_conn.merge(connection)
-          connection.force_reset
-        end
-      end
-      new_connection.once(:connect_error) do |err|
-        if connection.connecting?
-          # main connection has the requests
-          connection.merge(new_connection)
-          new_connection.emit(:cloned, connection)
-          new_connection.force_reset
-        else
-          new_connection.__send__(:handle_error, err)
-        end
+        @origin_conds[connection.origin.to_s].signal
       end
-
-      init_connection(new_connection, connection.options)
-      new_connection
     end
 
-    def on_resolver_connection(connection)
-      @connections << connection unless @connections.include?(connection)
-      found_connection = @connections.find do |ch|
-        ch != connection && ch.mergeable?(connection)
-      end
-      return register_connection(connection) unless found_connection
+    def checkout_mergeable_connection(connection)
+      return if connection.options.io
 
-      if found_connection.open?
-        coalesce_connections(found_connection, connection)
-        throw(:coalesced, found_connection) unless @connections.include?(connection)
-      else
-        found_connection.once(:open) do
-          coalesce_connections(found_connection, connection)
+      @connection_mtx.synchronize do
+        idx = @connections.find_index do |ch|
+          ch != connection && ch.mergeable?(connection)
         end
+        @connections.delete_at(idx) if idx
       end
     end
 
-    def on_resolver_error(connection, error)
-      return connection.emit(:connect_error, error) if connection.connecting? && connection.callbacks_for?(:connect_error)
-
-      connection.emit(:error, error)
+    def reset_resolvers
+      @resolver_mtx.synchronize { @resolvers.clear }
     end
 
-    def on_resolver_close(resolver)
-      resolver_type = resolver.class
-      return if resolver.closed?
+    def checkout_resolver(options)
+      resolver_type = options.resolver_class
+      resolver_type = Resolver.resolver_for(resolver_type)
 
-      @resolvers.delete(resolver_type)
+      @resolver_mtx.synchronize do
+        resolvers = @resolvers[resolver_type]
 
-      deselect_connection(resolver)
-      resolver.close unless resolver.closed?
+        idx = resolvers.find_index do |res|
+          res.options == options
+        end
+        resolvers.delete_at(idx) if idx
+      end || checkout_new_resolver(resolver_type, options)
     end
 
-    def register_connection(connection)
-      select_connection(connection)
-    end
+    def checkin_resolver(resolver)
+      @resolver_mtx.synchronize do
+        resolvers = @resolvers[resolver.class]
 
-    def unregister_connection(connection, cleanup = !connection.used?)
-      @connections.delete(connection) if cleanup
-      deselect_connection(connection)
-    end
+        resolver = resolver.multi
 
-    def select_connection(connection)
-      @selector.register(connection)
+        resolvers << resolver unless resolvers.include?(resolver)
+      end
     end
 
-    def deselect_connection(connection)
-      @selector.deregister(connection)
-    end
+    private
 
-    def coalesce_connections(conn1, conn2)
-      return register_connection(conn2) unless conn1.coalescable?(conn2)
+    def acquire_connection(uri, options)
+      idx = @connections.find_index do |connection|
+        connection.match?(uri, options)
+      end
 
-      conn2.emit(:tcp_open, conn1)
-      conn1.merge(conn2)
-      @connections.delete(conn2)
+      @connections.delete_at(idx) if idx
     end
 
-    def next_timeout
-      [
-        @timers.wait_interval,
-        *@resolvers.values.reject(&:closed?).filter_map(&:timeout),
-        *@connections.filter_map(&:timeout),
-      ].compact.min
+    def checkout_new_connection(uri, options)
+      options.connection_class.new(uri, options)
     end
 
-    def find_resolver_for(connection)
-      connection_options = connection.options
-      resolver_type = connection_options.resolver_class
-      resolver_type = Resolver.resolver_for(resolver_type)
-
-      @resolvers[resolver_type] ||= begin
-        resolver_manager = if resolver_type.multi?
-          Resolver::Multi.new(resolver_type, connection_options)
-        else
-          resolver_type.new(connection_options)
-        end
-        resolver_manager.on(:resolve, &method(:on_resolver_connection))
-        resolver_manager.on(:error, &method(:on_resolver_error))
-        resolver_manager.on(:close, &method(:on_resolver_close))
-        resolver_manager
-      end
-
-      manager = @resolvers[resolver_type]
-
-      (manager.is_a?(Resolver::Multi) && manager.early_resolve(connection)) || manager.resolvers.each do |resolver|
-        resolver.pool = self
-        yield resolver
+    def checkout_new_resolver(resolver_type, options)
+      if resolver_type.multi?
+        Resolver::Multi.new(resolver_type, options)
+      else
+        resolver_type.new(options)
       end
-
-      manager
     end
   end
 end

data/lib/httpx/request/body.rb

@@ -4,30 +4,44 @@ module HTTPX
   # Implementation of the HTTP Request body as a delegator which iterates (responds to +each+) payload chunks.
   class Request::Body < SimpleDelegator
     class << self
-      def new(_, options)
-        return options.body if options.body.is_a?(self)
+      def new(_, options, body: nil, **params)
+        if body.is_a?(self)
+          # request derives its options from body
+          body.options = options.merge(params)
+          return body
+        end
 
         super
       end
     end
 
-    # inits the instance with the request +headers+ and +options+, which contain the payload definition.
-    def initialize(headers, options)
-      @headers = headers
+    attr_accessor :options
 
-      # forego compression in the Range request case
-      if @headers.key?("range")
-        @headers.delete("accept-encoding")
-      else
-        @headers["accept-encoding"] ||= options.supported_compression_formats
-      end
+    # inits the instance with the request +headers+, +options+ and +params+, which contain the payload definition.
+    # it wraps the given body with the appropriate encoder on initialization.
+    #
+    #   ..., json: { foo: "bar" }) #=> json encoder
+    #   ..., form: { foo: "bar" }) #=> form urlencoded encoder
+    #   ..., form: { foo: Pathname.open("path/to/file") }) #=> multipart urlencoded encoder
+    #   ..., form: { foo: File.open("path/to/file") }) #=> multipart urlencoded encoder
+    #   ..., form: { body: "bla") }) #=> raw data encoder
+    def initialize(h, options, **params)
+      @headers = h
+      @body = self.class.initialize_body(params)
+      @options = options.merge(params)
 
-      initialize_body(options)
+      if @body
+        if @options.compress_request_body && @headers.key?("content-encoding")
 
-      return if @body.nil?
+          @headers.get("content-encoding").each do |encoding|
+            @body = self.class.initialize_deflater_body(@body, encoding)
+          end
+        end
+
+        @headers["content-type"] ||= @body.content_type
+        @headers["content-length"] = @body.bytesize unless unbounded_body?
+      end
 
-      @headers["content-type"] ||= @body.content_type
-      @headers["content-length"] = @body.bytesize unless unbounded_body?
       super(@body)
     end
 
@@ -38,7 +52,11 @@ module HTTPX
 
       body = stream(@body)
       if body.respond_to?(:read)
-        ::IO.copy_stream(body, ProcIO.new(block))
+        while (chunk = body.read(16_384))
+          block.call(chunk)
+        end
+        # TODO: use copy_stream once bug is resolved: https://bugs.ruby-lang.org/issues/21131
+        # ::IO.copy_stream(body, ProcIO.new(block))
       elsif body.respond_to?(:each)
         body.each(&block)
       else
@@ -46,6 +64,10 @@ module HTTPX
       end
     end
 
+    def close
+      @body.close if @body.respond_to?(:close)
+    end
+
     # if the +@body+ is rewindable, it rewinnds it.
     def rewind
       return if empty?
@@ -99,34 +121,20 @@ module HTTPX
     end
     # :nocov:
 
-    private
-
-    # wraps the given body with the appropriate encoder.
-    #
-    #   ..., json: { foo: "bar" }) #=> json encoder
-    #   ..., form: { foo: "bar" }) #=> form urlencoded encoder
-    #   ..., form: { foo: Pathname.open("path/to/file") }) #=> multipart urlencoded encoder
-    #   ..., form: { foo: File.open("path/to/file") }) #=> multipart urlencoded encoder
-    #   ..., form: { body: "bla") }) #=> raw data encoder
-    def initialize_body(options)
-      @body = if options.body
-        Transcoder::Body.encode(options.body)
-      elsif options.form
-        Transcoder::Form.encode(options.form)
-      elsif options.json
-        Transcoder::JSON.encode(options.json)
-      elsif options.xml
-        Transcoder::Xml.encode(options.xml)
-      end
-
-      return unless @body && options.compress_request_body && @headers.key?("content-encoding")
-
-      @headers.get("content-encoding").each do |encoding|
-        @body = self.class.initialize_deflater_body(@body, encoding)
+    class << self
+      def initialize_body(params)
+        if (body = params.delete(:body))
+          # @type var body: bodyIO
+          Transcoder::Body.encode(body)
+        elsif (form = params.delete(:form))
+          # @type var form: Transcoder::urlencoded_input
+          Transcoder::Form.encode(form)
+        elsif (json = params.delete(:json))
+          # @type var body: _ToJson
+          Transcoder::JSON.encode(json)
+        end
       end
-    end
 
-    class << self
       # returns the +body+ wrapped with the correct deflater accordinng to the given +encodisng+.
       def initialize_deflater_body(body, encoding)
         case encoding
@@ -142,17 +150,4 @@ module HTTPX
       end
     end
   end
-
-  # Wrapper yielder which can be used with functions which expect an IO writer.
-  class ProcIO
-    def initialize(block)
-      @block = block
-    end
-
-    # Implementation the IO write protocol, which yield the given chunk to +@block+.
-    def write(data)
-      @block.call(data.dup)
-      data.bytesize
-    end
-  end
 end