httpx 0.0.5 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 3fd5760406dc7a2cb5abb040160144fb8a788a19
-  data.tar.gz: 2fcf4228f1ff06b7621b7e688e9fe2a173e39096
+SHA256:
+  metadata.gz: 34654a12cf778aeffd39429a869bbfb62dc487369ed50fdfc8b14c512e141c91
+  data.tar.gz: 055b3f79a33ecf43982264f2af5d61631d290aab74c7b63d30fc82501ba366c3
 SHA512:
-  metadata.gz: adc85e755255e5e460bce9a84c5e5c3c03a8271702eed4373aded5002d71b28d99787bc4f4837d3bee4634f58fbe5541cf6f3a0282c54e4b3c5d86233f7b581c
-  data.tar.gz: 58f6d7c64c527bb654a8ab7107eff77315ad4c3d6f17da06b081be0d25345169736b78082b9e4335373dde707e071823d2bafa74102336535f9af07234bbd3d6
+  metadata.gz: b9cc0fb05f09c33d2b18f7aa3b46313240744ecb0a8474ffb5345afc2e533768b987609eabd8f1461c00f64815610dcd83e68f340933ce1695ee3efcbc6653a2
+  data.tar.gz: 21bc5f92e8c8c639a2b0f0885d7652805a099f44a89900da8336993c1e033359245666204d2adccc9fbfb18e49c6dd883fc09ffac5c56b194df056a8cda4b0de

data/README.md

@@ -1,4 +1,4 @@
-# HTTPX: A Ruby HTTP HTTPX for tomorrow... and beyond!
+# HTTPX: A Ruby HTTP library for tomorrow... and beyond!
 
 [![pipeline status](https://gitlab.com/honeyryderchuck/httpx/badges/master/pipeline.svg)](https://gitlab.com/honeyryderchuck/httpx/commits/master)
 [![coverage report](https://gitlab.com/honeyryderchuck/httpx/badges/master/coverage.svg)](https://honeyryderchuck.gitlab.io/httpx/coverage/#_AllFiles)

data/lib/httpx/channel.rb

@@ -42,14 +42,15 @@ module HTTPX
 
     class << self
       def by(uri, options)
-        io = case uri.scheme
-             when "http"
-               IO.registry("tcp").new(uri.host, uri.port, options)
-             when "https"
-               IO.registry("ssl").new(uri.host, uri.port, options)
-             else
-               raise Error, "#{uri}: #{uri.scheme}: unrecognized channel"
+        type = options.transport || begin
+          case uri.scheme
+          when "http" then "tcp"
+          when "https" then "ssl"
+          else
+            raise Error, "#{uri}: #{uri.scheme}: unrecognized channel"
+          end
         end
+        io = IO.registry(type).new(uri, options)
         new(io, options)
       end
     end
@@ -153,7 +154,9 @@ module HTTPX
       loop do
         siz = @io.read(wsize, @read_buffer)
         unless siz
-          emit(:close)
+          ex = EOFError.new("descriptor closed")
+          ex.set_backtrace(caller)
+          on_error(ex)
           return
         end
         return if siz.zero?
@@ -167,7 +170,9 @@ module HTTPX
         return if @write_buffer.empty?
         siz = @io.write(@write_buffer)
         unless siz
-          emit(:close)
+          ex = EOFError.new("descriptor closed")
+          ex.set_backtrace(caller)
+          on_error(ex)
           return
         end
         log { "WRITE: #{siz} bytes..." }
@@ -206,7 +211,7 @@ module HTTPX
         end
       end
       parser.on(:error) do |request, ex|
-        response = ErrorResponse.new(ex, 0, @options)
+        response = ErrorResponse.new(ex, @options)
         emit(:response, request, response)
       end
       parser
@@ -246,8 +251,8 @@ module HTTPX
     end
 
     def handle_error(e)
-      parser.handle_error(e)
-      response = ErrorResponse.new(e, 0, @options)
+      parser.handle_error(e) if parser.respond_to?(:handle_error)
+      response = ErrorResponse.new(e, @options)
       @pending.each do |request, _|
         emit(:response, request, response)
       end

data/lib/httpx/channel/http1.rb

@@ -101,7 +101,7 @@ module HTTPX
 
       response << chunk
 
-      # dispatch if response.complete?
+      @has_response = response.complete?
     end
 
     def on_message_complete

data/lib/httpx/client.rb

@@ -51,13 +51,7 @@ module HTTPX
     end
 
     def fetch_response(request)
-      response = @responses.delete(request)
-      if response.is_a?(ErrorResponse) && response.retryable?
-        channel = find_channel(request)
-        channel.send(request, retries: response.retries - 1)
-        return
-      end
-      response
+      @responses.delete(request)
     end
 
     def find_channel(request, **options)

data/lib/httpx/connection.rb

@@ -24,7 +24,10 @@ module HTTPX
         end
         monitor.interests = channel.interests
       end
-    rescue TimeoutError => ex
+    rescue TimeoutError,
+           Errno::ECONNRESET,
+           Errno::ECONNABORTED,
+           Errno::EPIPE => ex
       @channels.each do |ch|
         ch.emit(:error, ex)
       end

data/lib/httpx/io.rb

@@ -1,255 +1,15 @@
 # frozen_string_literal: true
 
-require "resolv"
 require "socket"
-require "openssl"
-require "ipaddr"
+require "httpx/io/tcp"
+require "httpx/io/ssl"
+require "httpx/io/unix"
 
 module HTTPX
-  class TCP
-    include Loggable
-
-    attr_reader :ip, :port
-
-    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 = Resolv.getaddress(@hostname)
-                @options.io[@ip] || @options.io["#{@ip}:#{@port}"]
-              else
-                @ip = hostname
-                @options.io
-        end
-        unless @io.nil?
-          @keep_open = true
-          @state = :connected
-        end
-      else
-        @ip = Resolv.getaddress(@hostname)
-      end
-      @io ||= build_socket
-    end
-
-    def scheme
-      "http"
-    end
-
-    def to_io
-      @io.to_io
-    end
-
-    def protocol
-      @fallback_protocol
-    end
-
-    def connect
-      return unless closed?
-      begin
-        if @io.closed?
-          transition(:idle)
-          @io = build_socket
-        end
-        @io.connect_nonblock(Socket.sockaddr_in(@port, @ip))
-      rescue Errno::EISCONN
-      end
-      transition(:connected)
-    rescue Errno::EINPROGRESS,
-           Errno::EALREADY,
-           ::IO::WaitReadable
-    end
-
-    if RUBY_VERSION < "2.3"
-      def read(size, buffer)
-        @io.read_nonblock(size, buffer)
-        buffer.bytesize
-      rescue ::IO::WaitReadable
-        0
-      rescue EOFError
-        nil
-      end
-
-      def write(buffer)
-        siz = @io.write_nonblock(buffer)
-        buffer.slice!(0, siz)
-        siz
-      rescue ::IO::WaitWritable
-        0
-      rescue EOFError
-        nil
-      end
-    else
-      def read(size, buffer)
-        ret = @io.read_nonblock(size, buffer, exception: false)
-        return 0 if ret == :wait_readable
-        return if ret.nil?
-        buffer.bytesize
-      end
-
-      def write(buffer)
-        siz = @io.write_nonblock(buffer, exception: false)
-        return 0 if siz == :wait_writable
-        return if siz.nil?
-        buffer.slice!(0, siz)
-        siz
-      end
-    end
-
-    def close
-      return if @keep_open || closed?
-      begin
-        @io.close
-      ensure
-        transition(:closed)
-      end
-    end
-
-    def connected?
-      @state == :connected
-    end
-
-    def closed?
-      @state == :idle || @state == :closed
-    end
-
-    def inspect
-      id = @io.closed? ? "closed" : @io.fileno
-      "#<TCP(fd: #{id}): #{@ip}:#{@port} (state: #{@state})>"
-    end
-
-    private
-
-    def build_socket
-      addr = IPAddr.new(@ip)
-      Socket.new(addr.family, :STREAM, 0)
-    end
-
-    def transition(nextstate)
-      case nextstate
-      # when :idle
-      when :connected
-        return unless @state == :idle
-      when :closed
-        return unless @state == :connected
-      end
-      do_transition(nextstate)
-    end
-
-    def do_transition(nextstate)
-      log(level: 1, label: "#{inspect}: ") { nextstate.to_s }
-      @state = nextstate
-    end
-  end
-
-  class SSL < TCP
-    TLS_OPTIONS = if OpenSSL::SSL::SSLContext.instance_methods.include?(:alpn_protocols)
-      { alpn_protocols: %w[h2 http/1.1] }
-    else
-      {}
-    end
-
-    def initialize(_, _, options)
-      @ctx = OpenSSL::SSL::SSLContext.new
-      ctx_options = TLS_OPTIONS.merge(options.ssl)
-      @ctx.set_params(ctx_options) unless ctx_options.empty?
-      super
-      @state = :negotiated if @keep_open
-    end
-
-    def scheme
-      "https"
-    end
-
-    def protocol
-      @io.alpn_protocol || super
-    rescue StandardError
-      super
-    end
-
-    def close
-      super
-      # allow reconnections
-      # connect only works if initial @io is a socket
-      @io = @io.io if @io.respond_to?(:io)
-      @negotiated = false
-    end
-
-    def connected?
-      @state == :negotiated
-    end
-
-    def connect
-      super
-      if @keep_open
-        @state = :negotiated
-        return
-      end
-      return if @state == :negotiated ||
-                @state != :connected
-      unless @io.is_a?(OpenSSL::SSL::SSLSocket)
-        @io = OpenSSL::SSL::SSLSocket.new(@io, @ctx)
-        @io.hostname = @hostname
-        @io.sync_close = true
-      end
-      # TODO: this might block it all
-      @io.connect_nonblock
-      transition(:negotiated)
-    rescue ::IO::WaitReadable,
-           ::IO::WaitWritable
-    end
-
-    if RUBY_VERSION < "2.3"
-      def read(*)
-        super
-      rescue ::IO::WaitWritable
-        0
-      end
-
-      def write(*)
-        super
-      rescue ::IO::WaitReadable
-        0
-      end
-    else
-      if OpenSSL::VERSION < "2.0.6"
-        def read(size, buffer)
-          @io.read_nonblock(size, buffer)
-          buffer.bytesize
-        rescue ::IO::WaitReadable,
-               ::IO::WaitWritable
-          0
-        rescue EOFError
-          nil
-        end
-      end
-    end
-
-    def inspect
-      id = @io.closed? ? "closed" : @io.to_io.fileno
-      "#<SSL(fd: #{id}): #{@ip}:#{@port} state: #{@state}>"
-    end
-
-    private
-
-    def transition(nextstate)
-      case nextstate
-      when :negotiated
-        return unless @state == :connected
-      when :closed
-        return unless @state == :negotiated ||
-                      @state == :connected
-      end
-      do_transition(nextstate)
-    end
-  end
   module IO
     extend Registry
     register "tcp", TCP
     register "ssl", SSL
+    register "unix", HTTPX::UNIX
   end
 end

data/lib/httpx/io/ssl.rb

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+require "openssl"
+
+module HTTPX
+  class SSL < TCP
+    TLS_OPTIONS = if OpenSSL::SSL::SSLContext.instance_methods.include?(:alpn_protocols)
+      { alpn_protocols: %w[h2 http/1.1] }
+    else
+      {}
+    end
+
+    def initialize(_, options)
+      @ctx = OpenSSL::SSL::SSLContext.new
+      ctx_options = TLS_OPTIONS.merge(options.ssl)
+      @ctx.set_params(ctx_options) unless ctx_options.empty?
+      super
+      @state = :negotiated if @keep_open
+    end
+
+    def scheme
+      "https"
+    end
+
+    def protocol
+      @io.alpn_protocol || super
+    rescue StandardError
+      super
+    end
+
+    def close
+      super
+      # allow reconnections
+      # connect only works if initial @io is a socket
+      @io = @io.io if @io.respond_to?(:io)
+      @negotiated = false
+    end
+
+    def connected?
+      @state == :negotiated
+    end
+
+    def connect
+      super
+      if @keep_open
+        @state = :negotiated
+        return
+      end
+      return if @state == :negotiated ||
+                @state != :connected
+      unless @io.is_a?(OpenSSL::SSL::SSLSocket)
+        @io = OpenSSL::SSL::SSLSocket.new(@io, @ctx)
+        @io.hostname = @hostname
+        @io.sync_close = true
+      end
+      @io.connect_nonblock
+      @io.post_connection_check(@hostname) if @ctx.verify_mode != OpenSSL::SSL::VERIFY_NONE
+      transition(:negotiated)
+    rescue ::IO::WaitReadable,
+           ::IO::WaitWritable
+    end
+
+    if RUBY_VERSION < "2.3"
+      def read(*)
+        super
+      rescue ::IO::WaitWritable
+        0
+      end
+
+      def write(*)
+        super
+      rescue ::IO::WaitReadable
+        0
+      end
+    else
+      if OpenSSL::VERSION < "2.0.6"
+        def read(size, buffer)
+          @io.read_nonblock(size, buffer)
+          buffer.bytesize
+        rescue ::IO::WaitReadable,
+               ::IO::WaitWritable
+          0
+        rescue EOFError
+          nil
+        end
+      end
+    end
+
+    def inspect
+      id = @io.closed? ? "closed" : @io.to_io.fileno
+      "#<SSL(fd: #{id}): #{@ip}:#{@port} state: #{@state}>"
+    end
+
+    private
+
+    def transition(nextstate)
+      case nextstate
+      when :negotiated
+        return unless @state == :connected
+      when :closed
+        return unless @state == :negotiated ||
+                      @state == :connected
+      end
+      do_transition(nextstate)
+    end
+  end
+end

data/lib/httpx/io/tcp.rb

@@ -0,0 +1,148 @@
+# frozen_string_literal: true
+
+require "resolv"
+require "ipaddr"
+
+module HTTPX
+  class TCP
+    include Loggable
+
+    attr_reader :ip, :port
+
+    alias_method :host, :ip
+
+    def initialize(uri, options)
+      @state = :idle
+      @hostname = uri.host
+      @options = Options.new(options)
+      @fallback_protocol = @options.fallback_protocol
+      @port = uri.port
+      if @options.io
+        @io = case @options.io
+              when Hash
+                @ip = Resolv.getaddress(@hostname)
+                @options.io[@ip] || @options.io["#{@ip}:#{@port}"]
+              else
+                @ip = @hostname
+                @options.io
+        end
+        unless @io.nil?
+          @keep_open = true
+          @state = :connected
+        end
+      else
+        @ip = Resolv.getaddress(@hostname)
+      end
+      @io ||= build_socket
+    end
+
+    def scheme
+      "http"
+    end
+
+    def to_io
+      @io.to_io
+    end
+
+    def protocol
+      @fallback_protocol
+    end
+
+    def connect
+      return unless closed?
+      begin
+        if @io.closed?
+          transition(:idle)
+          @io = build_socket
+        end
+        @io.connect_nonblock(Socket.sockaddr_in(@port, @ip))
+      rescue Errno::EISCONN
+      end
+      transition(:connected)
+    rescue Errno::EINPROGRESS,
+           Errno::EALREADY,
+           ::IO::WaitReadable
+    end
+
+    if RUBY_VERSION < "2.3"
+      def read(size, buffer)
+        @io.read_nonblock(size, buffer)
+        buffer.bytesize
+      rescue ::IO::WaitReadable
+        0
+      rescue EOFError
+        nil
+      end
+
+      def write(buffer)
+        siz = @io.write_nonblock(buffer)
+        buffer.slice!(0, siz)
+        siz
+      rescue ::IO::WaitWritable
+        0
+      rescue EOFError
+        nil
+      end
+    else
+      def read(size, buffer)
+        ret = @io.read_nonblock(size, buffer, exception: false)
+        return 0 if ret == :wait_readable
+        return if ret.nil?
+        buffer.bytesize
+      end
+
+      def write(buffer)
+        siz = @io.write_nonblock(buffer, exception: false)
+        return 0 if siz == :wait_writable
+        return if siz.nil?
+        buffer.slice!(0, siz)
+        siz
+      end
+    end
+
+    def close
+      return if @keep_open || closed?
+      begin
+        @io.close
+      ensure
+        transition(:closed)
+      end
+    end
+
+    def connected?
+      @state == :connected
+    end
+
+    def closed?
+      @state == :idle || @state == :closed
+    end
+
+    def inspect
+      id = @io.closed? ? "closed" : @io.fileno
+      "#<TCP(fd: #{id}): #{@ip}:#{@port} (state: #{@state})>"
+    end
+
+    private
+
+    def build_socket
+      addr = IPAddr.new(@ip)
+      Socket.new(addr.family, :STREAM, 0)
+    end
+
+    def transition(nextstate)
+      case nextstate
+      # when :idle
+      when :connected
+        return unless @state == :idle
+      when :closed
+        return unless @state == :connected
+      end
+      do_transition(nextstate)
+    end
+
+    def do_transition(nextstate)
+      log(level: 1, label: "#{inspect}: ") { nextstate.to_s }
+      @state = nextstate
+    end
+  end
+end

data/lib/httpx/io/unix.rb

@@ -0,0 +1,56 @@
+require "forwardable"
+
+module HTTPX
+  class UNIX < TCP
+    extend Forwardable
+
+    def_delegator :@uri, :port, :scheme
+
+    def initialize(uri, options)
+      @uri = uri
+      @state = :idle
+      @options = Options.new(options)
+      @path = @options.transport_options[:path]
+      @fallback_protocol = @options.fallback_protocol
+      if @options.io
+        @io = case @options.io
+              when Hash
+                @options.io[@path]
+              else
+                @options.io
+        end
+        unless @io.nil?
+          @keep_open = true
+          @state = :connected
+        end
+      end
+      @io ||= build_socket
+    end
+
+    def hostname
+      @uri.host
+    end
+
+    def connect
+      return unless closed?
+      begin
+        if @io.closed?
+          transition(:idle)
+          @io = build_socket
+        end
+        @io.connect_nonblock(Socket.sockaddr_un(@path))
+      rescue Errno::EISCONN
+      end
+      transition(:connected)
+    rescue Errno::EINPROGRESS,
+           Errno::EALREADY,
+           ::IO::WaitReadable
+    end
+
+    private
+
+    def build_socket
+      Socket.new(Socket::PF_UNIX, :STREAM, 0)
+    end
+  end
+end

data/lib/httpx/options.rb

@@ -3,7 +3,6 @@
 module HTTPX
   class Options
     MAX_CONCURRENT_REQUESTS = 100
-    MAX_RETRIES = 3
     WINDOW_SIZE = 1 << 14 # 16K
     MAX_BODY_THRESHOLD_SIZE = (1 << 10) * 112 # 112K
 
@@ -47,7 +46,6 @@ module HTTPX
         :timeout                  => Timeout.new,
         :headers                  => {},
         :max_concurrent_requests  => MAX_CONCURRENT_REQUESTS,
-        :max_retries              => MAX_RETRIES,
         :window_size              => WINDOW_SIZE,
         :body_threshold_size      => MAX_BODY_THRESHOLD_SIZE,
         :request_class            => Class.new(Request),
@@ -55,6 +53,8 @@ module HTTPX
         :headers_class            => Class.new(Headers),
         :request_body_class       => Class.new(Request::Body),
         :response_body_class      => Class.new(Response::Body),
+        :transport                => nil,
+        :transport_options        => nil,
       }
 
       defaults.merge!(options)
@@ -84,11 +84,17 @@ module HTTPX
       self.body_threshold_size = Integer(num)
     end
 
+    def_option(:transport) do |tr|
+      transport = tr.to_s
+      raise Error, "#{transport} is an unsupported transport type" unless IO.registry.keys.include?(transport)
+      self.transport = transport
+    end
+
     %w[
       params form json body
-      follow ssl http2_settings max_retries
+      follow ssl http2_settings
       request_class response_class headers_class request_body_class response_body_class
-      io fallback_protocol debug debug_level
+      io fallback_protocol debug debug_level transport_options
     ].each do |method_name|
       def_option(method_name)
     end

data/lib/httpx/plugins/follow_redirects.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 module HTTPX
+  InsecureRedirectError = Class.new(Error)
   module Plugins
     module FollowRedirects
       module InstanceMethods
@@ -48,9 +49,24 @@ module HTTPX
 
         private
 
+        def fetch_response(request)
+          response = super
+          if response &&
+             REDIRECT_STATUS.include?(response.status) &&
+             !@options.follow_insecure_redirects
+            redirect_uri = __get_location_from_response(response)
+            if response.uri.scheme == "https" &&
+               redirect_uri.scheme == "http"
+              error = InsecureRedirectError.new(redirect_uri.to_s)
+              error.set_backtrace(caller)
+              response = ErrorResponse.new(error, @options)
+            end
+          end
+          response
+        end
+
         def __build_redirect_req(request, response, options)
-          redirect_uri = URI(response.headers["location"])
-          redirect_uri = response.uri.merge(redirect_uri) if redirect_uri.relative?
+          redirect_uri = __get_location_from_response(response)
 
           # TODO: integrate cookies in the next request
           # redirects are **ALWAYS** GET
@@ -58,12 +74,24 @@ module HTTPX
                                         body: request.body)
           __build_req(:get, redirect_uri, retry_options)
         end
+
+        def __get_location_from_response(response)
+          location_uri = URI(response.headers["location"])
+          location_uri = response.uri.merge(location_uri) if location_uri.relative?
+          location_uri
+        end
       end
 
       module OptionsMethods
         def self.included(klass)
           super
-          klass.def_option(:max_redirects)
+          klass.def_option(:max_redirects) do |num|
+            num = Integer(num)
+            raise Error, ":max_redirects must be positive" unless num.positive?
+            num
+          end
+
+          klass.def_option(:follow_insecure_redirects)
         end
       end
     end

data/lib/httpx/plugins/proxy.rb

@@ -34,10 +34,15 @@ module HTTPX
         private
 
         def proxy_params(uri)
-          return @options.proxy if @options.proxy
-          uri = URI(uri).find_proxy
-          return unless uri
-          { uri: uri }
+          @_proxy_uris ||= begin
+            uris = @options.proxy ? Array(@options.proxy[:uri]) : []
+            if uris.empty?
+              uri = URI(uri).find_proxy
+              uris << uri if uri
+            end
+            uris
+          end
+          @options.proxy.merge(uri: @_proxy_uris.shift) unless @_proxy_uris.empty?
         end
 
         def find_channel(request, **options)
@@ -55,12 +60,27 @@ module HTTPX
           parameters = Parameters.new(**proxy)
           uri = parameters.uri
           log { "proxy: #{uri}" }
-          io = TCP.new(uri.host, uri.port, @options)
+          io = TCP.new(uri, @options)
           proxy_type = Parameters.registry(parameters.uri.scheme)
           channel = proxy_type.new(io, parameters, @options.merge(options), &method(:on_response))
           @connection.__send__(:register_channel, channel)
           channel
         end
+
+        def fetch_response(request)
+          response = super
+          if response.is_a?(ErrorResponse) &&
+             # either it was a timeout error connecting, or it was a proxy error
+             (((response.error.is_a?(TimeoutError) || response.error.is_a?(IOError)) && request.state == :idle) ||
+              response.error.is_a?(Error)) &&
+             !@_proxy_uris.empty?
+            log { "failed connecting to proxy, trying next..." }
+            channel = find_channel(request)
+            channel.send(request)
+            return
+          end
+          response
+        end
       end
 
       module OptionsMethods
@@ -91,6 +111,10 @@ module HTTPX
       true
     end
 
+    def send(request, **args)
+      @pending << [request, args]
+    end
+
     def to_io
       case @state
       when :idle
@@ -108,12 +132,19 @@ module HTTPX
         consume
       end
     end
+
+    def reset
+      @state = :open
+      transition(:closing)
+      transition(:closed)
+      emit(:close)
+    end
   end
 
   class ProxySSL < SSL
     def initialize(tcp, request_uri, options)
       @io = tcp.to_io
-      super(tcp.ip, tcp.port, options)
+      super(tcp, options)
       @hostname = request_uri.host
       @state = :connected
     end

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

@@ -30,11 +30,7 @@ module HTTPX
               transition(:connected)
               throw(:called)
             else
-              response = ErrorResponse.new(Error.new("socks error: #{status}"), 0, @options)
-              until @pending.empty?
-                req, _ = @pending.shift
-                emit(:response, req, response)
-              end
+              on_socks_error("socks error: #{status}")
             end
           end
 
@@ -53,9 +49,16 @@ module HTTPX
               return unless @state == :connecting
               @parser = nil
             end
-            log(level: 1, label: "SOCKS4: ") { "#{nextstate}: #{@write_buffer.to_s.inspect}" }
+            log(level: 1, label: "SOCKS4: ") { "#{nextstate}: #{@write_buffer.to_s.inspect}" } unless nextstate == :open
             super
           end
+
+          def on_socks_error(message)
+            ex = Error.new(message)
+            ex.set_backtrace(caller)
+            on_error(ex)
+            throw(:called)
+          end
         end
         Parameters.register("socks4", Socks4ProxyChannel)
         Parameters.register("socks4a", Socks4ProxyChannel)

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

@@ -45,7 +45,7 @@ module HTTPX
                 transition(:authenticating)
                 return
               when NONE
-                on_error_response("no supported authorization methods")
+                on_socks_error("no supported authorization methods")
               else
                 transition(:negotiating)
               end
@@ -53,11 +53,11 @@ module HTTPX
               version, status = packet.unpack("CC")
               check_version(version)
               return transition(:negotiating) if status == SUCCESS
-              on_error_response("socks authentication error: #{status}")
+              on_socks_error("socks authentication error: #{status}")
             when :negotiating
               version, reply, = packet.unpack("CC")
               check_version(version)
-              return on_error_response("socks5 negotiation error: #{reply}") unless reply == SUCCESS
+              on_socks_error("socks5 negotiation error: #{reply}") unless reply == SUCCESS
               req, _ = @pending.first
               request_uri = req.uri
               @io = ProxySSL.new(@io, request_uri, @options) if request_uri.scheme == "https"
@@ -86,22 +86,22 @@ module HTTPX
               return unless @state == :negotiating
               @parser = nil
             end
-            log(level: 1, label: "SOCKS5: ") { "#{nextstate}: #{@write_buffer.to_s.inspect}" }
+            log(level: 1, label: "SOCKS5: ") { "#{nextstate}: #{@write_buffer.to_s.inspect}" } unless nextstate == :open
             super
           end
 
           def check_version(version)
-            raise Error, "invalid SOCKS version (#{version})" if version != 5
+            on_socks_error("invalid SOCKS version (#{version})") if version != 5
           end
 
-          def on_error_response(error)
-            response = ErrorResponse.new(Error.new(error), 0, @options)
-            until @pending.empty?
-              req, _ = @pending.shift
-              emit(:response, req, response)
-            end
+          def on_socks_error(message)
+            ex = Error.new(message)
+            ex.set_backtrace(caller)
+            on_error(ex)
+            throw(:called)
           end
         end
+
         Parameters.register("socks5", Socks5ProxyChannel)
 
         class SocksParser

data/lib/httpx/plugins/retries.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module HTTPX
+  module Plugins
+    module Retries
+      MAX_RETRIES = 3
+      IDEMPOTENT_METHODS = %i[get options head put delete].freeze
+
+      module InstanceMethods
+        def max_retries(n)
+          branch(default_options.with_max_retries(n.to_i))
+        end
+
+        private
+
+        def fetch_response(request)
+          response = super
+          if response.is_a?(ErrorResponse) &&
+             request.retries.positive? &&
+             IDEMPOTENT_METHODS.include?(request.verb)
+            request.retries -= 1
+            channel = find_channel(request)
+            channel.send(request)
+            return
+          end
+          response
+        end
+      end
+
+      module RequestMethods
+        attr_accessor :retries
+
+        def initialize(*args)
+          super
+          @retries = @options.max_retries || MAX_RETRIES
+        end
+      end
+
+      module OptionsMethods
+        def self.included(klass)
+          super
+          klass.def_option(:max_retries) do |num|
+            num = Integer(num)
+            raise Error, ":max_retries must be positive" unless num.positive?
+            num
+          end
+        end
+      end
+    end
+    register_plugin :retries, Retries
+  end
+end

data/lib/httpx/request.rb

@@ -43,7 +43,7 @@ module HTTPX
 
     def initialize(verb, uri, options = {})
       @verb    = verb.to_s.downcase.to_sym
-      @uri     = URI(uri)
+      @uri     = URI(URI.escape(uri.to_s))
       @options = Options.new(options)
 
       raise(Error, "unknown method: #{verb}") unless METHODS.include?(@verb)
@@ -65,7 +65,7 @@ module HTTPX
     end
 
     def path
-      path = uri.path
+      path = uri.path.dup
       path << "/" if path.empty?
       path << "?#{query}" unless query.empty?
       path

data/lib/httpx/response.rb

@@ -216,14 +216,12 @@ module HTTPX
   class ErrorResponse
     include Loggable
 
-    attr_reader :error, :retries
+    attr_reader :error
 
-    def initialize(error, retries, options)
+    def initialize(error, options)
       @error = error
-      @retries = retries
       @options = Options.new(options)
       log { "#{error.class}: #{error}" }
-      log { caller.join("\n") }
     end
 
     def status
@@ -233,9 +231,5 @@ module HTTPX
     def raise_for_status
       raise @error
     end
-
-    def retryable?
-      @retries.positive?
-    end
   end
 end

data/lib/httpx/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: httpx
 version: !ruby/object:Gem::Version
-  version: 0.0.5
+  version: 0.1.0
 platform: ruby
 authors:
 - Tiago Cardoso
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-04-03 00:00:00.000000000 Z
+date: 2018-07-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: http-2
@@ -94,8 +94,9 @@ 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/io/ssl.rb
+- lib/httpx/io/tcp.rb
+- lib/httpx/io/unix.rb
 - lib/httpx/loggable.rb
 - lib/httpx/options.rb
 - lib/httpx/plugins/authentication.rb
@@ -113,6 +114,7 @@ files:
 - lib/httpx/plugins/proxy/socks4.rb
 - lib/httpx/plugins/proxy/socks5.rb
 - lib/httpx/plugins/push_promise.rb
+- lib/httpx/plugins/retries.rb
 - lib/httpx/plugins/stream.rb
 - lib/httpx/registry.rb
 - lib/httpx/request.rb
@@ -145,7 +147,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.6.14.1
+rubygems_version: 2.7.6
 signing_key: 
 specification_version: 4
 summary: HTTPX, to the future, and beyond

data/lib/httpx/io/resolver.rb

@@ -1,135 +0,0 @@
-# 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) || 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}" }
-        @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) }
-
-      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 StandardError
-    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 StandardError
-    end
-  end
-end

data/lib/httpx/io/udp.rb

@@ -1,65 +0,0 @@
-# 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