httpx 0.3.1 → 0.4.0

data/lib/httpx/{channel → connection}/http1.rb

@@ -3,7 +3,7 @@
 require "httpx/parser/http1"
 
 module HTTPX
-  class Channel::HTTP1
+  class Connection::HTTP1
     include Callbacks
     include Loggable
 
@@ -39,7 +39,7 @@ module HTTPX
       @parser << data
     end
 
-    def send(request, **)
+    def send(request)
       if @max_requests.positive? &&
          @requests.size >= @max_concurrent_requests
         @pending << request
@@ -79,11 +79,11 @@ module HTTPX
       return if @request.response
 
       log(level: 2) { "headers received" }
-      headers = @options.headers_class.new(h)
-      response = @options.response_class.new(@request,
-                                             @parser.status_code,
-                                             @parser.http_version.join("."),
-                                             headers, @options)
+      headers = @request.options.headers_class.new(h)
+      response = @request.options.response_class.new(@request,
+                                                     @parser.status_code,
+                                                     @parser.http_version.join("."),
+                                                     headers)
       log(color: :yellow) { "-> HEADLINE: #{response.status} HTTP/#{@parser.http_version.join(".")}" }
       log(color: :yellow) { response.headers.each.map { |f, v| "-> HEADER: #{f}: #{v}" }.join("\n") }
 
@@ -93,6 +93,7 @@ module HTTPX
 
     def on_trailers(h)
       return unless @request
+
       response = @request.response
       log(level: 2) { "trailer headers received" }
 
@@ -102,6 +103,7 @@ module HTTPX
 
     def on_data(chunk)
       return unless @request
+
       log(color: :green) { "-> DATA: #{chunk.bytesize} bytes..." }
       log(level: 2, color: :green) { "-> #{chunk.inspect}" }
       response = @request.response
@@ -111,6 +113,7 @@ module HTTPX
 
     def on_complete
       return unless @request
+
       log(level: 2) { "parsing complete" }
       dispatch
     end
@@ -140,9 +143,7 @@ module HTTPX
 
     def handle_error(ex)
       if @pipelining
-        disable_pipelining
-        emit(:reset)
-        throw(:called)
+        disable
       else
         @requests.each do |request|
           emit(:error, request, ex)
@@ -158,6 +159,7 @@ module HTTPX
       when /keep\-alive/i
         keep_alive = response.headers["keep-alive"]
         return unless keep_alive
+
         parameters = Hash[keep_alive.split(/ *, */).map do |pair|
           pair.split(/ *= */)
         end]
@@ -166,16 +168,27 @@ module HTTPX
           keep_alive_timeout = parameters["timeout"].to_i
           emit(:timeout, keep_alive_timeout)
         end
-        # TODO: on keep alive timeout, reset
-      when /close/i, nil
-        disable_pipelining
+      when /close/i
         @max_requests = Float::INFINITY
-        emit(:reset)
+        disable
+      when nil
+        # In HTTP/1.1, it's keep alive by default
+        return if response.version == "1.1"
+
+        @max_requests = Float::INFINITY
+        disable
       end
     end
 
+    def disable
+      disable_pipelining
+      emit(:reset)
+      throw(:called)
+    end
+
     def disable_pipelining
       return if @requests.empty?
+
       @requests.each { |r| r.transition(:idle) }
       # server doesn't handle pipelining, and probably
       # doesn't support keep-alive. Fallback to send only
@@ -226,6 +239,7 @@ module HTTPX
 
     def join_body(request)
       return if request.empty?
+
       while (chunk = request.drain_body)
         log(color: :green) { "<- DATA: #{chunk.bytesize} bytes..." }
         log(level: 2, color: :green) { "<- #{chunk.inspect}" }
@@ -243,5 +257,5 @@ module HTTPX
       UPCASED[field] || field.to_s.split("-").map(&:capitalize).join("-")
     end
   end
-  Channel.register "http/1.1", Channel::HTTP1
+  Connection.register "http/1.1", Connection::HTTP1
 end

data/lib/httpx/{channel → connection}/http2.rb

@@ -4,7 +4,7 @@ require "io/wait"
 require "http/2"
 
 module HTTPX
-  class Channel::HTTP2
+  class Connection::HTTP2
     include Callbacks
     include Loggable
 
@@ -158,6 +158,8 @@ module HTTPX
     end
 
     def join_body(stream, request)
+      return if request.empty?
+
       chunk = @drains.delete(request) || request.drain_body
       while chunk
         next_chunk = request.drain_body
@@ -181,8 +183,8 @@ module HTTPX
         h.map { |k, v| "<- HEADER: #{k}: #{v}" }.join("\n")
       end
       _, status = h.shift
-      headers = @options.headers_class.new(h)
-      response = @options.response_class.new(request, status, "2.0", headers, @options)
+      headers = request.options.headers_class.new(h)
+      response = request.options.response_class.new(request, status, "2.0", headers)
       request.response = response
       @streams[request] = stream
     end
@@ -195,6 +197,7 @@ module HTTPX
 
     def on_stream_close(stream, request, error)
       return handle(request, stream) if request.expects?
+
       if error
         ex = Error.new(stream.id, error)
         ex.set_backtrace(caller)
@@ -230,9 +233,12 @@ module HTTPX
       if error
         ex = Error.new(0, error)
         ex.set_backtrace(caller)
-        emit(:error, request, ex)
+        @streams.each_key do |request|
+          emit(:error, request, ex)
+        end
       end
       return unless @connection.state == :closed && @connection.active_stream_count.zero?
+
       emit(:close)
     end
 
@@ -269,7 +275,7 @@ module HTTPX
     end
 
     def on_promise(stream)
-      emit(:promise, self, stream)
+      emit(:promise, @streams.key(stream.parent), stream)
     end
 
     def respond_to_missing?(meth, *args)
@@ -284,5 +290,5 @@ module HTTPX
       end
     end
   end
-  Channel.register "h2", Channel::HTTP2
+  Connection.register "h2", Connection::HTTP2
 end

data/lib/httpx/errors.rb

@@ -20,6 +20,8 @@ module HTTPX
     end
   end
 
+  TotalTimeoutError = Class.new(TimeoutError)
+
   ConnectTimeoutError = Class.new(TimeoutError)
 
   ResolveError = Class.new(Error)

data/lib/httpx/headers.rb

@@ -7,6 +7,7 @@ module HTTPX
     class << self
       def new(headers = nil)
         return headers if headers.is_a?(self)
+
         super
       end
     end
@@ -14,6 +15,7 @@ module HTTPX
     def initialize(headers = nil)
       @headers = {}
       return unless headers
+
       headers.each do |field, value|
         array_value(value).each do |v|
           add(downcased(field), v)
@@ -44,7 +46,6 @@ module HTTPX
     # ignore what the +other+ headers has. Otherwise, set
     #
     def merge(other)
-      # TODO: deep-copy
       headers = dup
       other.each do |field, value|
         headers[field] = value
@@ -64,6 +65,7 @@ module HTTPX
     #
     def []=(field, value)
       return unless value
+
       @headers[downcased(field)] = array_value(value)
     end
 
@@ -94,6 +96,7 @@ module HTTPX
     #
     def each
       return enum_for(__method__) { @headers.size } unless block_given?
+
       @headers.each do |field, value|
         yield(field, value.join(", ")) unless value.empty?
       end

data/lib/httpx/io/ssl.rb

@@ -31,6 +31,7 @@ module HTTPX
     def verify_hostname(host)
       return false if @ctx.verify_mode == OpenSSL::SSL::VERIFY_NONE
       return false if @io.peer_cert.nil?
+
       OpenSSL::SSL.verify_certificate_identity(@io.peer_cert, host)
     end
 
@@ -54,6 +55,7 @@ module HTTPX
       end
       return if @state == :negotiated ||
                 @state != :connected
+
       unless @io.is_a?(OpenSSL::SSL::SSLSocket)
         @io = OpenSSL::SSL::SSLSocket.new(@io, @ctx)
         @io.hostname = @hostname
@@ -112,8 +114,10 @@ module HTTPX
 
     def log_transition_state(nextstate)
       return super unless nextstate == :negotiated
+
       server_cert = @io.peer_cert
-      "SSL connection using #{@io.ssl_version} / #{@io.cipher.first}\n" \
+      "#{super}\n\n" \
+      "SSL connection using #{@io.ssl_version} / #{Array(@io.cipher).first}\n" \
         "ALPN, server accepted to use #{protocol}\n" \
         "Server certificate:\n" \
         " subject: #{server_cert.subject}\n" \

data/lib/httpx/io/tcp.rb

@@ -13,28 +13,29 @@ module HTTPX
 
     alias_method :host, :ip
 
-    def initialize(uri, addresses, options)
+    def initialize(origin, addresses, options)
       @state = :idle
-      @hostname = uri.host
+      @hostname = origin.host
       @addresses = addresses
-      @ip_index = @addresses.size - 1
       @options = Options.new(options)
       @fallback_protocol = @options.fallback_protocol
-      @port = uri.port
+      @port = origin.port
       if @options.io
         @io = case @options.io
               when Hash
-                @ip = @addresses[@ip_index]
-                @options.io[@ip] || @options.io["#{@ip}:#{@port}"]
+                @options.io[origin.authority]
               else
-                @ip = @hostname
                 @options.io
         end
+        _, _, _, @ip = @io.addr
+        @addresses ||= [@ip]
+        @ip_index = @addresses.size - 1
         unless @io.nil?
           @keep_open = true
           @state = :connected
         end
       else
+        @ip_index = @addresses.size - 1
         @ip = @addresses[@ip_index]
       end
       @io ||= build_socket
@@ -54,6 +55,7 @@ module HTTPX
 
     def connect
       return unless closed?
+
       begin
         if @io.closed?
           transition(:idle)
@@ -65,6 +67,7 @@ module HTTPX
       transition(:connected)
     rescue Errno::EHOSTUNREACH => e
       raise e if @ip_index <= 0
+
       @ip_index -= 1
       retry
     rescue Errno::EINPROGRESS,
@@ -96,6 +99,7 @@ module HTTPX
         ret = @io.read_nonblock(size, buffer, exception: false)
         return 0 if ret == :wait_readable
         return if ret.nil?
+
         buffer.bytesize
       end
 
@@ -103,6 +107,7 @@ module HTTPX
         siz = @io.write_nonblock(buffer, exception: false)
         return 0 if siz == :wait_writable
         return if siz.nil?
+
         buffer.slice!(0, siz)
         siz
       end
@@ -110,6 +115,7 @@ module HTTPX
 
     def close
       return if @keep_open || closed?
+
       begin
         @io.close
       ensure

data/lib/httpx/io/udp.rb

@@ -48,6 +48,7 @@ module HTTPX
         ret = @io.recvfrom_nonblock(size, 0, buffer, exception: false)
         return 0 if ret == :wait_readable
         return if ret.nil?
+
         buffer.bytesize
       rescue IOError
       end

data/lib/httpx/io/unix.rb

@@ -36,6 +36,7 @@ module HTTPX
 
     def connect
       return unless closed?
+
       begin
         if @io.closed?
           transition(:idle)

data/lib/httpx/loggable.rb

@@ -3,22 +3,47 @@
 module HTTPX
   module Loggable
     COLORS = {
-      black:   30,
-      red:     31,
-      green:   32,
-      yellow:  33,
-      blue:    34,
+      black: 30,
+      red: 31,
+      green: 32,
+      yellow: 33,
+      blue: 34,
       magenta: 35,
-      cyan:    36,
-      white:   37,
+      cyan: 36,
+      white: 37,
     }.freeze
 
     def log(level: @options.debug_level, label: "", color: nil, &msg)
       return unless @options.debug
       return unless @options.debug_level >= level
+
+      debug_stream = @options.debug
+
       message = (+label << msg.call << "\n")
-      message = "\e[#{COLORS[color]}m#{message}\e[0m" if color && @options.debug.isatty
-      @options.debug << message
+      message = "\e[#{COLORS[color]}m#{message}\e[0m" if debug_stream.respond_to?(:isatty) && debug_stream.isatty
+      debug_stream << message
+    end
+
+    if !Exception.instance_methods.include?(:full_message)
+
+      def log_exception(ex, level: @options.debug_level, label: "", color: nil)
+        return unless @options.debug
+        return unless @options.debug_level >= level
+
+        message = +"#{ex.message} (#{ex.class})"
+        message << "\n" << ex.backtrace.join("\n") unless ex.backtrace.nil?
+        log(level: level, label: label, color: color) { message }
+      end
+
+    else
+
+      def log_exception(ex, level: @options.debug_level, label: "", color: nil)
+        return unless @options.debug
+        return unless @options.debug_level >= level
+
+        log(level: level, label: label, color: color) { ex.full_message }
+      end
+
     end
   end
 end

data/lib/httpx/options.rb

@@ -16,6 +16,7 @@ module HTTPX
         # let enhanced options go through
         return options if self == Options && options.class > self
         return options if options.is_a?(self)
+
         super
       end
 
@@ -31,31 +32,35 @@ module HTTPX
         protected :"#{name}="
 
         define_method(:"with_#{name}") do |value|
-          dup { |opts| opts.send(:"#{name}=", instance_exec(value, &interpreter)) }
+          other = dup
+          other.send(:"#{name}=", other.instance_exec(value, &interpreter))
+          other
         end
       end
     end
 
     def initialize(options = {})
       defaults = {
-        :debug                    => ENV.key?("HTTPX_DEBUG") ? $stderr : nil,
-        :debug_level              => (ENV["HTTPX_DEBUG"] || 1).to_i,
-        :ssl                      => {},
-        :http2_settings           => { settings_enable_push: 0 },
-        :fallback_protocol        => "http/1.1",
-        :timeout                  => Timeout.new,
-        :headers                  => {},
-        :max_concurrent_requests  => MAX_CONCURRENT_REQUESTS,
-        :window_size              => WINDOW_SIZE,
-        :body_threshold_size      => MAX_BODY_THRESHOLD_SIZE,
-        :request_class            => Class.new(Request),
-        :response_class           => Class.new(Response),
-        :headers_class            => Class.new(Headers),
-        :request_body_class       => Class.new(Request::Body),
-        :response_body_class      => Class.new(Response::Body),
-        :transport                => nil,
-        :transport_options        => nil,
-        :resolver_class           => (ENV["HTTPX_RESOLVER"] || :native).to_sym,
+        :debug => ENV.key?("HTTPX_DEBUG") ? $stderr : nil,
+        :debug_level => (ENV["HTTPX_DEBUG"] || 1).to_i,
+        :ssl => {},
+        :http2_settings => { settings_enable_push: 0 },
+        :fallback_protocol => "http/1.1",
+        :timeout => Timeout.new,
+        :headers => {},
+        :max_concurrent_requests => MAX_CONCURRENT_REQUESTS,
+        :window_size => WINDOW_SIZE,
+        :body_threshold_size => MAX_BODY_THRESHOLD_SIZE,
+        :request_class => Class.new(Request),
+        :response_class => Class.new(Response),
+        :headers_class => Class.new(Headers),
+        :request_body_class => Class.new(Request::Body),
+        :response_body_class => Class.new(Response::Body),
+        :connection_class => Class.new(Connection),
+        :transport => nil,
+        :transport_options => nil,
+        :persistent => false,
+        :resolver_class => (ENV["HTTPX_RESOLVER"] || :native).to_sym,
       }
 
       defaults.merge!(options)
@@ -74,6 +79,7 @@ module HTTPX
     def_option(:max_concurrent_requests) do |num|
       max = Integer(num)
       raise Error, ":max_concurrent_requests must be positive" unless max.positive?
+
       self.max_concurrent_requests = max
     end
 
@@ -88,18 +94,27 @@ module HTTPX
     def_option(:transport) do |tr|
       transport = tr.to_s
       raise Error, "#{transport} is an unsupported transport type" unless IO.registry.key?(transport)
+
       self.transport = transport
     end
 
     %w[
       params form json body
       follow ssl http2_settings
-      request_class response_class headers_class request_body_class response_body_class
+      request_class response_class headers_class request_body_class response_body_class connection_class
       io fallback_protocol debug debug_level transport_options resolver_class resolver_options
+      persistent
     ].each do |method_name|
       def_option(method_name)
     end
 
+    def ==(other)
+      ivars = instance_variables | other.instance_variables
+      ivars.all? do |ivar|
+        instance_variable_get(ivar) == other.instance_variable_get(ivar)
+      end
+    end
+
     def merge(other)
       h1 = to_hash
       h2 = other.to_hash
@@ -123,17 +138,28 @@ module HTTPX
       Hash[*hash_pairs]
     end
 
-    def dup
-      dupped = super
-      dupped.headers             = headers.dup
-      dupped.ssl                 = ssl.dup
-      dupped.request_class       = request_class.dup
-      dupped.response_class      = response_class.dup
-      dupped.headers_class       = headers_class.dup
-      dupped.request_body_class  = request_body_class.dup
-      dupped.response_body_class = response_body_class.dup
-      yield(dupped) if block_given?
-      dupped
+    def initialize_dup(other)
+      self.headers             = other.headers.dup
+      self.ssl                 = other.ssl.dup
+      self.request_class       = other.request_class.dup
+      self.response_class      = other.response_class.dup
+      self.headers_class       = other.headers_class.dup
+      self.request_body_class  = other.request_body_class.dup
+      self.response_body_class = other.response_body_class.dup
+      self.connection_class    = other.connection_class.dup
+    end
+
+    def freeze
+      super
+
+      headers.freeze
+      ssl.freeze
+      request_class.freeze
+      response_class.freeze
+      headers_class.freeze
+      request_body_class.freeze
+      response_body_class.freeze
+      connection_class.freeze
     end
 
     protected