faraday 0.11.0 → 0.17.4

data/lib/faraday/adapter/net_http.rb

@@ -11,6 +11,7 @@ module Faraday
     class NetHttp < Faraday::Adapter
       NET_HTTP_EXCEPTIONS = [
         IOError,
+        Errno::EADDRNOTAVAIL,
         Errno::ECONNABORTED,
         Errno::ECONNREFUSED,
         Errno::ECONNRESET,
@@ -28,6 +29,11 @@ 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|
@@ -40,7 +46,7 @@ module Faraday
             if defined?(OpenSSL) && OpenSSL::SSL::SSLError === err
               raise Faraday::SSLError, err
             else
-              raise Error::ConnectionFailed, err
+              raise Faraday::ConnectionFailed, err
             end
           end
 
@@ -53,9 +59,11 @@ module Faraday
 
         @app.call env
       rescue Timeout::Error, Errno::ETIMEDOUT => err
-        raise Faraday::Error::TimeoutError, err
+        raise Faraday::TimeoutError, err
       end
 
+      private
+
       def create_request(env)
         request = Net::HTTPGenericRequest.new \
           env[:method].to_s.upcase,    # request method
@@ -87,10 +95,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 || (env[:url].scheme == 'https' ? 443 : 80))
+        end.new(env[:url].hostname, env[:url].port || (env[:url].scheme == 'https' ? 443 : 80))
       end
 
       def configure_ssl(http, ssl)
@@ -104,21 +112,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)
-        http.read_timeout = http.open_timeout = req[:timeout] if req[:timeout]
-        http.open_timeout = req[:open_timeout]                if req[:open_timeout]
+        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,13 +1,27 @@
-# 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
     class NetHttpPersistent < NetHttp
       dependency 'net/http/persistent'
 
+      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
@@ -16,34 +30,38 @@ module Faraday
             define_method(:user) { proxy[:user] }
             define_method(:password) { proxy[:password] }
           end if proxy[:user]
-          return Net::HTTP::Persistent.new 'Faraday', proxy_uri
         end
-
-        Net::HTTP::Persistent.new 'Faraday'
+        proxy_uri
       end
 
       def perform_request(http, env)
         http.request env[:url], create_request(env)
       rescue Errno::ETIMEDOUT => error
-        raise Faraday::Error::TimeoutError, 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

@@ -5,11 +5,12 @@ module Faraday
 
       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]
@@ -27,7 +28,7 @@ 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
 
         # Remove the "HTTP/1.1 200", leaving just the reason phrase
@@ -37,16 +38,16 @@ module Faraday
 
         @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
 
@@ -65,12 +66,30 @@ module Faraday
         end
       end
 
-      def create_session
-        session = ::Patron::Session.new
-        session.insecure = true
-        @config_block.call(session) if @config_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

data/lib/faraday/adapter/test.rb

@@ -53,17 +53,17 @@ module Faraday
           @stack.empty?
         end
 
-        def match(request_method, path, headers, body)
+        def match(request_method, host, path, headers, body)
           return false if !@stack.key?(request_method)
           stack = @stack[request_method]
           consumed = (@consumed[request_method] ||= [])
 
-          stub, meta = matches?(stack, path, headers, body)
+          stub, meta = matches?(stack, host, path, headers, body)
           if stub
             consumed << stack.delete(stub)
             return stub, meta
           end
-          matches?(consumed, path, headers, body)
+          matches?(consumed, host, path, headers, body)
         end
 
         def get(path, headers = {}, &block)
@@ -110,29 +110,35 @@ module Faraday
         protected
 
         def new_stub(request_method, path, headers = {}, body=nil, &block)
-          normalized_path = path.is_a?(Regexp) ? path : Faraday::Utils.normalize_path(path)
-          (@stack[request_method] ||= []) << Stub.new(normalized_path, headers, body, block)
+          normalized_path, host =
+            if path.is_a?(Regexp)
+              path
+            else
+              [Faraday::Utils.normalize_path(path), Faraday::Utils.URI(path).host]
+            end
+
+          (@stack[request_method] ||= []) << Stub.new(host, normalized_path, headers, body, block)
         end
 
-        def matches?(stack, path, headers, body)
+        def matches?(stack, host, path, headers, body)
           stack.each do |stub|
-            match_result, meta = stub.matches?(path, headers, body)
+            match_result, meta = stub.matches?(host, path, headers, body)
             return stub, meta if match_result
           end
           nil
         end
       end
 
-      class Stub < Struct.new(:path, :params, :headers, :body, :block)
-        def initialize(full, headers, body, block)
+      class Stub < Struct.new(:host, :path, :params, :headers, :body, :block)
+        def initialize(host, full, headers, body, block)
           path, query = full.respond_to?(:split) ? full.split("?") : full
           params = query ?
             Faraday::Utils.parse_nested_query(query) :
             {}
-          super(path, params, headers, body, block)
+          super(host, path, params, headers, body, block)
         end
 
-        def matches?(request_uri, request_headers, request_body)
+        def matches?(request_host, request_uri, request_headers, request_body)
           request_path, request_query = request_uri.split('?')
           request_params = request_query ?
             Faraday::Utils.parse_nested_query(request_query) :
@@ -140,7 +146,8 @@ module Faraday
           # meta is a hash use as carrier
           # that will be yielded to consumer block
           meta = {}
-          return path_match?(request_path, meta) &&
+          return (host.nil? || host == request_host) &&
+            path_match?(request_path, meta) &&
             params_match?(request_params) &&
             (body.to_s.size.zero? || request_body == body) &&
             headers_match?(request_headers), meta
@@ -183,10 +190,11 @@ module Faraday
 
       def call(env)
         super
+        host = env[:url].host
         normalized_path = Faraday::Utils.normalize_path(env[:url])
         params_encoder = env.request.params_encoder || Faraday::Utils.default_params_encoder
 
-        stub, meta = stubs.match(env[:method], normalized_path, env.request_headers, env[:body])
+        stub, meta = stubs.match(env[:method], host, normalized_path, env.request_headers, env[:body])
         if stub
           env[:params] = (query = env[:url].query) ?
             params_encoder.decode(query) : {}

data/lib/faraday/adapter/typhoeus.rb

@@ -1,123 +1,12 @@
 module Faraday
   class Adapter
+    # This class is just a stub, the real adapter is in https://github.com/philsturgeon/typhoeus/blob/master/lib/typhoeus/adapters/faraday.rb
     class Typhoeus < Faraday::Adapter
-      self.supports_parallel = true
-
-      def self.setup_parallel_manager(options = {})
-        options.empty? ? ::Typhoeus::Hydra.hydra : ::Typhoeus::Hydra.new(options)
-      end
+      # Needs to define this method in order to support Typhoeus <= 1.3.0
+      def call; end
 
       dependency 'typhoeus'
-
-      def call(env)
-        super
-        perform_request env
-        @app.call env
-      end
-
-      def perform_request(env)
-        read_body env
-
-        hydra = env[:parallel_manager] || self.class.setup_parallel_manager
-        hydra.queue request(env)
-        hydra.run unless parallel?(env)
-      rescue Errno::ECONNREFUSED
-        raise Error::ConnectionFailed, $!
-      end
-
-      # TODO: support streaming requests
-      def read_body(env)
-        env[:body] = env[:body].read if env[:body].respond_to? :read
-      end
-
-      def request(env)
-        method = env[:method]
-        # For some reason, prevents Typhoeus from using "100-continue".
-        # We want this because Webrick 1.3.1 can't seem to handle it w/ PUT.
-        method = method.to_s.upcase if method == :put
-
-        req = ::Typhoeus::Request.new env[:url].to_s,
-          :method  => method,
-          :body    => env[:body],
-          :headers => env[:request_headers],
-          :disable_ssl_peer_verification => (env[:ssl] && env[:ssl].disable?)
-
-        configure_ssl     req, env
-        configure_proxy   req, env
-        configure_timeout req, env
-        configure_socket  req, env
-
-        req.on_complete do |resp|
-          if resp.timed_out?
-            if parallel?(env)
-              # TODO: error callback in async mode
-            else
-              raise Faraday::Error::TimeoutError, "request timed out"
-            end
-          end
-
-          case resp.curl_return_code
-          when 0
-            # everything OK
-          when 7
-            raise Error::ConnectionFailed, resp.curl_error_message
-          when 60
-            raise Faraday::SSLError, resp.curl_error_message
-          else
-            raise Error::ClientError, resp.curl_error_message
-          end
-
-          save_response(env, resp.code, resp.body) do |response_headers|
-            response_headers.parse resp.headers
-          end
-          # in async mode, :response is initialized at this point
-          env[:response].finish(env) if parallel?(env)
-        end
-
-        req
-      end
-
-      def configure_ssl(req, env)
-        ssl = env[:ssl]
-
-        req.ssl_version = ssl[:version]          if ssl[:version]
-        req.ssl_cert    = ssl[:client_cert] if ssl[:client_cert]
-        req.ssl_key     = ssl[:client_key]  if ssl[:client_key]
-        req.ssl_cacert  = ssl[:ca_file]          if ssl[:ca_file]
-        req.ssl_capath  = ssl[:ca_path]          if ssl[:ca_path]
-      end
-
-      def configure_proxy(req, env)
-        proxy = request_options(env)[:proxy]
-        return unless proxy
-
-        req.proxy = "#{proxy[:uri].host}:#{proxy[:uri].port}"
-
-        if proxy[:user] && proxy[:password]
-          req.proxy_username = proxy[:user]
-          req.proxy_password = proxy[:password]
-        end
-      end
-
-      def configure_timeout(req, env)
-        env_req = request_options(env)
-        req.timeout = req.connect_timeout = (env_req[:timeout] * 1000) if env_req[:timeout]
-        req.connect_timeout = (env_req[:open_timeout] * 1000)          if env_req[:open_timeout]
-      end
-
-      def configure_socket(req, env)
-        if bind = request_options(env)[:bind]
-          req.interface = bind[:host]
-        end
-      end
-
-      def request_options(env)
-        env[:request]
-      end
-
-      def parallel?(env)
-        !!env[:parallel_manager]
-      end
+      dependency 'typhoeus/adapters/faraday'
     end
   end
 end

data/lib/faraday/adapter.rb

@@ -40,6 +40,8 @@ module Faraday
       env.clear_body if env.needs_body?
     end
 
+    private
+
     def save_response(env, status, body, headers = nil, reason_phrase = nil)
       env.status = status
       env.body = body

data/lib/faraday/autoload.rb

@@ -53,9 +53,9 @@ module Faraday
     autoload_all 'faraday/adapter',
       :NetHttp           => 'net_http',
       :NetHttpPersistent => 'net_http_persistent',
-      :Typhoeus          => 'typhoeus',
       :EMSynchrony       => 'em_synchrony',
       :EMHttp            => 'em_http',
+      :Typhoeus          => 'typhoeus',
       :Patron            => 'patron',
       :Excon             => 'excon',
       :Test              => 'test',

data/lib/faraday/connection.rb

@@ -39,6 +39,9 @@ module Faraday
     # Public: Sets the default parallel manager for this connection.
     attr_writer :default_parallel_manager
 
+    # Public: Gets or Sets the Hash proxy options.
+    # attr_reader :proxy
+
     # Public: Initializes a new Faraday::Connection.
     #
     # url     - URI or String base URL to use as a prefix for all
@@ -55,9 +58,9 @@ module Faraday
     #                     :user     - String (optional)
     #                     :password - String (optional)
     def initialize(url = nil, options = nil)
-      options = ConnectionOptions.from(options) unless options and options.is_a?(ConnectionOptions)
+      options = ConnectionOptions.from(options)
 
-      if url.is_a?(Hash)
+      if url.is_a?(Hash) || url.is_a?(ConnectionOptions)
         options = options.merge(url)
         url     = options.url
       end
@@ -79,14 +82,9 @@ module Faraday
       @params.update(options.params)   if options.params
       @headers.update(options.headers) if options.headers
 
-      @proxy = nil
-      proxy(options.fetch(:proxy) {
-        uri = ENV['http_proxy']
-        if uri && !uri.empty?
-          uri = 'http://' + uri if uri !~ /^http/i
-          uri
-        end
-      })
+      @manual_proxy = !!options.proxy
+      @proxy = options.proxy ? ProxyOptions.from(options.proxy) : proxy_from_env(url)
+      @temp_proxy = @proxy
 
       yield(self) if block_given?
 
@@ -283,9 +281,17 @@ module Faraday
     # Public: Gets or Sets the Hash proxy options.
     def proxy(arg = nil)
       return @proxy if arg.nil?
+      warn 'Warning: use of proxy(new_value) to set connection proxy have been DEPRECATED and will be removed in Faraday 1.0'
+      @manual_proxy = true
       @proxy = ProxyOptions.from(arg)
     end
 
+    # Public: Sets the Hash proxy options.
+    def proxy=(new_value)
+      @manual_proxy = true
+      @proxy = new_value ? ProxyOptions.from(new_value) : nil
+    end
+
     def_delegators :url_prefix, :scheme, :scheme=, :host, :host=, :port, :port=
     def_delegator :url_prefix, :path, :path_prefix
 
@@ -304,7 +310,7 @@ module Faraday
     #
     #   conn.get("nigiri?page=2") # accesses https://sushi.com/api/nigiri
     #
-    # Returns the parsed URI from teh given input..
+    # Returns the parsed URI from the given input..
     def url_prefix=(url, encoder = nil)
       uri = @url_prefix = Utils.URI(url)
       self.path_prefix = uri.path
@@ -367,7 +373,11 @@ module Faraday
         raise ArgumentError, "unknown http method: #{method}"
       end
 
+      # Resets temp_proxy
+      @temp_proxy = proxy_for_request(url)
+
       request = build_request(method) do |req|
+        req.options = req.options.merge(:proxy => @temp_proxy)
         req.url(url)                if url
         req.headers.update(headers) if headers
         req.body = body             if body
@@ -384,7 +394,7 @@ module Faraday
       Request.create(method) do |req|
         req.params  = self.params.dup
         req.headers = self.headers.dup
-        req.options = self.options.merge(:proxy => self.proxy)
+        req.options = self.options
         yield(req) if block_given?
       end
     end
@@ -433,5 +443,42 @@ module Faraday
         header(*args)
       headers[Faraday::Request::Authorization::KEY] = header
     end
+
+    def proxy_from_env(url)
+      return if Faraday.ignore_env_proxy
+      uri = nil
+      if URI.parse('').respond_to?(:find_proxy)
+        case url
+        when String
+            uri = Utils.URI(url)
+            uri = URI.parse("#{uri.scheme}://#{uri.hostname}").find_proxy
+          when URI
+            uri = url.find_proxy
+          when nil
+            uri = find_default_proxy
+        end
+      else
+        warn 'no_proxy is unsupported' if ENV['no_proxy'] || ENV['NO_PROXY']
+        uri = find_default_proxy
+      end
+      ProxyOptions.from(uri) if uri
+    end
+
+    def find_default_proxy
+      uri = ENV['http_proxy']
+      if uri && !uri.empty?
+        uri = 'http://' + uri if uri !~ /^http/i
+        uri
+      end
+    end
+
+    def proxy_for_request(url)
+      return self.proxy if @manual_proxy
+      if url && Utils.URI(url).absolute?
+        proxy_from_env(url)
+      else
+        self.proxy
+      end
+    end
   end
 end