faraday 0.6.0 → 0.8.0

data/faraday.gemspec

@@ -1,59 +1,41 @@
-## 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=
 
-  ## 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'
+  s.name    = 'faraday'
+  s.version = '0.8.0'
 
-  ## 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."
+  # TODO: s.description
 
-  ## 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'
+  s.homepage = 'https://github.com/technoweenie/faraday'
 
-  ## 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]
+  s.add_dependency 'multipart-post', '~> 1.1'
+  s.add_development_dependency 'rake'
+  s.add_development_dependency 'simplecov'
+  s.add_development_dependency 'test-unit'
+  s.add_development_dependency 'webmock'
 
-  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"])
-
-  ## 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
+    LICENSE.md
     README.md
     Rakefile
+    config.ru
     faraday.gemspec
     lib/faraday.rb
     lib/faraday/adapter.rb
-    lib/faraday/adapter/action_dispatch.rb
+    lib/faraday/adapter/em_http.rb
     lib/faraday/adapter/em_synchrony.rb
+    lib/faraday/adapter/em_synchrony/parallel_manager.rb
     lib/faraday/adapter/excon.rb
     lib/faraday/adapter/net_http.rb
+    lib/faraday/adapter/net_http_persistent.rb
     lib/faraday/adapter/patron.rb
+    lib/faraday/adapter/rack.rb
     lib/faraday/adapter/test.rb
     lib/faraday/adapter/typhoeus.rb
     lib/faraday/builder.rb
@@ -61,29 +43,40 @@ Gem::Specification.new do |s|
     lib/faraday/error.rb
     lib/faraday/middleware.rb
     lib/faraday/request.rb
-    lib/faraday/request/json.rb
+    lib/faraday/request/authorization.rb
+    lib/faraday/request/basic_authentication.rb
     lib/faraday/request/multipart.rb
+    lib/faraday/request/retry.rb
+    lib/faraday/request/token_authentication.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/default_test.rb
+    test/adapters/em_http_test.rb
+    test/adapters/em_synchrony_test.rb
+    test/adapters/excon_test.rb
+    test/adapters/integration.rb
     test/adapters/logger_test.rb
+    test/adapters/net_http_persistent_test.rb
     test/adapters/net_http_test.rb
+    test/adapters/patron_test.rb
+    test/adapters/rack_test.rb
     test/adapters/test_middleware_test.rb
+    test/adapters/typhoeus_test.rb
+    test/authentication_middleware_test.rb
     test/connection_test.rb
     test/env_test.rb
     test/helper.rb
     test/live_server.rb
+    test/middleware/retry_test.rb
     test/middleware_stack_test.rb
     test/request_middleware_test.rb
     test/response_middleware_test.rb
   ]
   # = MANIFEST =
 
-  ## 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/ }
+  s.test_files = s.files.select { |path| path =~ %r{^test/*/.+\.rb} }
 end

data/lib/faraday/adapter/em_http.rb

@@ -0,0 +1,204 @@
+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
+
+      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
+      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"
+        end
+        raise errklass, msg
+      end
+
+      def connection_config(env)
+        options = {}
+        configure_ssl(options, env)
+        configure_proxy(options, env)
+        configure_timeout(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)
+        # configure_proxy_auth
+        # :proxy => {:authorization => [user, pass]}
+        # proxy[:username] && proxy[:password]
+        options
+      end
+
+      def read_body(env)
+        body = env[:body]
+        body.respond_to?(:read) ? body.read : body
+      end
+
+      def configure_ssl(options, env)
+        if ssl = env[:ssl]
+          # :ssl => {
+          #   :private_key_file => '/tmp/server.key',
+          #   :cert_chain_file => '/tmp/server.crt',
+          #   :verify_peer => false
+        end
+      end
+
+      def configure_proxy(options, env)
+        if proxy = request_options(env)[:proxy]
+          options[:proxy] = {
+            :host => proxy[:uri].host,
+            :port => proxy[:uri].port
+          }
+        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
+
+      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

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,11 +1,21 @@
+require 'uri'
+
 module Faraday
   class Adapter
     class EMSynchrony < Faraday::Adapter
+
       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))
@@ -22,10 +32,10 @@ module Faraday
 
         if req = env[:request]
           if proxy = req[:proxy]
-            uri = Addressable::URI.parse(proxy[:uri])
+            uri = URI.parse(proxy[:uri])
             options[:proxy] = {
               :host => uri.host,
-              :port => uri.inferred_port
+              :port => uri.port
             }
             if proxy[:username] && proxy[:password]
               options[:proxy][:authorization] = [proxy[:username], proxy[:password]]
@@ -38,23 +48,43 @@ module Faraday
           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
-          }
+        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, options) 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 = block.call
-        end
+          client = nil
+          block = lambda { request.send(http_method, options) }
+
+          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
+          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
@@ -63,3 +93,24 @@ module Faraday
     end
   end
 end
+
+require 'faraday/adapter/em_synchrony/parallel_manager'
+
+# add missing patch(), options() methods
+EventMachine::HTTPMethods.module_eval do
+  ([:patch, :options] - instance_methods).each do |type|
+    module_eval %[
+      def #{type}(options = {}, &blk)
+        f = Fiber.current
+        conn = setup_request(:#{type}, options, &blk)
+        if conn.error.nil?
+          conn.callback { f.resume(conn) }
+          conn.errback  { f.resume(conn) }
+          Fiber.yield
+        else
+          conn
+        end
+      end
+    ]
+  end
+end

data/lib/faraday/adapter/excon.rb

@@ -17,8 +17,7 @@ module Faraday
           :headers => env[:request_headers],
           :body    => env[:body]
 
-        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

data/lib/faraday/adapter/net_http.rb

@@ -8,64 +8,107 @@ end
 module Faraday
   class Adapter
     class NetHttp < Faraday::Adapter
-      def call(env)
-        super
-        url = env[:url]
-        req = env[:request]
+      NET_HTTP_EXCEPTIONS = [
+        EOFError,
+        Errno::ECONNABORTED,
+        Errno::ECONNREFUSED,
+        Errno::ECONNRESET,
+        Errno::EINVAL,
+        Net::HTTPBadResponse,
+        Net::HTTPHeaderSyntaxError,
+        Net::ProtocolError,
+        SocketError
+      ]
 
-        http = net_http_class(env).new(url.host, url.inferred_port)
+      NET_HTTP_EXCEPTIONS << OpenSSL::SSL::SSLError if defined?(OpenSSL)
 
-        if http.use_ssl = (url.scheme == 'https' && env[:ssl])
-          ssl = env[:ssl]
-          http.verify_mode = ssl[:verify_mode] || ssl.fetch(:verify, true) ?
-                               OpenSSL::SSL::VERIFY_PEER : OpenSSL::SSL::VERIFY_NONE
-          http.cert        = ssl[:client_cert] if ssl[:client_cert]
-          http.key         = ssl[:client_key]  if ssl[:client_key]
-          http.ca_file     = ssl[:ca_file]     if ssl[:ca_file]
-          http.cert_store  = ssl[:cert_store]  if ssl[:cert_store]
-        end
+      def call(env)
+        super
+        http = net_http_connection(env)
+        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]
 
-        if :get != env[:method]
-          http_request = Net::HTTPGenericRequest.new \
-            env[:method].to_s.upcase,    # request method
-            !!env[:body],                # is there data
-            true,                        # does net/http love you, true or false?
-            url.request_uri,             # request uri path
-            env[:request_headers]        # request headers
-
-          if env[:body].respond_to?(:read)
-            http_request.body_stream = env[:body]
-            env[:body] = nil
-          end
-        end
-
         begin
-          http_response = if :get == env[:method]
-            # prefer `get` to `request` because the former handles gzip (ruby 1.9)
-            http.get url.request_uri, env[:request_headers]
-          else
-            http.request http_request, env[:body]
-          end
-        rescue Errno::ECONNREFUSED
+          http_response = perform_request(http, env)
+        rescue *NET_HTTP_EXCEPTIONS
           raise Error::ConnectionFailed, $!
         end
 
-        http_response.each_header do |key, value|
-          response_headers(env)[key] = value
+        save_response(env, http_response.code.to_i, http_response.body) do |response_headers|
+          http_response.each_header do |key, value|
+            response_headers[key] = value
+          end
         end
-        env.update :status => http_response.code.to_i, :body => http_response.body
 
         @app.call env
+      rescue Timeout::Error => err
+        raise Faraday::Error::TimeoutError, err
+      end
+
+      def create_request(env)
+        request = Net::HTTPGenericRequest.new \
+          env[:method].to_s.upcase,    # request method
+          !!env[:body],                # is there request body
+          :head != env[:method],       # 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 perform_request(http, env)
+        if :get == env[:method] and !env[:body]
+          # prefer `get` to `request` because the former handles gzip (ruby 1.9)
+          http.get env[:url].request_uri, env[:request_headers]
+        else
+          http.request create_request(env)
+        end
       end
 
-      def net_http_class(env)
+      def net_http_connection(env)
         if proxy = env[:request][:proxy]
           Net::HTTP::Proxy(proxy[:uri].host, proxy[:uri].port, proxy[:user], proxy[:password])
         else
           Net::HTTP
+        end.new(env[:url].host, env[:url].port)
+      end
+
+      def configure_ssl(http, ssl)
+        http.use_ssl      = true
+        http.verify_mode  = ssl_verify_mode(ssl)
+        http.cert_store   = ssl_cert_store(ssl)
+
+        http.cert         = ssl[:client_cert]  if ssl[:client_cert]
+        http.key          = ssl[:client_key]   if ssl[:client_key]
+        http.ca_file      = ssl[:ca_file]      if ssl[:ca_file]
+        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]
+      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
+        cert_store = OpenSSL::X509::Store.new
+        cert_store.set_default_paths
+        cert_store
+      end
+
+      def ssl_verify_mode(ssl)
+        ssl[:verify_mode] || begin
+          if ssl.fetch(:verify, true)
+            OpenSSL::SSL::VERIFY_PEER
+          else
+            OpenSSL::SSL::VERIFY_NONE
+          end
         end
       end
     end