faraday-net_http_persistent 2.0.0 → 2.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f4da892e0d8f0da0870720d9be4fe02ba9a43b3ad02abef06a95cf1665c14dd8
-  data.tar.gz: fe2b3d188a12ace453e570c3d80d21075887c4e703746fe4e71b6c6d64cb528b
+  metadata.gz: ffe757e1437110d467bf12e5b02dfb9c645148637fda7dbd819960bc606a083f
+  data.tar.gz: ea0f218c8a5cc9fff614d7642148059e98c3664fb66a8c9a82b520c19aa4f74a
 SHA512:
-  metadata.gz: 31f8bb4f02d25a74f2a3bcc1f79f6deb2d2e097afd6a1d9eb29c5f33a4d6e097dc61d07a8412e1ba218972f60bb2ac41b12445b75c9c3f19d80dc2f636d5e64d
-  data.tar.gz: 45d15ddfe4306489388634c58f3f9c0c90b7da6e38000df13f7c49004d99f176614463faf2285d1824bb88785120fbab6a2248cd3a6cdd183e1e665227edd966
+  metadata.gz: 704efa657b1583d555b29a6cc71d75e936dc2dab9ac419d09d92a0a433eba72470f48b7dede5a005c8604a7a36dae62b86c53249be1090819df472a3bee55542
+  data.tar.gz: ec494b194dbbf5dd42c91166a2cd17de25d57d7cf0155cabaf4c9dda60d906592cd8fa8558b7a6d34b523e3bedaeeaffa39b03beedfc56459bdc6bc454a6a8f0

data/lib/faraday/adapter/net_http_persistent.rb

@@ -1,30 +1,138 @@
 # 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
+
       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 +141,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 = {
@@ -100,6 +196,27 @@ module Faraday
       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.0"
+    VERSION = "2.1.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,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: faraday-net_http_persistent
 version: !ruby/object:Gem::Version
-  version: 2.0.0
+  version: 2.1.0
 platform: ruby
 authors:
 - Mike Rogers
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2022-01-04 00:00:00.000000000 Z
+date: 2022-08-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: faraday
@@ -16,28 +16,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.0'
+        version: '2.5'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.0'
-- !ruby/object:Gem::Dependency
-  name: faraday-net_http
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '2.0'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '2.0'
+        version: '2.5'
 - !ruby/object:Gem::Dependency
   name: net-http-persistent
   requirement: !ruby/object:Gem::Requirement
@@ -70,7 +56,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.0
+  changelog_uri: https://github.com/lostisland/faraday-net_http_persistent/releases/tag/v2.1.0
 post_install_message: 
 rdoc_options: []
 require_paths: