httpx 0.6.7 → 0.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: '086c7a29b7788e44b3b1e84dff63b55443e0521e7939ba680ba9334690bb3d10'
-  data.tar.gz: d8a69f563dfd7fe892e1227ad8aba6ae258b16a10b22545aa52e5127e6822ee0
+  metadata.gz: e0f44b6fc0f644a3f70b58a7051e963c5f74f9a5cb8ce6ccde0f6d2aa8909b14
+  data.tar.gz: d341c978e49312b3abe26c24845b672be5055fd4a4a2cab9e2aa9d1acf79aa63
 SHA512:
-  metadata.gz: 10ef2a61f98d0418eacef74e99f3d7cc3873bbd0f52ed1e312ea705df39eacb9cc943ceac30bc26b880f2faa05e9a5840706a311306616ae0cd417904e492b98
-  data.tar.gz: 729b0ab97ae5e5a4cb6693593218c9e2a6f10505d190dd3c87461fb77f685e833180e2583bca19fdaf8f7267952f21dc752f4b4a9abf22a8a7f67fe1c85ce3c0
+  metadata.gz: c6a9e8caa8f2424c8628153535deda5f1d8623253801ae329884ee51f10c5f0e5237d4c6e2548faa40d14c0e0e3dd982c050e6f67521a8b2a56e39a1bbab40aa
+  data.tar.gz: db1b34ff9023343b4f9580b1a72c54765cf7d446f59f96bea22ec9230825ce42cd42f0ac26ec168cd3b721e75e6cf5c2964a05afea1895a778d8f27932f61d65

data/lib/httpx/adapters/faraday.rb

@@ -153,7 +153,7 @@ module Faraday
           proxy_options = { uri: env.request.proxy }
 
           session = @session.with(options_from_env(env))
-          session = session.plugin(:proxy).with_proxy(proxy_options) if env.request.proxy
+          session = session.plugin(:proxy).with(proxy: proxy_options) if env.request.proxy
 
           responses = session.request(requests)
           Array(responses).each_with_index do |response, index|
@@ -192,7 +192,7 @@ module Faraday
         meth, uri, request_options = build_request(env)
 
         session = @session.with(options_from_env(env))
-        session = session.plugin(:proxy).with_proxy(proxy_options) if env.request.proxy
+        session = session.plugin(:proxy).with(proxy: proxy_options) if env.request.proxy
         response = session.__send__(meth, uri, **request_options)
         response.raise_for_status unless response.is_a?(::HTTPX::Response)
         save_response(env, response.status, response.body.to_s, response.headers, response.reason) do |response_headers|

data/lib/httpx/chainable.rb

@@ -12,16 +12,20 @@ module HTTPX
       branch(default_options).request(verb, uri, **options)
     end
 
+    # :nocov:
     def timeout(**args)
-      branch(default_options.with_timeout(args))
+      warn ":#{__method__} is deprecated, use :with_timeout instead"
+      branch(default_options.with(timeout: args))
     end
 
     def headers(headers)
-      branch(default_options.with_headers(headers))
+      warn ":#{__method__} is deprecated, use :with_headers instead"
+      branch(default_options.with(headers: headers))
     end
+    # :nocov:
 
     def accept(type)
-      headers("accept" => String(type))
+      with(headers: { "accept" => String(type) })
     end
 
     def wrap(&blk)
@@ -59,5 +63,18 @@ module HTTPX
 
       Session.new(options, &blk)
     end
+
+    def method_missing(meth, *args, **options)
+      if meth =~ /\Awith_(.+)/
+        option = Regexp.last_match(1).to_sym
+        with(option => (args.first || options))
+      else
+        super
+      end
+    end
+
+    def respond_to_missing?(meth, *args)
+      default_options.respond_to?(meth, *args) || super
+    end
   end
 end

data/lib/httpx/connection.rb

@@ -46,6 +46,8 @@ module HTTPX
 
     attr_reader :origin, :state, :pending, :options
 
+    attr_writer :timers
+
     def initialize(type, uri, options)
       @type = type
       @origins = [uri.origin]
@@ -80,6 +82,8 @@ module HTTPX
     def match?(uri, options)
       return false if @state == :closing || @state == :closed
 
+      return false if exhausted?
+
       (
         (
           @origins.include?(uri.origin) &&
@@ -95,6 +99,8 @@ module HTTPX
     def mergeable?(connection)
       return false if @state == :closing || @state == :closed || !@io
 
+      return false if exhausted?
+
       !(@io.addresses & connection.addresses).empty? && @options == connection.options
     end
 
@@ -110,10 +116,13 @@ module HTTPX
       end
     end
 
+    def create_idle
+      self.class.new(@type, @origin, @options)
+    end
+
     def merge(connection)
       @origins += connection.instance_variable_get(:@origins)
-      pending = connection.instance_variable_get(:@pending)
-      pending.each do |req|
+      connection.purge_pending do |req|
         send(req)
       end
     end
@@ -130,7 +139,10 @@ module HTTPX
     end
 
     def purge_pending
-      [*@parser.pending, *@pending].each do |pending|
+      pendings = []
+      pendings << @parser.pending if @parser
+      pendings << @pending
+      pendings.each do |pending|
         pending.reject! do |request|
           yield request
         end
@@ -213,6 +225,10 @@ module HTTPX
 
     private
 
+    def exhausted?
+      @parser && parser.exhausted?
+    end
+
     def consume
       catch(:called) do
         dread
@@ -285,6 +301,9 @@ module HTTPX
       parser.on(:promise) do |request, stream|
         request.emit(:promise, parser, stream)
       end
+      parser.on(:exhausted) do
+        emit(:exhausted)
+      end
       parser.on(:origin) do |origin|
         @origins << origin
       end
@@ -319,6 +338,8 @@ module HTTPX
       when :open
         return if @state == :closed
 
+        total_timeout
+
         @io.connect
         return unless @io.connected?
 
@@ -330,6 +351,11 @@ module HTTPX
         return unless @state == :closing
         return unless @write_buffer.empty?
 
+        if @total_timeout
+          @total_timeout.cancel
+          remove_instance_variable(:@total_timeout)
+        end
+
         @io.close
         @read_buffer.clear
         remove_instance_variable(:@timeout) if defined?(@timeout)
@@ -373,5 +399,18 @@ module HTTPX
         request.emit(:response, ErrorResponse.new(request, error, @options))
       end
     end
+
+    def total_timeout
+      total = @options.timeout.total_timeout
+
+      return unless total
+
+      @total_timeout ||= @timers.after(total) do
+        ex = TotalTimeoutError.new(total, "Timed out after #{total} seconds")
+        ex.set_backtrace(caller)
+        @parser.close if @parser
+        on_error(ex)
+      end
+    end
   end
 end

data/lib/httpx/connection/http1.rb

@@ -7,14 +7,15 @@ module HTTPX
     include Callbacks
     include Loggable
 
+    MAX_REQUESTS = 100
     CRLF = "\r\n"
 
     attr_reader :pending
 
     def initialize(buffer, options)
       @options = Options.new(options)
-      @max_concurrent_requests = @options.max_concurrent_requests
-      @max_requests = Float::INFINITY
+      @max_concurrent_requests = @options.max_concurrent_requests || MAX_REQUESTS
+      @max_requests = @options.max_requests || MAX_REQUESTS
       @parser = Parser::HTTP1.new(self)
       @buffer = buffer
       @version = [1, 1]
@@ -23,6 +24,7 @@ module HTTPX
     end
 
     def reset
+      @max_requests = @options.max_requests || MAX_REQUESTS
       @parser.reset!
     end
 
@@ -31,6 +33,10 @@ module HTTPX
       emit(:close)
     end
 
+    def exhausted?
+      !@max_requests.positive?
+    end
+
     def empty?
       # this means that for every request there's an available
       # partial response, so there are no in-flight requests waiting.
@@ -42,15 +48,16 @@ module HTTPX
     end
 
     def send(request)
-      if @max_requests.positive? &&
-         @requests.size >= @max_concurrent_requests
+      unless @max_requests.positive?
         @pending << request
         return
       end
+
       unless @requests.include?(request)
         @requests << request
         @pipelining = true if @requests.size > 1
       end
+
       handle(request)
     end
 
@@ -163,13 +170,11 @@ module HTTPX
           emit(:timeout, keep_alive_timeout)
         end
       when /close/i
-        @max_requests = Float::INFINITY
         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

data/lib/httpx/connection/http2.rb

@@ -8,6 +8,8 @@ module HTTPX
     include Callbacks
     include Loggable
 
+    MAX_CONCURRENT_REQUESTS = HTTP2Next::DEFAULT_MAX_CONCURRENT_STREAMS
+
     Error = Class.new(Error) do
       def initialize(id, code)
         super("stream #{id} closed with error: #{code}")
@@ -18,7 +20,8 @@ module HTTPX
 
     def initialize(buffer, options)
       @options = Options.new(options)
-      @max_concurrent_requests = @options.max_concurrent_requests
+      @max_concurrent_requests = @options.max_concurrent_requests || MAX_CONCURRENT_REQUESTS
+      @max_requests = @options.max_requests || 0
       @pending = []
       @streams = {}
       @drains  = {}
@@ -28,20 +31,25 @@ module HTTPX
     end
 
     def close
-      @connection.goaway
+      @connection.goaway unless @connection.state == :closed
     end
 
     def empty?
       @connection.state == :closed || @streams.empty?
     end
 
+    def exhausted?
+      @connection.active_stream_count >= @max_requests
+    end
+
     def <<(data)
       @connection << data
     end
 
-    def send(request, **)
+    def send(request)
       if !@handshake_completed ||
-         @streams.size >= @max_concurrent_requests
+         @streams.size >= @max_concurrent_requests ||
+         @streams.size >= @max_requests
         @pending << request
         return
       end
@@ -49,9 +57,13 @@ module HTTPX
         stream = @connection.new_stream
         handle_stream(stream, request)
         @streams[request] = stream
+        @max_requests -= 1
       end
       handle(request, stream)
       true
+    rescue HTTP2Next::Error::StreamLimitExceeded
+      @pending.unshift(request)
+      emit(:exhausted)
     end
 
     def consume
@@ -95,6 +107,7 @@ module HTTPX
 
     def init_connection
       @connection = HTTP2Next::Client.new(@options.http2_settings)
+      @connection.max_streams = @max_requests if @connection.respond_to?(:max_streams=) && @max_requests.positive?
       @connection.on(:frame, &method(:on_frame))
       @connection.on(:frame_sent, &method(:on_frame_sent))
       @connection.on(:frame_received, &method(:on_frame_received))
@@ -195,6 +208,11 @@ module HTTPX
 
       @streams.delete(request)
       send(@pending.shift) unless @pending.empty?
+      return unless @streams.empty? && exhausted?
+
+      close
+      emit(:close)
+      emit(:exhausted) unless @pending.empty?
     end
 
     def on_frame(bytes)
@@ -203,8 +221,10 @@ module HTTPX
 
     def on_settings(*)
       @handshake_completed = true
-      @max_concurrent_requests = [@max_concurrent_requests,
-                                  @connection.remote_settings[:settings_max_concurrent_streams]].min
+
+      @max_requests = [@max_requests, @connection.remote_settings[:settings_max_concurrent_streams]].max
+
+      @max_concurrent_requests = [@max_concurrent_requests, @max_requests].min
       send_pending
     end
 

data/lib/httpx/options.rb

@@ -2,7 +2,6 @@
 
 module HTTPX
   class Options
-    MAX_CONCURRENT_REQUESTS = 100
     WINDOW_SIZE = 1 << 14 # 16K
     MAX_BODY_THRESHOLD_SIZE = (1 << 10) * 112 # 112K
 
@@ -28,7 +27,14 @@ module HTTPX
         defined_options << name.to_sym
         interpreter ||= ->(v) { v }
 
-        attr_accessor name
+        attr_reader name
+
+        define_method(:"#{name}=") do |value|
+          return if value.nil?
+
+          instance_variable_set(:"@#{name}", instance_exec(value, &interpreter))
+        end
+
         protected :"#{name}="
 
         define_method(:"with_#{name}") do |value|
@@ -48,7 +54,6 @@ module HTTPX
         :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),
@@ -66,37 +71,48 @@ module HTTPX
 
       defaults.merge!(options)
       defaults[:headers] = Headers.new(defaults[:headers])
-      defaults.each { |(k, v)| self[k] = v }
+      defaults.each do |(k, v)|
+        __send__(:"#{k}=", v)
+      end
     end
 
     def_option(:headers) do |headers|
-      self.headers.merge(headers)
+      if self.headers
+        self.headers.merge(headers)
+      else
+        headers
+      end
     end
 
     def_option(:timeout) do |opts|
-      self.timeout = Timeout.new(opts)
+      Timeout.new(opts)
     end
 
     def_option(:max_concurrent_requests) do |num|
-      max = Integer(num)
-      raise Error, ":max_concurrent_requests must be positive" unless max.positive?
+      raise Error, ":max_concurrent_requests must be positive" unless num.positive?
 
-      self.max_concurrent_requests = max
+      num
+    end
+
+    def_option(:max_requests) do |num|
+      raise Error, ":max_requests must be positive" unless num.positive?
+
+      num
     end
 
     def_option(:window_size) do |num|
-      self.window_size = Integer(num)
+      Integer(num)
     end
 
     def_option(:body_threshold_size) do |num|
-      self.body_threshold_size = Integer(num)
+      Integer(num)
     end
 
     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
+      transport
     end
 
     %w[
@@ -172,11 +188,5 @@ module HTTPX
       response_body_class.freeze
       connection_class.freeze
     end
-
-    protected
-
-    def []=(option, val)
-      send(:"#{option}=", val)
-    end
   end
 end

data/lib/httpx/plugins/authentication.rb

@@ -11,7 +11,7 @@ module HTTPX
     module Authentication
       module InstanceMethods
         def authentication(token)
-          headers("authorization" => token)
+          with(headers: { "authorization" => token })
         end
       end
     end

data/lib/httpx/plugins/cookies.rb

@@ -17,14 +17,22 @@ module HTTPX
       def self.extra_options(options)
         Class.new(options.class) do
           def_option(:cookies) do |cookies|
-            return cookies if cookies.is_a?(Store)
-
-            Store.new(cookies)
+            if cookies.is_a?(Store)
+              cookies
+            else
+              Store.new(cookies)
+            end
           end
         end.new(options)
       end
 
       class Store
+        def self.new(cookies = nil)
+          return cookies if cookies.is_a?(self)
+
+          super
+        end
+
         def initialize(cookies = nil)
           @store = Hash.new { |hash, origin| hash[origin] = HTTP::CookieJar.new }
           return unless cookies
@@ -74,10 +82,6 @@ module HTTPX
           super({ cookies: Store.new }.merge(options), &blk)
         end
 
-        def with_cookies(cookies)
-          branch(default_options.with_cookies(cookies))
-        end
-
         def wrap
           return super unless block_given?
 
@@ -86,7 +90,7 @@ module HTTPX
             begin
               yield session
             ensure
-              @options = @options.with_cookies(old_cookies_store)
+              @options = @options.with(cookies: old_cookies_store)
             end
           end
         end

data/lib/httpx/plugins/expect.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module HTTPX
+  module Plugins
+    #
+    # This plugin makes all HTTP/1.1 requests with a body send the "Expect: 100-continue".
+    #
+    # https://gitlab.com/honeyryderchuck/httpx/wikis/Expect#expect
+    #
+    module Expect
+      EXPECT_TIMEOUT = 2
+
+      def self.extra_options(options)
+        Class.new(options.class) do
+          def_option(:expect_timeout) do |seconds|
+            seconds = Integer(seconds)
+            raise Error, ":expect_timeout must be positive" unless seconds.positive?
+
+            seconds
+          end
+        end.new(options).merge(expect_timeout: EXPECT_TIMEOUT)
+      end
+
+      module RequestBodyMethods
+        def initialize(*)
+          super
+          return if @body.nil?
+
+          @headers["expect"] = "100-continue"
+        end
+      end
+
+      module ConnectionMethods
+        def send(request)
+          request.once(:expects) do
+            @timers.after(@options.expect_timeout) do
+              if request.state == :expects && !request.expects?
+                request.headers.delete("expect")
+                handle(request)
+              end
+            end
+          end
+          super
+        end
+      end
+
+      module InstanceMethods
+        def fetch_response(request, connections, options)
+          response = @responses.delete(request)
+          return unless response
+
+          if response.status == 417 && request.headers.key?("expect")
+            request.headers.delete("expect")
+            request.transition(:idle)
+            connection = find_connection(request, connections, options)
+            connection.send(request)
+            return
+          end
+
+          response
+        end
+      end
+    end
+    register_plugin :expect, Expect
+  end
+end

data/lib/httpx/plugins/follow_redirects.rb

@@ -21,7 +21,7 @@ module HTTPX
         Class.new(options.class) do
           def_option(:max_redirects) do |num|
             num = Integer(num)
-            raise Error, ":max_redirects must be positive" unless num.positive?
+            raise Error, ":max_redirects must be positive" if num.negative?
 
             num
           end
@@ -61,7 +61,6 @@ module HTTPX
 
           connection = find_connection(retry_request, connections, options)
           connection.send(retry_request)
-          set_request_timeout(connection, retry_request, options)
           nil
         end
 

data/lib/httpx/plugins/h2c.rb

@@ -42,7 +42,6 @@ module HTTPX
             connection = find_connection(request, connections, options)
             connections << connection unless connections.include?(connection)
             connection.upgrade(request, response)
-            set_request_timeout(connection, request, options)
           end
           response
         end

data/lib/httpx/plugins/proxy.rb

@@ -68,17 +68,17 @@ module HTTPX
         def extra_options(options)
           Class.new(options.class) do
             def_option(:proxy) do |pr|
-              Hash[pr]
+              if pr.is_a?(Parameters)
+                pr
+              else
+                Hash[pr]
+              end
             end
           end.new(options)
         end
       end
 
       module InstanceMethods
-        def with_proxy(*args)
-          branch(default_options.with_proxy(*args))
-        end
-
         private
 
         def proxy_uris(uri, options)
@@ -104,7 +104,7 @@ module HTTPX
           connection = pool.find_connection(uri, proxy_options) || build_connection(uri, proxy_options)
           unless connections.nil? || connections.include?(connection)
             connections << connection
-            set_connection_callbacks(connection, options)
+            set_connection_callbacks(connection, connections, options)
           end
           connection
         end
@@ -129,13 +129,12 @@ module HTTPX
             connection = find_connection(request, connections, options)
             connections << connection unless connections.include?(connection)
             connection.send(request)
-            set_request_timeout(connection, request, options)
             return
           end
           response
         end
 
-        def build_altsvc_connection(_, _, _, _, options)
+        def build_altsvc_connection(_, _, _, _, _, options)
           return if options.proxy
 
           super

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

@@ -91,15 +91,13 @@ module HTTPX
           def headline_uri(request)
             return super unless request.verb == :connect
 
-            uri = request.uri
-            tunnel = "#{uri.hostname}:#{uri.port}"
+            tunnel = request.path
             log { "establishing HTTP proxy tunnel to #{tunnel}" }
             tunnel
           end
 
           def empty?
-            @requests.reject { |r| r.verb == :connect }.empty? ||
-              @requests.all? { |request| !request.response.nil? }
+            @requests.reject { |r| r.verb == :connect }.empty? || @requests.all? { |request| !request.response.nil? }
           end
         end
 

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

@@ -19,10 +19,6 @@ module HTTPX
         end
 
         module InstanceMethods
-          def with_proxy(*args)
-            branch(default_options.with_proxy(*args))
-          end
-
           private
 
           def send_requests(*requests, options)

data/lib/httpx/plugins/retries.rb

@@ -28,10 +28,10 @@ module HTTPX
           # number of seconds after which one can retry the request
           def_option(:retry_after) do |num|
             # return early if callable
-            return num if num.respond_to?(:call)
-
-            num = Integer(num)
-            raise Error, ":retry_after must be positive" unless num.positive?
+            unless num.respond_to?(:call)
+              num = Integer(num)
+              raise Error, ":retry_after must be positive" unless num.positive?
+            end
 
             num
           end
@@ -46,7 +46,7 @@ module HTTPX
           def_option(:retry_change_requests)
 
           def_option(:retry_on) do |callback|
-            raise ":retry_on must be called with the response" unless callback.respond_to?(:call) && callback.method(:call).arity == 1
+            raise ":retry_on must be called with the response" unless callback.respond_to?(:call)
 
             callback
           end
@@ -73,8 +73,22 @@ module HTTPX
             request.retries -= 1
             log { "failed to get response, #{request.retries} tries to go..." }
             request.transition(:idle)
-            connection = find_connection(request, connections, options)
-            __retry_request(connection, request, options)
+
+            retry_after = options.retry_after
+            if retry_after
+              retry_after = retry_after.call(request) if retry_after.respond_to?(:call)
+
+              log { "retrying after #{retry_after} secs..." }
+              pool.after(retry_after) do
+                log { "retrying!!" }
+                connection = find_connection(request, connections, options)
+                connection.send(request)
+              end
+            else
+              connection = find_connection(request, connections, options)
+              connection.send(request)
+            end
+
             return
           end
           response
@@ -87,23 +101,6 @@ module HTTPX
         def __retryable_error?(ex)
           RETRYABLE_ERRORS.any? { |klass| ex.is_a?(klass) }
         end
-
-        def __retry_request(connection, request, options)
-          retry_after = options.retry_after
-          unless retry_after
-            connection.send(request)
-            set_request_timeout(connection, request, options)
-            return
-          end
-
-          retry_after = retry_after.call(request) if retry_after.respond_to?(:call)
-          log { "retrying after #{retry_after} secs..." }
-          pool.after(retry_after) do
-            log { "retrying!!" }
-            connection.send(request)
-            set_request_timeout(connection, request, options)
-          end
-        end
       end
 
       module RequestMethods

data/lib/httpx/pool.rb

@@ -27,7 +27,13 @@ module HTTPX
 
     def next_tick
       catch(:jump_tick) do
-        @selector.select(next_timeout || @timers.wait_interval) do |monitor|
+        timeout = [next_timeout, @timers.wait_interval].compact.min
+        if timeout.negative?
+          @timers.fire
+          throw(:jump_tick)
+        end
+
+        @selector.select(timeout) do |monitor|
           monitor.io.call
           monitor.interests = monitor.io.interests
         end
@@ -51,6 +57,7 @@ module HTTPX
 
     def init_connection(connection, _options)
       resolve_connection(connection)
+      connection.timers = @timers
       connection.on(:open) do
         @connected_connections += 1
       end

data/lib/httpx/request.rb

@@ -37,8 +37,6 @@ module HTTPX
 
     attr_reader :options, :response
 
-    attr_accessor :timer
-
     def_delegator :@body, :<<
 
     def_delegator :@body, :empty?
@@ -83,7 +81,6 @@ module HTTPX
     def response=(response)
       return unless response
 
-      @timer.cancel if @timer
       @response = response
     end
 
@@ -238,15 +235,13 @@ module HTTPX
           when 100
             # deallocate
             @response = nil
-          when 417
-            @response = @response
-            return
           end
         end
       when :done
         return if @state == :expect
       end
       @state = nextstate
+      emit(@state)
       nil
     end
 

data/lib/httpx/response.rb

@@ -103,6 +103,8 @@ module HTTPX
       def read(*args)
         return unless @buffer
 
+        rewind
+
         @buffer.read(*args)
       end
 

data/lib/httpx/session.rb

@@ -60,22 +60,33 @@ module HTTPX
       connection = pool.find_connection(uri, options) || build_connection(uri, options)
       unless connections.nil? || connections.include?(connection)
         connections << connection
-        set_connection_callbacks(connection, options)
+        set_connection_callbacks(connection, connections, options)
       end
       connection
     end
 
-    def set_connection_callbacks(connection, options)
+    def set_connection_callbacks(connection, connections, options)
       connection.on(:uncoalesce) do |uncoalesced_uri|
         other_connection = build_connection(uncoalesced_uri, options)
+        connections << other_connection
         connection.unmerge(other_connection)
       end
       connection.on(:altsvc) do |alt_origin, origin, alt_params|
-        build_altsvc_connection(connection, alt_origin, origin, alt_params, options)
+        other_connection = build_altsvc_connection(connection, connections, alt_origin, origin, alt_params, options)
+        connections << other_connection if other_connection
+      end
+      connection.on(:exhausted) do
+        other_connection = connection.create_idle
+        other_connection.merge(connection)
+        catch(:coalesced) do
+          pool.init_connection(other_connection, options)
+        end
+        set_connection_callbacks(other_connection, connections, options)
+        connections << other_connection
       end
     end
 
-    def build_altsvc_connection(existing_connection, alt_origin, origin, alt_params, options)
+    def build_altsvc_connection(existing_connection, connections, alt_origin, origin, alt_params, options)
       altsvc = AltSvc.cached_altsvc_set(origin, alt_params.merge("origin" => alt_origin))
 
       # altsvc already exists, somehow it wasn't advertised, probably noop
@@ -85,7 +96,7 @@ module HTTPX
       # advertised altsvc is the same origin being used, ignore
       return if connection == existing_connection
 
-      set_connection_callbacks(connection, options)
+      set_connection_callbacks(connection, connections, options)
 
       log(level: 1) { "#{origin} alt-svc: #{alt_origin}" }
 
@@ -99,8 +110,10 @@ module HTTPX
       end
 
       connection.merge(existing_connection)
+      connection
     rescue UnsupportedSchemeError
       altsvc["noop"] = true
+      nil
     end
 
     def build_requests(*args, options)
@@ -155,7 +168,6 @@ module HTTPX
         error = catch(:resolve_error) do
           connection = find_connection(request, connections, request_options)
           connection.send(request)
-          set_request_timeout(connection, request, request_options)
         end
         next unless error.is_a?(ResolveError)
 
@@ -191,21 +203,6 @@ module HTTPX
       request
     end
 
-    def set_request_timeout(connection, request, options)
-      total = options.timeout.total_timeout
-      return unless total
-
-      timer = pool.after(total) do
-        unless @responses[request]
-          error = TotalTimeoutError.new(total, "Timed out after #{total} seconds")
-          response = ErrorResponse.new(request, error, options)
-          request.emit(:response, response)
-          connection.reset
-        end
-      end
-      request.timer = timer
-    end
-
     @default_options = Options.new
     @default_options.freeze
     @plugins = []

data/lib/httpx/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: httpx
 version: !ruby/object:Gem::Version
-  version: 0.6.7
+  version: 0.7.0
 platform: ruby
 authors:
 - Tiago Cardoso
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-02-29 00:00:00.000000000 Z
+date: 2020-03-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: http-2-next
@@ -109,6 +109,7 @@ files:
 - lib/httpx/plugins/compression/gzip.rb
 - lib/httpx/plugins/cookies.rb
 - lib/httpx/plugins/digest_authentication.rb
+- lib/httpx/plugins/expect.rb
 - lib/httpx/plugins/follow_redirects.rb
 - lib/httpx/plugins/h2c.rb
 - lib/httpx/plugins/multipart.rb