httpx 0.18.3 → 0.18.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 81b7e14071e0e1978c864c63b0c8146044f255a9b2f7d9d3e917b564fb301ffb
-  data.tar.gz: 7492d34e586d86e373f62f151ceb6962719fcec156597ff34dae4c10b8347072
+  metadata.gz: ab9b9577b0e266b140e21030307b3f2436af346a13f1e0931af05020ba42f7e6
+  data.tar.gz: c5d043448ef41b0532c08d1622540d80c68511ef59cffcc810a6f8bd92f348d5
 SHA512:
-  metadata.gz: 5c5930cd68b2ba0f42ea60e6dc5a76ff24b2643f16c300b778e8af62f0f04d8c01baadbf0163e2b925275bbfdf44d8dd73bbf78e06dd2c86b2e54d0eb99cbbdc
-  data.tar.gz: 20a70c6ffc8895c7b54f84f9832bc8831942048ba37dc83907e0b4fef83484d1f6797a0792b075539cb985a8df65798085f3089e6746d1246e9d27ef0cb63d96
+  metadata.gz: 8b4ec58f2ab031d23f28a86bc47b40d0f0d79eea9aea64590b0cc3d07269738513de1364608e0c0282a6956d816b78b900520dbad4daab1f73522b8b7f73d138
+  data.tar.gz: f2d2c297b530bfb3567ebcd1678bad1d729187dd75c9107839c925def1a708c4648fe80df614a01af02bce309594e256e274e042f3c6b8347182aebff1df9935

data/doc/release_notes/0_18_3.md

@@ -4,4 +4,4 @@
 
 * request bodies eager-loaded from enumerables yield duped partial chunks.
 
-An error was observed while looking at webmock integration, where requests formed via the multipart plugin where returning an empty string as body. The issue was caused by an optimization on multipart encoder, which reuses the same buffer when reading chunks. Unfortunately, these cannot be yielded the same way via IO.copy_stream, as the same (cleared) buffer will be used to generate the eager-loaded body chunks.
+An error was observed while looking at webmock integration, where requests formed via the multipart plugin were returning an empty string as body. The issue was caused by an optimization on multipart encoder, which reuses the same buffer when reading chunks. Unfortunately, these cannot be yielded the same way via IO.copy_stream, as the same (cleared) buffer will be used to generate the eager-loaded body chunks.

data/doc/release_notes/0_18_4.md

@@ -0,0 +1,14 @@
+# 0.18.4
+
+## Improvements
+
+* faraday adapter: added support for `#on_data` callback in order to support [faraday streaming](https://lostisland.github.io/faraday/usage/streaming).
+
+* multipart plugin: removed support for file mime type detection using `mime-types`. The reasoning behind it was that `mime-types` uses the filename, which is a very inaccurate detection strategy (ex: an mp4 video will be identified as `application/mp4`, instead of the correct `video/mp4`).
+* multipart plugin: supported for file mime type detection using `marcel` and `filemagic` was added. Both use the magic header bytes, which is a more accurate strategy for file type detection.
+
+## Bugfixes
+
+* webmock adapter has been reimplemented to work with `httpx` plugins (such as the `:retries` plugin). Some other fixes were applied to make it work better under `vcr` (a common `webmock` extension).
+
+* fixed the URI-related bug which was making requests stall under ruby 3.1 (still not officially testing against it).

data/doc/release_notes/0_18_5.md

@@ -0,0 +1,10 @@
+# 0.18.5
+
+## Improvements
+
+* ruby 3.1 is now officially supported.
+* when a user sets a `Host` header for an HTTP/2 request, this will be used in the `:authority` HTTP/2 pseudo-header, instead of silently ignored (mimicking what "curl" does).
+
+## Bugfixes
+
+* fixed "throw outside of catch block" error happening when pipelining requests on an HTTP/1 connection and resulting in a timeout.

data/doc/release_notes/0_18_6.md

@@ -0,0 +1,5 @@
+# 0.18.6
+
+## Bugfixes
+
+* multipart plugin: fixed missing constant in `filemagic` integration.

data/doc/release_notes/0_18_7.md

@@ -0,0 +1,5 @@
+# 0.18.6
+
+## Bugfixes
+
+* multipart plugin: fixed `filemagic` integration by rewinding the file after mime-type detection.

data/lib/httpx/adapters/faraday.rb

@@ -21,6 +21,17 @@ module Faraday
       end
       # :nocov:
 
+      unless Faraday::RequestOptions.method_defined?(:stream_response?)
+        module RequestOptionsExtensions
+          refine Faraday::RequestOptions do
+            def stream_response?
+              false
+            end
+          end
+        end
+        using RequestOptionsExtensions
+      end
+
       module RequestMixin
         using ::HTTPX::HashExtensions
 
@@ -64,6 +75,27 @@ module Faraday
 
       include RequestMixin
 
+      module OnDataPlugin
+        module RequestMethods
+          attr_writer :response_on_data
+
+          def response=(response)
+            super
+            response.body.on_data = @response_on_data
+          end
+        end
+
+        module ResponseBodyMethods
+          attr_writer :on_data
+
+          def write(chunk)
+            return super unless @on_data
+
+            @on_data.call(chunk, chunk.bytesize)
+          end
+        end
+      end
+
       class Session < ::HTTPX::Session
         plugin(:compression)
         plugin(:persistent)
@@ -137,15 +169,21 @@ module Faraday
         end
 
         def run
-          requests = @handlers.map { |handler| build_request(handler.env) }
           env = @handlers.last.env
 
-          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: { uri: env.request.proxy }) if env.request.proxy
+          session = session.plugin(OnDataPlugin) if env.request.stream_response?
+
+          requests = @handlers.map { |handler| session.build_request(*build_request(handler.env)) }
+
+          if env.request.stream_response?
+            requests.each do |request|
+              request.response_on_data = env.request.on_data
+            end
+          end
 
-          responses = session.request(requests)
+          responses = session.request(*requests)
           Array(responses).each_with_index do |response, index|
             handler = @handlers[index]
             handler.on_response.call(response)
@@ -179,11 +217,15 @@ module Faraday
           return handler
         end
 
-        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
-        response = session.__send__(meth, uri, **request_options)
+        session = session.plugin(:proxy).with(proxy: { uri: env.request.proxy }) if env.request.proxy
+        session = session.plugin(OnDataPlugin) if env.request.stream_response?
+
+        request = session.build_request(*build_request(env))
+
+        request.response_on_data = env.request.on_data if env.request.stream_response?
+
+        response = session.request(request)
         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|
           response_headers.merge!(response.headers)

data/lib/httpx/adapters/webmock.rb

@@ -16,56 +16,8 @@ module WebMock
     # Requests are "hijacked" at the session, before they're distributed to a connection.
     #
     module Plugin
-      module InstanceMethods
-        private
-
-        def send_requests(*requests)
-          request_signatures = requests.map do |request|
-            request_signature = _build_webmock_request_signature(request)
-            WebMock::RequestRegistry.instance.requested_signatures.put(request_signature)
-            request_signature
-          end
-
-          responses = request_signatures.map do |request_signature|
-            WebMock::StubRegistry.instance.response_for_request(request_signature)
-          end
-
-          real_requests = {}
-
-          requests.each_with_index.each_with_object([request_signatures, responses]) do |(request, idx), (sig_reqs, mock_responses)|
-            if (webmock_response = mock_responses[idx])
-              mock_responses[idx] = _build_from_webmock_response(request, webmock_response)
-              WebMock::CallbackRegistry.invoke_callbacks({ lib: :httpx }, sig_reqs[idx], webmock_response)
-              log { "mocking #{request.uri} with #{mock_responses[idx].inspect}" }
-            elsif WebMock.net_connect_allowed?(sig_reqs[idx].uri)
-              log { "performing #{request.uri}" }
-              real_requests[request] = idx
-            else
-              raise WebMock::NetConnectNotAllowedError, sig_reqs[idx]
-            end
-          end
-
-          unless real_requests.empty?
-            reqs = real_requests.keys
-            reqs.zip(super(*reqs)).each do |req, res|
-              idx = real_requests[req]
-
-              if WebMock::CallbackRegistry.any_callbacks?
-                webmock_response = _build_webmock_response(req, res)
-                WebMock::CallbackRegistry.invoke_callbacks(
-                  { lib: :httpx, real_request: true }, request_signatures[idx],
-                  webmock_response
-                )
-              end
-
-              responses[idx] = res
-            end
-          end
-
-          responses
-        end
-
-        def _build_webmock_request_signature(request)
+      class << self
+        def build_webmock_request_signature(request)
           uri = WebMock::Util::URI.heuristic_parse(request.uri)
           uri.path = uri.normalized_path.gsub("[^:]//", "/")
 
@@ -77,7 +29,7 @@ module WebMock
           )
         end
 
-        def _build_webmock_response(_request, response)
+        def build_webmock_response(_request, response)
           webmock_response = WebMock::Response.new
           webmock_response.status = [response.status, HTTP_REASONS[response.status]]
           webmock_response.body = response.body.to_s
@@ -85,10 +37,10 @@ module WebMock
           webmock_response
         end
 
-        def _build_from_webmock_response(request, webmock_response)
-          return _build_error_response(request, HTTPX::TimeoutError.new(1, "Timed out")) if webmock_response.should_timeout
+        def build_from_webmock_response(request, webmock_response)
+          return build_error_response(request, HTTPX::TimeoutError.new(1, "Timed out")) if webmock_response.should_timeout
 
-          return _build_error_response(request, webmock_response.exception) if webmock_response.exception
+          return build_error_response(request, webmock_response.exception) if webmock_response.exception
 
           response = request.options.response_class.new(request,
                                                         webmock_response.status[0],
@@ -98,10 +50,70 @@ module WebMock
           response
         end
 
-        def _build_error_response(request, exception)
+        def build_error_response(request, exception)
           HTTPX::ErrorResponse.new(request, exception, request.options)
         end
       end
+
+      module InstanceMethods
+        def build_connection(*)
+          connection = super
+          connection.once(:unmock_connection) do
+            pool.__send__(:resolve_connection, connection)
+            pool.__send__(:unregister_connection, connection) unless connection.addresses
+          end
+          connection
+        end
+      end
+
+      module ConnectionMethods
+        def initialize(*)
+          super
+          @mocked = true
+        end
+
+        def open?
+          return true if @mocked
+
+          super
+        end
+
+        def interests
+          return if @mocked
+
+          super
+        end
+
+        def send(request)
+          request_signature = Plugin.build_webmock_request_signature(request)
+          WebMock::RequestRegistry.instance.requested_signatures.put(request_signature)
+
+          if (mock_response = WebMock::StubRegistry.instance.response_for_request(request_signature))
+            response = Plugin.build_from_webmock_response(request, mock_response)
+            WebMock::CallbackRegistry.invoke_callbacks({ lib: :httpx }, request_signature, mock_response)
+            log { "mocking #{request.uri} with #{mock_response.inspect}" }
+            request.response = response
+            request.emit(:response, response)
+          elsif WebMock.net_connect_allowed?(request_signature.uri)
+            if WebMock::CallbackRegistry.any_callbacks?
+              request.on(:response) do |resp|
+                unless resp.is_a?(HTTPX::ErrorResponse)
+                  webmock_response = Plugin.build_webmock_response(request, resp)
+                  WebMock::CallbackRegistry.invoke_callbacks(
+                    { lib: :httpx, real_request: true }, request_signature,
+                    webmock_response
+                  )
+                end
+              end
+            end
+            @mocked = false
+            emit(:unmock_connection, self)
+            super
+          else
+            raise WebMock::NetConnectNotAllowedError, request_signature
+          end
+        end
+      end
     end
 
     class HttpxAdapter < HttpLibAdapter
@@ -109,12 +121,12 @@ module WebMock
 
       class << self
         def enable!
-          @original_session = ::HTTPX::Session
+          @original_session = HTTPX::Session
 
-          webmock_session = ::HTTPX.plugin(Plugin)
+          webmock_session = HTTPX.plugin(Plugin)
 
-          ::HTTPX.send(:remove_const, :Session)
-          ::HTTPX.send(:const_set, :Session, webmock_session.class)
+          HTTPX.send(:remove_const, :Session)
+          HTTPX.send(:const_set, :Session, webmock_session.class)
         end
 
         def disable!

data/lib/httpx/altsvc.rb

@@ -70,7 +70,7 @@ module HTTPX
 
       scanner = StringScanner.new(altsvc)
       until scanner.eos?
-        alt_origin = scanner.scan(/[^=]+=("[^"]+"|[^;,]+)/)
+        alt_service = scanner.scan(/[^=]+=("[^"]+"|[^;,]+)/)
 
         alt_params = []
         loop do
@@ -80,29 +80,45 @@ module HTTPX
           break if scanner.eos? || scanner.scan(/ *, */)
         end
         alt_params = Hash[alt_params.map { |field| field.split("=") }]
-        yield(parse_altsvc_origin(alt_origin), alt_params)
+
+        alt_proto, alt_authority = alt_service.split("=")
+        alt_origin = parse_altsvc_origin(alt_proto, alt_authority)
+        return unless alt_origin
+
+        yield(alt_origin, alt_params.merge("proto" => alt_proto))
+      end
+    end
+
+    def parse_altsvc_scheme(alt_proto)
+      case alt_proto
+      when "h2c"
+        "http"
+      when "h2"
+        "https"
       end
     end
 
     # :nocov:
     if RUBY_VERSION < "2.2"
-      def parse_altsvc_origin(alt_origin)
-        alt_proto, alt_origin = alt_origin.split("=")
+      def parse_altsvc_origin(alt_proto, alt_origin)
+        alt_scheme = parse_altsvc_scheme(alt_proto) or return
+
         alt_origin = alt_origin[1..-2] if alt_origin.start_with?("\"") && alt_origin.end_with?("\"")
         if alt_origin.start_with?(":")
-          alt_origin = "#{alt_proto}://dummy#{alt_origin}"
+          alt_origin = "#{alt_scheme}://dummy#{alt_origin}"
           uri = URI.parse(alt_origin)
           uri.host = nil
           uri
         else
-          URI.parse("#{alt_proto}://#{alt_origin}")
+          URI.parse("#{alt_scheme}://#{alt_origin}")
         end
       end
     else
-      def parse_altsvc_origin(alt_origin)
-        alt_proto, alt_origin = alt_origin.split("=")
+      def parse_altsvc_origin(alt_proto, alt_origin)
+        alt_scheme = parse_altsvc_scheme(alt_proto) or return
         alt_origin = alt_origin[1..-2] if alt_origin.start_with?("\"") && alt_origin.end_with?("\"")
-        URI.parse("#{alt_proto}://#{alt_origin}")
+
+        URI.parse("#{alt_scheme}://#{alt_origin}")
       end
     end
     # :nocov:

data/lib/httpx/connection/http1.rb

@@ -184,7 +184,7 @@ module HTTPX
       end
 
       if @pipelining
-        disable
+        catch(:called) { disable }
       else
         @requests.each do |request|
           emit(:error, request, ex)
@@ -297,10 +297,6 @@ module HTTPX
       extra_headers
     end
 
-    def headline_uri(request)
-      request.path
-    end
-
     def handle(request)
       catch(:buffer_full) do
         request.transition(:headers)
@@ -314,8 +310,12 @@ module HTTPX
       end
     end
 
+    def join_headline(request)
+      "#{request.verb.to_s.upcase} #{request.path} HTTP/#{@version.join(".")}"
+    end
+
     def join_headers(request)
-      headline = "#{request.verb.to_s.upcase} #{headline_uri(request)} HTTP/#{@version.join(".")}"
+      headline = join_headline(request)
       @buffer << headline << CRLF
       log(color: :yellow) { "<- HEADLINE: #{headline.chomp.inspect}" }
       extra_headers = set_protocol_headers(request)

data/lib/httpx/connection/http2.rb

@@ -158,10 +158,6 @@ module HTTPX
       end
     end
 
-    def headline_uri(request)
-      request.path
-    end
-
     def handle(request, stream)
       catch(:buffer_full) do
         request.transition(:headers)
@@ -213,13 +209,19 @@ module HTTPX
       {
         ":scheme" => request.scheme,
         ":method" => request.verb.to_s.upcase,
-        ":path" => headline_uri(request),
+        ":path" => request.path,
         ":authority" => request.authority,
       }
     end
 
     def join_headers(stream, request)
       extra_headers = set_protocol_headers(request)
+
+      if request.headers.key?("host")
+        log { "forbidden \"host\" header found (#{request.headers["host"]}), will use it as authority..." }
+        extra_headers[":authority"] = request.headers["host"]
+      end
+
       log(level: 1, color: :yellow) do
         request.headers.merge(extra_headers).each.map { |k, v| "#{stream.id}: -> HEADER: #{k}: #{v}" }.join("\n")
       end

data/lib/httpx/connection.rb

@@ -44,7 +44,7 @@ module HTTPX
 
     def_delegator :@write_buffer, :empty?
 
-    attr_reader :origin, :state, :pending, :options
+    attr_reader :origin, :origins, :state, :pending, :options
 
     attr_writer :timers
 
@@ -489,6 +489,18 @@ module HTTPX
     end
 
     def transition(nextstate)
+      handle_transition(nextstate)
+   rescue Errno::ECONNREFUSED,
+          Errno::EADDRNOTAVAIL,
+          Errno::EHOSTUNREACH,
+          TLSError => e
+     # connect errors, exit gracefully
+     handle_error(e)
+     @state = :closed
+     emit(:close)
+    end
+
+    def handle_transition(nextstate)
       case nextstate
       when :idle
         @timeout = @current_timeout = @options.timeout[:connect_timeout]
@@ -525,14 +537,6 @@ module HTTPX
         emit(:activate)
       end
       @state = nextstate
-    rescue Errno::ECONNREFUSED,
-           Errno::EADDRNOTAVAIL,
-           Errno::EHOSTUNREACH,
-           TLSError => e
-      # connect errors, exit gracefully
-      handle_error(e)
-      @state = :closed
-      emit(:close)
     end
 
     def purge_after_closed
@@ -550,6 +554,10 @@ module HTTPX
           ex.set_backtrace(error.backtrace)
           error = ex
         else
+          # inactive connections do not contribute to the select loop, therefore
+          # they should fail due to such errors.
+          return if @state == :inactive
+
           if @timeout
             @timeout -= error.timeout
             return unless @timeout <= 0

data/lib/httpx/io/tcp.rb

@@ -57,7 +57,9 @@ module HTTPX
         @io = build_socket
       end
       try_connect
-    rescue Errno::EHOSTUNREACH => e
+    rescue Errno::ECONNREFUSED,
+           Errno::EADDRNOTAVAIL,
+           Errno::EHOSTUNREACH => e
       raise e if @ip_index <= 0
 
       @ip_index -= 1

data/lib/httpx/io/udp.rb

@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 
-require "socket"
 require "ipaddr"
 
 module HTTPX

data/lib/httpx/plugins/internal_telemetry.rb

@@ -81,7 +81,7 @@ module HTTPX
           super
         end
 
-        def transition(nextstate)
+        def handle_transition(nextstate)
           state = @state
           super
           meter_elapsed_time("Connection##{object_id}[#{@origin}]: #{state} -> #{nextstate}") if nextstate == @state

data/lib/httpx/plugins/multipart/mime_type_detector.rb

@@ -8,11 +8,25 @@ module HTTPX
       DEFAULT_MIMETYPE = "application/octet-stream"
 
       # inspired by https://github.com/shrinerb/shrine/blob/master/lib/shrine/plugins/determine_mime_type.rb
-      if defined?(MIME::Types)
+      if defined?(FileMagic)
+        MAGIC_NUMBER = 256 * 1024
 
-        def call(_file, filename)
-          mime = MIME::Types.of(filename).first
-          mime.content_type if mime
+        def call(file, _)
+          return nil if file.eof? # FileMagic returns "application/x-empty" for empty files
+
+          mime = FileMagic.open(FileMagic::MAGIC_MIME_TYPE) do |filemagic|
+            filemagic.buffer(file.read(MAGIC_NUMBER))
+          end
+
+          file.rewind
+
+          mime
+        end
+      elsif defined?(Marcel)
+        def call(file, filename)
+          return nil if file.eof? # marcel returns "application/octet-stream" for empty files
+
+          Marcel::MimeType.for(file, name: filename)
         end
 
       elsif defined?(MimeMagic)

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

@@ -13,7 +13,7 @@ module HTTPX
 
           private
 
-          def transition(nextstate)
+          def handle_transition(nextstate)
             return super unless @options.proxy && @options.proxy.uri.scheme == "http"
 
             case nextstate
@@ -23,7 +23,8 @@ module HTTPX
               @io.connect
               return unless @io.connected?
 
-              @parser = ConnectProxyParser.new(@write_buffer, @options.merge(max_concurrent_requests: 1))
+              @parser = registry(@io.protocol).new(@write_buffer, @options.merge(max_concurrent_requests: 1))
+              @parser.extend(ProxyParser)
               @parser.once(:response, &method(:__http_on_connect))
               @parser.on(:close) { transition(:closing) }
               __http_proxy_connect
@@ -36,7 +37,7 @@ module HTTPX
                 @parser.close
                 @parser = nil
               when :idle
-                @parser = ProxyParser.new(@write_buffer, @options)
+                @parser.callbacks.clear
                 set_parser_callbacks(@parser)
               end
             end
@@ -54,7 +55,7 @@ module HTTPX
               @inflight += 1
               parser.send(connect_request)
             else
-              transition(:connected)
+              handle_transition(:connected)
             end
           end
 
@@ -76,9 +77,11 @@ module HTTPX
           end
         end
 
-        class ProxyParser < Connection::HTTP1
-          def headline_uri(request)
-            request.uri.to_s
+        module ProxyParser
+          def join_headline(request)
+            return super if request.verb == :connect
+
+            "#{request.verb.to_s.upcase} #{request.uri} HTTP/#{@version.join(".")}"
           end
 
           def set_protocol_headers(request)
@@ -91,22 +94,6 @@ module HTTPX
           end
         end
 
-        class ConnectProxyParser < ProxyParser
-          attr_reader :pending
-
-          def headline_uri(request)
-            return super unless request.verb == :connect
-
-            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? }
-          end
-        end
-
         class ConnectRequest < Request
           def initialize(uri, _options)
             super(:connect, uri, {})

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

@@ -27,7 +27,7 @@ module HTTPX
 
           private
 
-          def transition(nextstate)
+          def handle_transition(nextstate)
             return super unless @options.proxy && PROTOCOLS.include?(@options.proxy.uri.scheme)
 
             case nextstate

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

@@ -46,7 +46,7 @@ module HTTPX
 
           private
 
-          def transition(nextstate)
+          def handle_transition(nextstate)
             return super unless @options.proxy && @options.proxy.uri.scheme == "socks5"
 
             case nextstate

data/lib/httpx/plugins/proxy.rb

@@ -85,7 +85,7 @@ module HTTPX
             end
             uris
           end
-          options.proxy.merge(uri: @_proxy_uris.first) unless @_proxy_uris.empty?
+          { uri: @_proxy_uris.first } unless @_proxy_uris.empty?
         end
 
         def find_connection(request, connections, options)
@@ -109,8 +109,10 @@ module HTTPX
           return super unless proxy
 
           connection = options.connection_class.new("tcp", uri, options)
-          pool.init_connection(connection, options)
-          connection
+          catch(:coalesced) do
+            pool.init_connection(connection, options)
+            connection
+          end
         end
 
         def fetch_response(request, connections, options)
@@ -138,10 +140,20 @@ module HTTPX
           error = response.error
           case error
           when NativeResolveError
+            return false unless @_proxy_uris && !@_proxy_uris.empty?
+
+            proxy_uri = URI(@_proxy_uris.first)
+
+            origin = error.connection.origin
+
             # failed resolving proxy domain
-            error.connection.origin.to_s == @_proxy_uris.first
+            origin.host == proxy_uri.host && origin.port == proxy_uri.port
           when ResolveError
-            error.message.end_with?(@_proxy_uris.first)
+            return false unless @_proxy_uris && !@_proxy_uris.empty?
+
+            proxy_uri = URI(@_proxy_uris.first)
+
+            error.message.end_with?(proxy_uri.to_s)
           when *PROXY_ERRORS
             # timeout errors connecting to proxy
             true
@@ -160,7 +172,9 @@ module HTTPX
 
           # redefining the connection origin as the proxy's URI,
           # as this will be used as the tcp peer ip.
-          @origin = URI(@options.proxy.uri.origin)
+          proxy_uri = URI(@options.proxy.uri)
+          @origin.host = proxy_uri.host
+          @origin.port = proxy_uri.port
         end
 
         def match?(uri, options)
@@ -169,11 +183,20 @@ module HTTPX
           super && @options.proxy == options.proxy
         end
 
-        # should not coalesce connections here, as the IP is the IP of the proxy
-        def coalescable?(*)
+        def coalescable?(connection)
           return super unless @options.proxy
 
-          false
+          if @io.protocol == "h2" &&
+             @origin.scheme == "https" &&
+             connection.origin.scheme == "https" &&
+             @io.can_verify_peer?
+            # in proxied connections, .origin is the proxy ; Given names
+            # are stored in .origins, this is what is used.
+            origin = URI(connection.origins.first)
+            @io.verify_hostname(origin.host)
+          else
+            @origin == connection.origin
+          end
         end
 
         def send(request)
@@ -222,7 +245,7 @@ module HTTPX
           end
         end
 
-        def transition(nextstate)
+        def handle_transition(nextstate)
           return super unless @options.proxy
 
           case nextstate

data/lib/httpx/resolver/https.rb

@@ -29,7 +29,7 @@ module HTTPX
     attr_writer :pool
 
     def initialize(options)
-      @options = Options.new(options)
+      @options = HTTPX::Options.new(options)
       @resolver_options = DEFAULTS.merge(@options.resolver_options)
       @_record_types = Hash.new { |types, host| types[host] = @resolver_options[:record_types].dup }
       @queries = {}

data/lib/httpx/resolver/native.rb

@@ -50,7 +50,7 @@ module HTTPX
     attr_reader :state
 
     def initialize(options)
-      @options = Options.new(options)
+      @options = HTTPX::Options.new(options)
       @ns_index = 0
       @resolver_options = DEFAULTS.merge(@options.resolver_options)
       @nameserver = @resolver_options[:nameserver]
@@ -200,6 +200,7 @@ module HTTPX
         hostname, connection = @queries.first
         if @_record_types[hostname].empty?
           @queries.delete(hostname)
+          @timeouts.delete(hostname)
           @connections.delete(connection)
           ex = NativeResolveError.new(connection, hostname, e.message)
           ex.set_backtrace(e.backtrace)
@@ -213,6 +214,7 @@ module HTTPX
         if @_record_types[hostname].empty?
           @queries.delete(hostname)
           @_record_types.delete(hostname)
+          @timeouts.delete(hostname)
           @connections.delete(connection)
 
           raise NativeResolveError.new(connection, hostname)
@@ -236,13 +238,18 @@ module HTTPX
         end
 
         if address.key?("alias") # CNAME
-          if early_resolve(connection, hostname: address["alias"])
+          # clean up intermediate queries
+          @timeouts.delete(address["name"]) unless connection.origin.host == address["name"]
+
+          if catch(:coalesced) { early_resolve(connection, hostname: address["alias"]) }
+            @timeouts.delete(connection.origin.host)
             @connections.delete(connection)
           else
             resolve(connection, address["alias"])
             return
           end
         else
+          @timeouts.delete(connection.origin.host)
           @connections.delete(connection)
           Resolver.cached_lookup_set(connection.origin.host, addresses) if @resolver_options[:cache]
           emit_addresses(connection, addresses.map { |addr| addr["data"] })

data/lib/httpx/resolver/resolver_mixin.rb

@@ -32,7 +32,7 @@ module HTTPX
         end
         log { "resolver: answer #{connection.origin.host}: #{addresses.inspect}" }
         connection.addresses = addresses
-        catch(:coalesced) { emit(:resolve, connection) }
+        emit(:resolve, connection)
       end
 
       def early_resolve(connection, hostname: connection.origin.host)

data/lib/httpx/resolver/system.rb

@@ -15,7 +15,7 @@ module HTTPX
     attr_reader :state
 
     def initialize(options)
-      @options = Options.new(options)
+      @options = HTTPX::Options.new(options)
       @resolver_options = @options.resolver_options
       @state = :idle
       resolv_options = @resolver_options.dup

data/lib/httpx/session.rb

@@ -163,7 +163,7 @@ module HTTPX
         case uri.scheme
         when "http"
           "tcp"
-        when "https", "h2"
+        when "https"
           "ssl"
         else
           raise UnsupportedSchemeError, "#{uri}: #{uri.scheme}: unsupported URI scheme"
@@ -207,7 +207,7 @@ module HTTPX
 
           return responses unless request
 
-          pool.next_tick until (response = fetch_response(request, connections, request.options))
+          catch(:coalesced) { pool.next_tick } until (response = fetch_response(request, connections, request.options))
 
           responses << response
           requests.shift
@@ -309,18 +309,4 @@ module HTTPX
       # :nocov:
     end
   end
-
-  unless ENV.grep(/https?_proxy$/i).empty?
-    proxy_session = plugin(:proxy)
-    ::HTTPX.send(:remove_const, :Session)
-    ::HTTPX.send(:const_set, :Session, proxy_session.class)
-  end
-
-  # :nocov:
-  if Session.default_options.debug_level > 2
-    proxy_session = plugin(:internal_telemetry)
-    ::HTTPX.send(:remove_const, :Session)
-    ::HTTPX.send(:const_set, :Session, proxy_session.class)
-  end
-  # :nocov:
 end

data/lib/httpx/session_extensions.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module HTTPX
+  unless ENV.keys.grep(/\Ahttps?_proxy\z/i).empty?
+    proxy_session = plugin(:proxy)
+    remove_const(:Session)
+    const_set(:Session, proxy_session.class)
+    remove_const(:Options)
+    const_set(:Options, proxy_session.class.default_options.class)
+  end
+
+  # :nocov:
+  if Session.default_options.debug_level > 2
+    proxy_session = plugin(:internal_telemetry)
+    remove_const(:Session)
+    const_set(:Session, proxy_session.class)
+  end
+  # :nocov:
+end

data/lib/httpx/version.rb

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

data/lib/httpx.rb

@@ -64,3 +64,4 @@ module HTTPX
 end
 
 require "httpx/session"
+require "httpx/session_extensions"

data/sig/connection/http1.rbs

@@ -67,8 +67,6 @@ module HTTPX
 
     def set_protocol_headers: (Request) -> _Each[[String, String]]
 
-    def headline_uri: (Request) -> String
-
     def handle: (Request request) -> void
 
     def join_headers: (Request request) -> void

data/sig/connection/http2.rbs

@@ -46,8 +46,6 @@ module HTTPX
 
     def send_pending: () -> void
 
-    def headline_uri: (Request) -> String
-
     def set_protocol_headers: (Request) -> _Each[[String, String]]
 
     def handle: (Request request, HTTP2Next::Stream stream) -> void
@@ -56,6 +54,8 @@ module HTTPX
 
     def handle_stream: (HTTP2Next::Stream stream, Request request) -> void
 
+    def join_headline: (Request request) -> String
+
     def join_headers: (HTTP2Next::Stream stream, Request request) -> void
 
     def join_trailers: (HTTP2Next::Stream stream, Request request) -> void

data/sig/connection.rbs

@@ -22,6 +22,7 @@ module HTTPX
     BUFFER_SIZE: Integer
 
     attr_reader origin: URI::Generic
+    attr_reader origins: Array[String]
     attr_reader state: Symbol
     attr_reader pending: Array[Request]
     attr_reader options: Options

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: httpx
 version: !ruby/object:Gem::Version
-  version: 0.18.3
+  version: 0.18.7
 platform: ruby
 authors:
 - Tiago Cardoso
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-12-14 00:00:00.000000000 Z
+date: 2022-01-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: http-2-next
@@ -66,6 +66,10 @@ extra_rdoc_files:
 - doc/release_notes/0_18_1.md
 - doc/release_notes/0_18_2.md
 - doc/release_notes/0_18_3.md
+- doc/release_notes/0_18_4.md
+- doc/release_notes/0_18_5.md
+- doc/release_notes/0_18_6.md
+- doc/release_notes/0_18_7.md
 - doc/release_notes/0_1_0.md
 - doc/release_notes/0_2_0.md
 - doc/release_notes/0_2_1.md
@@ -125,6 +129,10 @@ files:
 - doc/release_notes/0_18_1.md
 - doc/release_notes/0_18_2.md
 - doc/release_notes/0_18_3.md
+- doc/release_notes/0_18_4.md
+- doc/release_notes/0_18_5.md
+- doc/release_notes/0_18_6.md
+- doc/release_notes/0_18_7.md
 - doc/release_notes/0_1_0.md
 - doc/release_notes/0_2_0.md
 - doc/release_notes/0_2_1.md
@@ -228,6 +236,7 @@ files:
 - lib/httpx/selector.rb
 - lib/httpx/session.rb
 - lib/httpx/session2.rb
+- lib/httpx/session_extensions.rb
 - lib/httpx/timers.rb
 - lib/httpx/transcoder.rb
 - lib/httpx/transcoder/body.rb
@@ -322,7 +331,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.2.22
+rubygems_version: 3.2.32
 signing_key:
 specification_version: 4
 summary: HTTPX, to the future, and beyond