faraday 0.9.1 → 1.8.0

data/lib/faraday/adapter/em_http.rb

@@ -1,237 +0,0 @@
-module Faraday
-  class Adapter
-    # EventMachine adapter is useful for either asynchronous requests
-    # when in EM reactor loop or for making parallel requests in
-    # synchronous code.
-    class EMHttp < Faraday::Adapter
-      module Options
-        def connection_config(env)
-          options = {}
-          configure_proxy(options, env)
-          configure_timeout(options, env)
-          configure_socket(options, env)
-          configure_ssl(options, env)
-          options
-        end
-
-        def request_config(env)
-          options = {
-            :body => read_body(env),
-            :head => env[:request_headers],
-            # :keepalive => true,
-            # :file => 'path/to/file', # stream data off disk
-          }
-          configure_compression(options, env)
-          options
-        end
-
-        def read_body(env)
-          body = env[:body]
-          body.respond_to?(:read) ? body.read : body
-        end
-
-        def configure_proxy(options, env)
-          if proxy = request_options(env)[:proxy]
-            options[:proxy] = {
-              :host => proxy[:uri].host,
-              :port => proxy[:uri].port,
-              :authorization => [proxy[:user], proxy[:password]]
-            }
-          end
-        end
-
-        def configure_socket(options, env)
-          if bind = request_options(env)[:bind]
-            options[:bind] = {
-              :host => bind[:host],
-              :port => bind[:port]
-            }
-          end
-        end
-
-        def configure_ssl(options, env)
-          if env[:url].scheme == 'https' && env[:ssl]
-            options[:ssl] = {
-              :cert_chain_file => env[:ssl][:ca_file],
-              :verify_peer => env[:ssl].fetch(:verify, true)
-            }
-          end
-        end
-
-        def configure_timeout(options, env)
-          timeout, open_timeout = request_options(env).values_at(:timeout, :open_timeout)
-          options[:connect_timeout] = options[:inactivity_timeout] = timeout
-          options[:connect_timeout] = open_timeout if open_timeout
-        end
-
-        def configure_compression(options, env)
-          if env[:method] == :get and not options[:head].key? 'accept-encoding'
-            options[:head]['accept-encoding'] = 'gzip, compressed'
-          end
-        end
-
-        def request_options(env)
-          env[:request]
-        end
-      end
-
-      include Options
-
-      dependency 'em-http'
-
-      self.supports_parallel = true
-
-      def self.setup_parallel_manager(options = nil)
-        Manager.new
-      end
-
-      def call(env)
-        super
-        perform_request env
-        @app.call env
-      end
-
-      def perform_request(env)
-        if parallel?(env)
-          manager = env[:parallel_manager]
-          manager.add {
-            perform_single_request(env).
-              callback { env[:response].finish(env) }
-          }
-        else
-          unless EventMachine.reactor_running?
-            error = nil
-            # start EM, block until request is completed
-            EventMachine.run do
-              perform_single_request(env).
-                callback { EventMachine.stop }.
-                errback { |client|
-                  error = error_message(client)
-                  EventMachine.stop
-                }
-            end
-            raise_error(error) if error
-          else
-            # EM is running: instruct upstream that this is an async request
-            env[:parallel_manager] = true
-            perform_single_request(env).
-              callback { env[:response].finish(env) }.
-              errback {
-                # TODO: no way to communicate the error in async mode
-                raise NotImplementedError
-              }
-          end
-        end
-      rescue EventMachine::Connectify::CONNECTError => err
-        if err.message.include?("Proxy Authentication Required")
-          raise Error::ConnectionFailed, %{407 "Proxy Authentication Required "}
-        else
-          raise Error::ConnectionFailed, err
-        end
-      rescue => err
-        if defined?(OpenSSL) && OpenSSL::SSL::SSLError === err
-          raise Faraday::SSLError, err
-        else
-          raise
-        end
-      end
-
-      # TODO: reuse the connection to support pipelining
-      def perform_single_request(env)
-        req = EventMachine::HttpRequest.new(env[:url], connection_config(env))
-        req.setup_request(env[:method], request_config(env)).callback { |client|
-          save_response(env, client.response_header.status, client.response) do |resp_headers|
-            client.response_header.each do |name, value|
-              resp_headers[name.to_sym] = value
-            end
-          end
-        }
-      end
-
-      def error_message(client)
-        client.error or "request failed"
-      end
-
-      def raise_error(msg)
-        errklass = Faraday::Error::ClientError
-        if msg == Errno::ETIMEDOUT
-          errklass = Faraday::Error::TimeoutError
-          msg = "request timed out"
-        elsif msg == Errno::ECONNREFUSED
-          errklass = Faraday::Error::ConnectionFailed
-          msg = "connection refused"
-        elsif msg == "connection closed by server"
-          errklass = Faraday::Error::ConnectionFailed
-        end
-        raise errklass, msg
-      end
-
-      def parallel?(env)
-        !!env[:parallel_manager]
-      end
-
-      # The parallel manager is designed to start an EventMachine loop
-      # and block until all registered requests have been completed.
-      class Manager
-        def initialize
-          reset
-        end
-
-        def reset
-          @registered_procs = []
-          @num_registered = 0
-          @num_succeeded = 0
-          @errors = []
-          @running = false
-        end
-
-        def running?() @running end
-
-        def add
-          if running?
-            perform_request { yield }
-          else
-            @registered_procs << Proc.new
-          end
-          @num_registered += 1
-        end
-
-        def run
-          if @num_registered > 0
-            @running = true
-            EventMachine.run do
-              @registered_procs.each do |proc|
-                perform_request(&proc)
-              end
-            end
-            if @errors.size > 0
-              raise Faraday::Error::ClientError, @errors.first || "connection failed"
-            end
-          end
-        ensure
-          reset
-        end
-
-        def perform_request
-          client = yield
-          client.callback { @num_succeeded += 1; check_finished }
-          client.errback { @errors << client.error; check_finished }
-        end
-
-        def check_finished
-          if @num_succeeded + @errors.size == @num_registered
-            EventMachine.stop
-          end
-        end
-      end
-    end
-  end
-end
-
-begin
-  require 'openssl'
-rescue LoadError
-  warn "Warning: no such file to load -- openssl. Make sure it is installed if you want HTTPS support"
-else
-  require 'faraday/adapter/em_http_ssl_patch'
-end if Faraday::Adapter::EMHttp.loaded?

data/lib/faraday/adapter/em_http_ssl_patch.rb

@@ -1,56 +0,0 @@
-require 'openssl'
-require 'em-http'
-
-module EmHttpSslPatch
-  def ssl_verify_peer(cert_string)
-    cert = nil
-    begin
-      cert = OpenSSL::X509::Certificate.new(cert_string)
-    rescue OpenSSL::X509::CertificateError
-      return false
-    end
-
-    @last_seen_cert = cert
-
-    if certificate_store.verify(@last_seen_cert)
-      begin
-        certificate_store.add_cert(@last_seen_cert)
-      rescue OpenSSL::X509::StoreError => e
-        raise e unless e.message == 'cert already in hash table'
-      end
-      true
-    else
-      raise OpenSSL::SSL::SSLError.new(%(unable to verify the server certificate for "#{host}"))
-    end
-  end
-
-  def ssl_handshake_completed
-    return true unless verify_peer?
-
-    unless OpenSSL::SSL.verify_certificate_identity(@last_seen_cert, host)
-      raise OpenSSL::SSL::SSLError.new(%(host "#{host}" does not match the server certificate))
-    else
-      true
-    end
-  end
-
-  def verify_peer?
-    parent.connopts.tls[:verify_peer]
-  end
-
-  def host
-    parent.connopts.host
-  end
-
-  def certificate_store
-    @certificate_store ||= begin
-      store = OpenSSL::X509::Store.new
-      store.set_default_paths
-      ca_file = parent.connopts.tls[:cert_chain_file]
-      store.add_file(ca_file) if ca_file
-      store
-    end
-  end
-end
-
-EventMachine::HttpStubConnection.send(:include, EmHttpSslPatch)

data/lib/faraday/adapter/em_synchrony/parallel_manager.rb

@@ -1,66 +0,0 @@
-module Faraday
-  class Adapter
-    class EMSynchrony < Faraday::Adapter
-      class ParallelManager
-
-        # Add requests to queue. The `request` argument should be a
-        # `EM::HttpRequest` object.
-        def add(request, method, *args, &block)
-          queue << {
-            :request => request,
-            :method => method,
-            :args => args,
-            :block => block
-          }
-        end
-
-        # Run all requests on queue with `EM::Synchrony::Multi`, wrapping
-        # it in a reactor and fiber if needed.
-        def run
-          result = nil
-          if !EM.reactor_running?
-            EM.run {
-              Fiber.new do
-                result = perform
-                EM.stop
-              end.resume
-            }
-          else
-            result = perform
-          end
-          result
-        end
-
-
-        private
-
-        # The request queue.
-        def queue
-          @queue ||= []
-        end
-
-        # Main `EM::Synchrony::Multi` performer.
-        def perform
-          multi = ::EM::Synchrony::Multi.new
-
-          queue.each do |item|
-            method = "a#{item[:method]}".to_sym
-
-            req = item[:request].send(method, *item[:args])
-            req.callback(&item[:block])
-
-            req_name = "req_#{multi.requests.size}".to_sym
-            multi.add(req_name, req)
-          end
-
-          # Clear the queue, so parallel manager objects can be reused.
-          @queue = []
-
-          # Block fiber until all requests have returned.
-          multi.perform
-        end
-
-      end # ParallelManager
-    end # EMSynchrony
-  end # Adapter
-end # Faraday

data/lib/faraday/adapter/em_synchrony.rb

@@ -1,92 +0,0 @@
-require 'uri'
-
-module Faraday
-  class Adapter
-    class EMSynchrony < Faraday::Adapter
-      include EMHttp::Options
-
-      dependency do
-        require 'em-synchrony/em-http'
-        require 'em-synchrony/em-multi'
-        require 'fiber'
-      end
-
-      self.supports_parallel = true
-
-      def self.setup_parallel_manager(options = {})
-        ParallelManager.new
-      end
-
-      def call(env)
-        super
-        request = EventMachine::HttpRequest.new(Utils::URI(env[:url].to_s), connection_config(env))
-
-        http_method = env[:method].to_s.downcase.to_sym
-
-        # Queue requests for parallel execution.
-        if env[:parallel_manager]
-          env[:parallel_manager].add(request, http_method, request_config(env)) do |resp|
-            save_response(env, resp.response_header.status, resp.response) do |resp_headers|
-              resp.response_header.each do |name, value|
-                resp_headers[name.to_sym] = value
-              end
-            end
-
-            # Finalize the response object with values from `env`.
-            env[:response].finish(env)
-          end
-
-        # Execute single request.
-        else
-          client = nil
-          block = lambda { request.send(http_method, request_config(env)) }
-
-          if !EM.reactor_running?
-            EM.run do
-              Fiber.new {
-                client = block.call
-                EM.stop
-              }.resume
-            end
-          else
-            client = block.call
-          end
-
-          raise client.error if client.error
-
-          save_response(env, client.response_header.status, client.response) do |resp_headers|
-            client.response_header.each do |name, value|
-              resp_headers[name.to_sym] = value
-            end
-          end
-        end
-
-        @app.call env
-      rescue Errno::ECONNREFUSED
-        raise Error::ConnectionFailed, $!
-      rescue EventMachine::Connectify::CONNECTError => err
-        if err.message.include?("Proxy Authentication Required")
-          raise Error::ConnectionFailed, %{407 "Proxy Authentication Required "}
-        else
-          raise Error::ConnectionFailed, err
-        end
-      rescue => err
-        if defined?(OpenSSL) && OpenSSL::SSL::SSLError === err
-          raise Faraday::SSLError, err
-        else
-          raise
-        end
-      end
-    end
-  end
-end
-
-require 'faraday/adapter/em_synchrony/parallel_manager'
-
-begin
-  require 'openssl'
-rescue LoadError
-  warn "Warning: no such file to load -- openssl. Make sure it is installed if you want HTTPS support"
-else
-  require 'faraday/adapter/em_http_ssl_patch'
-end if Faraday::Adapter::EMSynchrony.loaded?

data/lib/faraday/adapter/excon.rb

@@ -1,80 +0,0 @@
-module Faraday
-  class Adapter
-    class Excon < Faraday::Adapter
-      dependency 'excon'
-
-      def initialize(app, connection_options = {})
-        @connection_options = connection_options
-        super(app)
-      end
-
-      def call(env)
-        super
-
-        opts = {}
-        if env[:url].scheme == 'https' && ssl = env[:ssl]
-          opts[:ssl_verify_peer] = !!ssl.fetch(:verify, true)
-          opts[:ssl_ca_path] = ssl[:ca_path] if ssl[:ca_path]
-          opts[:ssl_ca_file] = ssl[:ca_file] if ssl[:ca_file]
-          opts[:client_cert] = ssl[:client_cert] if ssl[:client_cert]
-          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]
-
-          # https://github.com/geemus/excon/issues/106
-          # https://github.com/jruby/jruby-ossl/issues/19
-          opts[:nonblock] = false
-        end
-
-        if ( req = env[:request] )
-          if req[:timeout]
-            opts[:read_timeout]      = req[:timeout]
-            opts[:connect_timeout]   = req[:timeout]
-            opts[:write_timeout]     = req[:timeout]
-          end
-
-          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,
-              :port     => req[:proxy][:uri].port,
-              :scheme   => req[:proxy][:uri].scheme,
-              :user     => req[:proxy][:user],
-              :password => req[:proxy][:password]
-            }
-          end
-        end
-
-        conn = ::Excon.new(env[:url].to_s, opts.merge(@connection_options))
-
-        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)
-
-        @app.call env
-      rescue ::Excon::Errors::SocketError => err
-        if err.message =~ /\btimeout\b/
-          raise Error::TimeoutError, err
-        elsif err.message =~ /\bcertificate\b/
-          raise Faraday::SSLError, err
-        else
-          raise Error::ConnectionFailed, err
-        end
-      rescue ::Excon::Errors::Timeout => err
-        raise Error::TimeoutError, err
-      end
-
-      # TODO: support streaming requests
-      def read_body(env)
-        env[:body].respond_to?(:read) ? env[:body].read : env[:body]
-      end
-    end
-  end
-end

data/lib/faraday/adapter/httpclient.rb

@@ -1,106 +0,0 @@
-module Faraday
-  class Adapter
-    class HTTPClient < Faraday::Adapter
-      dependency 'httpclient'
-
-      def client
-        @client ||= ::HTTPClient.new
-      end
-
-      def call(env)
-        super
-
-        if req = env[:request]
-          if proxy = req[:proxy]
-            configure_proxy proxy
-          end
-
-          if bind = req[:bind]
-            configure_socket bind
-          end
-
-          configure_timeouts req
-        end
-
-        if env[:url].scheme == 'https' && ssl = env[:ssl]
-          configure_ssl ssl
-        end
-
-        # TODO Don't stream yet.
-        # https://github.com/nahi/httpclient/pull/90
-        env[:body] = env[:body].read if env[:body].respond_to? :read
-
-        resp = client.request env[:method], env[:url],
-          :body   => env[:body],
-          :header => env[:request_headers]
-
-        save_response env, resp.status, resp.body, resp.headers
-
-        @app.call env
-      rescue ::HTTPClient::TimeoutError
-        raise Faraday::Error::TimeoutError, $!
-      rescue ::HTTPClient::BadResponseError => err
-        if err.message.include?('status 407')
-          raise Faraday::Error::ConnectionFailed, %{407 "Proxy Authentication Required "}
-        else
-          raise Faraday::Error::ClientError, $!
-        end
-      rescue Errno::ECONNREFUSED, EOFError
-        raise Faraday::Error::ConnectionFailed, $!
-      rescue => err
-        if defined?(OpenSSL) && OpenSSL::SSL::SSLError === err
-          raise Faraday::SSLError, err
-        else
-          raise
-        end
-      end
-
-      def configure_socket(bind)
-        client.socket_local.host = bind[:host]
-        client.socket_local.port = bind[:port]
-      end
-
-      def configure_proxy(proxy)
-        client.proxy = proxy[:uri]
-        if proxy[:user] && proxy[:password]
-          client.set_proxy_auth proxy[:user], proxy[:password]
-        end
-      end
-
-      def configure_ssl(ssl)
-        ssl_config = client.ssl_config
-
-        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)
-        if req[:timeout]
-          client.connect_timeout   = req[:timeout]
-          client.receive_timeout   = req[:timeout]
-          client.send_timeout      = req[:timeout]
-        end
-
-        if req[:open_timeout]
-          client.connect_timeout   = req[:open_timeout]
-          client.send_timeout      = req[:open_timeout]
-        end
-      end
-
-      def ssl_verify_mode(ssl)
-        ssl[:verify_mode] || begin
-          if ssl.fetch(:verify, true)
-            OpenSSL::SSL::VERIFY_PEER | OpenSSL::SSL::VERIFY_FAIL_IF_NO_PEER_CERT
-          else
-            OpenSSL::SSL::VERIFY_NONE
-          end
-        end
-      end
-    end
-  end
-end