faraday 0.6.0 → 0.9.0

data/faraday.gemspec

@@ -1,89 +1,34 @@
-## This is the rakegem gemspec template. Make sure you read and understand
-## all of the comments. Some sections require modification, and others can
-## be deleted if you don't need them. Once you understand the contents of
-## this file, feel free to delete any comments that begin with two hash marks.
-## You can find comprehensive Gem::Specification documentation, at
-## http://docs.rubygems.org/read/chapter/20
-Gem::Specification.new do |s|
-  s.specification_version = 2 if s.respond_to? :specification_version=
-  s.required_rubygems_version = Gem::Requirement.new(">= 1.3.5") if s.respond_to? :required_rubygems_version=
+lib = "faraday"
+lib_file = File.expand_path("../lib/#{lib}.rb", __FILE__)
+File.read(lib_file) =~ /\bVERSION\s*=\s*["'](.+?)["']/
+version = $1
 
-  ## Leave these as is they will be modified for you by the rake gemspec task.
-  ## If your rubyforge_project name is different, then edit it and comment out
-  ## the sub! line in the Rakefile
-  s.name              = 'faraday'
-  s.version           = '0.6.0'
-  s.date              = '2011-03-31'
-  s.rubyforge_project = 'faraday'
+Gem::Specification.new do |spec|
+  spec.specification_version = 2 if spec.respond_to? :specification_version=
+  spec.required_rubygems_version = '>= 1.3.5'
 
-  ## Make sure your summary is short. The description may be as long
-  ## as you like.
-  s.summary     = "HTTP/REST API client library."
-  s.description = "HTTP/REST API client library."
+  spec.name    = lib
+  spec.version = version
 
-  ## List the primary authors. If there are a bunch of authors, it's probably
-  ## better to set the email to an email list or something. If you don't have
-  ## a custom homepage, consider using your GitHub URL or the like.
-  s.authors  = ["Rick Olson"]
-  s.email    = 'technoweenie@gmail.com'
-  s.homepage = 'http://github.com/technoweenie/faraday'
+  spec.summary = "HTTP/REST API client library."
 
-  ## This gets added to the $LOAD_PATH so that 'lib/NAME.rb' can be required as
-  ## require 'NAME.rb' or'/lib/NAME/file.rb' can be as require 'NAME/file.rb'
-  s.require_paths = %w[lib]
+  spec.authors  = ["Rick Olson"]
+  spec.email    = 'technoweenie@gmail.com'
+  spec.homepage = 'https://github.com/lostisland/faraday'
+  spec.licenses = ['MIT']
 
-  s.add_development_dependency('rake', '~> 0.8')
-  s.add_runtime_dependency('addressable', '~> 2.2.4')
-  s.add_runtime_dependency('multipart-post', '~> 1.1.0')
-  s.add_runtime_dependency('rack', ['>= 1.1.0', "< 2"])
+  spec.add_dependency 'multipart-post', '>= 1.2', '< 3'
+  spec.add_development_dependency 'bundler', '~> 1.0'
 
-  ## Leave this section as-is. It will be automatically generated from the
-  ## contents of your Git repository via the gemspec task. DO NOT REMOVE
-  ## THE MANIFEST COMMENTS, they are used as delimiters by the task.
-  # = MANIFEST =
-  s.files = %w[
-    Gemfile
-    LICENSE
-    README.md
-    Rakefile
-    faraday.gemspec
-    lib/faraday.rb
-    lib/faraday/adapter.rb
-    lib/faraday/adapter/action_dispatch.rb
-    lib/faraday/adapter/em_synchrony.rb
-    lib/faraday/adapter/excon.rb
-    lib/faraday/adapter/net_http.rb
-    lib/faraday/adapter/patron.rb
-    lib/faraday/adapter/test.rb
-    lib/faraday/adapter/typhoeus.rb
-    lib/faraday/builder.rb
-    lib/faraday/connection.rb
-    lib/faraday/error.rb
-    lib/faraday/middleware.rb
-    lib/faraday/request.rb
-    lib/faraday/request/json.rb
-    lib/faraday/request/multipart.rb
-    lib/faraday/request/url_encoded.rb
-    lib/faraday/response.rb
-    lib/faraday/response/logger.rb
-    lib/faraday/response/raise_error.rb
-    lib/faraday/upload_io.rb
-    lib/faraday/utils.rb
-    test/adapters/live_test.rb
-    test/adapters/logger_test.rb
-    test/adapters/net_http_test.rb
-    test/adapters/test_middleware_test.rb
-    test/connection_test.rb
-    test/env_test.rb
-    test/helper.rb
-    test/live_server.rb
-    test/middleware_stack_test.rb
-    test/request_middleware_test.rb
-    test/response_middleware_test.rb
-  ]
-  # = MANIFEST =
+  spec.files = %w(.document CHANGELOG.md CONTRIBUTING.md Gemfile LICENSE.md README.md Rakefile)
+  spec.files << "#{lib}.gemspec"
+  spec.files += Dir.glob("lib/**/*.rb")
+  spec.files += Dir.glob("test/**/*.{rb,txt}")
+  spec.files += Dir.glob("script/*")
 
-  ## Test files will be grabbed from the file list. Make sure the path glob
-  ## matches what you actually use.
-  s.test_files = s.files.select { |path| path =~ /^test\/.*_test\.rb/ }
+  dev_null    = File.exist?('/dev/null') ? '/dev/null' : 'NUL'
+  git_files   = `git ls-files -z 2>#{dev_null}`
+  spec.files &= git_files.split("\0") if $?.success?
+
+  spec.test_files = Dir.glob("test/**/*.rb")
 end

data/lib/faraday/adapter/em_http.rb

@@ -0,0 +1,237 @@
+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

@@ -0,0 +1,56 @@
+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

@@ -0,0 +1,66 @@
+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,65 +1,92 @@
+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(URI::parse(env[:url].to_s))
-        options = {:head => env[:request_headers]}
-        options[:ssl] = env[:ssl] if env[:ssl]
+        request = EventMachine::HttpRequest.new(Utils::URI(env[:url].to_s), connection_config(env))
 
-        if env[:body]
-          if env[:body].respond_to? :read
-            options[:body] = env[:body].read
-          else
-            options[:body] = env[:body]
-          end
-        end
+        http_method = env[:method].to_s.downcase.to_sym
 
-        if req = env[:request]
-          if proxy = req[:proxy]
-            uri = Addressable::URI.parse(proxy[:uri])
-            options[:proxy] = {
-              :host => uri.host,
-              :port => uri.inferred_port
-            }
-            if proxy[:username] && proxy[:password]
-              options[:proxy][:authorization] = [proxy[:username], proxy[:password]]
+        # 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
-          end
 
-          # only one timeout currently supported by em http request
-          if req[:timeout] or req[:open_timeout]
-            options[:timeout] = [req[:timeout] || 0, req[:open_timeout] || 0].max
+            # Finalize the response object with values from `env`.
+            env[:response].finish(env)
           end
-        end
 
-        client = nil
-        block = lambda { request.send env[:method].to_s.downcase.to_sym, options }
-        if !EM.reactor_running?
-          EM.run {
-            Fiber.new do
-              client = block.call
-              EM.stop
-            end.resume
-          }
+        # Execute single request.
         else
-          client = block.call
-        end
+          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
 
-        client.response_header.each do |name, value|
-          response_headers(env)[name.to_sym] = value
+          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
-        env.update :status => client.response_header.status, :body => client.response
 
         @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

@@ -3,26 +3,77 @@ module Faraday
     class Excon < Faraday::Adapter
       dependency 'excon'
 
+      def initialize(app, connection_options = {})
+        @connection_options = connection_options
+        super(app)
+      end
+
       def call(env)
         super
 
-        conn = ::Excon.new(env[:url].to_s)
-        if ssl = (env[:url].scheme == 'https' && env[:ssl])
-          ::Excon.ssl_verify_peer = !!ssl.fetch(:verify, true)
-          ::Excon.ssl_ca_path = ssl[:ca_file] if ssl[:ca_file]
+        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    => env[:body]
+          :body    => read_body(env)
 
-        env.update :status => resp.status.to_i, :body => resp.body
-        response_headers(env).update resp.headers
+        save_response(env, resp.status.to_i, resp.body, resp.headers)
 
         @app.call env
-      rescue ::Excon::Errors::SocketError
-        raise Error::ConnectionFailed, $!
+      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