httpi 1.1.1 → 2.0.0.rc1

data/lib/httpi/adapter/em_http.rb

@@ -0,0 +1,126 @@
+require "httpi/adapter/base"
+require "httpi/response"
+
+module HTTPI
+  module Adapter
+
+    # An HTTPI adapter for `EventMachine::HttpRequest`. Due to limitations of
+    # the em-httprequest library, not all features are supported. In particular,
+    #
+    # * CA files,
+    # * certificate verification modes other than "none" and "peer,"
+    # * NTLM authentication,
+    # * digest authentication, and
+    # * password-protected certificate keys
+    #
+    # are supported by HTTPI but not em-httprequest.
+    #
+    # In addition, some features of em-httprequest are not represented in HTTPI
+    # and are therefore not supported. In particular,
+    #
+    # * SOCKS5 proxying,
+    # * automatic redirect following,
+    # * response streaming,
+    # * file body streaming,
+    # * keepalive,
+    # * pipelining, and
+    # * multi-request
+    #
+    # are supported by em-httprequest but not HTTPI.
+    class EmHttpRequest < Base
+
+      register :em_http, :deps => %w(em-synchrony em-synchrony/em-http em-http)
+
+      def initialize(request)
+        @request = request
+        @client = EventMachine::HttpRequest.new build_request_url(request.url)
+      end
+
+      attr_reader :client
+
+      def cert_directory
+        @cert_directory ||= "/tmp"
+      end
+
+      attr_writer :cert_directory
+
+      # Executes arbitrary HTTP requests.
+      # @see HTTPI.request
+      def request(method)
+        _request { |options| @client.send method, options }
+      end
+
+      private
+
+      def _request
+        options = client_options
+        setup_proxy(options) if @request.proxy
+        setup_http_auth(options) if @request.auth.http?
+
+        if @request.auth.ssl?
+          raise NotSupportedError, "EM-HTTP-Request does not support SSL client auth"
+        end
+
+        start_time = Time.now
+        respond_with yield(options), start_time
+      end
+
+      def client_options
+        {
+          :query              => @request.url.query,
+          :connect_timeout    => @request.open_timeout,
+          :inactivity_timeout => @request.read_timeout,
+          :head               => @request.headers.to_hash,
+          :body               => @request.body
+        }
+      end
+
+      def setup_proxy(options)
+        options[:proxy] = {
+          :host          => @request.proxy.host,
+          :port          => @request.proxy.port,
+          :authorization => [@request.proxy.user, @request.proxy.password]
+        }
+      end
+
+      def setup_http_auth(options)
+        unless @request.auth.type == :basic
+          raise NotSupportedError, "EM-HTTP-Request does only support HTTP basic auth"
+        end
+
+        options[:head] ||= {}
+        options[:head][:authorization] = @request.auth.credentials
+      end
+
+      def respond_with(http, start_time)
+        raise TimeoutError, "EM-HTTP-Request connection timed out: #{Time.now - start_time} sec" if http.response_header.status.zero?
+
+        Response.new http.response_header.status,
+          convert_headers(http.response_header), http.response
+      end
+
+      def build_request_url(url)
+        "%s://%s:%s%s" % [url.scheme, url.host, url.port, url.path]
+      end
+
+      # Takes any header names with an underscore as a word separator and
+      # converts the name to camel case, where words are separated by a dash.
+      #
+      # E.g. CONTENT_TYPE becomes Content-Type.
+      def convert_headers(headers)
+        return headers unless headers.keys.any? { |k| k =~ /_/ }
+
+        result = {}
+
+        headers.each do |k, v|
+          words = k.split("_")
+          key = words.map { |w| w.downcase.capitalize }.join("-")
+          result[key] = v
+        end
+
+        result
+      end
+    end
+
+  end
+end

data/lib/httpi/adapter/httpclient.rb

@@ -1,3 +1,4 @@
+require "httpi/adapter/base"
 require "httpi/response"
 
 module HTTPI
@@ -7,86 +8,55 @@ module HTTPI
     #
     # Adapter for the HTTPClient client.
     # http://rubygems.org/gems/httpclient
-    class HTTPClient
+    class HTTPClient < Base
 
-      def initialize(request = nil)
-      end
+      register :httpclient, :deps => %w(httpclient)
 
-      # Returns a memoized <tt>HTTPClient</tt> instance.
-      def client
-        @client ||= ::HTTPClient.new
+      def initialize(request)
+        @request = request
+        @client = ::HTTPClient.new
       end
 
-      # Executes an HTTP GET request.
-      # @see HTTPI.get
-      def get(request)
-        do_request request do |url, headers|
-          client.get url, nil, headers
-        end
-      end
+      attr_reader :client
 
-      # Executes an HTTP POST request.
-      # @see HTTPI.post
-      def post(request)
-        do_request request do |url, headers, body|
-          client.post url, body, headers
-        end
+      # Executes arbitrary HTTP requests.
+      # @see HTTPI.request
+      def request(method)
+        setup_client
+        respond_with @client.request(method, @request.url, nil, @request.body, @request.headers)
+      rescue OpenSSL::SSL::SSLError
+        raise SSLError
       end
 
-      # Executes an HTTP HEAD request.
-      # @see HTTPI.head
-      def head(request)
-        do_request request do |url, headers|
-          client.head url, nil, headers
-        end
-      end
+      private
 
-      # Executes an HTTP PUT request.
-      # @see HTTPI.put
-      def put(request)
-        do_request request do |url, headers, body|
-          client.put url, body, headers
-        end
+      def setup_client
+        basic_setup
+        setup_auth if @request.auth.http?
+        setup_ssl_auth if @request.auth.ssl?
       end
 
-      # Executes an HTTP DELETE request.
-      # @see HTTPI.delete
-      def delete(request)
-        do_request request do |url, headers|
-          client.delete url, headers
-        end
+      def basic_setup
+        @client.proxy = @request.proxy if @request.proxy
+        @client.connect_timeout = @request.open_timeout if @request.open_timeout
+        @client.receive_timeout = @request.read_timeout if @request.read_timeout
       end
 
-    private
-
-      def do_request(request)
-        setup_client request
-        respond_with yield(request.url, request.headers, request.body)
-      end
-
-      def setup_client(request)
-        basic_setup request
-        setup_auth request if request.auth.http?
-        setup_ssl_auth request.auth.ssl if request.auth.ssl?
+      def setup_auth
+        @client.set_auth @request.url, *@request.auth.credentials
       end
 
-      def basic_setup(request)
-        client.proxy = request.proxy if request.proxy
-        client.connect_timeout = request.open_timeout if request.open_timeout
-        client.receive_timeout = request.read_timeout if request.read_timeout
-      end
+      def setup_ssl_auth
+        ssl = @request.auth.ssl
 
-      def setup_auth(request)
-        client.set_auth request.url, *request.auth.credentials
-      end
-
-      def setup_ssl_auth(ssl)
         unless ssl.verify_mode == :none
-          client.ssl_config.client_cert = ssl.cert
-          client.ssl_config.client_key = ssl.cert_key
-          client.ssl_config.client_ca = ssl.ca_cert if ssl.ca_cert_file
+          @client.ssl_config.client_cert = ssl.cert
+          @client.ssl_config.client_key = ssl.cert_key
+          @client.ssl_config.add_trust_ca(ssl.ca_cert_file) if ssl.ca_cert_file
         end
-        client.ssl_config.verify_mode = ssl.openssl_verify_mode
+
+        @client.ssl_config.verify_mode = ssl.openssl_verify_mode
+        @client.ssl_config.ssl_version = ssl.ssl_version if ssl.ssl_version
       end
 
       def respond_with(response)

data/lib/httpi/adapter/net_http.rb

@@ -1,4 +1,6 @@
 require "uri"
+
+require "httpi/adapter/base"
 require "httpi/response"
 
 module HTTPI
@@ -8,89 +10,69 @@ module HTTPI
     #
     # Adapter for the Net::HTTP client.
     # http://ruby-doc.org/stdlib/libdoc/net/http/rdoc/
-    class NetHTTP
+    class NetHTTP < Base
+
+      register :net_http, :deps => %w(net/https)
 
       def initialize(request)
-        self.client = new_client request
+        @request = request
+        @client = create_client
       end
 
       attr_reader :client
 
-      # Executes an HTTP GET request.
-      # @see HTTPI.get
-      def get(request)
-        do_request :get, request do |http, get|
-          http.request get
-        end
-      end
-
-      # Executes an HTTP POST request.
-      # @see HTTPI.post
-      def post(request)
-        do_request :post, request do |http, post|
-          post.body = request.body
-          http.request post
-        end
-      end
-
-      # Executes an HTTP HEAD request.
-      # @see HTTPI.head
-      def head(request)
-        do_request :head, request do |http, head|
-          http.request head
+      # Executes arbitrary HTTP requests.
+      # @see HTTPI.request
+      def request(method)
+        unless REQUEST_METHODS.include? method
+          raise NotSupportedError, "Net::HTTP does not support custom HTTP methods"
         end
-      end
-
-      # Executes an HTTP PUT request.
-      # @see HTTPI.put
-      def put(request)
-        do_request :put, request do |http, put|
-          put.body = request.body
-          http.request put
-        end
-      end
 
-      # Executes an HTTP DELETE request.
-      # @see HTTPI.delete
-      def delete(request)
-        do_request :delete, request do |http, delete|
-          http.request delete
+        do_request(method) do |http, http_request|
+          http_request.body = @request.body
+          http.request http_request
         end
+      rescue OpenSSL::SSL::SSLError
+        raise SSLError
       end
 
-    private
+      private
 
-      attr_writer :client
-
-      def new_client(request)
-        proxy_url = request.proxy || URI("")
+      def create_client
+        proxy_url = @request.proxy || URI("")
         proxy = Net::HTTP::Proxy(proxy_url.host, proxy_url.port, proxy_url.user, proxy_url.password)
-        proxy.new request.url.host, request.url.port
+        proxy.new(@request.url.host, @request.url.port)
       end
 
-      def do_request(type, request)
-        setup_client request
-        setup_ssl_auth request.auth.ssl if request.auth.ssl?
+      def do_request(type)
+        setup_client
+        setup_ssl_auth if @request.auth.ssl?
 
-        respond_with(client.start do |http|
-          yield http, request_client(type, request)
+        respond_with(@client.start do |http|
+          yield http, request_client(type)
         end)
       end
 
-      def setup_client(request)
-        client.use_ssl = request.ssl?
-        client.open_timeout = request.open_timeout if request.open_timeout
-        client.read_timeout = request.read_timeout if request.read_timeout
+      def setup_client
+        @client.use_ssl = @request.ssl?
+        @client.open_timeout = @request.open_timeout if @request.open_timeout
+        @client.read_timeout = @request.read_timeout if @request.read_timeout
       end
 
-      def setup_ssl_auth(ssl)
-        client.key = ssl.cert_key
-        client.cert = ssl.cert
-        client.ca_file = ssl.ca_cert_file if ssl.ca_cert_file
-        client.verify_mode = ssl.openssl_verify_mode
+      def setup_ssl_auth
+        ssl = @request.auth.ssl
+
+        unless ssl.verify_mode == :none
+          @client.key = ssl.cert_key
+          @client.cert = ssl.cert
+          @client.ca_file = ssl.ca_cert_file if ssl.ca_cert_file
+        end
+
+        @client.verify_mode = ssl.openssl_verify_mode
+        @client.ssl_version = ssl.ssl_version if ssl.ssl_version
       end
 
-      def request_client(type, request)
+      def request_client(type)
         request_class = case type
           when :get    then Net::HTTP::Get
           when :post   then Net::HTTP::Post
@@ -99,8 +81,8 @@ module HTTPI
           when :delete then Net::HTTP::Delete
         end
 
-        request_client = request_class.new request.url.request_uri, request.headers
-        request_client.basic_auth *request.auth.credentials if request.auth.basic?
+        request_client = request_class.new @request.url.request_uri, @request.headers
+        request_client.basic_auth *@request.auth.credentials if @request.auth.basic?
 
         request_client
       end

data/lib/httpi/auth/ssl.rb

@@ -10,6 +10,7 @@ module HTTPI
 
       VERIFY_MODES = [:none, :peer, :fail_if_no_peer_cert, :client_once]
       CERT_TYPES = [:pem, :der]
+      SSL_VERSIONS = [:TLSv1, :SSLv2, :SSLv3]
 
       # Returns whether SSL configuration is present.
       def present?
@@ -37,7 +38,11 @@ module HTTPI
 
       # Sets the cert type to validate SSL certificates PEM|DER.
       def cert_type=(type)
-        raise ArgumentError, "Invalid SSL cert type: #{type}" unless CERT_TYPES.include? type
+        unless CERT_TYPES.include? type
+          raise ArgumentError, "Invalid SSL cert type #{type.inspect}\n" +
+                               "Please specify one of #{CERT_TYPES.inspect}"
+        end
+
         @cert_type = type
       end
 
@@ -48,10 +53,29 @@ module HTTPI
 
       # Sets the SSL verify mode. Expects one of <tt>HTTPI::Auth::SSL::VERIFY_MODES</tt>.
       def verify_mode=(mode)
-        raise ArgumentError, "Invalid SSL verify mode: #{mode}" unless VERIFY_MODES.include? mode
+        unless VERIFY_MODES.include? mode
+          raise ArgumentError, "Invalid SSL verify mode #{mode.inspect}\n" +
+                               "Please specify one of #{VERIFY_MODES.inspect}"
+        end
+
         @verify_mode = mode
       end
 
+      # Returns the SSL version number. Defaults to <tt>nil</tt> (auto-negotiate).
+      def ssl_version
+        @ssl_version
+      end
+
+      # Sets the SSL version number. Expects one of <tt>HTTPI::Auth::SSL::SSL_VERSIONS</tt>.
+      def ssl_version=(version)
+        unless SSL_VERSIONS.include? version
+          raise ArgumentError, "Invalid SSL version #{version.inspect}\n" +
+                               "Please specify one of #{SSL_VERSIONS.inspect}"
+        end
+
+        @ssl_version = version
+      end
+
       # Returns an <tt>OpenSSL::X509::Certificate</tt> for the +cert_file+.
       def cert
         @cert ||= (OpenSSL::X509::Certificate.new File.read(cert_file) if cert_file)