httpx 0.20.0 → 1.3.1

data/lib/httpx/callbacks.rb

@@ -4,6 +4,7 @@ module HTTPX
   module Callbacks
     def on(type, &action)
       callbacks(type) << action
+      self
     end
 
     def once(type, &block)
@@ -11,6 +12,7 @@ module HTTPX
         block.call(*args, &callback)
         :delete
       end
+      self
     end
 
     def only(type, &block)
@@ -22,12 +24,12 @@ module HTTPX
       callbacks(type).delete_if { |pr| :delete == pr.call(*args) } # rubocop:disable Style/YodaCondition
     end
 
-    protected
-
     def callbacks_for?(type)
-      @callbacks.key?(type) && !@callbacks[type].empty?
+      @callbacks.key?(type) && @callbacks[type].any?
     end
 
+    protected
+
     def callbacks(type = nil)
       return @callbacks unless type
 

data/lib/httpx/chainable.rb

@@ -1,89 +1,104 @@
 # frozen_string_literal: true
 
 module HTTPX
+  # Session mixin, implements most of the APIs that the users call.
+  # delegates to a default session when extended.
   module Chainable
-    %i[head get post put delete trace options connect patch].each do |meth|
+    %w[head get post put delete trace options connect patch].each do |meth|
       class_eval(<<-MOD, __FILE__, __LINE__ + 1)
-        def #{meth}(*uri, **options)        # def get(*uri, **options)
-          request(:#{meth}, uri, **options) #   request(:get, uri, **options)
-        end                                 # end
+        def #{meth}(*uri, **options)                # def get(*uri, **options)
+          request("#{meth.upcase}", uri, **options) #   request("GET", uri, **options)
+        end                                         # end
       MOD
     end
 
+    # delegates to the default session (see HTTPX::Session#request).
     def request(*args, **options)
       branch(default_options).request(*args, **options)
     end
 
-    # :nocov:
-    def timeout(**args)
-      warn ":#{__method__} is deprecated, use :with_timeout instead"
-      with(timeout: args)
-    end
-
-    def headers(headers)
-      warn ":#{__method__} is deprecated, use :with_headers instead"
-      with(headers: headers)
-    end
-    # :nocov:
-
     def accept(type)
       with(headers: { "accept" => String(type) })
     end
 
+    # delegates to the default session (see HTTPX::Session#wrap).
     def wrap(&blk)
       branch(default_options).wrap(&blk)
     end
 
+    # returns a new instance loaded with the +pl+ plugin and +options+.
     def plugin(pl, options = nil, &blk)
-      klass = is_a?(Session) ? self.class : Session
+      klass = is_a?(S) ? self.class : Session
       klass = Class.new(klass)
       klass.instance_variable_set(:@default_options, klass.default_options.merge(default_options))
       klass.plugin(pl, options, &blk).new
     end
 
-    # deprecated
-    # :nocov:
-    def plugins(pls)
-      warn ":#{__method__} is deprecated, use :plugin instead"
-      klass = is_a?(Session) ? self.class : Session
-      klass = Class.new(klass)
-      klass.instance_variable_set(:@default_options, klass.default_options.merge(default_options))
-      klass.plugins(pls).new
-    end
-    # :nocov:
-
+    # returns a new instance loaded with +options+.
     def with(options, &blk)
       branch(default_options.merge(options), &blk)
     end
 
     private
 
+    # returns default instance of HTTPX::Options.
     def default_options
       @options || Session.default_options
     end
 
+    # returns a default instance of HTTPX::Session.
     def branch(options, &blk)
-      return self.class.new(options, &blk) if is_a?(Session)
+      return self.class.new(options, &blk) if is_a?(S)
 
       Session.new(options, &blk)
     end
 
-    def method_missing(meth, *args, **options)
-      return super unless meth =~ /\Awith_(.+)/
+    def method_missing(meth, *args, **options, &blk)
+      case meth
+      when /\Awith_(.+)/
 
-      option = Regexp.last_match(1)
+        option = Regexp.last_match(1)
 
-      return super unless option
+        return super unless option
 
-      with(option.to_sym => (args.first || options))
-    end
+        with(option.to_sym => args.first || options)
+      when /\Aon_(.+)/
+        callback = Regexp.last_match(1)
 
-    def respond_to_missing?(meth, *)
-      return super unless meth =~ /\Awith_(.+)/
+        return super unless %w[
+          connection_opened connection_closed
+          request_error
+          request_started request_body_chunk request_completed
+          response_started response_body_chunk response_completed
+        ].include?(callback)
 
-      option = Regexp.last_match(1)
+        warn "DEPRECATION WARNING: calling `.#{meth}` on plain HTTPX sessions is deprecated. " \
+             "Use HTTPX.plugin(:callbacks).#{meth} instead."
 
-      default_options.respond_to?(option) || super
+        plugin(:callbacks).__send__(meth, *args, **options, &blk)
+      else
+        super
+      end
+    end
+
+    def respond_to_missing?(meth, *)
+      case meth
+      when /\Awith_(.+)/
+        option = Regexp.last_match(1)
+
+        default_options.respond_to?(option) || super
+      when /\Aon_(.+)/
+        callback = Regexp.last_match(1)
+
+        %w[
+          connection_opened connection_closed
+          request_error
+          request_started request_body_chunk request_completed
+          response_started response_body_chunk response_completed
+        ].include?(callback) || super
+      else
+        super
+      end
     end
   end
 end

data/lib/httpx/connection/http1.rb

@@ -7,15 +7,17 @@ module HTTPX
     include Callbacks
     include Loggable
 
-    MAX_REQUESTS = 100
+    MAX_REQUESTS = 200
     CRLF = "\r\n"
 
     attr_reader :pending, :requests
 
+    attr_accessor :max_concurrent_requests
+
     def initialize(buffer, options)
-      @options = Options.new(options)
+      @options = options
       @max_concurrent_requests = @options.max_concurrent_requests || MAX_REQUESTS
-      @max_requests = @options.max_requests || MAX_REQUESTS
+      @max_requests = @options.max_requests
       @parser = Parser::HTTP1.new(self)
       @buffer = buffer
       @version = [1, 1]
@@ -47,6 +49,7 @@ module HTTPX
       @max_requests = @options.max_requests || MAX_REQUESTS
       @parser.reset!
       @handshake_completed = false
+      @pending.concat(@requests) unless @requests.empty?
     end
 
     def close
@@ -106,6 +109,7 @@ module HTTPX
 
     def on_headers(h)
       @request = @requests.first
+
       return if @request.response
 
       log(level: 2) { "headers received" }
@@ -118,7 +122,7 @@ module HTTPX
       log(color: :yellow) { response.headers.each.map { |f, v| "-> HEADER: #{f}: #{v}" }.join("\n") }
 
       @request.response = response
-      on_complete if response.complete?
+      on_complete if response.finished?
     end
 
     def on_trailers(h)
@@ -132,32 +136,42 @@ module HTTPX
     end
 
     def on_data(chunk)
-      return unless @request
+      request = @request
+
+      return unless request
 
       log(color: :green) { "-> DATA: #{chunk.bytesize} bytes..." }
       log(level: 2, color: :green) { "-> #{chunk.inspect}" }
-      response = @request.response
+      response = request.response
 
       response << chunk
+    rescue StandardError => e
+      error_response = ErrorResponse.new(request, e)
+      request.response = error_response
+      dispatch
     end
 
     def on_complete
-      return unless @request
+      request = @request
+
+      return unless request
 
       log(level: 2) { "parsing complete" }
       dispatch
     end
 
     def dispatch
-      if @request.expects?
+      request = @request
+
+      if request.expects?
         @parser.reset!
-        return handle(@request)
+        return handle(request)
       end
 
-      request = @request
       @request = nil
       @requests.shift
       response = request.response
+      response.finish! unless response.is_a?(ErrorResponse)
       emit(:response, request, response)
 
       if @parser.upgrade?
@@ -167,12 +181,23 @@ module HTTPX
 
       @parser.reset!
       @max_requests -= 1
-      manage_connection(response)
+      if response.is_a?(ErrorResponse)
+        disable
+      else
+        manage_connection(request, response)
+      end
 
-      send(@pending.shift) unless @pending.empty?
+      if exhausted?
+        @pending.concat(@requests)
+        @requests.clear
+
+        emit(:exhausted)
+      else
+        send(@pending.shift) unless @pending.empty?
+      end
     end
 
-    def handle_error(ex)
+    def handle_error(ex, request = nil)
       if (ex.is_a?(EOFError) || ex.is_a?(TimeoutError)) && @request && @request.response &&
          !@request.response.headers.key?("content-length") &&
          !@request.response.headers.key?("transfer-encoding")
@@ -186,23 +211,28 @@ module HTTPX
       if @pipelining
         catch(:called) { disable }
       else
-        @requests.each do |request|
-          emit(:error, request, ex)
+        @requests.each do |req|
+          next if request && request == req
+
+          emit(:error, req, ex)
         end
-        @pending.each do |request|
-          emit(:error, request, ex)
+        @pending.each do |req|
+          next if request && request == req
+
+          emit(:error, req, ex)
         end
       end
     end
 
     def ping
+      reset
       emit(:reset)
       emit(:exhausted)
     end
 
     private
 
-    def manage_connection(response)
+    def manage_connection(request, response)
       connection = response.headers["connection"]
       case connection
       when /keep-alive/i
@@ -219,7 +249,7 @@ module HTTPX
         return unless keep_alive
 
         parameters = Hash[keep_alive.split(/ *, */).map do |pair|
-          pair.split(/ *= */)
+          pair.split(/ *= */, 2)
         end]
         @max_requests = parameters["max"].to_i - 1 if parameters.key?("max")
 
@@ -232,7 +262,7 @@ module HTTPX
         disable
       when nil
         # In HTTP/1.1, it's keep alive by default
-        return if response.version == "1.1"
+        return if response.version == "1.1" && request.headers["connection"] != "close"
 
         disable
       end
@@ -240,6 +270,7 @@ module HTTPX
 
     def disable
       disable_pipelining
+      reset
       emit(:reset)
       throw(:called)
     end
@@ -270,29 +301,31 @@ module HTTPX
         request.body.chunk!
       end
 
-      connection = request.headers["connection"]
+      extra_headers = {}
 
-      connection ||= if request.options.persistent
-        # when in a persistent connection, the request can't be at
-        # the edge of a renegotiation
-        if @requests.index(request) + 1 < @max_requests
-          "keep-alive"
-        else
-          "close"
-        end
-      else
-        # when it's not a persistent connection, it sets "Connection: close" always
-        # on the last request of the possible batch (either allowed max requests,
-        # or if smaller, the size of the batch itself)
-        requests_limit = [@max_requests, @requests.size].min
-        if request == @requests[requests_limit - 1]
-          "close"
+      unless request.headers.key?("connection")
+        connection_value = if request.persistent?
+          # when in a persistent connection, the request can't be at
+          # the edge of a renegotiation
+          if @requests.index(request) + 1 < @max_requests
+            "keep-alive"
+          else
+            "close"
+          end
         else
-          "keep-alive"
+          # when it's not a persistent connection, it sets "Connection: close" always
+          # on the last request of the possible batch (either allowed max requests,
+          # or if smaller, the size of the batch itself)
+          requests_limit = [@max_requests, @requests.size].min
+          if request == @requests[requests_limit - 1]
+            "close"
+          else
+            "keep-alive"
+          end
         end
-      end
 
-      extra_headers = { "connection" => connection }
+        extra_headers["connection"] = connection_value
+      end
       extra_headers["host"] = request.authority unless request.headers.key?("host")
       extra_headers
     end
@@ -311,7 +344,7 @@ module HTTPX
     end
 
     def join_headline(request)
-      "#{request.verb.to_s.upcase} #{request.path} HTTP/#{@version.join(".")}"
+      "#{request.verb} #{request.path} HTTP/#{@version.join(".")}"
     end
 
     def join_headers(request)
@@ -348,23 +381,21 @@ module HTTPX
     end
 
     def join_headers2(headers)
-      buffer = "".b
       headers.each do |field, value|
-        buffer << "#{capitalized(field)}: #{value}" << CRLF
+        buffer = "#{capitalized(field)}: #{value}#{CRLF}"
         log(color: :yellow) { "<- HEADER: #{buffer.chomp}" }
         @buffer << buffer
-        buffer.clear
       end
     end
 
     UPCASED = {
       "www-authenticate" => "WWW-Authenticate",
       "http2-settings" => "HTTP2-Settings",
+      "content-md5" => "Content-MD5",
     }.freeze
 
     def capitalized(field)
       UPCASED[field] || field.split("-").map(&:capitalize).join("-")
     end
   end
-  Connection.register "http/1.1", Connection::HTTP1
 end

data/lib/httpx/connection/http2.rb

@@ -1,14 +1,14 @@
 # frozen_string_literal: true
 
 require "securerandom"
-require "http/2/next"
+require "http/2"
 
 module HTTPX
   class Connection::HTTP2
     include Callbacks
     include Loggable
 
-    MAX_CONCURRENT_REQUESTS = HTTP2Next::DEFAULT_MAX_CONCURRENT_STREAMS
+    MAX_CONCURRENT_REQUESTS = ::HTTP2::DEFAULT_MAX_CONCURRENT_STREAMS
 
     class Error < Error
       def initialize(id, code)
@@ -25,7 +25,7 @@ module HTTPX
     attr_reader :streams, :pending
 
     def initialize(buffer, options)
-      @options = Options.new(options)
+      @options = options
       @settings = @options.http2_settings
       @pending = []
       @streams = {}
@@ -35,7 +35,7 @@ module HTTPX
       @handshake_completed = false
       @wait_for_handshake = @settings.key?(:wait_for_handshake) ? @settings.delete(:wait_for_handshake) : true
       @max_concurrent_requests = @options.max_concurrent_requests || MAX_CONCURRENT_REQUESTS
-      @max_requests = @options.max_requests || 0
+      @max_requests = @options.max_requests
       init_connection
     end
 
@@ -55,7 +55,7 @@ module HTTPX
         return :w
       end
 
-      unless (@connection.state == :connected && @handshake_completed)
+      unless @connection.state == :connected && @handshake_completed
         return @buffer.empty? ? :r : :rw
       end
 
@@ -73,8 +73,11 @@ module HTTPX
     end
 
     def close
-      @connection.goaway unless @connection.state == :closed
-      emit(:close)
+      unless @connection.state == :closed
+        @connection.goaway
+        emit(:timeout, @options.timeout[:close_handshake_timeout])
+      end
+      emit(:close, true)
     end
 
     def empty?
@@ -82,9 +85,7 @@ module HTTPX
     end
 
     def exhausted?
-      return false if @max_requests.zero? && @connection.active_stream_count.zero?
-
-      @connection.active_stream_count >= @max_requests
+      !@max_requests.positive?
     end
 
     def <<(data)
@@ -92,13 +93,9 @@ module HTTPX
     end
 
     def can_buffer_more_requests?
-      if @handshake_completed
+      (@handshake_completed || !@wait_for_handshake) &&
         @streams.size < @max_concurrent_requests &&
-          @streams.size < @max_requests
-      else
-        !@wait_for_handshake &&
-          @streams.size < @max_concurrent_requests
-      end
+        @streams.size < @max_requests
     end
 
     def send(request)
@@ -114,9 +111,8 @@ module HTTPX
       end
       handle(request, stream)
       true
-    rescue HTTP2Next::Error::StreamLimitExceeded
+    rescue ::HTTP2::Error::StreamLimitExceeded
       @pending.unshift(request)
-      emit(:exhausted)
     end
 
     def consume
@@ -127,7 +123,7 @@ module HTTPX
       end
     end
 
-    def handle_error(ex)
+    def handle_error(ex, request = nil)
       if ex.instance_of?(TimeoutError) && !@handshake_completed && @connection.state != :closed
         @connection.goaway(:settings_timeout, "closing due to settings timeout")
         emit(:close_handshake)
@@ -135,11 +131,15 @@ module HTTPX
         settings_ex.set_backtrace(ex.backtrace)
         ex = settings_ex
       end
-      @streams.each_key do |request|
-        emit(:error, request, ex)
+      @streams.each_key do |req|
+        next if request && request == req
+
+        emit(:error, req, ex)
       end
-      @pending.each do |request|
-        emit(:error, request, ex)
+      @pending.each do |req|
+        next if request && request == req
+
+        emit(:error, req, ex)
       end
     end
 
@@ -154,6 +154,7 @@ module HTTPX
 
     def send_pending
       while (request = @pending.shift)
+        # TODO: this request should go back to top of stack
         break unless send(request)
       end
     end
@@ -171,8 +172,7 @@ module HTTPX
     end
 
     def init_connection
-      @connection = HTTP2Next::Client.new(@settings)
-      @connection.max_streams = @max_requests if @connection.respond_to?(:max_streams=) && @max_requests.positive?
+      @connection = ::HTTP2::Client.new(@settings)
       @connection.on(:frame, &method(:on_frame))
       @connection.on(:frame_sent, &method(:on_frame_sent))
       @connection.on(:frame_received, &method(:on_frame_received))
@@ -208,7 +208,7 @@ module HTTPX
     def set_protocol_headers(request)
       {
         ":scheme" => request.scheme,
-        ":method" => request.verb.to_s.upcase,
+        ":method" => request.verb,
         ":path" => request.path,
         ":authority" => request.authority,
       }
@@ -313,11 +313,12 @@ module HTTPX
       if error
         ex = Error.new(stream.id, error)
         ex.set_backtrace(caller)
-        response = ErrorResponse.new(request, ex, request.options)
+        response = ErrorResponse.new(request, ex)
+        request.response = response
         emit(:response, request, response)
       else
         response = request.response
-        if response && response.status == 421
+        if response && response.is_a?(Response) && response.status == 421
           ex = MisdirectedRequestError.new(response)
           ex.set_backtrace(caller)
           emit(:error, request, ex)
@@ -339,14 +340,7 @@ module HTTPX
     def on_settings(*)
       @handshake_completed = true
       emit(:current_timeout)
-
-      if @max_requests.zero?
-        @max_requests = @connection.remote_settings[:settings_max_concurrent_streams]
-
-        @connection.max_streams = @max_requests if @connection.respond_to?(:max_streams=) && @max_requests.positive?
-      end
-
-      @max_concurrent_requests = [@max_concurrent_requests, @max_requests].min
+      @max_concurrent_requests = [@max_concurrent_requests, @connection.remote_settings[:settings_max_concurrent_streams]].min
       send_pending
     end
 
@@ -365,7 +359,7 @@ module HTTPX
         ex.set_backtrace(caller)
         handle_error(ex)
       end
-      return unless is_connection_closed && @streams.size.zero?
+      return unless is_connection_closed && @streams.empty?
 
       emit(:close, is_connection_closed)
     end
@@ -412,5 +406,4 @@ module HTTPX
       end
     end
   end
-  Connection.register "h2", Connection::HTTP2
 end