httpx 1.8.4 → 1.9.1

data/lib/httpx/connection.rb

@@ -39,9 +39,7 @@ module HTTPX
     attr_reader :type, :io, :origin, :origins, :state, :pending, :options, :ssl_session, :sibling,
                 :read_buffer, :write_buffer
 
-    attr_writer :current_selector
-
-    attr_accessor :current_session, :family
+    attr_accessor :current_selector, :current_session, :family
 
     protected :ssl_session, :sibling, :read_buffer, :write_buffer
 
@@ -52,9 +50,10 @@ module HTTPX
                                                                  @io = @ssl_session = @timeout = @connected_at = @response_received_at = nil
 
       @exhausted = @cloned = @main_sibling =
-                     # variable used to gate against a potential endless loop where the peer continuously closes the connection with
-                     # GOAWAY frames without ever processing a request.
-                     @previously_exhausted_with_error = false
+                     @reset_timeout_on_call =
+                       # variable used to gate against a potential endless loop where the peer continuously closes the connection with
+                       # GOAWAY frames without ever processing a request.
+                       @previously_exhausted_with_error = false
 
       @options = Options.new(options)
       @type = initialize_type(uri, @options)
@@ -64,8 +63,7 @@ module HTTPX
       @read_buffer = Buffer.new(@options.buffer_size)
       @write_buffer = Buffer.new(@options.buffer_size)
       @pending = []
-      @inflight = 0
-      @keep_alive_timeout = @options.timeout[:keep_alive_timeout]
+      @keep_alive_timeout = @options.timeout.keep_alive_timeout
       @no_more_requests_counter = 0
 
       if @options.io
@@ -77,7 +75,14 @@ module HTTPX
       else
         transition(:idle)
       end
-      self.addresses = @options.addresses if @options.addresses
+
+      case (addresses = @options.addresses)
+      when Array
+        self.addresses = addresses
+      when Hash
+        # TODO: && @origin.host not an IP
+        self.addresses = addresses[@origin.host]
+      end
     end
 
     # dupped initialization
@@ -87,7 +92,6 @@ module HTTPX
       @origins = orig.origins.dup
       @read_buffer = orig.read_buffer.dup
       @write_buffer = orig.write_buffer.dup
-      @inflight = 0
       @pending = []
       transition(:idle)
 
@@ -126,7 +130,7 @@ module HTTPX
     end
 
     def match?(uri, options)
-      return false if !used? && (@state == :closing || @state == :closed)
+      return false if @state == :closing || (!used? && @state == :closed)
 
       @origins.include?(uri.origin) &&
         # if there is more than one origin to match, it means that this connection
@@ -140,6 +144,9 @@ module HTTPX
     def mergeable?(connection)
       return false if @state == :closing || @state == :closed || !@io
 
+      # do not coalesce with HEv2 sibling
+      return false if @sibling.equal?(connection)
+
       return false unless connection.addresses
 
       (
@@ -187,19 +194,16 @@ module HTTPX
       end
     end
 
+    # returns the number of pending requests both in the connection as well as parser
+    # pending queues
+    def pending_count
+      @pending.size
+    end
+
     def purge_pending(&block)
-      if @parser
-        pending = @parser.pending
-        @inflight -= pending.size
-        pending.reject! do |req|
-          block.call(req)
-          true
-        end
-      end
-      @pending.reject! do |req|
-        block.call(req)
-        true
-      end
+      pending = @pending.dup
+      @pending.clear
+      pending.each(&block)
     end
 
     def io_connected?
@@ -212,6 +216,11 @@ module HTTPX
       @state == :idle
     end
 
+    # whether the connection can be removed from the selector.
+    def closed_for_select?
+      @state == :closed
+    end
+
     def inflight?
       @parser && (
         # parser may be dealing with other requests (possibly started from a different fiber)
@@ -224,14 +233,12 @@ module HTTPX
     def interests
       # connecting
       if connecting?
-        connect
+        try_connect
 
         return @io.interests if connecting?
       end
 
-      return @parser.interests if @parser
-
-      nil
+      @parser&.interests
     rescue Error => e
       on_error(e)
       nil
@@ -242,18 +249,23 @@ module HTTPX
     end
 
     def call
+      if @reset_timeout_on_call
+        @timeout = nil
+        @reset_timeout_on_call = false
+      end
+
       case @state
       when :idle
         return if no_more_requests?
 
-        connect
+        try_connect
 
         # when opening the tcp or ssl socket fails
         return if @state == :closed
 
         consume
       when :closed
-        return if no_more_requests?
+        return if no_requests_to_handle?
 
         # there are pending requests to send, restart the state machine.
         idling
@@ -264,8 +276,18 @@ module HTTPX
 
         call
       when :closing
+        # if bytes are available, that's the client GOAWAY frame. Otherwise, the peer closed it.
+        sending_goaway = !@write_buffer.empty?
+
         consume
-        transition(:closed)
+
+        if sending_goaway
+          # parser may have inflight streams which need terminating.
+          @parser&.close
+          transition(:closed)
+        elsif @state == :closing
+          return
+        end
 
         # @fiber-switch-guard
         # fiber may have switch while closing @io.
@@ -300,7 +322,7 @@ module HTTPX
     def close
       transition(:active) if @state == :inactive
 
-      @parser.close if @parser
+      @parser&.close
     end
 
     def terminate
@@ -310,6 +332,7 @@ module HTTPX
 
         # @fiber-switch-guard
         if @io.can_disconnect? && @pending.empty?
+          @state = :closed
           disconnect
           return
         end
@@ -329,11 +352,10 @@ module HTTPX
       if delete_pending
         @pending.clear
       elsif (parser = @parser)
-        enqueue_pending_requests_from_parser(parser)
+        parser.reset_requests if parser.respond_to?(:reset_requests)
+        return unless @pending.empty?
       end
 
-      return unless @pending.empty?
-
       disconnect
       emit(:force_closed, delete_pending)
     end
@@ -347,20 +369,19 @@ module HTTPX
     end
 
     def reset
-      return if @state == :closing || @state == :closed
+      return if @state == :closed
 
       # do not reset a connection which may have restarted back to :idle, such when the parser resets
       # (example: HTTP/1 parser disabling pipelining)
       return if @state == :idle && @pending.any?
 
-      if @ping_timer
-        @ping_timer.cancel
-        @ping_timer = nil
-      end
+      reset_ping_timer
 
       parser = @parser
 
       if parser && parser.respond_to?(:max_concurrent_requests)
+        # @type var parser: HTTP1
+
         # if connection being reset has at some downgraded the number of concurrent
         # requests, such as in the case where an attempt to use HTTP/1 pipelining failed,
         # keep that information around.
@@ -374,6 +395,8 @@ module HTTPX
     def send(request)
       return @coalesced_connection.send(request) if @coalesced_connection
 
+      request.connection = self
+
       if @parser && !@write_buffer.full?
         if @response_received_at && @keep_alive_timeout &&
            Utils.elapsed_time(@response_received_at) > @keep_alive_timeout
@@ -390,6 +413,8 @@ module HTTPX
 
         send_request_to_parser(request)
       else
+        set_connection_timeouts(request) if connecting?
+
         @pending << request
       end
     end
@@ -397,11 +422,14 @@ module HTTPX
     def timeout
       return if @state == :closed || @state == :inactive
 
-      return @timeout if @timeout
+      timeout = @timeout || @options.timeout.operation_timeout
 
-      return @options.timeout[:connect_timeout] if @state == :idle
+      return timeout unless connecting? && (attempt_timeout = connect_attempt_time_left)
 
-      @options.timeout[:operation_timeout]
+      # the attempt may already be overdue
+      attempt_timeout = 0 unless attempt_timeout.positive?
+
+      timeout && timeout < attempt_timeout ? timeout : attempt_timeout
     end
 
     def idling
@@ -413,7 +441,7 @@ module HTTPX
       transition(:idle)
       return unless @parser
 
-      enqueue_pending_requests_from_parser(parser)
+      @parser.reset_requests if @parser.respond_to?(:reset_requests)
       @parser = nil
     end
 
@@ -422,6 +450,9 @@ module HTTPX
     end
 
     def deactivate
+      # safety net so that connection state does not corrupt.
+      clear_pending_requests
+
       transition(:inactive)
     end
 
@@ -463,6 +494,9 @@ module HTTPX
 
       @current_session = @current_selector = nil
 
+      # NOTE: don't change state of the connection after this call!
+      # the connection is checked back into the pool, and may be checked out by
+      # another thread before the next statement.
       current_session.deselect_connection(self, current_selector, @cloned)
     end
 
@@ -486,16 +520,37 @@ module HTTPX
 
     def on_error(error, request = nil)
       if error.is_a?(OperationTimeoutError)
-
         # inactive connections do not contribute to the select loop, therefore
         # they should not fail due to such errors.
         return if @state == :inactive
 
-        if @timeout
-          @timeout -= error.timeout
-          return unless @timeout <= 0
+        attempt_timeout = connect_attempt_time_left if connecting?
+
+        current_timeout = @timeout
+        current_timeout ||= @options.timeout.operation_timeout unless @state == :closed
+
+        if current_timeout
+          # if @timeout isn't set, it's not a completion-based timeout, i.e.
+          # operation timeout; in such a case, we have to reset it once it piggybacks.
+          @reset_timeout_on_call ||= @timeout.nil?
+
+          @timeout = current_timeout - error.timeout
+
+          if @timeout.positive?
+            # if this was a connect timeout error and there are more addresses to try.
+            connect_next(error) if attempt_timeout && !attempt_timeout.positive?
+            return
+          end
 
           @timeout = nil
+          @reset_timeout_on_call = false
+        elsif attempt_timeout
+          # when request timeouts are set instead.
+          connect_next(error) unless attempt_timeout.positive?
+          return
+        else
+          # the select interval came from another selectable, as this one has no timeout set.
+          return
         end
 
         error = error.to_connection_error if connecting?
@@ -516,6 +571,26 @@ module HTTPX
 
     private
 
+    # the time left until the attempt to connect to the current address should be abandoned.
+    def connect_attempt_time_left
+      io = @io
+
+      return unless io.respond_to?(:connect_attempt_time_left)
+
+      io.connect_attempt_time_left
+    end
+
+    def connect_next(error)
+      @io.next_address!(error)
+
+      connect
+    end
+
+    def try_connect
+      emit(:connecting)
+      connect
+    end
+
     def connect
       transition(:open)
     end
@@ -539,7 +614,6 @@ module HTTPX
           # * the number of inflight requests
           # * whether the write buffer has bytes (i.e. for close handshake)
           if no_more_requests? && @write_buffer.empty?
-            no_more_requests_loop_check if @parser && @parser.pending.any?
 
             # terminate if an altsvc connection has been established
             terminate if @altsvc_connection
@@ -582,21 +656,19 @@ module HTTPX
             parser << @read_buffer.to_s
 
             # continue reading if possible.
-            break if interests == :w && !epiped
-
-            # exit the read loop if connection is preparing to be closed
-            break if @state == :closing || @state == :closed
+            break if (interests == :w && !epiped) ||
+                     # exit the read loop if connection is closed
+                     @state == :closed
 
             # exit #consume altogether if all outstanding requests have been dealt with
             if no_more_requests? && @write_buffer.empty? # rubocop:disable Style/Next
-              no_more_requests_loop_check if @parser && @parser.pending.any?
 
               # terminate if an altsvc connection has been established
               terminate if @altsvc_connection
 
               return
             end
-          end unless ((ints = interests).nil? || ints == :w || @state == :closing) && !epiped
+          end unless ((ints = interests).nil? || ints == :w) && !epiped
 
           #
           # tight write loop.
@@ -607,7 +679,7 @@ module HTTPX
             # buffer has been drained, mark and exit the write loop.
             if @write_buffer.empty?
               # we only mark as drained on the first loop
-              write_drained = write_drained.nil? && @inflight.positive?
+              write_drained = write_drained.nil? && !@parser&.no_more_requests?
 
               break
             end
@@ -642,11 +714,12 @@ module HTTPX
             end
 
             # exit write loop if marked to consume from peer, or is closing.
-            break if interests == :r || @state == :closing || @state == :closed
+            break if (ints = interests) == :r || @state == :closed
 
             write_drained = false
           end unless (ints = interests) == :r
 
+          # fill the write buffer with more requests
           send_pending if @state == :open
 
           # return if socket is drained
@@ -663,8 +736,9 @@ module HTTPX
     end
 
     def send_pending
-      while !@write_buffer.full? && (request = @pending.shift)
-        send_request_to_parser(request)
+      while (request = @pending.shift)
+        # request may have been rerouted to the pending list
+        break unless send_request_to_parser(request, true)
       end
     end
 
@@ -672,44 +746,29 @@ module HTTPX
       @parser ||= build_parser
     end
 
-    def send_request_to_parser(request)
-      @inflight += 1
-      request.peer_address = @io.ip && @io.ip.address
-      set_request_timeouts(request)
-
-      parser.send(request)
+    def send_request_to_parser(request, head = false)
+      request.peer_address = @io&.ip&.address
 
-      return unless @state == :inactive
-
-      transition(:active)
-      # mark request as ping, as this inactive connection may have been
-      # closed by the server, and we don't want that to influence retry
-      # bookkeeping.
-      request.ping!
-    end
-
-    def enqueue_pending_requests_from_parser(parser)
-      parser.reset_requests # move sequential requests back to pending queue.
-      parser_pending_requests = parser.pending
-
-      return if parser_pending_requests.empty?
-
-      # the connection will be reused, so parser requests must come
-      # back to the pending list before the parser is reset.
-      @inflight -= parser_pending_requests.size
-      @pending.unshift(*parser_pending_requests)
+      if @state == :inactive
+        transition(:active)
+        # mark request as ping, as this inactive connection may have been
+        # closed by the server, and we don't want that to influence retry
+        # bookkeeping.
+        request.ping!
+      end
 
-      parser.pending.clear
+      parser.send(request, head)
     end
 
     def build_parser(protocol = @io.protocol)
-      parser = parser_type(protocol).new(@write_buffer, @options)
+      parser = parser_type(protocol).new(@write_buffer, @pending, @options)
       set_parser_callbacks(parser)
       parser.max_concurrent_requests = @max_concurrent_requests if @max_concurrent_requests && parser.respond_to?(:max_concurrent_requests=)
       parser
     end
 
     def set_parser_callbacks(parser)
+      parser.on(:request_accepted, &method(:set_request_timeouts))
       parser.on(:response) do |request, response|
         AltSvc.emit(request, response) do |alt_origin, origin, alt_params|
           build_altsvc_connection(alt_origin, origin, alt_params)
@@ -717,7 +776,6 @@ module HTTPX
         @previously_exhausted_with_error = false
         @response_received_at = Utils.now
         @no_more_requests_counter = 0
-        @inflight -= 1
         response.finish!
         request.emit_response(response)
       end
@@ -731,7 +789,7 @@ module HTTPX
         request.emit(:promise, parser, stream)
       end
       parser.on(:exhausted) do |error|
-        enqueue_pending_requests_from_parser(parser)
+        parser.reset_requests
 
         if error
           if @previously_exhausted_with_error
@@ -739,6 +797,9 @@ module HTTPX
             on_error(error)
             next
           else
+            # in case the error came while waiting for a PING ack.
+            reset_ping_timer
+
             @previously_exhausted_with_error = true
           end
         end
@@ -757,6 +818,13 @@ module HTTPX
       parser.on(:origin) do |origin|
         @origins |= [origin]
       end
+      parser.on(:closing) do
+        # this happens if the peer server sent a GOAWAY frame while there are inflight
+        # streams; moving to :closing ensures that new requests won't be sent to this
+        # connection, while keeping it around to complete unfinished work
+        reset_ping_timer
+        transition(:closing)
+      end
       parser.on(:close) do
         reset
       end
@@ -764,15 +832,16 @@ module HTTPX
         consume unless @state == :closed
       end
       parser.on(:reset) do
-        enqueue_pending_requests_from_parser(parser)
+        parser.reset_requests
 
         reset
 
         next unless @state == :closed
 
+        # @fiber-switch-guard
         # :reset event only fired in http/1.1, so this guarantees
         # that the connection will be closed here.
-        idling unless @pending.empty?
+        call unless no_more_requests?
       end
       parser.on(:current_timeout) do
         @current_timeout = @timeout = parser.timeout
@@ -780,29 +849,33 @@ module HTTPX
       parser.on(:timeout) do |tout|
         @timeout = tout
       end
-      parser.on(:error) do |request, error|
-        case error
-        when :http_1_1_required
-          current_session = @current_session
-          current_selector = @current_selector
-          parser.close
-
-          other_connection = current_session.find_connection(@origin, current_selector,
-                                                             @options.merge(ssl: { alpn_protocols: %w[http/1.1] }))
-          other_connection.merge(self)
-          request.transition(:idle)
-          other_connection.send(request)
-          next
-        when OperationTimeoutError
-          # request level timeouts should take precedence
-          next unless request.active_timeouts.empty?
-        end
+      parser.on(:keep_alive_timeout) do |tout|
+        @keep_alive_timeout = tout
+      end
+      parser.on(:error, &method(:on_parser_error))
+    end
 
-        @inflight -= 1
-        response = ErrorResponse.new(request, error)
-        request.response = response
-        request.emit_response(response)
+    def on_parser_error(request, error)
+      case error
+      when :http_1_1_required
+        current_session = @current_session
+        current_selector = @current_selector
+        parser.close
+
+        request.transition(:idle)
+        current_session.__send__(:send_request, request, current_selector,
+                                 @options.merge(ssl: { alpn_protocols: %w[http/1.1] })) do |other_conn|
+          other_conn.merge(self)
+        end
+        return
+      when OperationTimeoutError
+        # request level timeouts should take precedence
+        return unless request.active_timeouts.empty?
       end
+
+      response = ErrorResponse.new(request, error)
+      request.response = response
+      request.emit_response(response)
     end
 
     def transition(nextstate)
@@ -834,7 +907,7 @@ module HTTPX
     def handle_transition(nextstate)
       case nextstate
       when :idle
-        @timeout = @current_timeout = @options.timeout[:connect_timeout]
+        @timeout = @current_timeout = @options.timeout.connect_timeout
 
         @connected_at = @response_received_at = nil
       when :open
@@ -853,32 +926,23 @@ module HTTPX
         emit(:open)
       when :inactive
         return unless @state == :open
-
-        # @type ivar @parser: HTTP1 | HTTP2
-
-        # do not deactivate connection in use
-        return if @inflight.positive? || @parser.waiting_for_ping?
       when :closing
         return unless connecting? || @state == :open
       when :closed
-        return unless @state == :closing
-        return unless @write_buffer.empty?
-
-        purge_after_closed
-
-        # @fiber-switch-guard
-        return unless @state == :closing && (@io.nil? || @io.can_disconnect?)
+        return unless @state == :closing && @write_buffer.empty?
       when :already_open
         nextstate = :open
         # the first check for given io readiness must still use a timeout.
         # connect is the reasonable choice in such a case.
-        @timeout = @options.timeout[:connect_timeout]
+        @timeout = @options.timeout.connect_timeout
         send_pending
       when :active
         return unless @state == :inactive
 
         nextstate = :open
 
+        @timeout = @current_timeout = parser.timeout
+
         # activate
         @current_session.select_connection(self, @current_selector)
       end
@@ -895,8 +959,10 @@ module HTTPX
         consume
         @write_buffer.clear
       when :closed
-        # TODO: should this raise an error instead?
-        return unless @pending.empty?
+        purge_after_closed
+
+        # @fiber-switch-guard
+        return unless no_more_requests?
 
         disconnect
       end
@@ -916,6 +982,13 @@ module HTTPX
       end
     end
 
+    def reset_ping_timer
+      return unless @ping_timer
+
+      @ping_timer.cancel
+      @ping_timer = nil
+    end
+
     def close_sibling
       sibling = @sibling
 
@@ -963,8 +1036,6 @@ module HTTPX
 
     # returns an HTTPX::Connection for the negotiated Alternative Service (or none).
     def build_altsvc_connection(alt_origin, origin, alt_params)
-      return if @altsvc_connection
-
       # do not allow security downgrades on altsvc negotiation
       return if @origin.scheme == "https" && alt_origin.scheme != "https"
 
@@ -973,6 +1044,8 @@ module HTTPX
       # altsvc already exists, somehow it wasn't advertised, probably noop
       return unless altsvc
 
+      return if @altsvc_connection
+
       alt_options = @options.merge(ssl: @options.ssl.merge(hostname: URI(origin).host))
 
       connection = @current_session.find_connection(alt_origin, @current_selector, alt_options)
@@ -1023,7 +1096,7 @@ module HTTPX
 
       return unless parser.waiting_for_ping?
 
-      ping_timeout = @options.timeout[:ping_timeout]
+      ping_timeout = @options.timeout.ping_timeout
 
       @ping_timer = @current_selector.after(ping_timeout) do
         log(level: 3) { "ping timeout expired..." }
@@ -1035,66 +1108,76 @@ module HTTPX
     end
 
     def pong
-      @ping_timer.cancel
-      @ping_timer = nil
+      reset_ping_timer
       @response_received_at = Utils.now
       @no_more_requests_counter = 0
       send_pending
     end
 
-    def no_more_requests_loop_check
-      log(level: 3) { "NO MORE REQUESTS..." }
-      @no_more_requests_counter += 1
+    def no_more_selector_check
+      return if @current_selector
 
-      return if @no_more_requests_counter < 50
+      raise Error, "request has been resend to an out-of-session connection, and this " \
+                   "should never happen!!! Please report this error! " \
+                   "(state:#{@state}, " \
+                   "parser?:#{!!@parser}, " \
+                   "bytes in write buffer?:#{!@write_buffer.empty?}, " \
+                   "cloned?:#{@cloned}, " \
+                   "sibling?:#{!!@sibling}, " \
+                   "coalesced?:#{coalesced?})"
+    end
 
-      raise Error, "connection corrupted, aborted after looping for a while, " \
-                   "please report this https://gitlab.com/os85/httpx/-/work_items " \
-                   "along with debug logs"
+    def clear_pending_requests
+      @pending.clear
     end
 
     # true when there are no more pending nor inflight (in parser) requests
     def no_more_requests?
-      @pending.empty? && @inflight.zero?
+      @pending.empty? && (
+        connecting? ||
+        @parser.nil? ||
+        !@parser.respond_to?(:no_more_requests?) ||
+        @parser.no_more_requests?
+      )
     end
 
+    alias_method :no_requests_to_handle?, :no_more_requests?
     # recover internal state and emit all relevant error responses when +error+ was raised.
     # this takes an optiona +request+ which may have already been handled and can be opted out
     # in the state recovery process.
     def handle_error(error, request = nil)
       if request
-        @inflight -= 1
         response = ErrorResponse.new(request, error)
         request.response = response
         request.emit_response(response)
       end
 
-      pending = @pending
       if (parser = @parser) && parser.respond_to?(:handle_error)
         # parser.handle_error may disconnect the connection
-        pending = @pending.dup
-        @pending = []
-
         parser.handle_error(error, request)
-      end
-
-      while (req = pending.shift)
-        next if request && req == request
+      else
+        while (req = @pending.shift)
+          next if request && req == request
 
-        resp = ErrorResponse.new(req, error)
-        req.response = resp
-        req.emit_response(resp)
+          resp = ErrorResponse.new(req, error)
+          req.response = resp
+          req.emit_response(resp)
+        end
       end
     end
 
     def set_request_timeouts(request)
-      request.connection = self
       set_request_write_timeout(request)
       set_request_read_timeout(request)
       set_request_request_timeout(request)
       set_request_total_request_timeout(request)
     end
 
+    def set_connection_timeouts(request)
+      set_connecting_request_timeout(request)
+      set_connecting_total_request_timeout(request)
+    end
+
     def set_request_read_timeout(request)
       read_timeout = request.read_timeout
 
@@ -1158,19 +1241,52 @@ module HTTPX
     end
 
     def set_request_timeout(label, request, timeout, start_event, finish_events, &callback)
+      return if request.active_timeouts.any? { |timer| timer.label == label }
+
       request.set_timeout_callback(start_event) do
-        unless (selector = @current_selector)
-          raise Error, "request has been resend to an out-of-session connection, and this " \
-                       "should never happen!!! Please report this error! " \
-                       "(state:#{@state}, " \
-                       "parser?:#{!!@parser}, " \
-                       "bytes in write buffer?:#{!@write_buffer.empty?}, " \
-                       "cloned?:#{@cloned}, " \
-                       "sibling?:#{!!@sibling}, " \
-                       "coalesced?:#{coalesced?})"
+        no_more_selector_check
+
+        timer = @current_selector.after(timeout, callback)
+        timer.label = label
+        request.active_timeouts << timer
+
+        Array(finish_events).each do |event|
+          # clean up request timeouts if the connection errors out
+          request.set_timeout_callback(event) do
+            timer.cancel
+            request.active_timeouts.delete(timer)
+          end
         end
+      end
+    end
+
+    def set_connecting_request_timeout(request)
+      request_timeout = request.request_timeout
+
+      return if request_timeout.nil? || request_timeout.infinite?
 
-        timer = selector.after(timeout, callback)
+      set_connection_timeout(:request_timeout, request, request_timeout, :connecting, :complete) do
+        read_timeout_callback(request, request_timeout, RequestTimeoutError)
+      end
+    end
+
+    def set_connecting_total_request_timeout(request)
+      return if request.started?
+
+      total_request_timeout = request.total_request_timeout
+
+      return if total_request_timeout.nil? || total_request_timeout.infinite?
+
+      set_connection_timeout(:total_request_timeout, request, total_request_timeout, :connecting, :complete) do
+        read_timeout_callback(request, total_request_timeout, TotalRequestTimeoutError)
+      end
+    end
+
+    def set_connection_timeout(label, request, timeout, start_event, finish_events, &callback)
+      cb = once(start_event) do
+        no_more_selector_check
+
+        timer = @current_selector.after(timeout, callback)
         timer.label = label
         request.active_timeouts << timer
 
@@ -1182,6 +1298,10 @@ module HTTPX
           end
         end
       end
+
+      request.once(:idle) do
+        callbacks(start_event).delete(cb)
+      end
     end
 
     def parser_type(protocol)