httpx 0.0.1 → 0.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA256:
-  metadata.gz: 76ac74f383584bdbf20b60f5a969ceb2827379fb9bd5d58bda52474b4ce22cdb
-  data.tar.gz: 045ae543497d77f74dfc7aea2e317fa5521b3b9bc31d4ca0733298d1555e773c
+SHA1:
+  metadata.gz: 9f092c95882dd48ff10a25b77c08b7dec71acc31
+  data.tar.gz: fc75a3d72c8151c28b2f24ea4617d64e92b56488
 SHA512:
-  metadata.gz: f3986c2e0e756b2e41904f33eb3116067557c3eb82852d1d2c222a0d2afdf4281766a331216e3d95e69113cffbe812974b18793b90344dfc97e942d8b6a2fc33
-  data.tar.gz: 97f6ee0db636710c51850d359e82302a49a33c7f05d7584492e7a43e33fb7b04d7fc34e9e8209b4b763044362ef75326aa8b482140e9beda2113748b60a8e729
+  metadata.gz: 1cb99410118ac67eb35bbaf212fda20e95745a77fa026b1ce6712e742ca985728b88e087fd397fd38310496f20fd15cd039827a104220b479a4c471e645b8ea8
+  data.tar.gz: b593dfe0b0b433d1d12fc8695581158ddcb2a3558d693df07f821efd160cdb61beac1a00fcc78da10fdda608f03464f3cb1bd3e6d32386be318cb5fea44dbd5e

data/README.md

@@ -90,6 +90,10 @@ It means that it loads the bare minimum to perform requests, and the user has to
 
 It also means that it ships with the minimum amount of dependencies.
 
+## Easy to test
+
+The test suite runs against [httpbin proxied over nghttp2](https://nghttp2.org/httpbin/), so there is no mocking/stubbing going on. The test suite uses [minitest](https://github.com/seattlerb/minitest), but its matchers usage is limit to assert (assert is all you need).
+
 ## Supported Rubies
 
 All Rubies greater or equal to 2.1, and always latest JRuby.

data/lib/httpx/channel.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require "resolv"
 require "forwardable"
 require "httpx/io"
 require "httpx/buffer"
@@ -68,13 +69,13 @@ module HTTPX
     end
 
     def match?(uri)
-      ip = begin
-             TCPSocket.getaddress(uri.host)
-           rescue StandardError
-             uri.host
-           end
+      ips = begin
+        Resolv.getaddresses(uri.host)
+      rescue StandardError
+        [uri.host]
+      end
 
-      ip == @io.ip &&
+      ips.include?(@io.ip) &&
         uri.port == @io.port &&
         uri.scheme == @io.scheme
     end
@@ -98,18 +99,9 @@ module HTTPX
       @io.to_io
     end
 
-    def close(hard = false)
-      pr = @parser
+    def close
+      @parser.close if @parser
       transition(:closing)
-      if hard || (pr && pr.empty?)
-        pr.close
-        @parser = nil
-      else
-        transition(:idle)
-        @parser = pr
-        parser.reenqueue!
-        return
-      end
     end
 
     def reset
@@ -154,7 +146,10 @@ module HTTPX
     def dread(wsize = @window_size)
       loop do
         siz = @io.read(wsize, @read_buffer)
-        throw(:close, self) unless siz
+        unless siz
+          emit(:close)
+          return
+        end
         return if siz.zero?
         log { "READ: #{siz} bytes..." }
         parser << @read_buffer.to_s
@@ -165,7 +160,10 @@ module HTTPX
       loop do
         return if @write_buffer.empty?
         siz = @io.write(@write_buffer)
-        throw(:close, self) unless siz
+        unless siz
+          emit(:close)
+          return
+        end
         log { "WRITE: #{siz} bytes..." }
         return if siz.zero?
       end
@@ -190,11 +188,8 @@ module HTTPX
       parser.on(:promise) do |*args|
         emit(:promise, *args)
       end
-      # parser.inherit_callbacks(self)
-      parser.on(:complete) { throw(:close, self) }
       parser.on(:close) do
-        transition(:closed)
-        emit(:close)
+        transition(:closing)
       end
       parser
     end

data/lib/httpx/channel/http1.rb

@@ -151,7 +151,7 @@ module HTTPX
         # 1 keep alive request.
         @max_concurrent_requests = 1
       end
-      emit(:complete)
+      emit(:close)
     end
 
     private

data/lib/httpx/channel/http2.rb

@@ -170,7 +170,7 @@ module HTTPX
 
     def on_close(*)
       return unless @connection.state == :closed && @connection.active_stream_count.zero?
-      emit(:complete)
+      emit(:close)
     end
 
     def on_frame_sent(frame)

data/lib/httpx/client.rb

@@ -112,7 +112,7 @@ module HTTPX
           break
         end
       end
-      requests.size == 1 ? responses.first : responses
+      responses
     end
 
     def __build_req(verb, uri, options = {})

data/lib/httpx/connection.rb

@@ -19,19 +19,15 @@ module HTTPX
     def next_tick(timeout: @timeout.timeout)
       @selector.select(timeout) do |monitor|
         if (channel = monitor.value)
-          consume(channel)
+          channel.call
         end
         monitor.interests = channel.interests
       end
     end
 
-    def close(channel = nil)
-      if channel
-        channel.close
-      else
-        @channels.each(&:close)
-        next_tick until @selector.empty?
-      end
+    def close
+      @channels.each(&:close)
+      next_tick until @channels.empty?
     end
 
     def reset
@@ -65,10 +61,5 @@ module HTTPX
       end
       @channels << channel
     end
-
-    def consume(channel)
-      ch = catch(:close) { channel.call }
-      close(ch) if ch
-    end
   end
 end

data/lib/httpx/io.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require "resolv"
 require "socket"
 require "openssl"
 require "ipaddr"
@@ -12,13 +13,14 @@ module HTTPX
 
     def initialize(hostname, port, options)
       @state = :idle
+      @hostname = hostname
       @options = Options.new(options)
       @fallback_protocol = @options.fallback_protocol
       @port = port
       if @options.io
         @io = case @options.io
               when Hash
-                @ip = TCPSocket.getaddress(hostname)
+                @ip = Resolv.getaddress(@hostname)
                 @options.io[@ip] || @options.io["#{@ip}:#{@port}"]
               else
                 @ip = hostname
@@ -29,7 +31,7 @@ module HTTPX
           @state = :connected
         end
       else
-        @ip = TCPSocket.getaddress(hostname)
+        @ip = Resolv.getaddress(@hostname)
       end
       @io ||= build_socket
     end

data/lib/httpx/io/resolver.rb

@@ -0,0 +1,135 @@
+# frozen_string_literal: true
+
+require "forwardable"
+require "ipaddr"
+require "resolv"
+
+module HTTPX
+  class Resolver
+    include Loggable
+    extend Forwardable
+    # Maximum UDP packet we'll accept
+    MAX_PACKET_SIZE = 512
+    DNS_PORT        = 53
+
+    @mutex = Mutex.new
+    @identifier = 1
+
+    def self.generate_id
+      @mutex.synchronize { @identifier = (@identifier + 1) & 0xFFFF }
+    end
+
+    def self.nameservers
+      Resolv::DNS::Config.default_config_hash[:nameserver]
+    end
+
+    def_delegator :@io, :closed?
+    def initialize(options)
+      @options = Options.new(options)
+      # early return for edge case when there are no nameservers configured
+      # but we still want to be able to static lookups using #resolve_hostname
+      @nameservers = self.class.nameservers or return
+      server = IPAddr.new(@nameservers.sample)
+      @io = UDP.new(server, DNS_PORT)
+      @read_buffer = "".b
+      @addresses = {}
+      @hostnames = []
+      @callbacks = []
+      @state = :idle
+    end
+
+    def to_io
+      @io.to_io
+    end
+
+    def resolve(hostname, &action)
+      if host = resolve_hostname(hostname)
+        unless ip_address = resolve_host(host)
+          raise Resolv::ResolvError, "invalid entry in hosts file: #{host}"
+        end
+        @addresses[hostname] = ip_address
+        action.call(ip_address)
+      end
+      @hostnames << hostname
+      @callbacks << action
+      query = build_query(hostname).encode
+      log { "resolving #{hostname}: #{query.inspect}" }
+      siz = @io.write(query)
+      log { "WRITE: #{siz} bytes..."}
+    end
+
+    def call
+      return if @state == :closed
+      return if @hostnames.empty?
+      dread
+    end
+
+    def dread(wsize = MAX_PACKET_SIZE)
+      loop do
+        siz = @io.read(wsize, @read_buffer)
+        throw(:close, self) unless siz
+        return if siz.zero?
+        log { "READ: #{siz} bytes..."}
+        addrs = parse(@read_buffer)
+        @read_buffer.clear
+        next if addrs.empty?
+
+        hostname = @hostnames.shift
+        callback = @callbacks.shift
+        addr = addrs.index(addrs.rand(addrs.size))
+        log { "resolved #{hostname}: #{addr.to_s}"}
+        @addresses[hostname] = addr
+        callback.call(addr)
+      end
+    end
+
+    private
+
+    def parse(frame)
+      response = Resolv::DNS::Message.decode(frame)
+
+      addrs = []
+      # The answer might include IN::CNAME entries so filters them out
+      # to include IN::A & IN::AAAA entries only.
+      response.each_answer { |name, ttl, value| addrs << value.address if value.respond_to?(:address) }
+
+      return addrs
+    end
+
+    def resolve_hostname(hostname)
+      # Resolv::Hosts#getaddresses pushes onto a stack
+      # so since we want the first occurance, simply
+      # pop off the stack.
+      resolv.getaddresses(hostname).pop
+    rescue
+    end
+
+    def resolv
+      @resolv ||= Resolv::Hosts.new
+    end
+
+    def build_query(hostname)
+      Resolv::DNS::Message.new.tap do |query|
+        query.id = self.class.generate_id
+        query.rd = 1
+        query.add_question hostname, Resolv::DNS::Resource::IN::A
+      end
+    end
+
+    def resolve_host(host)
+      resolve_ip(Resolv::IPv4, host) || get_address(host) || resolve_ip(Resolv::IPv6, host)
+    end
+
+    def resolve_ip(klass, host)
+      klass.create(host)
+    rescue ArgumentError
+    end
+
+    private
+
+    def get_address(host)
+      Resolv::Hosts.new(host).getaddress
+    rescue
+    end
+  end
+end

data/lib/httpx/io/udp.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+require "socket"
+require "ipaddr"
+
+module HTTPX
+  class UDP
+    include Loggable
+
+    attr_reader :ip, :port
+
+    def initialize(ip, port)
+      @ip = ip.to_s
+      @port = port
+      @io = UDPSocket.new(ip.family)
+      @closed = false
+    end
+
+    def to_io
+      @io.to_io
+    end
+
+    if RUBY_VERSION < "2.3"
+      def read(size, buffer)
+        data, _ = @io.recvfrom_nonblock(size)
+        buffer.replace(data)
+        buffer.bytesize
+      rescue ::IO::WaitReadable
+        0
+      rescue EOFError
+        nil
+      end
+    else
+      def read(size, buffer)
+        @io.recvfrom_nonblock(size, 0, buffer, exception: false)
+        buffer.bytesize
+      rescue ::IO::WaitReadable
+        0
+      rescue EOFError
+        nil
+      end
+    end
+
+    def write(buffer)
+      siz = @io.send(buffer, 0, @ip, @port)
+      buffer.slice!(0, siz)
+      siz
+    end
+
+    def close
+      return if @closed
+      @io.close
+    ensure
+      @closed = true
+    end
+
+    def closed?
+      @closed
+    end
+
+    def inspect
+      "#<(fd: #{@io.fileno}): #{@ip}:#{@port})>"
+    end
+  end
+end

data/lib/httpx/plugins/proxy/http.rb

@@ -34,7 +34,7 @@ module HTTPX
               return if @io.closed?
               @parser = ConnectProxyParser.new(@write_buffer, @options.merge(max_concurrent_requests: 1))
               @parser.once(:response, &method(:on_connect))
-              @parser.on(:complete) { throw(:close, self) }
+              @parser.on(:close) { transition(:closing) }
               proxy_connect
               return if @state == :open
             when :open
@@ -45,7 +45,7 @@ module HTTPX
               when :idle
                 @parser = ProxyParser.new(@write_buffer, @options)
                 @parser.inherit_callbacks(self)
-                @parser.on(:complete) { throw(:close, self) }
+                @parser.on(:close) { transition(:closing) }
               end
             end
             super

data/lib/httpx/selector.rb

@@ -48,10 +48,6 @@ class HTTPX::Selector
     @closed = false
   end
 
-  def empty?
-    @readers.empty? && @writers.empty?
-  end
-
   # deregisters +io+ from selectables.
   def deregister(io)
     @lock.synchronize do

data/lib/httpx/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: httpx
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.2
 platform: ruby
 authors:
 - Tiago Cardoso
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-02-24 00:00:00.000000000 Z
+date: 2018-03-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: http-2
@@ -94,6 +94,8 @@ files:
 - lib/httpx/extensions.rb
 - lib/httpx/headers.rb
 - lib/httpx/io.rb
+- lib/httpx/io/resolver.rb
+- lib/httpx/io/udp.rb
 - lib/httpx/loggable.rb
 - lib/httpx/options.rb
 - lib/httpx/plugins/authentication.rb
@@ -143,7 +145,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.7.6
+rubygems_version: 2.6.14
 signing_key: 
 specification_version: 4
 summary: HTTPX, to the future, and beyond