faraday 0.9.1 → 0.17.1

data/lib/faraday/adapter/em_synchrony.rb

@@ -19,7 +19,7 @@ module Faraday
 
       def call(env)
         super
-        request = EventMachine::HttpRequest.new(Utils::URI(env[:url].to_s), connection_config(env))
+        request = create_request(env)
 
         http_method = env[:method].to_s.downcase.to_sym
 
@@ -54,7 +54,9 @@ module Faraday
 
           raise client.error if client.error
 
-          save_response(env, client.response_header.status, client.response) do |resp_headers|
+          status = client.response_header.status
+          reason = client.response_header.http_reason
+          save_response(env, status, client.response, nil, reason) do |resp_headers|
             client.response_header.each do |name, value|
               resp_headers[name.to_sym] = value
             end
@@ -63,12 +65,20 @@ module Faraday
 
         @app.call env
       rescue Errno::ECONNREFUSED
-        raise Error::ConnectionFailed, $!
+        raise Faraday::ConnectionFailed, $!
       rescue EventMachine::Connectify::CONNECTError => err
         if err.message.include?("Proxy Authentication Required")
-          raise Error::ConnectionFailed, %{407 "Proxy Authentication Required "}
+          raise Faraday::ConnectionFailed, %{407 "Proxy Authentication Required "}
         else
-          raise Error::ConnectionFailed, err
+          raise Faraday::ConnectionFailed, err
+        end
+      rescue Errno::ETIMEDOUT => err
+        raise Faraday::TimeoutError, err
+      rescue RuntimeError => err
+        if err.message == "connection closed by server"
+          raise Faraday::ConnectionFailed, err
+        else
+          raise
         end
       rescue => err
         if defined?(OpenSSL) && OpenSSL::SSL::SSLError === err
@@ -77,6 +87,10 @@ module Faraday
           raise
         end
       end
+
+      def create_request(env)
+        EventMachine::HttpRequest.new(Utils::URI(env[:url].to_s), connection_config(env).merge(@connection_options))
+      end
     end
   end
 end

data/lib/faraday/adapter/excon.rb

@@ -3,11 +3,6 @@ module Faraday
     class Excon < Faraday::Adapter
       dependency 'excon'
 
-      def initialize(app, connection_options = {})
-        @connection_options = connection_options
-        super(app)
-      end
-
       def call(env)
         super
 
@@ -20,6 +15,9 @@ module Faraday
           opts[:client_key]  = ssl[:client_key]  if ssl[:client_key]
           opts[:certificate] = ssl[:certificate] if ssl[:certificate]
           opts[:private_key] = ssl[:private_key] if ssl[:private_key]
+          opts[:ssl_version] = ssl[:version] if ssl[:version]
+          opts[:ssl_min_version] = ssl[:min_version] if ssl[:min_version]
+          opts[:ssl_max_version] = ssl[:max_version] if ssl[:max_version]
 
           # https://github.com/geemus/excon/issues/106
           # https://github.com/jruby/jruby-ossl/issues/19
@@ -35,12 +33,12 @@ module Faraday
 
           if req[:open_timeout]
             opts[:connect_timeout]   = req[:open_timeout]
-            opts[:write_timeout]     = req[:open_timeout]
           end
 
           if req[:proxy]
             opts[:proxy] = {
               :host     => req[:proxy][:uri].host,
+              :hostname => req[:proxy][:uri].hostname,
               :port     => req[:proxy][:uri].port,
               :scheme   => req[:proxy][:uri].scheme,
               :user     => req[:proxy][:user],
@@ -49,26 +47,30 @@ module Faraday
           end
         end
 
-        conn = ::Excon.new(env[:url].to_s, opts.merge(@connection_options))
+        conn = create_connection(env, opts)
 
         resp = conn.request \
           :method  => env[:method].to_s.upcase,
           :headers => env[:request_headers],
           :body    => read_body(env)
 
-        save_response(env, resp.status.to_i, resp.body, resp.headers)
+        save_response(env, resp.status.to_i, resp.body, resp.headers, resp.reason_phrase)
 
         @app.call env
       rescue ::Excon::Errors::SocketError => err
         if err.message =~ /\btimeout\b/
-          raise Error::TimeoutError, err
+          raise Faraday::TimeoutError, err
         elsif err.message =~ /\bcertificate\b/
           raise Faraday::SSLError, err
         else
-          raise Error::ConnectionFailed, err
+          raise Faraday::ConnectionFailed, err
         end
       rescue ::Excon::Errors::Timeout => err
-        raise Error::TimeoutError, err
+        raise Faraday::TimeoutError, err
+      end
+
+      def create_connection(env, opts)
+        ::Excon.new(env[:url].to_s, opts.merge(@connection_options))
       end
 
       # TODO: support streaming requests

data/lib/faraday/adapter/httpclient.rb

@@ -10,6 +10,9 @@ module Faraday
       def call(env)
         super
 
+        # enable compression
+        client.transparent_gzip_decompression = true
+
         if req = env[:request]
           if proxy = req[:proxy]
             configure_proxy proxy
@@ -26,6 +29,8 @@ module Faraday
           configure_ssl ssl
         end
 
+        configure_client
+
         # TODO Don't stream yet.
         # https://github.com/nahi/httpclient/pull/90
         env[:body] = env[:body].read if env[:body].respond_to? :read
@@ -34,19 +39,19 @@ module Faraday
           :body   => env[:body],
           :header => env[:request_headers]
 
-        save_response env, resp.status, resp.body, resp.headers
+        save_response env, resp.status, resp.body, resp.headers, resp.reason
 
         @app.call env
-      rescue ::HTTPClient::TimeoutError
-        raise Faraday::Error::TimeoutError, $!
+      rescue ::HTTPClient::TimeoutError, Errno::ETIMEDOUT
+        raise Faraday::TimeoutError, $!
       rescue ::HTTPClient::BadResponseError => err
         if err.message.include?('status 407')
-          raise Faraday::Error::ConnectionFailed, %{407 "Proxy Authentication Required "}
+          raise Faraday::ConnectionFailed, %{407 "Proxy Authentication Required "}
         else
-          raise Faraday::Error::ClientError, $!
+          raise Faraday::ClientError, $!
         end
-      rescue Errno::ECONNREFUSED, EOFError
-        raise Faraday::Error::ConnectionFailed, $!
+      rescue Errno::ECONNREFUSED, IOError, SocketError
+        raise Faraday::ConnectionFailed, $!
       rescue => err
         if defined?(OpenSSL) && OpenSSL::SSL::SSLError === err
           raise Faraday::SSLError, err
@@ -69,14 +74,14 @@ module Faraday
 
       def configure_ssl(ssl)
         ssl_config = client.ssl_config
+        ssl_config.verify_mode = ssl_verify_mode(ssl)
+        ssl_config.cert_store = ssl_cert_store(ssl)
 
         ssl_config.add_trust_ca ssl[:ca_file]        if ssl[:ca_file]
         ssl_config.add_trust_ca ssl[:ca_path]        if ssl[:ca_path]
-        ssl_config.cert_store   = ssl[:cert_store]   if ssl[:cert_store]
         ssl_config.client_cert  = ssl[:client_cert]  if ssl[:client_cert]
         ssl_config.client_key   = ssl[:client_key]   if ssl[:client_key]
         ssl_config.verify_depth = ssl[:verify_depth] if ssl[:verify_depth]
-        ssl_config.verify_mode  = ssl_verify_mode(ssl)
       end
 
       def configure_timeouts(req)
@@ -92,6 +97,23 @@ module Faraday
         end
       end
 
+      def configure_client
+        @config_block.call(client) if @config_block
+      end
+
+      def ssl_cert_store(ssl)
+        return ssl[:cert_store] if ssl[:cert_store]
+        # Memoize the cert store so that the same one is passed to
+        # HTTPClient each time, to avoid resyncing SSL sesions when
+        # it's changed
+        @cert_store ||= begin
+          # Use the default cert store by default, i.e. system ca certs
+          cert_store = OpenSSL::X509::Store.new
+          cert_store.set_default_paths
+          cert_store
+        end
+      end
+
       def ssl_verify_mode(ssl)
         ssl[:verify_mode] || begin
           if ssl.fetch(:verify, true)

data/lib/faraday/adapter/net_http.rb

@@ -10,13 +10,14 @@ module Faraday
   class Adapter
     class NetHttp < Faraday::Adapter
       NET_HTTP_EXCEPTIONS = [
-        EOFError,
+        IOError,
         Errno::ECONNABORTED,
         Errno::ECONNREFUSED,
         Errno::ECONNRESET,
         Errno::EHOSTUNREACH,
         Errno::EINVAL,
         Errno::ENETUNREACH,
+        Errno::EPIPE,
         Net::HTTPBadResponse,
         Net::HTTPHeaderSyntaxError,
         Net::ProtocolError,
@@ -27,14 +28,16 @@ module Faraday
       NET_HTTP_EXCEPTIONS << OpenSSL::SSL::SSLError if defined?(OpenSSL)
       NET_HTTP_EXCEPTIONS << Net::OpenTimeout if defined?(Net::OpenTimeout)
 
+      def initialize(app = nil, opts = {}, &block)
+        @cert_store = nil
+        super(app, opts, &block)
+      end
+
       def call(env)
         super
         with_net_http_connection(env) do |http|
           configure_ssl(http, env[:ssl]) if env[:url].scheme == 'https' and env[:ssl]
-
-          req = env[:request]
-          http.read_timeout = http.open_timeout = req[:timeout] if req[:timeout]
-          http.open_timeout = req[:open_timeout]                if req[:open_timeout]
+          configure_request(http, env[:request])
 
           begin
             http_response = perform_request(http, env)
@@ -42,11 +45,11 @@ module Faraday
             if defined?(OpenSSL) && OpenSSL::SSL::SSLError === err
               raise Faraday::SSLError, err
             else
-              raise Error::ConnectionFailed, err
+              raise Faraday::ConnectionFailed, err
             end
           end
 
-          save_response(env, http_response.code.to_i, http_response.body || '') do |response_headers|
+          save_response(env, http_response.code.to_i, http_response.body || '', nil, http_response.message) do |response_headers|
             http_response.each_header do |key, value|
               response_headers[key] = value
             end
@@ -54,10 +57,12 @@ module Faraday
         end
 
         @app.call env
-      rescue Timeout::Error => err
-        raise Faraday::Error::TimeoutError, err
+      rescue Timeout::Error, Errno::ETIMEDOUT => err
+        raise Faraday::TimeoutError, err
       end
 
+      private
+
       def create_request(env)
         request = Net::HTTPGenericRequest.new \
           env[:method].to_s.upcase,    # request method
@@ -89,10 +94,10 @@ module Faraday
 
       def net_http_connection(env)
         if proxy = env[:request][:proxy]
-          Net::HTTP::Proxy(proxy[:uri].host, proxy[:uri].port, proxy[:user], proxy[:password])
+          Net::HTTP::Proxy(proxy[:uri].hostname, proxy[:uri].port, proxy[:user], proxy[:password])
         else
           Net::HTTP
-        end.new(env[:url].host, env[:url].port)
+        end.new(env[:url].hostname, env[:url].port || (env[:url].scheme == 'https' ? 443 : 80))
       end
 
       def configure_ssl(http, ssl)
@@ -106,14 +111,31 @@ module Faraday
         http.ca_path      = ssl[:ca_path]      if ssl[:ca_path]
         http.verify_depth = ssl[:verify_depth] if ssl[:verify_depth]
         http.ssl_version  = ssl[:version]      if ssl[:version]
+        http.min_version  = ssl[:min_version]  if ssl[:min_version]
+        http.max_version  = ssl[:max_version]  if ssl[:max_version]
+      end
+
+      def configure_request(http, req)
+        if req[:timeout]
+          http.read_timeout  = req[:timeout]
+          http.open_timeout  = req[:timeout]
+          http.write_timeout = req[:timeout] if http.respond_to?(:write_timeout=)
+        end
+        http.open_timeout  = req[:open_timeout]  if req[:open_timeout]
+        http.write_timeout = req[:write_timeout] if req[:write_timeout] && http.respond_to?(:write_timeout=)
+          # 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) if @config_block
       end
 
       def ssl_cert_store(ssl)
         return ssl[:cert_store] if ssl[:cert_store]
+        return @cert_store if @cert_store
         # Use the default cert store by default, i.e. system ca certs
-        cert_store = OpenSSL::X509::Store.new
-        cert_store.set_default_paths
-        cert_store
+        @cert_store = OpenSSL::X509::Store.new
+        @cert_store.set_default_paths
+        @cert_store
       end
 
       def ssl_verify_mode(ssl)

data/lib/faraday/adapter/net_http_persistent.rb

@@ -1,15 +1,28 @@
-# Rely on autoloading instead of explicit require; helps avoid the "already
-# initialized constant" warning on Ruby 1.8.7 when NetHttp is refereced below.
-# require 'faraday/adapter/net_http'
-
 module Faraday
   class Adapter
-    # Experimental adapter for net-http-persistent
     class NetHttpPersistent < NetHttp
       dependency 'net/http/persistent'
 
-      def with_net_http_connection(env)
-        if proxy = env[:request][:proxy]
+      private
+
+      def net_http_connection(env)
+        @cached_connection ||=
+          if Net::HTTP::Persistent.instance_method(:initialize).parameters.first == [: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')
+          end
+
+        proxy_uri = proxy_uri(env)
+        @cached_connection.proxy = proxy_uri if @cached_connection.proxy_uri != proxy_uri
+        @cached_connection
+      end
+
+      def proxy_uri(env)
+        proxy_uri = nil
+        if (proxy = env[:request][:proxy])
           proxy_uri = ::URI::HTTP === proxy[:uri] ? proxy[:uri].dup : ::URI.parse(proxy[:uri].to_s)
           proxy_uri.user = proxy_uri.password = nil
           # awful patch for net-http-persistent 2.8 not unescaping user/password
@@ -18,30 +31,37 @@ module Faraday
             define_method(:password) { proxy[:password] }
           end if proxy[:user]
         end
-
-        yield Net::HTTP::Persistent.new 'Faraday', proxy_uri
+        proxy_uri
       end
 
       def perform_request(http, env)
         http.request env[:url], create_request(env)
+      rescue Errno::ETIMEDOUT => error
+        raise Faraday::TimeoutError, error
       rescue Net::HTTP::Persistent::Error => error
         if error.message.include? 'Timeout'
-          raise Faraday::Error::TimeoutError, error
+          raise Faraday::TimeoutError, error
         elsif error.message.include? 'connection refused'
-          raise Faraday::Error::ConnectionFailed, error
+          raise Faraday::ConnectionFailed, error
         else
           raise
         end
       end
 
       def configure_ssl(http, ssl)
-        http.verify_mode  = ssl_verify_mode(ssl)
-        http.cert_store   = ssl_cert_store(ssl)
+        http_set(http, :verify_mode, ssl_verify_mode(ssl))
+        http_set(http, :cert_store,  ssl_cert_store(ssl))
+
+        http_set(http, :certificate, ssl[:client_cert]) if ssl[:client_cert]
+        http_set(http, :private_key, ssl[:client_key])  if ssl[:client_key]
+        http_set(http, :ca_file,     ssl[:ca_file])     if ssl[:ca_file]
+        http_set(http, :ssl_version, ssl[:version])     if ssl[:version]
+      end
 
-        http.certificate  = ssl[:client_cert]  if ssl[:client_cert]
-        http.private_key  = ssl[:client_key]   if ssl[:client_key]
-        http.ca_file      = ssl[:ca_file]      if ssl[:ca_file]
-        http.ssl_version  = ssl[:version]      if ssl[:version]
+      def http_set(http, attr, value)
+        if http.send(attr) != value
+          http.send("#{attr}=", value)
+        end
       end
     end
   end

data/lib/faraday/adapter/patron.rb

@@ -3,18 +3,14 @@ module Faraday
     class Patron < Faraday::Adapter
       dependency 'patron'
 
-      def initialize(app, &block)
-        super(app)
-        @block = block
-      end
-
       def call(env)
         super
-
         # TODO: support streaming requests
         env[:body] = env[:body].read if env[:body].respond_to? :read
 
-        session = @session ||= create_session
+        session = ::Patron::Session.new
+        @config_block.call(session) if @config_block
+        configure_ssl(session, env[:ssl]) if env[:url].scheme == 'https' and env[:ssl]
 
         if req = env[:request]
           session.timeout = session.connect_timeout = req[:timeout] if req[:timeout]
@@ -32,23 +28,26 @@ module Faraday
           data = env[:body] ? env[:body].to_s : nil
           session.request(env[:method], env[:url].to_s, env[:request_headers], :data => data)
         rescue Errno::ECONNREFUSED, ::Patron::ConnectionFailed
-          raise Error::ConnectionFailed, $!
+          raise Faraday::ConnectionFailed, $!
         end
 
-        save_response(env, response.status, response.body, response.headers)
+        # Remove the "HTTP/1.1 200", leaving just the reason phrase
+        reason_phrase = response.status_line.gsub(/^.* \d{3} /, '')
+
+        save_response(env, response.status, response.body, response.headers, reason_phrase)
 
         @app.call env
       rescue ::Patron::TimeoutError => err
-        if err.message == "Connection time-out"
-          raise Faraday::Error::ConnectionFailed, err
+        if connection_timed_out_message?(err.message)
+          raise Faraday::ConnectionFailed, err
         else
-          raise Faraday::Error::TimeoutError, err
+          raise Faraday::TimeoutError, err
         end
       rescue ::Patron::Error => err
         if err.message.include?("code 407")
-          raise Error::ConnectionFailed, %{407 "Proxy Authentication Required "}
+          raise Faraday::ConnectionFailed, %{407 "Proxy Authentication Required "}
         else
-          raise Error::ConnectionFailed, err
+          raise Faraday::ConnectionFailed, err
         end
       end
 
@@ -56,17 +55,41 @@ module Faraday
         # HAX: helps but doesn't work completely
         # https://github.com/toland/patron/issues/34
         ::Patron::Request::VALID_ACTIONS.tap do |actions|
-          actions << :patch unless actions.include? :patch
-          actions << :options unless actions.include? :options
+          if actions[0].is_a?(Symbol)
+            actions << :patch unless actions.include? :patch
+            actions << :options unless actions.include? :options
+          else
+            # Patron 0.4.20 and up
+            actions << "PATCH" unless actions.include? "PATCH"
+            actions << "OPTIONS" unless actions.include? "OPTIONS"
+          end
         end
       end
 
-      def create_session
-        session = ::Patron::Session.new
-        session.insecure = true
-        @block.call(session) if @block
-        session
+      def configure_ssl(session, ssl)
+        if ssl.fetch(:verify, true)
+          session.cacert = ssl[:ca_file]
+        else
+          session.insecure = true
+        end
       end
+
+      private
+
+      CURL_TIMEOUT_MESSAGES = [ "Connection time-out",
+          "Connection timed out",
+          "Timed out before name resolve",
+          "server connect has timed out",
+          "Resolving timed out",
+          "name lookup timed out",
+          "timed out before SSL",
+          "connect() timed out"
+        ].freeze
+
+      def connection_timed_out_message?(message)
+        CURL_TIMEOUT_MESSAGES.any? { |curl_message| message.include?(curl_message) }
+      end
+
     end
   end
 end

data/lib/faraday/adapter/rack.rb

@@ -41,7 +41,7 @@ module Faraday
 
         timeout  = env[:request][:timeout] || env[:request][:open_timeout]
         response = if timeout
-          Timer.timeout(timeout, Faraday::Error::TimeoutError) { execute_request(env, rack_env) }
+          Timer.timeout(timeout, Faraday::TimeoutError) { execute_request(env, rack_env) }
         else
           execute_request(env, rack_env)
         end