httpi 2.0.2 → 2.1.0

data/lib/httpi/adapter/net_http.rb

@@ -2,6 +2,9 @@ require "uri"
 
 require "httpi/adapter/base"
 require "httpi/response"
+require 'net/ntlm'
+require 'kconv'
+require 'socket'
 
 module HTTPI
   module Adapter
@@ -27,10 +30,17 @@ module HTTPI
         unless REQUEST_METHODS.include? method
           raise NotSupportedError, "Net::HTTP does not support custom HTTP methods"
         end
-
         do_request(method) do |http, http_request|
           http_request.body = @request.body
-          http.request http_request
+          if @request.on_body then
+            perform(http, http_request) do |res|
+              res.read_body do |seg|
+                @request.on_body.call(seg)
+              end
+            end
+          else
+            perform(http, http_request)
+          end
         end
       rescue OpenSSL::SSL::SSLError
         raise SSLError
@@ -41,19 +51,81 @@ module HTTPI
 
       private
 
+      def perform(http, http_request, &block)
+        http.request http_request, &block
+      end
+
       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)
       end
 
-      def do_request(type)
+      def do_request(type, &requester)
+        setup
+        response = @client.start do |http|
+          negotiate_ntlm_auth(http, &requester) if @request.auth.ntlm?
+          requester.call(http, request_client(type))
+        end
+        respond_with(response)
+      end
+
+      def setup
         setup_client
         setup_ssl_auth if @request.auth.ssl?
+      end
+
+      def negotiate_ntlm_auth(http, &requester)
+        # first figure out if we should use NTLM or Negotiate
+        nego_auth_response = respond_with(requester.call(http, request_client(:head)))
+        if nego_auth_response.headers['www-authenticate'].include? 'Negotiate'
+          auth_method = 'Negotiate'
+        elsif nego_auth_response.headers['www-authenticate'].include? 'NTLM'
+          auth_method = 'NTLM'
+        else
+          auth_method = 'NTLM'
+          HTTPI.logger.debug 'Server does not support NTLM/Negotiate. Trying NTLM anyway'
+        end
+
+        # initiate a request is to authenticate (exchange secret and auth) using the method determined above...
+        ntlm_message_type1 = Net::NTLM::Message::Type1.new
+        %w(workstation domain).each do |a|
+          ntlm_message_type1.send("#{a}=",'')
+          ntlm_message_type1.enable(a.to_sym)
+        end
+
+        @request.headers["Authorization"] = "#{auth_method} #{ntlm_message_type1.encode64}"
+
+        auth_response = respond_with(requester.call(http, request_client(:head)))
+
+        # build an authentication request based on the token provided by the server
+        if auth_response.headers["WWW-Authenticate"] =~ /(NTLM|Negotiate) (.+)/
+          auth_token = $2
+          ntlm_message = Net::NTLM::Message.decode64(auth_token)
+          
+          message_builder = {}
+          # copy the username and password from the authorization parameters
+          message_builder[:user] = @request.auth.ntlm[0]
+          message_builder[:password] = @request.auth.ntlm[1]
+
+          # we need to provide a domain in the packet if an only if it was provided by the user in the auth request
+          if @request.auth.ntlm[2]
+            message_builder[:domain] = Net::NTLM::EncodeUtil.encode_utf16le(@request.auth.ntlm[2].upcase)
+          else
+            message_builder[:domain] = ''
+          end
+
+          # we should also provide the workstation name, currently the rubyntlm provider does not automatically
+          # set the workstation name
+          message_builder[:workstation] = Net::NTLM::EncodeUtil.encode_utf16le(Socket.gethostname)
+          
+          ntlm_response = ntlm_message.response(message_builder ,
+                                                 {:ntlmv2 => true})
+          # Finally add header of Authorization
+          @request.headers["Authorization"] = "#{auth_method} #{ntlm_response.encode64}"
+        end
 
-        respond_with(@client.start do |http|
-          yield http, request_client(type)
-        end)
+        nil
       end
 
       def setup_client
@@ -66,11 +138,13 @@ module HTTPI
         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
 
+        # Send client-side certificate regardless of state of SSL verify mode
+        @client.key = ssl.cert_key
+        @client.cert = ssl.cert
+
         @client.verify_mode = ssl.openssl_verify_mode
         @client.ssl_version = ssl.ssl_version if ssl.ssl_version
       end
@@ -87,6 +161,10 @@ module HTTPI
         request_client = request_class.new @request.url.request_uri, @request.headers
         request_client.basic_auth *@request.auth.credentials if @request.auth.basic?
 
+        if @request.auth.digest?
+          raise NotSupportedError, "Net::HTTP does not support HTTP digest authentication"
+        end
+
         request_client
       end
 
@@ -95,7 +173,8 @@ module HTTPI
         headers.each do |key, value|
           headers[key] = value[0] if value.size <= 1
         end
-        Response.new response.code, headers, response.body
+        body = (response.body.kind_of?(Net::ReadAdapter) ? "" : response.body)
+        Response.new response.code, headers, body
       end
 
     end

data/lib/httpi/adapter/net_http_persistent.rb

@@ -0,0 +1,43 @@
+module HTTPI
+  module Adapter
+
+    # = HTTPI::Adapter::NetHTTPPersistent
+    #
+    # Adapter for the Net::HTTP::Persistent client.
+    # http://docs.seattlerb.org/net-http-persistent/Net/HTTP/Persistent.html
+    class NetHTTPPersistent < NetHTTP
+
+      register :net_http_persistent, :deps => %w(net/http/persistent)
+
+      private
+
+      def create_client
+        Net::HTTP::Persistent.new thread_key
+      end
+
+      def perform(http, http_request, &on_body)
+        http.request @request.url, http_request, &on_body
+      end
+
+      def do_request(type, &requester)
+        setup
+        response = requester.call @client, request_client(type)
+        respond_with(response)
+      end
+
+      def setup_client
+        if @request.auth.ntlm?
+          raise NotSupportedError, "Net::HTTP-Persistent does not support NTLM authentication"
+        end
+
+        @client.open_timeout = @request.open_timeout if @request.open_timeout
+        @client.read_timeout = @request.read_timeout if @request.read_timeout
+      end
+
+      def thread_key
+        @request.url.host.split(/\W/).reject{|p|p == ""}.join('-')
+      end
+
+    end
+  end
+end

data/lib/httpi/adapter/rack.rb

@@ -0,0 +1,92 @@
+require 'httpi/adapter/base'
+require 'httpi/response'
+
+module HTTPI
+  module Adapter
+
+    # = HTTPI::Adapter::Rack
+    #
+    # Adapter for Rack::MockRequest.
+    # Due to limitations, not all features are supported.
+    # https://github.com/rack/rack/blob/master/lib/rack/mock.rb
+    #
+    # Usage:
+    #
+    #   HTTPI::Adapter::Rack.mount 'application', RackApplication
+    #   HTTPI.get("http://application/path", :rack)
+    class Rack < Base
+      register :rack, :deps => %w(rack/mock)
+
+      attr_reader :client
+
+      class << self
+        attr_accessor :mounted_apps
+      end
+
+      self.mounted_apps = {}
+
+      # Attaches Rack endpoint at specified host.
+      # Endpoint will be acessible at {http://host/ http://host/} url.
+      def self.mount(host, application)
+        self.mounted_apps[host] = application
+      end
+
+      # Removes Rack endpoint.
+      def self.unmount(host)
+        self.mounted_apps.delete(host)
+      end
+
+      def initialize(request)
+        @app = self.class.mounted_apps[request.url.host]
+
+
+        if @app.nil?
+          message  = "Application '#{request.url.host}' not mounted: ";
+          message += "use `HTTPI::Adapter::Rack.mount('#{request.url.host}', RackApplicationClass)`"
+
+          raise message
+        end
+
+        @request = request
+        @client  = ::Rack::MockRequest.new(@app)
+      end
+
+      # Executes arbitrary HTTP requests.
+      # You have to mount required Rack application before you can use it.
+      #
+      # @see .mount
+      # @see HTTPI.request
+      def request(method)
+        unless REQUEST_METHODS.include? method
+          raise NotSupportedError, "Rack adapter does not support custom HTTP methods"
+        end
+
+        env = {}
+        @request.headers.each do |header, value|
+          env["HTTP_#{header.gsub('-', '_').upcase}"] = value
+        end
+
+        if @request.proxy
+          raise NotSupportedError, "Rack adapter does not support proxying"
+        end
+
+        if @request.auth.http?
+          raise NotSupportedError, "Rack adapter does not support HTTP auth"
+        end
+
+        if @request.auth.ssl?
+          raise NotSupportedError, "Rack adapter does not support SSL client auth"
+        end
+
+        if @request.on_body
+          raise NotSupportedError, "Rack adapter does not support response streaming"
+        end
+
+        response = @client.request(method.to_s.upcase, @request.url.to_s,
+              { :fatal => true, :input => @request.body.to_s }.merge(env))
+
+        Response.new(response.status, response.headers, response.body)
+      end
+    end
+  end
+end

data/lib/httpi/auth/config.rb

@@ -10,7 +10,7 @@ module HTTPI
     class Config
 
       # Supported authentication types.
-      TYPES = [:basic, :digest, :gssnegotiate, :ssl]
+      TYPES = [:basic, :digest, :gssnegotiate, :ssl, :ntlm]
 
       # Accessor for the HTTP basic auth credentials.
       def basic(*args)
@@ -53,14 +53,15 @@ module HTTPI
         type == :basic || type == :digest
       end
 
-      # Only available with the httpi-ntlm gem.
       def ntlm(*args)
-        raise "Install the httpi-ntlm gem for experimental NTLM support"
+        return @ntlm if args.empty?
+
+        self.type = :ntlm
+        @ntlm = args.flatten.compact
       end
 
-      # Only available with the httpi-ntlm gem.
       def ntlm?
-        raise "Install the httpi-ntlm gem for experimental NTLM support"
+        type == :ntlm
       end
 
       # Returns the <tt>HTTPI::Auth::SSL</tt> object.

data/lib/httpi/request.rb

@@ -99,6 +99,15 @@ module HTTPI
       @body = params.kind_of?(Hash) ? Rack::Utils.build_query(params) : params
     end
 
+    # Sets the block to be called while processing the response. The block
+    # accepts a single parameter - the chunked response body.
+    def on_body(&block)
+      if block_given? then
+        @on_body = block
+      end
+      @on_body
+    end
+
     # Returns the <tt>HTTPI::Authentication</tt> object.
     def auth
       @auth ||= Auth::Config.new

data/lib/httpi/version.rb

@@ -1,5 +1,5 @@
 module HTTPI
 
-  VERSION = "2.0.2"
+  VERSION = "2.1.0"
 
 end

data/spec/httpi/adapter/curb_spec.rb

@@ -168,6 +168,15 @@ unless RUBY_PLATFORM =~ /java/
         end
       end
 
+      describe "NTLM authentication" do
+        it "is not supported" do
+          request.auth.ntlm("tester", "vReqSoafRe5O")
+
+          expect { adapter.request(:get) }.
+            to raise_error(HTTPI::NotSupportedError, /does not support NTLM authentication/)
+        end
+      end
+
       describe "http_auth_types" do
         it "is set to :basic for HTTP basic auth" do
           request.auth.basic "username", "password"
@@ -217,6 +226,14 @@ unless RUBY_PLATFORM =~ /java/
           request
         end
 
+        it "send certificate regardless of state of SSL verify mode" do
+          request.auth.ssl.verify_mode = :none
+          curb.expects(:cert_key=).with(request.auth.ssl.cert_key_file)
+          curb.expects(:cert=).with(request.auth.ssl.cert_file)
+
+          adapter.request(:get)
+        end
+
         it "cert_key, cert and ssl_verify_peer should be set" do
           curb.expects(:cert_key=).with(request.auth.ssl.cert_key_file)
           curb.expects(:cert=).with(request.auth.ssl.cert_file)

data/spec/httpi/adapter/em_http_spec.rb

@@ -21,7 +21,7 @@ begin
     describe "#request(:get)" do
       it "returns a valid HTTPI::Response" do
         em_http.expects(:get).
-          with(:query => nil, :connect_timeout => nil, :inactivity_timeout => nil, :head => {}, :body => nil).
+          with(:query => nil, :head => {}, :body => nil).
           returns(http_message)
 
         adapter.request(:get).should match_response(:body => Fixture.xml)
@@ -31,7 +31,7 @@ begin
     describe "#request(:post)" do
       it "returns a valid HTTPI::Response" do
         em_http.expects(:post).
-          with(:query => nil, :connect_timeout => nil, :inactivity_timeout => nil, :head => {}, :body => Fixture.xml).
+          with(:query => nil, :head => {}, :body => Fixture.xml).
           returns(http_message)
 
         request.body = Fixture.xml
@@ -42,7 +42,7 @@ begin
     describe "#request(:head)" do
       it "returns a valid HTTPI::Response" do
         em_http.expects(:head).
-          with(:query => nil, :connect_timeout => nil, :inactivity_timeout => nil, :head => {}, :body => nil).
+          with(:query => nil, :head => {}, :body => nil).
           returns(http_message)
 
         adapter.request(:head).should match_response(:body => Fixture.xml)
@@ -52,7 +52,7 @@ begin
     describe "#request(:put)" do
       it "returns a valid HTTPI::Response" do
         em_http.expects(:put).
-          with(:query => nil, :connect_timeout => nil, :inactivity_timeout => nil, :head => {}, :body => Fixture.xml).
+          with(:query => nil, :head => {}, :body => Fixture.xml).
           returns(http_message)
 
         request.body = Fixture.xml
@@ -63,7 +63,7 @@ begin
     describe "#request(:delete)" do
       it "returns a valid HTTPI::Response" do
         em_http.expects(:delete).
-          with(:query => nil, :connect_timeout => nil, :inactivity_timeout => nil, :head => {}, :body => nil).
+          with(:query => nil, :head => {}, :body => nil).
           returns(http_message(""))
 
         adapter.request(:delete).should match_response(:body => "")
@@ -73,7 +73,7 @@ begin
     describe "#request(:custom)" do
       it "returns a valid HTTPI::Response" do
         em_http.expects(:custom).
-          with(:query => nil, :connect_timeout => nil, :inactivity_timeout => nil, :head => {}, :body => nil).
+          with(:query => nil, :head => {}, :body => nil).
           returns(http_message(""))
 
         adapter.request(:custom).should match_response(:body => "")
@@ -88,38 +88,48 @@ begin
           request.proxy.password = "password"
         end
 
-        it "sets host, port, and authorization" do
-          em_http.expects(:get).once.
-            with(has_entries(:proxy => { :host => "proxy-host.com", :port => 443, :authorization => %w( username password ) })).
-            returns(http_message)
+        it "sets host, port and authorization" do
+          url = 'http://example.com:80'
 
-          adapter.request(:get)
+          connection_options = {
+            :connect_timeout    => nil,
+            :inactivity_timeout => nil,
+            :proxy              => {
+              :host          => 'proxy-host.com',
+              :port          => 443,
+              :authorization => ['username', 'password']
+            }
+          }
+
+          EventMachine::HttpRequest.expects(:new).with(url, connection_options)
+
+          adapter
         end
       end
 
       describe "connect_timeout" do
-        it "is not set unless specified" do
-          em_http.expects(:get).once.with(has_entries(:connect_timeout => nil)).returns(http_message)
-          adapter.request(:get)
-        end
-
-        it "is set if specified" do
+        it "is passed as a connection option" do
           request.open_timeout = 30
-          em_http.expects(:get).once.with(has_entries(:connect_timeout => 30)).returns(http_message)
-          adapter.request(:get)
+
+          url = 'http://example.com:80'
+          connection_options = { :connect_timeout => 30, :inactivity_timeout => nil }
+
+          EventMachine::HttpRequest.expects(:new).with(url, connection_options)
+
+          adapter
         end
       end
 
       describe "receive_timeout" do
-        it "is not set unless specified" do
-          em_http.expects(:get).once.with(has_entries(:inactivity_timeout => nil)).returns(http_message)
-          adapter.request(:get)
-        end
+        it "is passed as a connection option" do
+          request.read_timeout = 60
 
-        it "is set if specified" do
-          request.read_timeout = 30
-          em_http.expects(:get).once.with(has_entries(:inactivity_timeout => 30)).returns(http_message)
-          adapter.request(:get)
+          url = 'http://example.com:80'
+          connection_options = { :connect_timeout => nil, :inactivity_timeout => 60 }
+
+          EventMachine::HttpRequest.expects(:new).with(url, connection_options)
+
+          adapter
         end
       end