httpx 0.24.1 → 0.24.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 588deec0af9ead32480f7cca9ce8c278b344ccdd2e608cc2a6a8db8c6135647f
-  data.tar.gz: 3b69af49050cd6ba7b0317ddcd2286cbe6a2261add9fd0b9839bb89290e3962a
+  metadata.gz: 145a6e293b5ae6bfc1008765a755ab823d490edf7c50bdbf1de01194e3e1537b
+  data.tar.gz: 42d235a66fdb050a993b305d3aefed91893d26253cc62864ff2d0d088167ef0a
 SHA512:
-  metadata.gz: e630447fb6bc2aabb6efd842fdd322734e78e7859ea03126ab3d45cf4580d91ede945aa4e77700ae6cbe92179cc0a7e96fdc294ccaf729b287c4b4269b9b40b8
-  data.tar.gz: 138310fead4041c202f32b3e53564023472383f5cc251c59cc88b115c8f2947801da8269518d3dce48ff8b53abe3b1350d92b553a9264be8ab052064a135b605
+  metadata.gz: 7b10d4d91debc907d3445526ab864357a1e39cddfbe8b628f104241ed9015ae340e122dd49535be21bda7b20b95ebc047db4c476b7ff412e310d685f835e62c3
+  data.tar.gz: 3d82a8bc8bc3d5e6f94c2dde6f330ab52a3a42e0cd95e4b62328e4b6b005aac9946d1903d384f0944112e997ca26801dc342d77b44290dddb8e88ec0523e1338

data/doc/release_notes/0_24_2.md

@@ -0,0 +1,12 @@
+# 0.24.2
+
+## Improvements
+
+* besides an array, `:resolver_options` can now receive a hash for `:nameserver`, which **must** be indexed by IP family (`Socket::AF_INET6` or `Socket::AF_INET`); each group of nameservers will be used for emitting DNS queries of that iP family.
+* `:authentication` plugin: Added `#bearer_auth` helper, which receives a token, and sets it as `"Bearer $TOKEN` in the `"authorization"` header.
+* `faraday` adapter: now implements `#build_connection` and `#close`, will now interact with `faraday` native timeouts (`:read`, `:write` and `:connect`).
+
+
+## Bugfixes
+
+* fixed native resolver bug when queries involving intermediate alias would be kept after the original query and mess with re-queries.

data/doc/release_notes/0_24_3.md

@@ -0,0 +1,12 @@
+# 0.24.3
+
+## Improvements
+
+* faraday adapter: reraise httpx timeout errors as faraday errors.
+* faraday adapter: support `:bind` option, which expects a host and port to connect to.
+
+## Bugfixes
+
+* faraday adapter: fix `#close` implementation using the wrong ivar.
+* faraday adapter: fix usage of `requestt_timeout` translation of faraday timeouts into httpx timeouts.
+* faraday adapter: `ssl: { verify: false }` was being ignored, and certification verification was still proceeding.

data/lib/httpx/adapters/faraday.rb

@@ -35,8 +35,55 @@ module Faraday
       module RequestMixin
         using ::HTTPX::HashExtensions
 
+        def build_connection(env)
+          return @connection if defined?(@connection)
+
+          @connection = ::HTTPX.plugin(:compression).plugin(:persistent).plugin(ReasonPlugin)
+          @connection = @connection.with(@connection_options) unless @connection_options.empty?
+          connection_opts = options_from_env(env)
+
+          if (bind = env.request.bind)
+            @bind = TCPSocket.new(bind[:host], bind[:port])
+            connection_opts[:io] = @bind
+          end
+          @connection = @connection.with(connection_opts)
+
+          if (proxy = env.request.proxy)
+            proxy_options = { uri: proxy.uri }
+            proxy_options[:username] = proxy.user if proxy.user
+            proxy_options[:password] = proxy.password if proxy.password
+
+            @connection = @connection.plugin(:proxy).with(proxy: proxy_options)
+          end
+          @connection = @connection.plugin(OnDataPlugin) if env.request.stream_response?
+
+          @connection
+        end
+
+        def close
+          @connection.close if @connection
+          @bind.close if @bind
+        end
+
         private
 
+        def connect(env, &blk)
+          connection(env, &blk)
+        rescue ::HTTPX::TLSError => e
+          raise SSL_ERROR, e
+        rescue Errno::ECONNABORTED,
+               Errno::ECONNREFUSED,
+               Errno::ECONNRESET,
+               Errno::EHOSTUNREACH,
+               Errno::EINVAL,
+               Errno::ENETUNREACH,
+               Errno::EPIPE,
+               ::HTTPX::ConnectionError => e
+          raise CONNECTION_FAILED_ERROR, e
+        rescue ::HTTPX::TimeoutError => e
+          raise Faraday::TimeoutError, e
+        end
+
         def build_request(env)
           meth = env[:method]
 
@@ -48,28 +95,40 @@ module Faraday
         end
 
         def options_from_env(env)
-          timeout_options = {
-            connect_timeout: env.request.open_timeout,
-            operation_timeout: env.request.timeout,
-          }.compact
+          timeout_options = {}
+          req_opts = env.request
+          if (sec = request_timeout(:read, req_opts))
+            timeout_options[:operation_timeout] = sec
+          end
+
+          if (sec = request_timeout(:write, req_opts))
+            timeout_options[:operation_timeout] = sec
+          end
+
+          if (sec = request_timeout(:open, req_opts))
+            timeout_options[:connect_timeout] = sec
+          end
+
+          ssl_options = {}
+
+          unless env.ssl.verify.nil?
+            ssl_options[:verify_mode] = env.ssl.verify ? OpenSSL::SSL::VERIFY_PEER : OpenSSL::SSL::VERIFY_NONE
+          end
 
-          options = {
-            ssl: {},
+          ssl_options[:ca_file] = env.ssl.ca_file if env.ssl.ca_file
+          ssl_options[:ca_path] = env.ssl.ca_path if env.ssl.ca_path
+          ssl_options[:cert_store] = env.ssl.cert_store if env.ssl.cert_store
+          ssl_options[:cert] = env.ssl.client_cert if env.ssl.client_cert
+          ssl_options[:key] = env.ssl.client_key if env.ssl.client_key
+          ssl_options[:ssl_version] = env.ssl.version if env.ssl.version
+          ssl_options[:verify_depth] = env.ssl.verify_depth if env.ssl.verify_depth
+          ssl_options[:min_version] = env.ssl.min_version if env.ssl.min_version
+          ssl_options[:max_version] = env.ssl.max_version if env.ssl.max_version
+
+          {
+            ssl: ssl_options,
             timeout: timeout_options,
           }
-
-          options[:ssl][:verify_mode] = OpenSSL::SSL::VERIFY_PEER if env.ssl.verify
-          options[:ssl][:ca_file] = env.ssl.ca_file if env.ssl.ca_file
-          options[:ssl][:ca_path] = env.ssl.ca_path if env.ssl.ca_path
-          options[:ssl][:cert_store] = env.ssl.cert_store if env.ssl.cert_store
-          options[:ssl][:cert] = env.ssl.client_cert if env.ssl.client_cert
-          options[:ssl][:key] = env.ssl.client_key if env.ssl.client_key
-          options[:ssl][:ssl_version] = env.ssl.version if env.ssl.version
-          options[:ssl][:verify_depth] = env.ssl.verify_depth if env.ssl.verify_depth
-          options[:ssl][:min_version] = env.ssl.min_version if env.ssl.min_version
-          options[:ssl][:max_version] = env.ssl.max_version if env.ssl.max_version
-
-          options
         end
       end
 
@@ -122,10 +181,6 @@ module Faraday
         end
       end
 
-      def self.session
-        @session ||= ::HTTPX.plugin(:compression).plugin(:persistent).plugin(ReasonPlugin)
-      end
-
       class ParallelManager
         class ResponseHandler < SimpleDelegator
           attr_reader :env
@@ -158,8 +213,9 @@ module Faraday
 
         include RequestMixin
 
-        def initialize
+        def initialize(options)
           @handlers = []
+          @connection_options = options
         end
 
         def enqueue(request)
@@ -173,40 +229,54 @@ module Faraday
 
           env = @handlers.last.env
 
-          session = HTTPX.session.with(options_from_env(env))
-          session = session.plugin(:proxy).with(proxy: { uri: env.request.proxy }) if env.request.proxy
-          session = session.plugin(OnDataPlugin) if env.request.stream_response?
+          connect(env) do |session|
+            requests = @handlers.map { |handler| session.build_request(*build_request(handler.env)) }
 
-          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
 
-          if env.request.stream_response?
-            requests.each do |request|
-              request.response_on_data = env.request.on_data
+            responses = session.request(*requests)
+            Array(responses).each_with_index do |response, index|
+              handler = @handlers[index]
+              handler.on_response.call(response)
+              handler.on_complete.call(handler.env)
             end
           end
+        rescue ::HTTPX::TimeoutError => e
+          raise Faraday::TimeoutError, e
+        end
+
+        # from Faraday::Adapter#connection
+        def connection(env)
+          conn = build_connection(env)
+          return conn unless block_given?
+
+          yield conn
+        end
+
+        private
 
-          responses = session.request(*requests)
-          Array(responses).each_with_index do |response, index|
-            handler = @handlers[index]
-            handler.on_response.call(response)
-            handler.on_complete.call(handler.env)
+        # from Faraday::Adapter#request_timeout
+        def request_timeout(type, options)
+          key = Faraday::Adapter::TIMEOUT_KEYS.fetch(type) do
+            msg = "Expected :read, :write, :open. Got #{type.inspect} :("
+            raise ArgumentError, msg
           end
+          options[key] || options[:timeout]
         end
       end
 
       self.supports_parallel = true
 
       class << self
-        def setup_parallel_manager
-          ParallelManager.new
+        def setup_parallel_manager(options = {})
+          ParallelManager.new(options)
         end
       end
 
-      def initialize(app, options = {})
-        super(app)
-        @session_options = options
-      end
-
       def call(env)
         super
         if parallel?(env)
@@ -224,38 +294,30 @@ module Faraday
           return handler
         end
 
-        session = HTTPX.session
-        session = session.with(@session_options) unless @session_options.empty?
-        session = session.with(options_from_env(env))
-        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)
-        # do not call #raise_for_status for HTTP 4xx or 5xx, as faraday has a middleware for that.
-        response.raise_for_status unless response.is_a?(::HTTPX::Response)
+        response = connect_and_request(env)
         save_response(env, response.status, response.body.to_s, response.headers, response.reason) do |response_headers|
           response_headers.merge!(response.headers)
         end
         @app.call(env)
-      rescue ::HTTPX::TLSError => e
-        raise SSL_ERROR, e
-      rescue Errno::ECONNABORTED,
-             Errno::ECONNREFUSED,
-             Errno::ECONNRESET,
-             Errno::EHOSTUNREACH,
-             Errno::EINVAL,
-             Errno::ENETUNREACH,
-             Errno::EPIPE,
-             ::HTTPX::ConnectionError => e
-        raise CONNECTION_FAILED_ERROR, e
       end
 
       private
 
+      def connect_and_request(env)
+        connect(env) do |session|
+          request = session.build_request(*build_request(env))
+
+          request.response_on_data = env.request.on_data if env.request.stream_response?
+
+          response = session.request(request)
+          # do not call #raise_for_status for HTTP 4xx or 5xx, as faraday has a middleware for that.
+          response.raise_for_status unless response.is_a?(::HTTPX::Response)
+          response
+        end
+      rescue ::HTTPX::TimeoutError => e
+        raise Faraday::TimeoutError, e
+      end
+
       def parallel?(env)
         env[:parallel_manager]
       end

data/lib/httpx/plugins/authentication.rb

@@ -13,6 +13,10 @@ module HTTPX
         def authentication(token)
           with(headers: { "authorization" => token })
         end
+
+        def bearer_auth(token)
+          authentication("Bearer #{token}")
+        end
       end
     end
     register_plugin :authentication, Authentication

data/lib/httpx/plugins/response_cache/file_store.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require "pathname"
+require_relative "store"
 
 module HTTPX::Plugins
   module ResponseCache

data/lib/httpx/resolver/native.rb

@@ -29,12 +29,15 @@ module HTTPX
 
     attr_reader :state
 
-    def initialize(_, options)
+    def initialize(family, options)
       super
       @ns_index = 0
       @resolver_options = DEFAULTS.merge(@options.resolver_options)
       @socket_type = @resolver_options.fetch(:socket_type, :udp)
-      @nameserver = Array(@resolver_options[:nameserver]) if @resolver_options[:nameserver]
+      @nameserver = if (nameserver = @resolver_options[:nameserver])
+        nameserver = nameserver[family] if nameserver.is_a?(Hash)
+        Array(nameserver)
+      end
       @ndots = @resolver_options[:ndots]
       @search = Array(@resolver_options[:search]).map { |srch| srch.scan(/[^.]+/) }
       @_timeouts = Array(@resolver_options[:timeouts])
@@ -318,7 +321,7 @@ module HTTPX
             return
           end
         else
-          @timeouts.delete(name)
+          reset_hostname(name, connection: connection)
           @timeouts.delete(connection.origin.host)
           @connections.delete(connection)
           Resolver.cached_lookup_set(connection.origin.host, @family, addresses) if @resolver_options[:cache]
@@ -429,9 +432,8 @@ module HTTPX
       end
     end
 
-    def reset_hostname(hostname, reset_candidates: true)
+    def reset_hostname(hostname, connection: @queries.delete(hostname), reset_candidates: true)
       @timeouts.delete(hostname)
-      connection = @queries.delete(hostname)
       @timeouts.delete(hostname)
 
       return unless connection && reset_candidates

data/lib/httpx/version.rb

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

data/sig/plugins/authentication.rbs

@@ -3,6 +3,8 @@ module HTTPX
     module Authentication
       module InstanceMethods
         def authentication: (string token) -> instance
+
+        def bearer_auth: (string token) -> instance
       end
     end
 

data/sig/resolver/native.rbs

@@ -63,7 +63,7 @@ module HTTPX
 
       def handle_error: (NativeResolveError | StandardError) -> void
 
-      def reset_hostname: (String hostname, ?reset_candidates: bool) -> void
+      def reset_hostname: (String hostname, ?connection: Connection, ?reset_candidates: bool) -> void
     end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: httpx
 version: !ruby/object:Gem::Version
-  version: 0.24.1
+  version: 0.24.3
 platform: ruby
 authors:
 - Tiago Cardoso
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-06-27 00:00:00.000000000 Z
+date: 2023-07-31 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: http-2-next
@@ -101,6 +101,8 @@ extra_rdoc_files:
 - doc/release_notes/0_23_4.md
 - doc/release_notes/0_24_0.md
 - doc/release_notes/0_24_1.md
+- doc/release_notes/0_24_2.md
+- doc/release_notes/0_24_3.md
 - doc/release_notes/0_2_0.md
 - doc/release_notes/0_2_1.md
 - doc/release_notes/0_3_0.md
@@ -194,6 +196,8 @@ files:
 - doc/release_notes/0_23_4.md
 - doc/release_notes/0_24_0.md
 - doc/release_notes/0_24_1.md
+- doc/release_notes/0_24_2.md
+- doc/release_notes/0_24_3.md
 - doc/release_notes/0_2_0.md
 - doc/release_notes/0_2_1.md
 - doc/release_notes/0_3_0.md