httpx 1.3.4 → 1.4.1

data/lib/httpx/selector.rb

@@ -2,137 +2,202 @@
 
 require "io/wait"
 
-class HTTPX::Selector
-  READABLE = %i[rw r].freeze
-  WRITABLE = %i[rw w].freeze
+module HTTPX
+  class Selector
+    extend Forwardable
 
-  private_constant :READABLE
-  private_constant :WRITABLE
+    READABLE = %i[rw r].freeze
+    WRITABLE = %i[rw w].freeze
 
-  def initialize
-    @selectables = []
-  end
+    private_constant :READABLE
+    private_constant :WRITABLE
 
-  # deregisters +io+ from selectables.
-  def deregister(io)
-    @selectables.delete(io)
-  end
+    def_delegator :@timers, :after
 
-  # register +io+.
-  def register(io)
-    return if @selectables.include?(io)
+    def_delegator :@selectables, :empty?
 
-    @selectables << io
-  end
+    def initialize
+      @timers = Timers.new
+      @selectables = []
+    end
 
-  private
+    def each(&blk)
+      @selectables.each(&blk)
+    end
 
-  def select_many(interval, &block)
-    selectables, r, w = nil
+    def next_tick
+      catch(:jump_tick) do
+        timeout = next_timeout
+        if timeout && timeout.negative?
+          @timers.fire
+          throw(:jump_tick)
+        end
 
-    # first, we group IOs based on interest type. On call to #interests however,
-    # things might already happen, and new IOs might be registered, so we might
-    # have to start all over again. We do this until we group all selectables
-    begin
-      loop do
         begin
-          r = nil
-          w = nil
+          select(timeout, &:call)
+          @timers.fire
+        rescue TimeoutError => e
+          @timers.fire(e)
+        end
+      end
+    rescue StandardError => e
+      emit_error(e)
+    rescue Exception # rubocop:disable Lint/RescueException
+      each_connection(&:force_reset)
+      raise
+    end
 
-          selectables = @selectables
-          @selectables = []
+    def terminate
+      # array may change during iteration
+      selectables = @selectables.reject(&:inflight?)
 
-          selectables.delete_if do |io|
-            interests = io.interests
+      selectables.each(&:terminate)
 
-            (r ||= []) << io if READABLE.include?(interests)
-            (w ||= []) << io if WRITABLE.include?(interests)
+      until selectables.empty?
+        next_tick
+
+        selectables &= @selectables
+      end
+    end
 
-            io.state == :closed
-          end
+    def find_resolver(options)
+      res = @selectables.find do |c|
+        c.is_a?(Resolver::Resolver) && options == c.options
+      end
 
-          if @selectables.empty?
-            @selectables = selectables
+      res.multi if res
+    end
 
-            # do not run event loop if there's nothing to wait on.
-            # this might happen if connect failed and connection was unregistered.
-            return if (!r || r.empty?) && (!w || w.empty?) && !selectables.empty?
+    def each_connection(&block)
+      return enum_for(__method__) unless block
 
-            break
-          else
-            @selectables.concat(selectables)
-          end
-        rescue StandardError
-          @selectables = selectables if selectables
-          raise
+      @selectables.each do |c|
+        if c.is_a?(Resolver::Resolver)
+          c.each_connection(&block)
+        else
+          yield c
         end
       end
+    end
 
-      # TODO: what to do if there are no selectables?
-
-      readers, writers = IO.select(r, w, nil, interval)
+    def find_connection(request_uri, options)
+      each_connection.find do |connection|
+        connection.match?(request_uri, options)
+      end
+    end
 
-      if readers.nil? && writers.nil? && interval
-        [*r, *w].each { |io| io.handle_socket_timeout(interval) }
-        return
+    def find_mergeable_connection(connection)
+      each_connection.find do |ch|
+        ch != connection && ch.mergeable?(connection)
       end
-    rescue IOError, SystemCallError
-      @selectables.reject!(&:closed?)
-      retry
     end
 
-    if writers
-      readers.each do |io|
-        yield io
+    # deregisters +io+ from selectables.
+    def deregister(io)
+      @selectables.delete(io)
+    end
 
-        # so that we don't yield 2 times
-        writers.delete(io)
-      end if readers
+    # register +io+.
+    def register(io)
+      return if @selectables.include?(io)
 
-      writers.each(&block)
-    else
-      readers.each(&block) if readers
+      @selectables << io
     end
-  end
 
-  def select_one(interval)
-    io = @selectables.first
+    private
 
-    return unless io
+    def select(interval, &block)
+      # do not cause an infinite loop here.
+      #
+      # this may happen if timeout calculation actually triggered an error which causes
+      # the connections to be reaped (such as the total timeout error) before #select
+      # gets called.
+      return if interval.nil? && @selectables.empty?
 
-    interests = io.interests
+      return select_one(interval, &block) if @selectables.size == 1
 
-    result = case interests
-             when :r then io.to_io.wait_readable(interval)
-             when :w then io.to_io.wait_writable(interval)
-             when :rw then io.to_io.wait(interval, :read_write)
-             when nil then return
+      select_many(interval, &block)
     end
 
-    unless result || interval.nil?
-      io.handle_socket_timeout(interval)
-      return
+    def select_many(interval, &block)
+      r, w = nil
+
+      # first, we group IOs based on interest type. On call to #interests however,
+      # things might already happen, and new IOs might be registered, so we might
+      # have to start all over again. We do this until we group all selectables
+      begin
+        @selectables.delete_if do |io|
+          interests = io.interests
+
+          (r ||= []) << io if READABLE.include?(interests)
+          (w ||= []) << io if WRITABLE.include?(interests)
+
+          io.state == :closed
+        end
+
+        # TODO: what to do if there are no selectables?
+
+        readers, writers = IO.select(r, w, nil, interval)
+
+        if readers.nil? && writers.nil? && interval
+          [*r, *w].each { |io| io.handle_socket_timeout(interval) }
+          return
+        end
+      end
+
+      if writers
+        readers.each do |io|
+          yield io
+
+          # so that we don't yield 2 times
+          writers.delete(io)
+        end if readers
+
+        writers.each(&block)
+      else
+        readers.each(&block) if readers
+      end
     end
-    # raise HTTPX::TimeoutError.new(interval, "timed out while waiting on select")
 
-    yield io
-  rescue IOError, SystemCallError
-    @selectables.reject!(&:closed?)
-    raise unless @selectables.empty?
-  end
+    def select_one(interval)
+      io = @selectables.first
 
-  def select(interval, &block)
-    # do not cause an infinite loop here.
-    #
-    # this may happen if timeout calculation actually triggered an error which causes
-    # the connections to be reaped (such as the total timeout error) before #select
-    # gets called.
-    return if interval.nil? && @selectables.empty?
+      return unless io
 
-    return select_one(interval, &block) if @selectables.size == 1
+      interests = io.interests
 
-    select_many(interval, &block)
-  end
+      result = case interests
+               when :r then io.to_io.wait_readable(interval)
+               when :w then io.to_io.wait_writable(interval)
+               when :rw then io.to_io.wait(interval, :read_write)
+               when nil then return
+      end
+
+      unless result || interval.nil?
+        io.handle_socket_timeout(interval)
+        return
+      end
+      # raise TimeoutError.new(interval, "timed out while waiting on select")
+
+      yield io
+      # rescue IOError, SystemCallError
+      #   @selectables.reject!(&:closed?)
+      #   raise unless @selectables.empty?
+    end
 
-  public :select
+    def next_timeout
+      [
+        @timers.wait_interval,
+        @selectables.filter_map(&:timeout).min,
+      ].compact.min
+    end
+
+    def emit_error(e)
+      @selectables.each do |c|
+        next if c.is_a?(Resolver::Resolver)
+
+        c.emit(:error, e)
+      end
+    end
+  end
 end