httpx 0.3.1 → 0.4.0

data/lib/httpx/resolver/native.rb

@@ -33,9 +33,9 @@ module HTTPX
 
     DNS_PORT = 53
 
-    def_delegator :@channels, :empty?
+    def_delegator :@connections, :empty?
 
-    def initialize(_, options)
+    def initialize(options)
       @options = Options.new(options)
       @ns_index = 0
       @resolver_options = Resolver::Options.new(DEFAULTS.merge(@options.resolver_options || {}))
@@ -43,7 +43,7 @@ module HTTPX
       @_timeouts = Array(@resolver_options.timeouts)
       @timeouts = Hash.new { |timeouts, host| timeouts[host] = @_timeouts.dup }
       @_record_types = Hash.new { |types, host| types[host] = @resolver_options.record_types.dup }
-      @channels = []
+      @connections = []
       @queries = {}
       @read_buffer = Buffer.new(@resolver_options.packet_size)
       @write_buffer = Buffer.new(@resolver_options.packet_size)
@@ -81,8 +81,8 @@ module HTTPX
       if @ns_index < @nameserver.size
         transition(:idle)
       else
-        @queries.each do |host, channel|
-          emit_resolve_error(channel, host, e)
+        @queries.each do |host, connection|
+          emit_resolve_error(connection, host, e)
         end
       end
     end
@@ -97,14 +97,16 @@ module HTTPX
       end
     end
 
-    def <<(channel)
-      return if early_resolve(channel)
+    def <<(connection)
+      return if early_resolve(connection)
+
       if @nameserver.nil?
-        ex = ResolveError.new("Can't resolve #{channel.uri.host}: no nameserver")
+        ex = ResolveError.new("Can't resolve #{connection.origin.host}: no nameserver")
         ex.set_backtrace(caller)
-        emit(:error, channel, ex)
+        emit(:error, connection, ex)
       else
-        @channels << channel
+        @connections << connection
+        resolve
       end
     end
 
@@ -124,31 +126,32 @@ module HTTPX
 
     def do_retry
       return if @queries.empty?
+
       loop_time = Process.clock_gettime(Process::CLOCK_MONOTONIC) - @start_timeout
-      channels = []
+      connections = []
       queries = {}
       while (query = @queries.shift)
-        h, channel = query
-        host = channel.uri.host
+        h, connection = query
+        host = connection.origin.host
         timeout = (@timeouts[host][0] -= loop_time)
         unless timeout.negative?
-          queries[h] = channel
+          queries[h] = connection
           next
         end
         @timeouts[host].shift
         if @timeouts[host].empty?
           @timeouts.delete(host)
-          emit_resolve_error(channel, host)
+          emit_resolve_error(connection, host)
           return
         else
-          channels << channel
+          connections << connection
           log(label: "resolver: ") do
             "timeout after #{prev_timeout}s, retry(#{timeouts.first}) #{host}..."
           end
         end
       end
       @queries = queries
-      channels.each { |ch| resolve(ch) }
+      connections.each { |ch| resolve(ch) }
     end
 
     def dread(wsize = @read_buffer.limit)
@@ -159,6 +162,7 @@ module HTTPX
           return
         end
         return if siz.zero?
+
         log(label: "resolver: ") { "READ: #{siz} bytes..." }
         parse(@read_buffer.to_s)
       end
@@ -167,6 +171,7 @@ module HTTPX
     def dwrite
       loop do
         return if @write_buffer.empty?
+
         siz = @io.write(@write_buffer)
         unless siz
           emit(:close)
@@ -178,62 +183,66 @@ module HTTPX
     end
 
     def parse(buffer)
-      addresses = begin
-        Resolver.decode_dns_answer(buffer)
+      begin
+        addresses = Resolver.decode_dns_answer(buffer)
       rescue Resolv::DNS::DecodeError => e
-        hostname, channel = @queries.first
+        hostname, connection = @queries.first
         if @_record_types[hostname].empty?
-          emit_resolve_error(channel, hostname, e)
+          emit_resolve_error(connection, hostname, e)
           return
         end
       end
 
       if addresses.empty?
-        hostname, channel = @queries.first
+        hostname, connection = @queries.first
         @_record_types[hostname].shift
         if @_record_types[hostname].empty?
           @_record_types.delete(hostname)
-          emit_resolve_error(channel, hostname)
+          emit_resolve_error(connection, hostname)
           return
         end
       else
         address = addresses.first
-        channel = @queries.delete(address["name"])
-        return unless channel # probably a retried query for which there's an answer
+        connection = @queries.delete(address["name"])
+        return unless connection # probably a retried query for which there's an answer
+
         if address.key?("alias") # CNAME
-          if early_resolve(channel, hostname: address["alias"])
-            @channels.delete(channel)
+          if early_resolve(connection, hostname: address["alias"])
+            @connections.delete(connection)
           else
-            resolve(channel, address["alias"])
+            resolve(connection, address["alias"])
             @queries.delete(address["name"])
             return
           end
         else
-          @channels.delete(channel)
-          Resolver.cached_lookup_set(channel.uri.host, addresses)
-          emit_addresses(channel, addresses.map { |addr| addr["data"] })
+          @connections.delete(connection)
+          Resolver.cached_lookup_set(connection.origin.host, addresses)
+          emit_addresses(connection, addresses.map { |addr| addr["data"] })
         end
       end
-      return emit(:close) if @channels.empty?
+      return emit(:close) if @connections.empty?
+
       resolve
     end
 
-    def resolve(channel = @channels.first, hostname = nil)
-      raise Error, "no URI to resolve" unless channel
+    def resolve(connection = @connections.first, hostname = nil)
+      raise Error, "no URI to resolve" unless connection
       return unless @write_buffer.empty?
-      hostname = hostname || @queries.key(channel) || channel.uri.host
-      @queries[hostname] = channel
+
+      hostname = hostname || @queries.key(connection) || connection.origin.host
+      @queries[hostname] = connection
       type = @_record_types[hostname].first
       log(label: "resolver: ") { "query #{type} for #{hostname}" }
       begin
         @write_buffer << Resolver.encode_dns_query(hostname, type: RECORD_TYPES[type])
       rescue Resolv::DNS::EncodeError => e
-        emit_resolve_error(channel, hostname, e)
+        emit_resolve_error(connection, hostname, e)
       end
     end
 
     def build_socket
       return if @io
+
       ip, port = @nameserver[@ns_index]
       port ||= DNS_PORT
       uri = URI::Generic.build(scheme: "udp", port: port)
@@ -253,11 +262,13 @@ module HTTPX
         @timeouts.clear
       when :open
         return unless @state == :idle
+
         build_socket
         @io.connect
         return unless @io.connected?
       when :closed
         return unless @state == :open
+
         @io.close if @io
       end
       @state = nextstate

data/lib/httpx/resolver/resolver_mixin.rb

@@ -18,27 +18,31 @@ module HTTPX
         end
       end
 
-      def uncache(channel)
-        hostname = hostname || @queries.key(channel) || channel.uri.host
+      def uncache(connection)
+        hostname = hostname || @queries.key(connection) || connection.origin.host
         Resolver.uncache(hostname)
         @_record_types[hostname].shift
       end
 
       private
 
-      def emit_addresses(channel, addresses)
+      def emit_addresses(connection, addresses)
         addresses.map! do |address|
           address.is_a?(IPAddr) ? address : IPAddr.new(address.to_s)
         end
-        log(label: "resolver: ") { "answer #{channel.uri.host}: #{addresses.inspect}" }
-        channel.addresses = addresses
-        emit(:resolve, channel, addresses)
+        log(label: "resolver: ") { "answer #{connection.origin.host}: #{addresses.inspect}" }
+        connection.addresses = addresses
+        emit(:resolve, connection)
       end
 
-      def early_resolve(channel, hostname: channel.uri.host)
-        addresses = ip_resolve(hostname) || Resolver.cached_lookup(hostname) || system_resolve(hostname)
+      def early_resolve(connection, hostname: connection.origin.host)
+        addresses = connection.addresses ||
+                    ip_resolve(hostname) ||
+                    Resolver.cached_lookup(hostname) ||
+                    system_resolve(hostname)
         return unless addresses
-        emit_addresses(channel, addresses)
+
+        emit_addresses(connection, addresses)
       end
 
       def ip_resolve(hostname)
@@ -49,14 +53,15 @@ module HTTPX
         @system_resolver ||= Resolv::Hosts.new
         ips = @system_resolver.getaddresses(hostname)
         return if ips.empty?
+
         ips.map { |ip| IPAddr.new(ip) }
       end
 
-      def emit_resolve_error(channel, hostname, ex = nil)
+      def emit_resolve_error(connection, hostname, ex = nil)
         message = ex ? ex.message : "Can't resolve #{hostname}"
         error = ResolveError.new(message)
         error.set_backtrace(ex ? ex.backtrace : caller)
-        emit(:error, channel, error)
+        emit(:error, connection, error)
       end
     end
   end

data/lib/httpx/resolver/system.rb

@@ -12,7 +12,7 @@ module HTTPX
                      Resolv::DNS::EncodeError,
                      Resolv::DNS::DecodeError].freeze
 
-    def initialize(_, options)
+    def initialize(options)
       @options = Options.new(options)
       roptions = @options.resolver_options
       @state = :idle
@@ -28,13 +28,17 @@ module HTTPX
       true
     end
 
-    def <<(channel)
-      hostname = channel.uri.host
-      addresses = ip_resolve(hostname) || system_resolve(hostname) || @resolver.getaddresses(hostname)
-      return emit_resolve_error(channel, hostname) if addresses.empty?
-      emit_addresses(channel, addresses)
+    def <<(connection)
+      hostname = connection.origin.host
+      addresses = connection.addresses ||
+                  ip_resolve(hostname) ||
+                  system_resolve(hostname) ||
+                  @resolver.getaddresses(hostname)
+      return emit_resolve_error(connection, hostname) if addresses.empty?
+
+      emit_addresses(connection, addresses)
     rescue Errno::EHOSTUNREACH, *RESOLV_ERRORS => e
-      emit_resolve_error(channel, hostname, e)
+      emit_resolve_error(connection, hostname, e)
     end
 
     def uncache(*); end

data/lib/httpx/response.rb

@@ -21,10 +21,10 @@ module HTTPX
 
     def_delegator :@request, :uri
 
-    def initialize(request, status, version, headers, options = {})
-      @options = Options.new(options)
-      @version = version
+    def initialize(request, status, version, headers)
       @request = request
+      @options = request.options
+      @version = version
       @status = Integer(status)
       @headers = @options.headers_class.new(headers)
       @body = @options.response_body_class.new(self, threshold_size: @options.body_threshold_size,
@@ -58,6 +58,7 @@ module HTTPX
 
     def raise_for_status
       return if @status < 400
+
       raise HTTPError, self
     end
 
@@ -70,6 +71,7 @@ module HTTPX
         @status == 304 || begin
         content_length = @headers["content-length"]
         return false if content_length.nil?
+
         content_length == "0"
       end
     end
@@ -94,6 +96,7 @@ module HTTPX
 
       def read(*args)
         return unless @buffer
+
         @buffer.read(*args)
       end
 
@@ -103,6 +106,7 @@ module HTTPX
 
       def each
         return enum_for(__method__) unless block_given?
+
         begin
           unless @state == :idle
             rewind
@@ -137,6 +141,7 @@ module HTTPX
 
       def copy_to(dest)
         return unless @buffer
+
         if dest.respond_to?(:path) && @buffer.respond_to?(:path)
           FileUtils.mv(@buffer.path, dest.path)
         else
@@ -148,6 +153,7 @@ module HTTPX
       # closes/cleans the buffer, resets everything
       def close
         return if @state == :idle
+
         @buffer.close
         @buffer.unlink if @buffer.respond_to?(:unlink)
         @buffer = nil
@@ -163,6 +169,7 @@ module HTTPX
 
       def rewind
         return if @state == :idle
+
         @buffer.rewind
       end
 
@@ -182,10 +189,9 @@ module HTTPX
             @buffer = Tempfile.new("httpx", encoding: @encoding, mode: File::RDWR)
             aux.rewind
             ::IO.copy_stream(aux, @buffer)
-            # TODO: remove this if/when minor ruby is 2.3
-            # (this looks like a bug from older versions)
-            @buffer.pos = aux.pos #######################
-            #############################################
+            # (this looks like a bug from Ruby < 2.3
+            @buffer.pos = aux.pos ##################
+            ########################################
             aux.close
             @state = :buffer
           end
@@ -197,8 +203,8 @@ module HTTPX
   end
 
   class ContentType
-    MIME_TYPE_RE = %r{^([^/]+/[^;]+)(?:$|;)}
-    CHARSET_RE   = /;\s*charset=([^;]+)/i
+    MIME_TYPE_RE = %r{^([^/]+/[^;]+)(?:$|;)}.freeze
+    CHARSET_RE   = /;\s*charset=([^;]+)/i.freeze
 
     attr_reader :mime_type, :charset
 
@@ -237,7 +243,7 @@ module HTTPX
     def initialize(error, options)
       @error = error
       @options = Options.new(options)
-      log { "#{error.class}: #{error}" }
+      log_exception(@error)
     end
 
     def status
@@ -247,5 +253,13 @@ module HTTPX
     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)
+
+      super
+    end
+    # rubocop:enable Style/MissingRespondToMissing
   end
 end

data/lib/httpx/selector.rb

@@ -11,7 +11,7 @@ class HTTPX::Selector
   # I/O monitor
   #
   class Monitor
-    attr_accessor :value, :interests, :readiness
+    attr_accessor :io, :interests, :readiness
 
     def initialize(io, interests, reactor)
       @io = io
@@ -31,6 +31,7 @@ class HTTPX::Selector
     # closes +@io+, deregisters from reactor (unless +deregister+ is false)
     def close(deregister = true)
       return if @closed
+
       @closed = true
       @reactor.deregister(@io) if deregister
     end
@@ -49,49 +50,44 @@ class HTTPX::Selector
   def initialize
     @readers = {}
     @writers = {}
-    @lock = Mutex.new
     @__r__, @__w__ = IO.pipe
     @closed = false
   end
 
   # deregisters +io+ from selectables.
   def deregister(io)
-    @lock.synchronize do
-      rmonitor = @readers.delete(io)
-      wmonitor = @writers.delete(io)
-      monitor = rmonitor || wmonitor
-      monitor.close(false) if monitor
-    end
+    rmonitor = @readers.delete(io)
+    wmonitor = @writers.delete(io)
+    monitor = rmonitor || wmonitor
+    monitor.close(false) if monitor
   end
 
   # register +io+ for +interests+ events.
   def register(io, interests)
     readable = READABLE.include?(interests)
     writable = WRITABLE.include?(interests)
-    @lock.synchronize do
-      if readable
-        monitor = @readers[io]
-        if monitor
-          monitor.interests = interests
-        else
-          monitor = Monitor.new(io, interests, self)
-        end
-        @readers[io] = monitor
-        @writers.delete(io) unless writable
+    if readable
+      monitor = @readers[io]
+      if monitor
+        monitor.interests = interests
+      else
+        monitor = Monitor.new(io, interests, self)
       end
-      if writable
-        monitor = @writers[io]
-        if monitor
-          monitor.interests = interests
-        else
-          # reuse object
-          monitor = readable ? @readers[io] : Monitor.new(io, interests, self)
-        end
-        @writers[io] = monitor
-        @readers.delete(io) unless readable
+      @readers[io] = monitor
+      @writers.delete(io) unless writable
+    end
+    if writable
+      monitor = @writers[io]
+      if monitor
+        monitor.interests = interests
+      else
+        # reuse object
+        monitor = readable ? @readers[io] : Monitor.new(io, interests, self)
       end
-      monitor
+      @writers[io] = monitor
+      @readers.delete(io) unless readable
     end
+    monitor
   end
 
   # waits for read/write events for +interval+. Yields for monitors of
@@ -99,22 +95,16 @@ class HTTPX::Selector
   #
   def select(interval)
     begin
-      r = nil
-      w = nil
-      @lock.synchronize do
-        r = @readers.keys
-        w = @writers.keys
-      end
+      r = @readers.keys
+      w = @writers.keys
       r.unshift(@__r__)
 
       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
-      @lock.synchronize do
-        @readers.reject! { |io, _| io.closed? }
-        @writers.reject! { |io, _| io.closed? }
-      end
+      @readers.reject! { |io, _| io.closed? }
+      @writers.reject! { |io, _| io.closed? }
       retry
     end
 
@@ -125,6 +115,7 @@ class HTTPX::Selector
       else
         monitor = io.closed? ? @readers.delete(io) : @readers[io]
         next unless monitor
+
         monitor.readiness = writers.delete(io) ? :rw : :r
         yield monitor
       end
@@ -133,6 +124,7 @@ class HTTPX::Selector
     writers.each do |io|
       monitor = io.closed? ? @writers.delete(io) : @writers[io]
       next unless monitor
+
       # don't double run this, the last iteration might have run this task already
       monitor.readiness = :w
       yield monitor
@@ -143,6 +135,7 @@ class HTTPX::Selector
   #
   def close
     return if @closed
+
     @__r__.close
     @__w__.close
   rescue IOError