httpx 0.7.0 → 0.10.0

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
@@ -82,9 +94,14 @@ module HTTPX
     def resolve(connection = @connections.first, hostname = nil)
       return if @building_connection
 
-      hostname = hostname || @queries.key(connection) || connection.origin.host
+      hostname ||= @queries.key(connection)
+
+      if hostname.nil?
+        hostname = connection.origin.host
+        log { "resolver: resolve IDN #{connection.origin.non_ascii_hostname} as #{hostname}" } if connection.origin.non_ascii_hostname
+      end
       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 +128,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
 
@@ -194,7 +211,7 @@ module HTTPX
       case response.headers["content-type"]
       when "application/dns-json",
            "application/json",
-           %r{^application\/x\-javascript} # because google...
+           %r{^application/x-javascript} # because google...
         payload = JSON.parse(response.to_s)
         payload["Answer"]
       when "application/dns-udpwireformat",

data/lib/httpx/resolver/native.rb

@@ -7,6 +7,7 @@ module HTTPX
   class Resolver::Native
     extend Forwardable
     include Resolver::ResolverMixin
+    using URIExtensions
 
     RESOLVE_TIMEOUT = 5
     RECORD_TYPES = {
@@ -73,14 +74,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 +86,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 +96,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 +157,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 +167,10 @@ 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..." }
         parse(@read_buffer)
+        return if @state == :closed
       end
     end
 
@@ -190,12 +179,9 @@ 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?
+
+        return if @state == :closed
       end
     end
 
@@ -250,10 +236,15 @@ module HTTPX
       raise Error, "no URI to resolve" unless connection
       return unless @write_buffer.empty?
 
-      hostname = hostname || @queries.key(connection) || connection.origin.host
+      hostname ||= @queries.key(connection)
+
+      if hostname.nil?
+        hostname = connection.origin.host
+        log { "resolver: resolve IDN #{connection.origin.non_ascii_hostname} as #{hostname}" } if connection.origin.non_ascii_hostname
+      end
       @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 +260,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 +276,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:
 
@@ -75,11 +75,11 @@ module HTTPX
         @status == 204 ||
         @status == 205 ||
         @status == 304 || begin
-        content_length = @headers["content-length"]
-        return false if content_length.nil?
+          content_length = @headers["content-length"]
+          return false if content_length.nil?
 
-        content_length == "0"
-      end
+          content_length == "0"
+        end
     end
 
     class Body
@@ -95,6 +95,8 @@ module HTTPX
       end
 
       def write(chunk)
+        return if @state == :closed
+
         @length += chunk.bytesize
         transition
         @buffer.write(chunk)
@@ -116,7 +118,7 @@ module HTTPX
         return enum_for(__method__) unless block_given?
 
         begin
-          unless @state == :idle
+          if @buffer
             rewind
             while (chunk = @buffer.read(@window_size))
               yield(chunk.force_encoding(@encoding))
@@ -150,23 +152,24 @@ 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
-          @buffer.rewind
           ::IO.copy_stream(@buffer, dest)
         end
       end
 
       # closes/cleans the buffer, resets everything
       def close
-        return if @state == :idle
-
-        @buffer.close
-        @buffer.unlink if @buffer.respond_to?(:unlink)
-        @buffer = nil
+        if @buffer
+          @buffer.close
+          @buffer.unlink if @buffer.respond_to?(:unlink)
+          @buffer = nil
+        end
         @length = 0
-        @state = :idle
+        @state = :closed
       end
 
       def ==(other)
@@ -184,7 +187,7 @@ module HTTPX
       private
 
       def rewind
-        return if @state == :idle
+        return unless @buffer
 
         @buffer.rewind
       end
@@ -237,13 +240,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('"')
@@ -267,13 +268,17 @@ module HTTPX
       @error.message
     end
 
+    def to_s
+      @error.backtrace.join("\n")
+    end
+
     def raise_for_status
       raise @error
     end
 
     # rubocop:disable Style/MissingRespondToMissing
     def method_missing(meth, *, &block)
-      raise NoMethodError, "undefined response method `#{meth}' for error response" if Response.public_method_defined?(meth)
+      raise NoMethodError, "undefined response method `#{meth}' for error response" if @options.response_class.public_method_defined?(meth)
 
       super
     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,107 @@ 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, &block)
+    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
-    end if readers
+      yield io
 
-    writers.each do |io|
-      monitor = io.closed? ? @selectables.delete(io) : @selectables[io]
-      next unless monitor
+      # so that we don't yield 2 times
+      writers.delete(io)
+    end if readers
 
-      # don't double run this, the last iteration might have run this task already
-      monitor.readiness = :w
-      yield monitor
-    end if writers
+    writers.each(&block) 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