faraday-net_http_persistent 2.0.2 → 2.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0dd625c45c96455b07b3ea4a2345006c6bf18ace0e91e1d29d8760c32a851880
-  data.tar.gz: 6413a859583e2dc5d94916c32873899096b7c7cd44ea47bb64f19623e4e5cec5
+  metadata.gz: 191595752d82777e7edb7c18a0b3fd85953281b7c65ebb5e11f9fa3a0a36326f
+  data.tar.gz: 9bc82207a4020fe7b8df7fcee8e35bdd30308ad1555ff060ce87ff050f641c06
 SHA512:
-  metadata.gz: 5a847b8b8bf9131ee264b9878d3aca9748f358cd01ef432954e42a97847c9981e482cfc8914925c18680617c2016b8b28df5e593c28c4b5c9cc23a00b9337f47
-  data.tar.gz: 9487254402d21fe7be681a15a7212586fbf84995f2ac0ff764cb7de4a306e70bd87a8dd70ab915920a716c22b2021c83dc4bf89664294cd5f072941b57379bd2
+  metadata.gz: 8c6c9f078bef0572b9831b7e16fda71a331be9297b21c3d6dbb6c36713650dfe37ac5a4d2866977f9b4af87bbb06d0394f78a378c92fd0b60d50dd5a88feb378
+  data.tar.gz: fbeb087ef43f055a51168af96b6eab2d0fbb0f28f95548677de7cc5d543ec042a7f757d5094ba422eb14e6215a30814663ba87f5e274d4cea0554295cf5665f3

data/lib/faraday/adapter/net_http_persistent.rb

@@ -1,30 +1,142 @@
 # frozen_string_literal: true
 
-require "faraday/net_http"
 require "net/http/persistent"
 
 module Faraday
   class Adapter
     # Net::HTTP::Persistent adapter.
-    class NetHttpPersistent < NetHttp
+    class NetHttpPersistent < Faraday::Adapter
+      exceptions = [
+        IOError,
+        Errno::EADDRNOTAVAIL,
+        Errno::EALREADY,
+        Errno::ECONNABORTED,
+        Errno::ECONNREFUSED,
+        Errno::ECONNRESET,
+        Errno::EHOSTUNREACH,
+        Errno::EINVAL,
+        Errno::ENETUNREACH,
+        Errno::EPIPE,
+        Net::HTTPBadResponse,
+        Net::HTTPHeaderSyntaxError,
+        Net::ProtocolError,
+        SocketError,
+        Zlib::GzipFile::Error
+      ]
+
+      exceptions << ::OpenSSL::SSL::SSLError if defined?(::OpenSSL::SSL::SSLError)
+      # TODO (breaking): Enable this to make it consistent with net_http adapter.
+      #   See https://github.com/lostisland/faraday/issues/718#issuecomment-344549382
+      # exceptions << ::Net::OpenTimeout if defined?(::Net::OpenTimeout)
+
+      NET_HTTP_EXCEPTIONS = exceptions.freeze
+
+      def initialize(app = nil, opts = {}, &block)
+        @ssl_cert_store = nil
+        super(app, opts, &block)
+      end
+
+      def call(env)
+        super
+        connection(env) do |http|
+          perform_request(http, env)
+        rescue Net::HTTP::Persistent::Error => e
+          raise Faraday::TimeoutError, e if e.message.include?("Timeout")
+
+          raise Faraday::ConnectionFailed, e if e.message.include?("connection refused")
+
+          raise
+        rescue *NET_HTTP_EXCEPTIONS => e
+          raise Faraday::SSLError, e if defined?(OpenSSL) && e.is_a?(OpenSSL::SSL::SSLError)
+
+          raise Faraday::ConnectionFailed, e
+        end
+        @app.call env
+      rescue Timeout::Error, Errno::ETIMEDOUT => e
+        raise Faraday::TimeoutError, e
+      end
+
+      def close
+        @cached_connection&.shutdown
+      end
+
       private
 
-      def net_http_connection(env)
-        @cached_connection ||=
-          if Net::HTTP::Persistent.instance_method(:initialize)
-              .parameters.first == %i[key name]
-            options = {name: "Faraday"}
-            options[:pool_size] = @connection_options[:pool_size] if @connection_options.key?(:pool_size)
-            Net::HTTP::Persistent.new(**options)
-          else
-            Net::HTTP::Persistent.new("Faraday")
+      def build_connection(env)
+        net_http_connection(env).tap do |http|
+          http.use_ssl = env[:url].scheme == "https" if http.respond_to?(:use_ssl=)
+          configure_ssl(http, env[:ssl])
+          configure_request(http, env[:request])
+        end
+      end
+
+      def create_request(env)
+        request = Net::HTTPGenericRequest.new \
+          env[:method].to_s.upcase, # request method
+          !!env[:body], # is there request body
+          env[:method] != :head, # is there response body
+          env[:url].request_uri, # request uri path
+          env[:request_headers] # request headers
+
+        if env[:body].respond_to?(:read)
+          request.body_stream = env[:body]
+        else
+          request.body = env[:body]
+        end
+        request
+      end
+
+      def save_http_response(env, http_response)
+        save_response(
+          env, http_response.code.to_i, nil, nil, http_response.message, finished: false
+        ) do |response_headers|
+          http_response.each_header do |key, value|
+            response_headers[key] = value
           end
+        end
+      end
+
+      def configure_request(http, req)
+        if (sec = request_timeout(:read, req))
+          http.read_timeout = sec
+        end
+
+        if (sec = http.respond_to?(:write_timeout=) &&
+          request_timeout(:write, req))
+          http.write_timeout = sec
+        end
+
+        if (sec = request_timeout(:open, req))
+          http.open_timeout = sec
+        end
+
+        # Only set if Net::Http supports it, since Ruby 2.5.
+        http.max_retries = 0 if http.respond_to?(:max_retries=)
+
+        @config_block&.call(http)
+      end
+
+      def ssl_cert_store(ssl)
+        return ssl[:cert_store] if ssl[:cert_store]
+
+        # Use the default cert store by default, i.e. system ca certs
+        @ssl_cert_store ||= OpenSSL::X509::Store.new.tap(&:set_default_paths)
+      end
+
+      def net_http_connection(env)
+        @cached_connection ||= Net::HTTP::Persistent.new(**init_options)
 
         proxy_uri = proxy_uri(env)
         @cached_connection.proxy = proxy_uri if @cached_connection.proxy_uri != proxy_uri
         @cached_connection
       end
 
+      def init_options
+        options = {name: "Faraday"}
+        options[:pool_size] = @connection_options[:pool_size] if @connection_options.key?(:pool_size)
+        options
+      end
+
       def proxy_uri(env)
         proxy_uri = nil
         if (proxy = env[:request][:proxy])
@@ -33,48 +145,36 @@ module Faraday
           else
             ::URI.parse(proxy[:uri].to_s)
           end
-          proxy_uri.user = proxy_uri.password = nil
-          # awful patch for net-http-persistent 2.8
-          # not unescaping user/password
-          if proxy[:user]
-            (class << proxy_uri; self; end).class_eval do
-              define_method(:user) { proxy[:user] }
-              define_method(:password) { proxy[:password] }
-            end
-          end
+          proxy_uri.user = proxy[:user] if proxy[:user]
+          proxy_uri.password = proxy[:password] if proxy[:password]
         end
         proxy_uri
       end
 
       def perform_request(http, env)
-        if env[:request].stream_response?
-          size = 0
-          yielded = false
-
-          http_response = http.request(env[:url], create_request(env)) do |response|
-            response.read_body do |chunk|
-              if chunk.bytesize.positive? || size.positive?
-                yielded = true
-                size += chunk.bytesize
-                env[:request].on_data.call(chunk, size)
-              end
-            end
+        if env.stream_response?
+          http_response = env.stream_response do |&on_data|
+            request_with_wrapped_block(http, env, &on_data)
           end
-
-          env[:request].on_data.call(+"", 0) unless yielded
           http_response.body = nil
-          http_response
         else
-          http.request(env[:url], create_request(env))
+          http_response = request_with_wrapped_block(http, env)
         end
-      rescue Errno::ETIMEDOUT, Net::OpenTimeout => e
-        raise Faraday::TimeoutError, e
-      rescue Net::HTTP::Persistent::Error => e
-        raise Faraday::TimeoutError, e if e.message.include? "Timeout"
+        env.response_body = encoded_body(http_response)
+        env.response.finish(env)
+        http_response
+      end
 
-        raise Faraday::ConnectionFailed, e if e.message.include? "connection refused"
+      def request_with_wrapped_block(http, env)
+        http.request(env[:url], create_request(env)) do |response|
+          save_http_response(env, response)
 
-        raise
+          if block_given?
+            response.read_body do |chunk|
+              yield(chunk)
+            end
+          end
+        end
       end
 
       SSL_CONFIGURATIONS = {
@@ -83,7 +183,8 @@ module Faraday
         ca_file: :ca_file,
         ssl_version: :version,
         min_version: :min_version,
-        max_version: :max_version
+        max_version: :max_version,
+        verify_hostname: :verify_hostname
       }.freeze
 
       def configure_ssl(http, ssl)
@@ -93,13 +194,34 @@ module Faraday
         http_set(http, :cert_store, ssl_cert_store(ssl))
 
         SSL_CONFIGURATIONS
-          .select { |_, key| ssl[key] }
+          .select { |_, key| !ssl[key].nil? }
           .each { |target, key| http_set(http, target, ssl[key]) }
       end
 
       def http_set(http, attr, value)
         http.send("#{attr}=", value) if http.send(attr) != value
       end
+
+      def ssl_verify_mode(ssl)
+        ssl[:verify_mode] ||
+          if ssl.fetch(:verify, true)
+            OpenSSL::SSL::VERIFY_PEER
+          else
+            OpenSSL::SSL::VERIFY_NONE
+          end
+      end
+
+      def encoded_body(http_response)
+        body = http_response.body || +""
+        /\bcharset=\s*(.+?)\s*(;|$)/.match(http_response["Content-Type"]) do |match|
+          content_charset = ::Encoding.find(match.captures.first)
+          body = body.dup if body.frozen?
+          body.force_encoding(content_charset)
+        rescue ArgumentError
+          nil
+        end
+        body
+      end
     end
   end
 end

data/lib/faraday/net_http_persistent/version.rb

@@ -2,6 +2,6 @@
 
 module Faraday
   module NetHttpPersistent
-    VERSION = "2.0.2"
+    VERSION = "2.2.0"
   end
 end

data/lib/faraday/net_http_persistent.rb

@@ -1,7 +1,8 @@
 # frozen_string_literal: true
 
-require_relative "adapter/net_http_persistent"
-require_relative "net_http_persistent/version"
+require "faraday"
+require "faraday/adapter/net_http_persistent"
+require "faraday/net_http_persistent/version"
 
 module Faraday
   module NetHttpPersistent

metadata

@@ -1,43 +1,49 @@
 --- !ruby/object:Gem::Specification
 name: faraday-net_http_persistent
 version: !ruby/object:Gem::Version
-  version: 2.0.2
+  version: 2.2.0
 platform: ruby
 authors:
 - Mike Rogers
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2022-08-09 00:00:00.000000000 Z
+date: 2024-09-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: faraday-net_http
+  name: faraday
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "<"
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '3'
+        version: '2.5'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "<"
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '3'
+        version: '2.5'
 - !ruby/object:Gem::Dependency
   name: net-http-persistent
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '4.0'
+        version: 4.0.4
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '5'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 4.0.4
+    - - "<"
       - !ruby/object:Gem::Version
-        version: '4.0'
+        version: '5'
 description: Faraday adapter for NetHttpPersistent
 email:
 - me@mikerogers.io
@@ -56,7 +62,7 @@ licenses:
 metadata:
   homepage_uri: https://github.com/lostisland/faraday-net_http_persistent
   source_code_uri: https://github.com/lostisland/faraday-net_http_persistent
-  changelog_uri: https://github.com/lostisland/faraday-net_http_persistent/releases/tag/v2.0.2
+  changelog_uri: https://github.com/lostisland/faraday-net_http_persistent/releases/tag/v2.2.0
 post_install_message: 
 rdoc_options: []
 require_paths: