httpx 0.3.0 → 0.3.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bed8cbd465eb9d1b565024395767f619aaaff1bf2ee35d33dc15e9fe4eeec13e
-  data.tar.gz: 65ac8fee9f8c773d6b9a7894e68641547f75ee69159f01e60c8cdc1f30b648f0
+  metadata.gz: 52b8402031b6deeed1d1a5c92c56e1cc8d93cae1da650d3573ddca712a413948
+  data.tar.gz: b2c2528c1a187eb0cdfe72636eebf6a390a240e86b78e9ebed2b81f26f3f1c89
 SHA512:
-  metadata.gz: 1e891362a86b73f6d2670eb14a1fd0815a0fab0173f6adf58bdb8e8225d83012560492c5563291d10d03e05ab9e2d9c786ba0cc238e886832276639bab06a8aa
-  data.tar.gz: 539853ff0c6ca209f32d56b8f5eb6209ef60a4df02f0073a588b915a5a583753b7bebe66cd91b76e599a55bb214c6d56a9d1a4d47d6d7a4d5ea2e9b18254af3c
+  metadata.gz: '0837f66f56ca695dbc89e9d1557703dba32d74c0748c246f3d94b5fa4baaf13b50a931c8dd018a8c6d4ec80324aac7c164c271be5d9a50afe573c7316e6bf751'
+  data.tar.gz: ee65a86527d020d422e68d1b5972f11d7ce710267ae4ba31d6bd7d42f6966fa606ddfdf9d4a788175516d2c7a5a857000ab0980d5762667236e8e9e2ef13ce12

data/lib/httpx/connection.rb

@@ -61,7 +61,7 @@ module HTTPX
       channel.on(:reset) do
         @timeout.transition(:idle)
       end
-      channel.once(:unreachable) do
+      channel.on(:unreachable) do
         @resolver.uncache(channel)
         resolve_channel(channel)
       end

data/lib/httpx/resolver.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "resolv"
+
 module HTTPX
   module Resolver
     autoload :ResolverMixin, "httpx/resolver/resolver_mixin"

data/lib/httpx/resolver/https.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require "resolv"
 require "uri"
 require "cgi"
 require "forwardable"
@@ -67,13 +68,17 @@ module HTTPX
     def resolve(channel = @channels.first, hostname = nil)
       return if @building_channel
       hostname = hostname || @queries.key(channel) || channel.uri.host
-      type = @_record_types[hostname].shift
+      type = @_record_types[hostname].first
       log(label: "resolver: ") { "query #{type} for #{hostname}" }
-      request = build_request(hostname, type)
-      @requests[request] = channel
-      resolver_channel.send(request)
-      @queries[hostname] = channel
-      @channels << channel
+      begin
+        request = build_request(hostname, type)
+        @requests[request] = channel
+        resolver_channel.send(request)
+        @queries[hostname] = channel
+        @channels << channel
+      rescue Resolv::DNS::EncodeError, JSON::JSONError => e
+        emit_resolve_error(channel, hostname, e)
+      end
     end
 
     def find_channel(_request, **options)
@@ -107,10 +112,20 @@ module HTTPX
     end
 
     def parse(response)
-      answers = decode_response_body(response)
+      answers = begin
+        decode_response_body(response)
+      rescue Resolv::DNS::DecodeError, JSON::JSONError => e
+        host, channel = @queries.first
+        if @_record_types[host].empty?
+          emit_resolve_error(channel, host, e)
+          return
+        end
+      end
       if answers.empty?
         host, channel = @queries.first
+        @_record_types[host].shift
         if @_record_types[host].empty?
+          @_record_types.delete(host)
           emit_resolve_error(channel, host)
           return
         end
@@ -173,7 +188,6 @@ module HTTPX
       when "application/dns-udpwireformat",
            "application/dns-message"
         Resolver.decode_dns_answer(response.to_s)
-
         # TODO: what about the rest?
       end
     end

data/lib/httpx/resolver/native.rb

@@ -81,9 +81,9 @@ module HTTPX
       if @ns_index < @nameserver.size
         transition(:idle)
       else
-        ex = ResolvError.new(e.message)
-        ex.set_backtrace(e.backtrace)
-        raise ex
+        @queries.each do |host, channel|
+          emit_resolve_error(channel, host, e)
+        end
       end
     end
 
@@ -100,7 +100,7 @@ module HTTPX
     def <<(channel)
       return if early_resolve(channel)
       if @nameserver.nil?
-        ex = ResolveError.new("Can't resolve #{channel.uri.host}")
+        ex = ResolveError.new("Can't resolve #{channel.uri.host}: no nameserver")
         ex.set_backtrace(caller)
         emit(:error, channel, ex)
       else
@@ -178,10 +178,21 @@ module HTTPX
     end
 
     def parse(buffer)
-      addresses = Resolver.decode_dns_answer(buffer)
+      addresses = begin
+        Resolver.decode_dns_answer(buffer)
+      rescue Resolv::DNS::DecodeError => e
+        hostname, channel = @queries.first
+        if @_record_types[hostname].empty?
+          emit_resolve_error(channel, hostname, e)
+          return
+        end
+      end
+
       if addresses.empty?
         hostname, channel = @queries.first
+        @_record_types[hostname].shift
         if @_record_types[hostname].empty?
+          @_record_types.delete(hostname)
           emit_resolve_error(channel, hostname)
           return
         end
@@ -212,9 +223,13 @@ module HTTPX
       return unless @write_buffer.empty?
       hostname = hostname || @queries.key(channel) || channel.uri.host
       @queries[hostname] = channel
-      type = @_record_types[hostname].shift
+      type = @_record_types[hostname].first
       log(label: "resolver: ") { "query #{type} for #{hostname}" }
-      @write_buffer << Resolver.encode_dns_query(hostname, type: RECORD_TYPES[type])
+      begin
+        @write_buffer << Resolver.encode_dns_query(hostname, type: RECORD_TYPES[type])
+      rescue Resolv::DNS::EncodeError => e
+        emit_resolve_error(channel, hostname, e)
+      end
     end
 
     def build_socket

data/lib/httpx/resolver/resolver_mixin.rb

@@ -21,6 +21,7 @@ module HTTPX
       def uncache(channel)
         hostname = hostname || @queries.key(channel) || channel.uri.host
         Resolver.uncache(hostname)
+        @_record_types[hostname].shift
       end
 
       private
@@ -51,9 +52,10 @@ module HTTPX
         ips.map { |ip| IPAddr.new(ip) }
       end
 
-      def emit_resolve_error(channel, hostname)
-        error = ResolveError.new("Can't resolve #{hostname}")
-        error.set_backtrace(caller)
+      def emit_resolve_error(channel, 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)
       end
     end

data/lib/httpx/resolver/system.rb

@@ -7,6 +7,11 @@ module HTTPX
   class Resolver::System
     include Resolver::ResolverMixin
 
+    RESOLV_ERRORS = [Resolv::ResolvError,
+                     Resolv::DNS::Requester::RequestError,
+                     Resolv::DNS::EncodeError,
+                     Resolv::DNS::DecodeError].freeze
+
     def initialize(_, options)
       @options = Options.new(options)
       roptions = @options.resolver_options
@@ -26,7 +31,10 @@ module HTTPX
     def <<(channel)
       hostname = channel.uri.host
       addresses = ip_resolve(hostname) || system_resolve(hostname) || @resolver.getaddresses(hostname)
-      addresses.empty? ? emit_resolve_error(channel, hostname) : emit_addresses(channel, addresses)
+      return emit_resolve_error(channel, hostname) if addresses.empty?
+      emit_addresses(channel, addresses)
+    rescue Errno::EHOSTUNREACH, *RESOLV_ERRORS => e
+      emit_resolve_error(channel, hostname, e)
     end
 
     def uncache(*); end

data/lib/httpx/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module HTTPX
-  VERSION = "0.3.0"
+  VERSION = "0.3.1"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: httpx
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.3.1
 platform: ruby
 authors:
 - Tiago Cardoso
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-12-01 00:00:00.000000000 Z
+date: 2018-12-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: http-2