httpx 0.6.7 → 0.9.0

data/lib/httpx/registry.rb

@@ -64,7 +64,8 @@ module HTTPX
 
         case handler
         when Symbol, String
-          const_get(handler)
+          obj = const_get(handler)
+          @registry[tag] = obj
         else
           handler
         end

data/lib/httpx/request.rb

@@ -37,8 +37,6 @@ module HTTPX
 
     attr_reader :options, :response
 
-    attr_accessor :timer
-
     def_delegator :@body, :<<
 
     def_delegator :@body, :empty?
@@ -60,6 +58,12 @@ module HTTPX
       @state = :idle
     end
 
+    def interests
+      return :r if @state == :done || @state == :expect
+
+      :w
+    end
+
     # :nocov:
     if RUBY_VERSION < "2.2"
       # rubocop: disable Lint/UriEscapeUnescape:
@@ -83,7 +87,6 @@ module HTTPX
     def response=(response)
       return unless response
 
-      @timer.cancel if @timer
       @response = response
     end
 
@@ -222,6 +225,7 @@ module HTTPX
       case nextstate
       when :idle
         @response = nil
+        @drainer = nil
       when :headers
         return unless @state == :idle
       when :body
@@ -238,15 +242,13 @@ module HTTPX
           when 100
             # deallocate
             @response = nil
-          when 417
-            @response = @response
-            return
           end
         end
       when :done
         return if @state == :expect
       end
       @state = nextstate
+      emit(@state)
       nil
     end
 

data/lib/httpx/resolver.rb

@@ -1,19 +1,18 @@
 # frozen_string_literal: true
 
 require "resolv"
+require "httpx/resolver/resolver_mixin"
+require "httpx/resolver/system"
+require "httpx/resolver/native"
+require "httpx/resolver/https"
 
 module HTTPX
   module Resolver
-    autoload :ResolverMixin, "httpx/resolver/resolver_mixin"
-    autoload :System, "httpx/resolver/system"
-    autoload :Native, "httpx/resolver/native"
-    autoload :HTTPS, "httpx/resolver/https"
-
     extend Registry
 
-    register :system, :System
-    register :native, :Native
-    register :https,  :HTTPS
+    register :system, System
+    register :native, Native
+    register :https,  HTTPS
 
     @lookup_mutex = Mutex.new
     @lookups = Hash.new { |h, k| h[k] = [] }

data/lib/httpx/resolver/https.rb

@@ -25,7 +25,7 @@ module HTTPX
 
     def_delegator :@connections, :empty?
 
-    def_delegators :@resolver_connection, :to_io, :call, :interests, :close
+    def_delegators :@resolver_connection, :connecting?, :to_io, :call, :close
 
     def initialize(options)
       @options = Options.new(options)
@@ -62,8 +62,20 @@ module HTTPX
       resolver_connection.closed?
     end
 
+    def interests
+      return if @queries.empty?
+
+      resolver_connection.__send__(__method__)
+    end
+
     private
 
+    def connect
+      return if @queries.empty?
+
+      resolver_connection.__send__(__method__)
+    end
+
     def pool
       Thread.current[:httpx_connection_pool] ||= Pool.new
     end
@@ -84,7 +96,7 @@ module HTTPX
 
       hostname = hostname || @queries.key(connection) || connection.origin.host
       type = @_record_types[hostname].first
-      log(label: "resolver: ") { "query #{type} for #{hostname}" }
+      log { "resolver: query #{type} for #{hostname}" }
       begin
         request = build_request(hostname, type)
         @requests[request] = connection
@@ -111,7 +123,7 @@ module HTTPX
     end
 
     def on_promise(_, stream)
-      log(level: 2, label: "#{stream.id}: ") { "refusing stream!" }
+      log(level: 2) { "#{stream.id}: refusing stream!" }
       stream.refuse
     end
 

data/lib/httpx/resolver/native.rb

@@ -73,14 +73,6 @@ module HTTPX
     end
 
     def to_io
-      case @state
-      when :idle
-        transition(:open)
-      when :closed
-        transition(:idle)
-        transition(:open)
-      end
-      resolve if @queries.empty?
       @io.to_io
     end
 
@@ -93,11 +85,7 @@ module HTTPX
     rescue Errno::EHOSTUNREACH => e
       @ns_index += 1
       if @ns_index < @nameserver.size
-        log(label: "resolver: ") do
-          # :nocov:
-          "failed resolving on nameserver #{@nameserver[@ns_index - 1]} (#{e.message})"
-          # :nocov:
-        end
+        log { "resolver: failed resolving on nameserver #{@nameserver[@ns_index - 1]} (#{e.message})" }
         transition(:idle)
       else
         handle_error(e)
@@ -107,6 +95,14 @@ module HTTPX
     end
 
     def interests
+      case @state
+      when :idle
+        transition(:open)
+      when :closed
+        transition(:idle)
+        transition(:open)
+      end
+
       !@write_buffer.empty? || @queries.empty? ? :w : :r
     end
 
@@ -160,11 +156,7 @@ module HTTPX
           raise NativeResolveError.new(connection, host)
         else
           connections << connection
-          log(label: "resolver: ") do
-            # :nocov:
-            "timeout after #{prev_timeout}s, retry(#{timeouts.first}) #{host}..."
-            # :nocov:
-          end
+          log { "resolver: timeout after #{prev_timeout}s, retry(#{timeouts.first}) #{host}..." }
         end
       end
       @queries = queries
@@ -174,14 +166,11 @@ module HTTPX
     def dread(wsize = @resolver_options.packet_size)
       loop do
         siz = @io.read(wsize, @read_buffer)
-        unless siz
-          emit(:close)
-          return
-        end
-        return if siz.zero?
+        return unless siz && siz.positive?
 
-        log(label: "resolver: ") { "READ: #{siz} bytes..." }
+        log { "resolver: READ: #{siz} bytes..." }
         parse(@read_buffer)
+        return if @state == :closed
       end
     end
 
@@ -190,12 +179,10 @@ module HTTPX
         return if @write_buffer.empty?
 
         siz = @io.write(@write_buffer)
-        unless siz
-          emit(:close)
-          return
-        end
-        log(label: "resolver: ") { "WRITE: #{siz} bytes..." }
-        return if siz.zero?
+        return unless siz && siz.positive?
+
+        log { "resolver: WRITE: #{siz} bytes..." }
+        return if @state == :closed
       end
     end
 
@@ -253,7 +240,7 @@ module HTTPX
       hostname = hostname || @queries.key(connection) || connection.origin.host
       @queries[hostname] = connection
       type = @_record_types[hostname].first
-      log(label: "resolver: ") { "query #{type} for #{hostname}" }
+      log { "resolver: query #{type} for #{hostname}" }
       begin
         @write_buffer << Resolver.encode_dns_query(hostname, type: RECORD_TYPES[type])
       rescue Resolv::DNS::EncodeError => e
@@ -269,7 +256,7 @@ module HTTPX
       uri = URI::Generic.build(scheme: "udp", port: port)
       uri.hostname = ip
       type = IO.registry(uri.scheme)
-      log(label: "resolver: ") { "server: #{uri}..." }
+      log { "resolver: server: #{uri}..." }
       @io = type.new(uri, [IPAddr.new(ip)], @options)
     end
 
@@ -285,8 +272,11 @@ module HTTPX
         return unless @state == :idle
 
         build_socket
+
         @io.connect
         return unless @io.connected?
+
+        resolve if @queries.empty?
       when :closed
         return unless @state == :open
 

data/lib/httpx/resolver/options.rb

@@ -6,7 +6,7 @@ module HTTPX
       @options = options
     end
 
-    def method_missing(m, *args, &block)
+    def method_missing(m, *, &block)
       if @options.key?(m)
         @options[m]
       else
@@ -14,7 +14,7 @@ module HTTPX
       end
     end
 
-    def respond_to_missing?(m)
+    def respond_to_missing?(m, *)
       @options.key?(m) || super
     end
 

data/lib/httpx/resolver/resolver_mixin.rb

@@ -30,7 +30,7 @@ module HTTPX
         addresses.map! do |address|
           address.is_a?(IPAddr) ? address : IPAddr.new(address.to_s)
         end
-        log(label: "resolver: ") { "answer #{connection.origin.host}: #{addresses.inspect}" }
+        log { "resolver: answer #{connection.origin.host}: #{addresses.inspect}" }
         connection.addresses = addresses
         catch(:coalesced) { emit(:resolve, connection) }
       end

data/lib/httpx/response.rb

@@ -58,7 +58,7 @@ module HTTPX
       "HTTP/#{version} " \
       "@status=#{@status} " \
       "@headers=#{@headers} " \
-      "@body=#{@body}>"
+      "@body=#{@body.bytesize}>"
     end
     # :nocov:
 
@@ -103,6 +103,8 @@ module HTTPX
       def read(*args)
         return unless @buffer
 
+        rewind
+
         @buffer.read(*args)
       end
 
@@ -148,6 +150,8 @@ module HTTPX
       def copy_to(dest)
         return unless @buffer
 
+        rewind
+
         if dest.respond_to?(:path) && @buffer.respond_to?(:path)
           FileUtils.mv(@buffer.path, dest.path)
         else
@@ -235,13 +239,11 @@ module HTTPX
 
       private
 
-      # :nodoc:
       def mime_type(str)
         m = str.to_s[MIME_TYPE_RE, 1]
         m && m.strip.downcase
       end
 
-      # :nodoc:
       def charset(str)
         m = str.to_s[CHARSET_RE, 1]
         m && m.strip.delete('"')
@@ -265,6 +267,18 @@ module HTTPX
       @error.message
     end
 
+    def reason
+      @error.class.name
+    end
+
+    def headers
+      {}
+    end
+
+    def body
+      @error.backtrace.join("\n")
+    end
+
     def raise_for_status
       raise @error
     end

data/lib/httpx/selector.rb

@@ -1,5 +1,26 @@
 # frozen_string_literal: true
 
+require "io/wait"
+
+module IOExtensions
+  refine IO do
+    def wait(timeout = nil, mode = :read)
+      case mode
+      when :read
+        wait_readable(timeout)
+      when :write
+        wait_writable(timeout)
+      when :read_write
+        r, w = IO.select([self], [self], nil, timeout)
+
+        return unless r || w
+
+        self
+      end
+    end
+  end
+end
+
 class HTTPX::Selector
   READABLE = %i[rw r].freeze
   WRITABLE = %i[rw w].freeze
@@ -7,129 +28,109 @@ class HTTPX::Selector
   private_constant :READABLE
   private_constant :WRITABLE
 
-  #
-  # I/O monitor
-  #
-  class Monitor
-    attr_accessor :io, :interests, :readiness
-
-    def initialize(io, interests, reactor)
-      @io = io
-      @interests = interests
-      @reactor = reactor
-      @closed = false
-    end
-
-    def readable?
-      READABLE.include?(@interests)
-    end
-
-    def writable?
-      WRITABLE.include?(@interests)
-    end
-
-    # closes +@io+, deregisters from reactor (unless +deregister+ is false)
-    def close(deregister = true)
-      return if @closed
-
-      @closed = true
-      @reactor.deregister(@io) if deregister
-    end
-
-    def closed?
-      @closed
-    end
-
-    # :nocov:
-    def to_s
-      "#<#{self.class}: #{@io}(closed:#{@closed}) #{@interests} #{object_id.to_s(16)}>"
-    end
-    # :nocov:
-  end
+  using IOExtensions unless IO.method_defined?(:wait) && IO.instance_method(:wait).arity == 2
 
   def initialize
-    @selectables = {}
-    @__r__, @__w__ = IO.pipe
-    @closed = false
+    @selectables = []
   end
 
   # deregisters +io+ from selectables.
   def deregister(io)
-    monitor = @selectables.delete(io)
-    monitor.close(false) if monitor
+    @selectables.delete(io)
   end
 
-  # register +io+ for +interests+ events.
-  def register(io, interests)
-    monitor = @selectables[io]
-    if monitor
-      monitor.interests = interests
-    else
-      monitor = Monitor.new(io, interests, self)
-      @selectables[io] = monitor
-    end
-    monitor
-  end
+  # register +io+.
+  def register(io)
+    return if @selectables.include?(io)
 
-  # waits for read/write events for +interval+. Yields for monitors of
-  # selected IO objects.
-  #
-  def select(interval)
-    begin
-      r = [@__r__]
-      w = []
+    @selectables << io
+  end
 
-      @selectables.each do |io, monitor|
-        r << io if monitor.interests == :r || monitor.interests == :rw
-        w << io if monitor.interests == :w || monitor.interests == :rw
-        monitor.readiness = nil
+  private
+
+  READ_INTERESTS = %i[r rw].freeze
+  WRITE_INTERESTS = %i[w rw].freeze
+
+  def select_many(interval)
+    selectables, 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
+    loop do
+      begin
+        r = nil
+        w = nil
+
+        selectables = @selectables
+        @selectables = []
+
+        selectables.each do |io|
+          interests = io.interests
+
+          (r ||= []) << io if READ_INTERESTS.include?(interests)
+          (w ||= []) << io if WRITE_INTERESTS.include?(interests)
+        end
+
+        if @selectables.empty?
+          @selectables = selectables
+          break
+        else
+          @selectables = [*selectables, @selectables]
+        end
+      rescue StandardError
+        @selectables = selectables if selectables
+        raise
       end
+    end
+
+    # TODO: what to do if there are no selectables?
 
+    begin
       readers, writers = IO.select(r, w, nil, interval)
 
       raise HTTPX::TimeoutError.new(interval, "timed out while waiting on select") if readers.nil? && writers.nil?
     rescue IOError, SystemCallError
-      @selectables.reject! { |io, _| io.closed? }
+      @selectables.reject!(&:closed?)
       retry
     end
 
     readers.each do |io|
-      if io == @__r__
-        # clean up wakeups
-        @__r__.read(@__r__.stat.size)
-      else
-        monitor = io.closed? ? @selectables.delete(io) : @selectables[io]
-        next unless monitor
-
-        monitor.readiness = writers.delete(io) ? :rw : :r
-        yield monitor
-      end
+      yield io
+
+      # so that we don't yield 2 times
+      writers.delete(io)
     end if readers
 
     writers.each do |io|
-      monitor = io.closed? ? @selectables.delete(io) : @selectables[io]
-      next unless monitor
-
-      # don't double run this, the last iteration might have run this task already
-      monitor.readiness = :w
-      yield monitor
+      yield io
     end if writers
   end
 
-  # Closes the selector.
-  #
-  def close
-    return if @closed
+  def select_one(interval)
+    io = @selectables.first
+
+    interests = io.interests
+
+    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
+
+    raise HTTPX::TimeoutError.new(interval, "timed out while waiting on select") unless result
 
-    @__r__.close
-    @__w__.close
-  rescue IOError
-  ensure
-    @closed = true
+    yield io
+  rescue IOError, SystemCallError
+    @selectables.reject!(&:closed?)
   end
 
-  # interrupts the select call.
-  def wakeup
-    @__w__.write_nonblock("\0", exception: false)
+  def select(interval, &block)
+    return select_one(interval, &block) if @selectables.size == 1
+
+    select_many(interval, &block)
   end
+
+  public :select
 end