httpx 1.7.2 → 1.7.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c67e4695d8ef368321f14a3c113daad0e49280413e3da42272644ad84fe6f622
-  data.tar.gz: 62bb1ab9d91ca69c9b1fa561051ffb0ed137afb53e0b40f71cfd477a84a78773
+  metadata.gz: 54c87d9d8b2be0d12570204fd3c60d37f82127b624dde3a233085d5bcb43778c
+  data.tar.gz: 8bfec9fadfe697d083d37a9317e9ec9d6e23016f174bd62cabf24275f18fee79
 SHA512:
-  metadata.gz: 266576dae6b8ed604228b464281239b760df9682d27e9010b18ac7dbab4fb00f23115e5bcae1a0ecee6b191ee03a0eca758c37f8f0baee0e2ad9df5ca0c7eff6
-  data.tar.gz: e355df3c634811d0d8e08bcb10b661a4f486073e6ca808ca3af3585a4d014cd404c8d7a55e38d0d05419f205d9dc81a54fb5a17eab7e1716c38c160297963e0f
+  metadata.gz: 2c425e8714c36bdca0ab5d068157caa94ca591829466ccdb888e903487aaab50c9a8756eaa53f1cd692a109160deca10ec9ce4405a7690f38149a9e95ec9fb17
+  data.tar.gz: 20c6ae3067f1fe187402c743fb1741a131ba09e5039ed86e5c5d2eb8c94d590c84644ca3e6ab5fd3948b635d328bba4149df3a1d94dde3dfbf257bd694730275

data/README.md

@@ -46,7 +46,9 @@ And that's the simplest one there is. But you can also do:
 HTTPX.post("http://example.com", form: { user: "john", password: "pass" })
 
 http = HTTPX.with(headers: { "x-my-name" => "joe" })
-http.patch("http://example.com/file", body: File.open("path/to/file")) # request body is streamed
+File.open("path/to/file") do |file|
+  http.patch("http://example.com/file", body: file) # request body is streamed
+end
 ```
 
 If you want to do some more things with the response, you can get an `HTTPX::Response`:

data/doc/release_notes/1_7_3.md

@@ -0,0 +1,29 @@
+# 1.7.3
+
+## Improvements
+
+### cookies plugin: Jar as CookieStore
+
+While previously an implementation detail, the cookie jar from a `:cookie` plugin-enabled session can now be manipulated by the end user:
+
+```ruby
+cookies_sess = HTTPX.plugin(:cookies)
+
+jar = cookies.make_jar
+
+sess = cookies_ses.with(cookies: jar)
+
+# perform requests using sess, get/set/delete cookies in jar
+```
+
+The jar API now closely follows the [Web Cookie Store API](https://developer.mozilla.org/en-US/docs/Web/API/CookieStore), by providing the same set of functions.
+
+Some API backwards compatibility is maintained, however since this was an internal implementation detail, this effort isn't meant to be thorough.
+
+## Bugfixes
+
+* `http-2`: clear buffered data chunks when receiving a `GOAWAY` stream frame; without this, the client kept sending the corresponding `DATA` frames, despite the peer server making it known that it wouldn't process it. While this is valid HTTP/2, this could increase the connection window until a point where it'd go over the max frame size. this issue was observed during large file uploads where the first request could fail and make the client renegotiate.
+* `webmock` adapter: fixed response body length accounting which was making `response.body.empty?` return true for responses with payload.
+* `:rate_limiter` plugin relies on an internal refactoring to be able to wait for the time suggested by the peer server instead of the potentially relying on custom user logic via own `:retry_after`.
+* `:fiber_concurrency`: fix wrong names for native/system resolver overrides.
+* connection: fix for race condition when closing the connection, where the state only transitions to `closed` after checking the connection back in to the pool, potentially corrupting it if another session meanwhile has picked it up and manipulated it.

data/lib/httpx/adapters/webmock.rb

@@ -82,6 +82,7 @@ module WebMock
 
         def mock!
           @mocked = true
+          @body.mock!
         end
 
         def mocked?
@@ -90,10 +91,8 @@ module WebMock
       end
 
       module ResponseBodyMethods
-        def decode_chunk(chunk)
-          return chunk if @response.mocked?
-
-          super
+        def mock!
+          @inflaters = nil
         end
       end
 

data/lib/httpx/connection/http1.rb

@@ -280,7 +280,6 @@ module HTTPX
     end
 
     def disable_pipelining
-      return if @requests.empty?
       # do not disable pipelining if already set to 1 request at a time
       return if @max_concurrent_requests == 1
 

data/lib/httpx/connection/http2.rb

@@ -3,8 +3,6 @@
 require "securerandom"
 require "http/2"
 
-HTTP2::Connection.__send__(:public, :send_buffer) if HTTP2::VERSION < "1.1.1"
-
 module HTTPX
   class Connection::HTTP2
     include Callbacks
@@ -215,9 +213,7 @@ module HTTPX
     def handle_stream(stream, request)
       request.on(:refuse, &method(:on_stream_refuse).curry(3)[stream, request])
       stream.on(:close, &method(:on_stream_close).curry(3)[stream, request])
-      stream.on(:half_close) do
-        log(level: 2) { "#{stream.id}: waiting for response..." }
-      end
+      stream.on(:half_close) { on_stream_half_close(stream, request) }
       stream.on(:altsvc, &method(:on_altsvc).curry(2)[request.origin])
       stream.on(:headers, &method(:on_stream_headers).curry(3)[stream, request])
       stream.on(:data, &method(:on_stream_data).curry(3)[stream, request])
@@ -302,7 +298,7 @@ module HTTPX
       end
 
       log(color: :yellow) do
-        h.map { |k, v| "#{stream.id}: <- HEADER: #{k}: #{log_redact_headers(v)}" }.join("\n")
+        h.map { |k, v| "#{stream.id}: <- HEADER: #{k}: #{k == ":status" ? v : log_redact_headers(v)}" }.join("\n")
       end
       _, status = h.shift
       headers = request.options.headers_class.new(h)
@@ -331,6 +327,16 @@ module HTTPX
       stream.close
     end
 
+    def on_stream_half_close(stream, _request)
+      unless stream.send_buffer.empty?
+        stream.send_buffer.clear
+        stream.data("", end_stream: true)
+      end
+
+      # TODO: omit log line if response already here
+      log(level: 2) { "#{stream.id}: waiting for response..." }
+    end
+
     def on_stream_close(stream, request, error)
       return if error == :stream_closed && !@streams.key?(request)
 
@@ -404,34 +410,39 @@ module HTTPX
 
     def on_frame_sent(frame)
       log(level: 2) { "#{frame[:stream]}: frame was sent!" }
-      log(level: 2, color: :blue) do
-        payload =
-          case frame[:type]
-          when :data
-            frame.merge(payload: frame[:payload].bytesize)
-          when :headers, :ping
-            frame.merge(payload: log_redact_headers(frame[:payload]))
-          else
-            frame
-          end
-        "#{frame[:stream]}: #{payload}"
-      end
+      log(level: 2, color: :blue) { "#{frame[:stream]}: #{frame_with_extra_info(frame)}" }
     end
 
     def on_frame_received(frame)
       log(level: 2) { "#{frame[:stream]}: frame was received!" }
-      log(level: 2, color: :magenta) do
-        payload =
-          case frame[:type]
-          when :data
-            frame.merge(payload: frame[:payload].bytesize)
-          when :headers, :ping
-            frame.merge(payload: log_redact_headers(frame[:payload]))
-          else
-            frame
-          end
-        "#{frame[:stream]}: #{payload}"
-      end
+      log(level: 2, color: :magenta) { "#{frame[:stream]}: #{frame_with_extra_info(frame)}" }
+    end
+
+    def frame_with_extra_info(frame)
+      case frame[:type]
+      when :data
+        frame.merge(payload: frame[:payload].bytesize)
+      when :headers, :ping
+        frame.merge(payload: log_redact_headers(frame[:payload]))
+      when :window_update
+        connection_or_stream = if (id = frame[:stream]).zero?
+          @connection
+        else
+          @streams.each_value.find { |s| s.id == id }
+        end
+        if connection_or_stream
+          frame.merge(
+            local_window: connection_or_stream.local_window,
+            remote_window: connection_or_stream.remote_window,
+            buffered_amount: connection_or_stream.buffered_amount,
+            stream_state: connection_or_stream.state,
+          )
+        else
+          frame
+        end
+      else
+        frame
+      end.merge(connection_state: @connection.state)
     end
 
     def on_altsvc(origin, frame)

data/lib/httpx/connection.rb

@@ -227,6 +227,9 @@ module HTTPX
         consume
       end
       nil
+    rescue IOError => e
+      @write_buffer.clear
+      on_io_error(e)
     rescue StandardError => e
       @write_buffer.clear
       on_error(e)
@@ -375,6 +378,11 @@ module HTTPX
       current_session.deselect_connection(self, current_selector, @cloned)
     end
 
+    def on_io_error(e)
+      on_error(e)
+      force_close(true)
+    end
+
     def on_error(error, request = nil)
       if error.is_a?(OperationTimeoutError)
 
@@ -493,7 +501,7 @@ module HTTPX
           # flush as many bytes as the sockets allow.
           #
           loop do
-            # buffer has been drainned, mark and exit the write loop.
+            # 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?
@@ -586,6 +594,8 @@ module HTTPX
       # back to the pending list before the parser is reset.
       @inflight -= parser_pending_requests.size
       @pending.unshift(*parser_pending_requests)
+
+      parser.pending.clear
     end
 
     def build_parser(protocol = @io.protocol)
@@ -721,8 +731,6 @@ module HTTPX
 
         # do not deactivate connection in use
         return if @inflight.positive? || @parser.waiting_for_ping?
-
-        disconnect
       when :closing
         return unless connecting? || @state == :open
 
@@ -740,8 +748,9 @@ module HTTPX
         return unless @write_buffer.empty?
 
         purge_after_closed
-        disconnect if @pending.empty?
 
+        # TODO: should this raise an error instead?
+        return unless @pending.empty?
       when :already_open
         nextstate = :open
         # the first check for given io readiness must still use a timeout.
@@ -758,6 +767,11 @@ module HTTPX
       end
       log(level: 3) { "#{@state} -> #{nextstate}" }
       @state = nextstate
+      # post state change
+      case nextstate
+      when :closed, :inactive
+        disconnect
+      end
     end
 
     def close_sibling

data/lib/httpx/plugins/auth/digest.rb

@@ -8,7 +8,8 @@ module HTTPX
   module Plugins
     module Authentication
       class Digest
-        Error = Class.new(Error)
+        class Error < Error
+        end
 
         def initialize(user, password, hashed: false, **)
           @user = user

data/lib/httpx/plugins/cookies/cookie.rb

@@ -14,12 +14,14 @@ module HTTPX
 
       attr_reader :domain, :path, :name, :value, :created_at
 
+      # assigns a new +path+ to this cookie.
       def path=(path)
         path = String(path)
+        @for_domain = false
         @path = path.start_with?("/") ? path : "/"
       end
 
-      # See #domain.
+      # assigns a new +domain+ to this cookie.
       def domain=(domain)
         domain = String(domain)
 
@@ -37,6 +39,13 @@ module HTTPX
         @domain = @domain_name.hostname
       end
 
+      # checks whether +other+ is the same cookie, i.e. name, value, domain and path are
+      # the same.
+      def ==(other)
+        @name == other.name && @value == other.value &&
+          @path == other.path && @domain == other.domain
+      end
+
       # Compares the cookie with another.  When there are many cookies with
       # the same name for a URL, the value of the smallest must be used.
       def <=>(other)
@@ -47,11 +56,29 @@ module HTTPX
           (@created_at <=> other.created_at).nonzero? || 0
       end
 
+      def match?(name_or_options)
+        case name_or_options
+        when String
+          @name == name_or_options
+        when Hash, Array
+          name_or_options.all? { |k, v| respond_to?(k) && send(k) == v }
+        else
+          false
+        end
+      end
+
       class << self
         def new(cookie, *args)
-          return cookie if cookie.is_a?(self)
+          case cookie
+          when self
+            cookie
+          when Array, Hash
+            options = Hash[cookie] #: cookie_attributes
+            super(options[:name], options[:value], options)
+          else
 
-          super
+            super
+          end
         end
 
         # Tests if +target_path+ is under +base_path+ as described in RFC
@@ -84,16 +111,12 @@ module HTTPX
         end
       end
 
-      def initialize(arg, *attrs)
+      def initialize(arg, value, attrs = nil)
         @created_at = Time.now
 
-        if attrs.empty?
-          attr_hash = Hash.try_convert(arg)
-        else
-          @name = arg
-          @value, attr_hash = attrs
-          attr_hash = Hash.try_convert(attr_hash)
-        end
+        @name = arg
+        @value = value
+        attr_hash = Hash.try_convert(attrs)
 
         attr_hash.each do |key, val|
           key = key.downcase.tr("-", "_").to_sym unless key.is_a?(Symbol)

data/lib/httpx/plugins/cookies/jar.rb

@@ -4,7 +4,12 @@ module HTTPX
   module Plugins::Cookies
     # The Cookie Jar
     #
-    # It holds a bunch of cookies.
+    # It stores and manages cookies for a session, such as i.e. evicting when expired, access methods, or
+    # initialization from parsing `Set-Cookie` HTTP header values.
+    #
+    # It closely follows the [CookieStore API](https://developer.mozilla.org/en-US/docs/Web/API/CookieStore),
+    # by implementing the same methods, with a few specific conveniences for this non-browser manipulation use-case.
+    #
     class Jar
       using URIExtensions
 
@@ -12,10 +17,14 @@ module HTTPX
 
       def initialize_dup(orig)
         super
+        @mtx = orig.instance_variable_get(:@mtx).dup
         @cookies = orig.instance_variable_get(:@cookies).dup
       end
 
+      # initializes the cookie store, either empty, or with whatever is passed as +cookies+, which
+      # can be an array of HTTPX::Plugins::Cookies::Cookie objects or hashes-or-tuples of cookie attributes.
       def initialize(cookies = nil)
+        @mtx = Thread::Mutex.new
         @cookies = []
 
         cookies.each do |elem|
@@ -32,48 +41,106 @@ module HTTPX
         end if cookies
       end
 
+      # parses the `Set-Cookie` header value as +set_cookie+ and does the corresponding updates.
       def parse(set_cookie)
         SetCookieParser.call(set_cookie) do |name, value, attrs|
-          add(Cookie.new(name, value, attrs))
+          set(Cookie.new(name, value, attrs))
+        end
+      end
+
+      # returns the first HTTPX::Plugins::Cookie::Cookie instance in the store which matches either the name
+      # (when String) or all attributes (when a Hash or array of tuples) passed to +name_or_options+
+      def get(name_or_options)
+        each.find { |ck| ck.match?(name_or_options) }
+      end
+
+      # returns all HTTPX::Plugins::Cookie::Cookie instances in the store which match either the name
+      # (when String) or all attributes (when a Hash or array of tuples) passed to +name_or_options+
+      def get_all(name_or_options)
+        each.select { |ck| ck.match?(name_or_options) } # rubocop:disable Style/SelectByRegexp
+      end
+
+      # when +name+ is a HTTPX::Plugins::Cookie::Cookie, it stores it internally; when +name+ is a String,
+      # it creates a cookie with it and the value-or-attributes passed to +value_or_options+.
+
+      # optionally, +name+ can also be the attributes hash-or-array as long it contains a <tt>:name</tt> field).
+      def set(name, value_or_options = nil)
+        cookie = case name
+                 when Cookie
+                   raise ArgumentError, "there should not be a second argument" if value_or_options
+
+                   name
+                 when Array, Hash
+                   raise ArgumentError, "there should not be a second argument" if value_or_options
+
+                   Cookie.new(name)
+                 else
+                   raise ArgumentError, "the second argument is required" unless value_or_options
+
+                   Cookie.new(name, value_or_options)
+        end
+
+        synchronize do
+          # If the user agent receives a new cookie with the same cookie-name, domain-value, and path-value
+          # as a cookie that it has already stored, the existing cookie is evicted and replaced with the new cookie.
+          @cookies.delete_if { |ck| ck.name == cookie.name && ck.domain == cookie.domain && ck.path == cookie.path }
+
+          @cookies << cookie
         end
       end
 
+      # @deprecated
       def add(cookie, path = nil)
+        warn "DEPRECATION WARNING: calling `##{__method__}` is deprecated. Use `#set` instead."
         c = cookie.dup
-
         c.path = path if path && c.path == "/"
+        set(c)
+      end
 
-        # If the user agent receives a new cookie with the same cookie-name, domain-value, and path-value
-        # as a cookie that it has already stored, the existing cookie is evicted and replaced with the new cookie.
-        @cookies.delete_if { |ck| ck.name == c.name && ck.domain == c.domain && ck.path == c.path }
-
-        @cookies << c
+      # deletes all cookies  in the store which match either the name (when String) or all attributes (when a Hash
+      # or array of tuples) passed to +name_or_options+.
+      #
+      # alternatively, of +name_or_options+ is an instance of HTTPX::Plugins::Cookies::Cookiem, it deletes it from the store.
+      def delete(name_or_options)
+        synchronize do
+          case name_or_options
+          when Cookie
+            @cookies.delete(name_or_options)
+          else
+            @cookies.delete_if { |ck| ck.match?(name_or_options) }
+          end
+        end
       end
 
+      # returns the list of valid cookies which matdh the domain and path from the URI object passed to +uri+.
       def [](uri)
         each(uri).sort
       end
 
+      # enumerates over all stored cookies. if +uri+ is passed, it'll filter out expired cookies and
+      # only yield cookies which match its domain and path.
       def each(uri = nil, &blk)
         return enum_for(__method__, uri) unless blk
 
-        return @cookies.each(&blk) unless uri
+        return synchronize { @cookies.each(&blk) } unless uri
 
         now = Time.now
         tpath = uri.path
 
-        @cookies.delete_if do |cookie|
-          if cookie.expired?(now)
-            true
-          else
-            yield cookie if cookie.valid_for_uri?(uri) && Cookie.path_match?(cookie.path, tpath)
-            false
+        synchronize do
+          @cookies.delete_if do |cookie|
+            if cookie.expired?(now)
+              true
+            else
+              yield cookie if cookie.valid_for_uri?(uri) && Cookie.path_match?(cookie.path, tpath)
+              false
+            end
           end
         end
       end
 
       def merge(other)
-        cookies_dup = dup
+        jar_dup = dup
 
         other.each do |elem|
           cookie = case elem
@@ -85,10 +152,18 @@ module HTTPX
                      Cookie.new(elem)
           end
 
-          cookies_dup.add(cookie)
+          jar_dup.set(cookie)
         end
 
-        cookies_dup
+        jar_dup
+      end
+
+      private
+
+      def synchronize(&block)
+        return yield if @mtx.owned?
+
+        @mtx.synchronize(&block)
       end
     end
   end

data/lib/httpx/plugins/cookies.rb

@@ -7,8 +7,6 @@ module HTTPX
     #
     # This plugin implements a persistent cookie jar for the duration of a session.
     #
-    # It also adds a *#cookies* helper, so that you can pre-fill the cookies of a session.
-    #
     # https://gitlab.com/os85/httpx/wikis/Cookies
     #
     module Cookies
@@ -46,6 +44,12 @@ module HTTPX
           request
         end
 
+        # factory method to return a Jar to the user, which can then manipulate
+        # externally to the session.
+        def make_jar(*args)
+          Jar.new(*args)
+        end
+
         private
 
         def set_request_callbacks(request)
@@ -96,7 +100,7 @@ module HTTPX
           cookies.each do |ck|
             ck.split(/ *; */).each do |cookie|
               name, value = cookie.split("=", 2)
-              jar.add(Cookie.new(name, value))
+              jar.set(name, value)
             end
           end
         end

data/lib/httpx/plugins/expect.rb

@@ -9,10 +9,34 @@ module HTTPX
     #
     module Expect
       EXPECT_TIMEOUT = 2
+      NOEXPECT_STORE_MUTEX = Thread::Mutex.new
+
+      class Store
+        def initialize
+          @store = []
+          @mutex = Thread::Mutex.new
+        end
+
+        def include?(host)
+          @mutex.synchronize { @store.include?(host) }
+        end
+
+        def add(host)
+          @mutex.synchronize { @store << host }
+        end
+
+        def delete(host)
+          @mutex.synchronize { @store.delete(host) }
+        end
+      end
 
       class << self
         def no_expect_store
-          @no_expect_store ||= []
+          return Ractor.store_if_absent(:httpx_no_expect_store) { Store.new } if Utils.in_ractor?
+
+          @no_expect_store ||= NOEXPECT_STORE_MUTEX.synchronize do
+            @no_expect_store || Store.new
+          end
         end
 
         def extra_options(options)
@@ -89,7 +113,7 @@ module HTTPX
           set_request_timeout(:expect_timeout, request, expect_timeout, :expect, %i[body response]) do
             # expect timeout expired
             if request.state == :expect && !request.expects?
-              Expect.no_expect_store << request.origin
+              Expect.no_expect_store.add(request.origin)
               request.headers.delete("expect")
               consume
             end

data/lib/httpx/plugins/fiber_concurrency.rb

@@ -160,9 +160,7 @@ module HTTPX
         end
       end
 
-      module NativeResolverMethods
-        private
-
+      module ResolverNativeMethods
         def calculate_interests
           return if @queries.empty?
 
@@ -172,7 +170,7 @@ module HTTPX
         end
       end
 
-      module SystemResolverMethods
+      module ResolverSystemMethods
         def interests
           return unless @queries.any? { |_, conn| conn.current_context? }
 

data/lib/httpx/plugins/follow_redirects.rb

@@ -1,7 +1,9 @@
 # frozen_string_literal: true
 
 module HTTPX
-  InsecureRedirectError = Class.new(Error)
+  class InsecureRedirectError < Error
+  end
+
   module Plugins
     #
     # This plugin adds support for automatically following redirect (status 30X) responses.

data/lib/httpx/plugins/rate_limiter.rb

@@ -16,25 +16,7 @@ module HTTPX
 
       class << self
         def load_dependencies(klass)
-          klass.plugin(:retries, retry_after: method(:retry_after_rate_limit))
-        end
-
-        # Servers send the "Retry-After" header field to indicate how long the
-        # user agent ought to wait before making a follow-up request.  When
-        # sent with a 503 (Service Unavailable) response, Retry-After indicates
-        # how long the service is expected to be unavailable to the client.
-        # When sent with any 3xx (Redirection) response, Retry-After indicates
-        # the minimum time that the user agent is asked to wait before issuing
-        # the redirected request.
-        #
-        def retry_after_rate_limit(_, response)
-          return unless response.is_a?(Response)
-
-          retry_after = response.headers["retry-after"]
-
-          return unless retry_after
-
-          Utils.parse_retry_after(retry_after)
+          klass.plugin(:retries)
         end
       end
 
@@ -52,6 +34,24 @@ module HTTPX
         def rate_limit_error?(response)
           response.is_a?(Response) && RATE_LIMIT_CODES.include?(response.status)
         end
+
+        # Servers send the "Retry-After" header field to indicate how long the
+        # user agent ought to wait before making a follow-up request.  When
+        # sent with a 503 (Service Unavailable) response, Retry-After indicates
+        # how long the service is expected to be unavailable to the client.
+        # When sent with any 3xx (Redirection) response, Retry-After indicates
+        # the minimum time that the user agent is asked to wait before issuing
+        # the redirected request.
+        #
+        def when_to_retry(_, response, options)
+          return super unless response.is_a?(Response)
+
+          retry_after = response.headers["retry-after"]
+
+          return super unless retry_after
+
+          Utils.parse_retry_after(retry_after)
+        end
       end
     end
 

data/lib/httpx/plugins/retries.rb

@@ -148,10 +148,7 @@ module HTTPX
             log { "failed to get response, #{request.retries} tries to go..." }
             prepare_to_retry(request, response)
 
-            retry_after = options.retry_after
-            retry_after = retry_after.call(request, response) if retry_after.respond_to?(:call)
-
-            if retry_after
+            if (retry_after = when_to_retry(request, response, options))
               # apply jitter
               if (jitter = request.options.retry_jitter)
                 retry_after = jitter.call(retry_after)
@@ -201,6 +198,12 @@ module HTTPX
           request.transition(:idle)
         end
 
+        def when_to_retry(request, response, options)
+          retry_after = options.retry_after
+          retry_after = retry_after.call(request, response) if retry_after.respond_to?(:call)
+          retry_after
+        end
+
         #
         # Attempt to set the request to perform a partial range request.
         # This happens if the peer server accepts byte-range requests, and
@@ -237,14 +240,15 @@ module HTTPX
         def initialize(*args)
           super
           @retries = @options.max_retries
+          @partial_response = nil
         end
 
         def response=(response)
-          if @partial_response
+          if (partial_response = @partial_response)
             if response.is_a?(Response) && response.status == 206
-              response.from_partial_response(@partial_response)
+              response.from_partial_response(partial_response)
             else
-              @partial_response.close
+              partial_response.close
             end
             @partial_response = nil
           end

data/lib/httpx/plugins/ssrf_filter.rb

@@ -106,6 +106,7 @@ module HTTPX
             error = ServerSideRequestForgeryError.new("#{request.uri} URI scheme not allowed")
             error.set_backtrace(caller)
             response = ErrorResponse.new(request, error)
+            request.response = response
             request.emit(:response, response)
             response
           end

data/lib/httpx/plugins/stream_bidi.rb

@@ -189,6 +189,10 @@ module HTTPX
           !@closed
         end
 
+        def force_close(*)
+          terminate
+        end
+
         def terminate
           return if @closed
 
@@ -202,6 +206,8 @@ module HTTPX
           terminate
         end
 
+        alias_method :on_io_error, :on_error
+
         # noop (the owner connection will take of it)
         def handle_socket_timeout(interval); end
       end

data/lib/httpx/request.rb

@@ -91,7 +91,7 @@ module HTTPX
       raise UnsupportedSchemeError, "#{@uri}: #{@uri.scheme}: unsupported URI scheme" unless ALLOWED_URI_SCHEMES.include?(@uri.scheme)
 
       @state = :idle
-      @response = @peer_address = @informational_status = nil
+      @response = @drainer = @peer_address = @informational_status = nil
       @ping = false
       @persistent = @options.persistent
       @active_timeouts = []

data/lib/httpx/resolver/resolver.rb

@@ -119,6 +119,11 @@ module HTTPX
       end
     end
 
+    def on_io_error(e)
+      on_error(e)
+      force_close(true)
+    end
+
     def on_error(error)
       handle_error(error)
       disconnect

data/lib/httpx/selector.rb

@@ -204,8 +204,7 @@ module HTTPX
       rescue IOError => e
         (Array(r) + Array(w)).each do |sel|
           # TODO: is there a way to cheaply find the IO associated with the error?
-          sel.on_error(e)
-          sel.force_close(true)
+          sel.on_io_error(e)
         end
       rescue StandardError => e
         (Array(r) + Array(w)).each do |sel|
@@ -249,8 +248,9 @@ module HTTPX
           when :rw then rw_wait(io, interval)
           end
       rescue IOError => e
-        io.on_error(e)
-        io.force_close(true)
+        io.on_io_error(e)
+
+        return
       rescue StandardError => e
         io.on_error(e)
 

data/lib/httpx/session.rb

@@ -140,9 +140,10 @@ module HTTPX
       end
       selector.deregister(connection)
 
+      # do not check-in connections only created for Happy Eyeballs
       return if cloned
 
-      return if @closing && connection.state == :closed
+      return if @closing && connection.state == :closed && !connection.used?
 
       connection.log(level: 2) { "check-in connection##{connection.object_id}(#{connection.state}) in pool##{@pool.object_id}" }
       @pool.checkin_connection(connection)
@@ -177,16 +178,15 @@ module HTTPX
 
     # returns the HTTPX::Connection through which the +request+ should be sent through.
     def find_connection(request_uri, selector, options)
-      log(level: 2) { "finding connection for #{request_uri}..." }
       if (connection = selector.find_connection(request_uri, options))
         connection.idling if connection.state == :closed
-        connection.log(level: 2) { "found connection##{connection.object_id}(#{connection.state}) in selector##{selector.object_id}" }
+        log(level: 2) { "found connection##{connection.object_id}(#{connection.state}) in selector##{selector.object_id}" }
         return connection
       end
 
       connection = @pool.checkout_connection(request_uri, options)
 
-      connection.log(level: 2) { "found connection##{connection.object_id}(#{connection.state}) in pool##{@pool.object_id}" }
+      log(level: 2) { "found connection##{connection.object_id}(#{connection.state}) in pool##{@pool.object_id}" }
 
       case connection.state
       when :idle
@@ -240,7 +240,7 @@ module HTTPX
 
       return unless response && response.finished?
 
-      log(level: 2) { "response fetched" }
+      log(level: 2) { "response##{response.object_id} fetched" }
 
       response
     end
@@ -249,6 +249,7 @@ module HTTPX
     def send_request(request, selector, options = request.options)
       error = begin
         catch(:resolve_error) do
+          log(level: 2) { "finding connection for request##{request.object_id}..." }
           connection = find_connection(request.uri, selector, options)
           connection.send(request)
         end

data/lib/httpx/version.rb

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

data/sig/chainable.rbs

@@ -29,7 +29,7 @@ module HTTPX
               | (:proxy, ?options) -> (Plugins::sessionProxy & Plugins::httpProxy)
               | (:push_promise, ?options) -> Plugins::sessionPushPromise
               | (:retries, ?options) -> Plugins::sessionRetries
-              | (:rate_limiter, ?options) -> Session
+              | (:rate_limiter, ?options) -> Plugins::sessionRateLimiter
               | (:stream, ?options) -> Plugins::sessionStream
               | (:stream_bidi, ?options) -> Plugins::sessionStreamBidi
               | (:aws_sigv4, ?options) -> Plugins::awsSigV4Session

data/sig/connection/http2.rbs

@@ -79,6 +79,8 @@ module HTTPX
 
     def on_stream_refuse: (::HTTP2::Stream stream, Request request, StandardError error) -> void
 
+    def on_stream_half_close: (::HTTP2::Stream stream, Request request) -> void
+
     def on_stream_close: (::HTTP2::Stream stream, Request request, (Symbol | StandardError)? error) -> void
 
     def on_frame: (string bytes) -> void
@@ -87,13 +89,15 @@ module HTTPX
 
     def on_close: (Integer last_frame, Symbol? error, String? payload) -> void
 
-    def on_frame_sent: (::HTTP2::frame) -> void
+    def on_frame_sent: (::HTTP2::frame frame) -> void
+
+    def frame_with_extra_info: (::HTTP2::frame frame) -> Hash[Symbol, untyped]
 
-    def on_frame_received: (::HTTP2::frame) -> void
+    def on_frame_received: (::HTTP2::frame frame) -> void
 
-    def on_altsvc: (String origin, ::HTTP2::frame) -> void
+    def on_altsvc: (String origin, ::HTTP2::frame frame) -> void
 
-    def on_promise: (::HTTP2::Stream) -> void
+    def on_promise: (::HTTP2::Stream stream) -> void
 
     def on_origin: (String) -> void
 

data/sig/connection.rbs

@@ -37,6 +37,7 @@ module HTTPX
     @read_buffer: Buffer
     @write_buffer: Buffer
     @inflight: Integer
+    @max_concurrent_requests: Integer?
     @keep_alive_timeout: Numeric?
     @timeout: Numeric?
     @current_timeout: Numeric?
@@ -119,6 +120,8 @@ module HTTPX
 
     def on_error: (HTTPX::TimeoutError | Error | StandardError error, ?Request? request) -> void
 
+    def on_io_error: (IOError error) -> void
+
     private
 
     def initialize: (http_uri uri, Options options) -> void

data/sig/plugins/cookies/cookie.rbs

@@ -31,6 +31,8 @@ module HTTPX
       def cookie_value: () -> String
       alias to_s cookie_value
 
+      def match?: (String | cookie_attributes name_or_options) -> bool
+
       def valid_for_uri?: (http_uri uri) -> bool
 
       def self.new: (Cookie) -> instance
@@ -41,8 +43,7 @@ module HTTPX
 
       private
 
-      def initialize: (cookie_attributes) -> untyped
-                    | (_ToS, _ToS, ?cookie_attributes) -> untyped
+      def initialize: (_ToS name, _ToS value, ?cookie_attributes) -> void
 
       def acceptable_from_uri?: (uri) -> bool
 

data/sig/plugins/cookies/jar.rbs

@@ -6,11 +6,20 @@ module HTTPX
       include Enumerable[Cookie]
 
       @cookies: Array[Cookie]
+      @mtx: Thread::Mutex
 
       def parse: (String set_cookie) -> void
 
+      def get: (String | cookie_attributes name_or_options) -> Cookie?
+
+      def get_all: (String | cookie_attributes name_or_options) -> Array[Cookie]
+
+      def set: (_ToS | Cookie name, ?(cookie_attributes | _ToS) value_or_options) -> void
+
       def add: (Cookie name, ?String path) -> void
 
+      def delete: (String | Cookie | cookie_attributes name_or_options) -> void
+
       def []: (http_uri) -> Array[Cookie]
 
       def each: (?http_uri?) { (Cookie) -> void } -> void
@@ -21,6 +30,8 @@ module HTTPX
       private
 
       def initialize: (?_Each[cookie] cookies) -> untyped
+
+      def synchronize: [T] { () -> T } -> T
     end
   end
 end

data/sig/plugins/cookies.rbs

@@ -15,6 +15,8 @@ module HTTPX
 
       module InstanceMethods
         def cookies: () -> Jar
+
+        def make_jar: (*untyped) -> Jar
       end
 
       module HeadersMethods

data/sig/plugins/expect.rbs

@@ -2,14 +2,29 @@ module HTTPX
   module Plugins
     module Expect
       EXPECT_TIMEOUT: Integer
+      NOEXPECT_STORE_MUTEX: Thread::Mutex
+
+      self.@no_expect_store: Store
+      def self.no_expect_store: () -> Store
+
+      def self.extra_options: (Options) -> (Options & _ExpectOptions)
+
+      class Store
+        @store: Array[String]
+        @mutex: Thread::Mutex
+
+        def include?: (String host) -> bool
+
+        def add: (String host) -> void
+
+        def delete: (String host) -> void
+      end
 
       interface _ExpectOptions
         def expect_timeout: () -> Integer?
 
         def expect_threshold_size: () -> Integer?
       end
-
-      def self.extra_options: (Options) -> (Options & _ExpectOptions)
     end
   end
 end

data/sig/plugins/proxy/socks4.rbs

@@ -5,6 +5,10 @@ module HTTPX
   module Plugins
     module Proxy
       module Socks4
+        VERSION: Integer
+        CONNECT: Integer
+        GRANTED: Integer
+        PROTOCOLS: Array[String]
 
         module ConnectionMethods
           def __socks4_proxy_connect: () ->  void

data/sig/plugins/rate_limiter.rbs

@@ -5,11 +5,11 @@ module HTTPX
 
       def self.load_dependencies: (singleton(Session)) -> void
 
-      def self.retry_after_rate_limit: (untyped, response) -> Numeric?
-
       module InstanceMethods
         def rate_limit_error?: (response response) -> bool
       end
     end
+
+    type sessionRateLimiter = Session & RateLimiter::InstanceMethods
   end
 end

data/sig/plugins/response_cache.rbs

@@ -51,7 +51,7 @@ module HTTPX
       module ResponseMethods
         attr_writer original_request: cacheRequest
 
-        @cache: bool
+        @cached: bool
         @cache_control: Array[String]?
         @vary: Array[String]?
         @date: Time?
@@ -66,9 +66,9 @@ module HTTPX
 
         def fresh?: () -> bool
 
-        def cache_control: () -> Array[String]?
+         %a{pure} def cache_control: () -> Array[String]?
 
-        def vary: () -> Array[String]?
+         %a{pure} def vary: () -> Array[String]?
 
         private
 

data/sig/plugins/retries.rbs

@@ -8,16 +8,16 @@ module HTTPX
       DEFAULT_JITTER: ^(Numeric) -> Numeric
       BACKOFF_ALGORITHMS: Array[Symbol]
 
-      def self?.retry_after_polynomial_backoff: (retriesRequest request, response response) -> Numeric
+      def self?.retry_after_polynomial_backoff: (retriesRequest request, retriesResponse response) -> Numeric
 
-      def self?.retry_after_exponential_backoff: (retriesRequest request, response response) -> Numeric
+      def self?.retry_after_exponential_backoff: (retriesRequest request, retriesResponse response) -> Numeric
 
       interface _RetryCallback
-        def call: (response response) -> bool?
+        def call: (retriesResponse response) -> bool?
       end
 
       interface _RetriesOptions
-        def retry_after: () -> (^(retriesRequest request, response response) -> Numeric | Numeric)?
+        def retry_after: () -> (^(retriesRequest request, retriesResponse response) -> Numeric | Numeric)?
 
         def retry_jitter: () -> ^(Numeric jitter) -> Numeric
 
@@ -35,17 +35,19 @@ module HTTPX
 
         private
 
-        def fetch_response: (retriesRequest request, Selector selector, retriesOptions options) -> (retriesResponse | ErrorResponse)?
+        def fetch_response: (retriesRequest request, Selector selector, retriesOptions options) -> retriesResponse?
 
-        def retryable_request?: (retriesRequest request, response response, retriesOptions options) -> boolish
+        def retryable_request?: (retriesRequest request, retriesResponse response, retriesOptions options) -> boolish
 
-        def retryable_response?: (response response, retriesOptions options) -> boolish
+        def retryable_response?: (retriesResponse response, retriesOptions options) -> boolish
 
         def retryable_error?: (_Exception error, Options options) -> boolish
 
-        def try_partial_retry: (retriesRequest request, (retriesResponse | ErrorResponse) response) -> void
+        def try_partial_retry: (retriesRequest request, retriesResponse response) -> void
 
-        def prepare_to_retry: (Request & RequestMethods request, response response) -> void
+        def prepare_to_retry: (Request & RequestMethods request, retriesResponse response) -> void
+
+        def when_to_retry: (Request & RequestMethods request, retriesResponse response, retriesOptions options) -> void
       end
 
       module RequestMethods
@@ -53,20 +55,22 @@ module HTTPX
 
         attr_accessor retries: Integer
 
-        attr_writer partial_response: Response?
+        attr_writer partial_response: retriesResponse?
 
-        def response=: (retriesResponse | ErrorResponse response) -> void
+        def response=: (retriesResponse response) -> void
       end
 
       module ResponseMethods
-        def from_partial_response: (Response response) -> void
+        def from_partial_response: (retriesHTTPResponse response) -> void
       end
 
       type retriesOptions = Options & _RetriesOptions
 
       type retriesRequest = Request & RequestMethods
 
-      type retriesResponse = Response & ResponseMethods
+      type retriesHTTPResponse = Response & ResponseMethods
+
+      type retriesResponse = retriesHTTPResponse | ErrorResponse
     end
 
     type sessionRetries = Session & Retries::InstanceMethods

data/sig/request.rbs

@@ -6,6 +6,7 @@ module HTTPX
 
     METHODS: Array[Symbol]
     USER_AGENT: String
+    ALLOWED_URI_SCHEMES: Array[String]
 
     attr_reader verb: verb
     attr_reader uri: http_uri

data/sig/resolver/native.rbs

@@ -37,6 +37,8 @@ module HTTPX
 
       def handle_socket_timeout: (Numeric interval) -> void
 
+      def on_io_error: (IOError error) -> void
+
       private
 
       def initialize: (ip_family family, options options) -> void

data/sig/resolver/resolver.rbs

@@ -27,8 +27,6 @@ module HTTPX
 
       def terminate: () -> void
 
-      def force_close: (*untyped args) -> void
-
       def closed?: () -> bool
 
       def empty?: () -> bool
@@ -60,6 +58,8 @@ module HTTPX
       def resolve_error: (String hostname, ?StandardError?) -> (ResolveError | ResolveTimeoutError)
 
       def close_or_resolve: () -> void
+
+      def disconnect: () -> void
     end
   end
 end

data/sig/selector.rbs

@@ -13,6 +13,10 @@ module HTTPX
     def handle_socket_timeout: (Numeric interval) -> void
 
     def on_error: (StandardError) -> void
+
+    def on_io_error: (IOError error) -> void
+
+    def force_close: (?bool delete_pending) -> void
   end
 
   class Selector

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: httpx
 version: !ruby/object:Gem::Version
-  version: 1.7.2
+  version: 1.7.3
 platform: ruby
 authors:
 - Tiago Cardoso
@@ -15,14 +15,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 1.0.0
+        version: 1.1.3
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 1.0.0
+        version: 1.1.3
 description: A client library for making HTTP requests from Ruby.
 email:
 - cardoso_tiago@hotmail.com
@@ -162,6 +162,7 @@ extra_rdoc_files:
 - doc/release_notes/1_7_0.md
 - doc/release_notes/1_7_1.md
 - doc/release_notes/1_7_2.md
+- doc/release_notes/1_7_3.md
 files:
 - LICENSE.txt
 - README.md
@@ -296,6 +297,7 @@ files:
 - doc/release_notes/1_7_0.md
 - doc/release_notes/1_7_1.md
 - doc/release_notes/1_7_2.md
+- doc/release_notes/1_7_3.md
 - lib/httpx.rb
 - lib/httpx/adapters/datadog.rb
 - lib/httpx/adapters/faraday.rb