httpi-ntlm 0.9.6

data/lib/httpi/adapter.rb

@@ -0,0 +1,67 @@
+require "httpi/adapter/httpclient"
+require "httpi/adapter/curb"
+require "httpi/adapter/net_http"
+
+module HTTPI
+
+  # = HTTPI::Adapter
+  #
+  # Manages the adapter classes. Currently supports:
+  #
+  # * httpclient
+  # * curb
+  # * net/http
+  module Adapter
+
+    ADAPTERS = {
+      :httpclient => { :class => HTTPClient, :dependencies => ["httpclient"] },
+      :curb       => { :class => Curb,       :dependencies => ["curb"] },
+      :net_http   => { :class => NetHTTP,    :dependencies => ["net/https", "net/ntlm_http"] }
+    }
+
+    LOAD_ORDER = [:httpclient, :curb, :net_http]
+
+    class << self
+
+      def use=(adapter)
+        return @adapter = nil if adapter.nil?
+
+        validate_adapter! adapter
+        load_dependencies adapter
+        @adapter = adapter
+      end
+
+      def use
+        @adapter ||= default_adapter
+      end
+
+      def load(adapter)
+        adapter = adapter ? validate_adapter!(adapter) : use
+        [adapter, ADAPTERS[adapter][:class]]
+      end
+
+    private
+
+      def validate_adapter!(adapter)
+        raise ArgumentError, "Invalid HTTPI adapter: #{adapter}" unless ADAPTERS[adapter]
+        adapter
+      end
+
+      def default_adapter
+        LOAD_ORDER.each do |adapter|
+          begin
+            load_dependencies adapter
+            return adapter
+          rescue LoadError
+            next
+          end
+        end
+      end
+
+      def load_dependencies(adapter)
+        ADAPTERS[adapter][:dependencies].each { |dependency| require dependency }
+      end
+
+    end
+  end
+end

data/lib/httpi/adapter/curb.rb

@@ -0,0 +1,125 @@
+require "httpi/response"
+
+module HTTPI
+  module Adapter
+
+    # = HTTPI::Adapter::Curb
+    #
+    # Adapter for the Curb client.
+    # http://rubygems.org/gems/curb
+    class Curb
+
+      def initialize(request = nil)
+      end
+
+      # Returns a memoized <tt>Curl::Easy</tt> instance.
+      def client
+        @client ||= Curl::Easy.new
+      end
+
+      # Executes an HTTP GET request.
+      # @see HTTPI.get
+      def get(request)
+        do_request(request) { |client| client.http_get }
+      end
+
+      # Executes an HTTP POST request.
+      # @see HTTPI.post
+      def post(request)
+        do_request(request) { |client| client.http_post request.body }
+      end
+
+      # Executes an HTTP HEAD request.
+      # @see HTTPI.head
+      def head(request)
+        do_request(request) { |client| client.http_head }
+      end
+
+      # Executes an HTTP PUT request.
+      # @see HTTPI.put
+      def put(request)
+        do_request(request) { |client| client.http_put request.body }
+      end
+
+      # Executes an HTTP DELETE request.
+      # @see HTTPI.delete
+      def delete(request)
+        do_request(request) { |client| client.http_delete }
+      end
+
+    private
+
+      def do_request(request)
+        setup_client request
+        yield client
+        respond_with client
+      end
+
+      def setup_client(request)
+        basic_setup request
+        setup_http_auth request if request.auth.http?
+        setup_ssl_auth request.auth.ssl if request.auth.ssl?
+        setup_ntlm_auth request if request.auth.ntlm?
+      end
+
+      def basic_setup(request)
+        client.url = request.url.to_s
+        client.proxy_url = request.proxy.to_s if request.proxy
+        client.timeout = request.read_timeout if request.read_timeout
+        client.connect_timeout = request.open_timeout if request.open_timeout
+        client.headers = request.headers.to_hash
+        client.verbose = false
+      end
+
+      def setup_http_auth(request)
+        client.http_auth_types = request.auth.type
+        client.username, client.password = *request.auth.credentials
+      end
+
+      def setup_ssl_auth(ssl)
+        client.cert_key = ssl.cert_key_file
+        client.cert = ssl.cert_file
+        client.cacert = ssl.ca_cert_file if ssl.ca_cert_file
+        client.certtype = ssl.cert_type.to_s.upcase
+        client.ssl_verify_peer = ssl.verify_mode == :peer
+      end
+
+      def setup_ntlm_auth(request)
+        client.username, client.password = *request.auth.credentials
+        client.http_auth_types = request.auth.type
+      end
+
+      def respond_with(client)
+        status, headers = parse_header_string(client.header_str)
+        Response.new client.response_code, headers, client.body_str
+      end
+
+      # Borrowed from Webmock's Curb adapter:
+      # http://github.com/bblimke/webmock/blob/master/lib/webmock/http_lib_adapters/curb.rb
+      def parse_header_string(header_string)
+        status, headers = nil, {}
+        return [status, headers] unless header_string
+
+        header_string.split(/\r\n/).each do |header|
+          if header =~ %r|^HTTP/1.[01] \d\d\d (.*)|
+            status = $1
+          else
+            parts = header.split(':', 2)
+            unless parts.empty?
+              parts[1].strip! unless parts[1].nil?
+              if headers.has_key?(parts[0])
+                headers[parts[0]] = [headers[parts[0]]] unless headers[parts[0]].kind_of? Array
+                headers[parts[0]] << parts[1]
+              else
+                headers[parts[0]] = parts[1]
+              end
+            end
+          end
+        end
+
+        [status, headers]
+      end
+
+    end
+  end
+end

data/lib/httpi/adapter/httpclient.rb

@@ -0,0 +1,98 @@
+require "httpi/response"
+
+module HTTPI
+  module Adapter
+
+    # = HTTPI::Adapter::HTTPClient
+    #
+    # Adapter for the HTTPClient client.
+    # http://rubygems.org/gems/httpclient
+    class HTTPClient
+
+      def initialize(request = nil)
+      end
+
+      # Returns a memoized <tt>HTTPClient</tt> instance.
+      def client
+        @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
+
+      # Executes an HTTP POST request.
+      # @see HTTPI.post
+      def post(request)
+        do_request request do |url, headers, body|
+          client.post url, body, headers
+        end
+      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
+
+      # Executes an HTTP PUT request.
+      # @see HTTPI.put
+      def put(request)
+        do_request request do |url, headers, body|
+          client.put url, body, headers
+        end
+      end
+
+      # Executes an HTTP DELETE request.
+      # @see HTTPI.delete
+      def delete(request)
+        do_request request do |url, headers|
+          client.delete url, headers
+        end
+      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? || request.auth.ntlm?
+        setup_ssl_auth request.auth.ssl if request.auth.ssl?
+      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_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
+        end
+        client.ssl_config.verify_mode = ssl.openssl_verify_mode
+      end
+
+      def respond_with(response)
+        Response.new response.code, Hash[*response.header.all.flatten], response.content
+      end
+
+    end
+  end
+end

data/lib/httpi/adapter/net_http.rb

@@ -0,0 +1,117 @@
+require "uri"
+require "httpi/response"
+
+module HTTPI
+  module Adapter
+
+    # = HTTPI::Adapter::NetHTTP
+    #
+    # Adapter for the Net::HTTP client.
+    # http://ruby-doc.org/stdlib/libdoc/net/http/rdoc/
+    class NetHTTP
+
+      def initialize(request)
+        self.client = new_client request
+      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
+        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
+        end
+      end
+
+    private
+
+      attr_writer :client
+
+      def new_client(request)
+        proxy = request.proxy || URI("")
+        Net::HTTP::Proxy(proxy.host, proxy.port).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?
+
+        respond_with(client.start do |http|
+          yield http, request_client(type, request)
+        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
+      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
+      end
+
+      def request_client(type, request)
+        request_class = case type
+          when :get    then Net::HTTP::Get
+          when :post   then Net::HTTP::Post
+          when :head   then Net::HTTP::Head
+          when :put    then Net::HTTP::Put
+          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.ntlm_auth *request.auth.credentials if request.auth.ntlm?
+
+        request_client
+      end
+
+      def respond_with(response)
+        headers = response.to_hash
+        headers.each { |key, value| headers[key] = value[0] }
+        Response.new response.code, headers, response.body
+      end
+
+    end
+  end
+end

data/lib/httpi/auth/config.rb

@@ -0,0 +1,81 @@
+require "httpi/auth/ssl"
+
+module HTTPI
+  module Auth
+
+    # = HTTPI::Auth::Config
+    #
+    # Manages HTTP and SSL auth configuration. Currently supports HTTP basic/digest
+    # and SSL client authentication.
+    class Config
+
+      # Supported authentication types.
+      TYPES = [:basic, :digest, :ssl, :ntlm]
+
+      # Accessor for the HTTP basic auth credentials.
+      def basic(*args)
+        return @basic if args.empty?
+
+        self.type = :basic
+        @basic = args.flatten.compact
+      end
+
+      # Returns whether to use HTTP basic auth.
+      def basic?
+        type == :basic
+      end
+
+      # Accessor for the HTTP digest auth credentials.
+      def digest(*args)
+        return @digest if args.empty?
+
+        self.type = :digest
+        @digest = args.flatten.compact
+      end
+
+      # Returns whether to use HTTP digest auth.
+      def digest?
+        type == :digest
+      end
+
+      # Returns whether to use HTTP basic or dihest auth.
+      def http?
+        type == :basic || type == :digest
+      end
+
+      # Accessor for the NTLM auth credentials.
+      def ntlm(*args)
+        return @ntlm if args.empty?
+
+        self.type = :ntlm
+        @ntlm = args.flatten.compact
+      end
+
+      # Returns whether to use NTLM auth.
+      def ntlm?
+        type == :ntlm
+      end
+
+      # Returns the <tt>HTTPI::Auth::SSL</tt> object.
+      def ssl
+        @ssl ||= SSL.new
+      end
+
+      # Returns whether to use SSL client auth.
+      def ssl?
+        ssl.present?
+      end
+
+      # Shortcut method for returning the credentials for the authentication specified.
+      # Returns +nil+ unless any authentication credentials were specified.
+      def credentials
+        return unless type
+        send type
+      end
+
+      # Accessor for the authentication type in use.
+      attr_accessor :type
+
+    end
+  end
+end