em-http-request 1.0.0.beta.3 → 1.0.0.beta.4

data/lib/em-http/http_connection_options.rb

@@ -0,0 +1,23 @@
+class HttpConnectionOptions
+  attr_reader :host, :port, :tls, :proxy
+  attr_reader :connect_timeout, :inactivity_timeout
+
+  def initialize(uri, options)
+    @connect_timeout     = options[:connect_timeout] || 5        # default connection setup timeout
+    @inactivity_timeout  = options[:inactivity_timeout] ||= 10   # default connection inactivity (post-setup) timeout
+
+    @tls   = options[:tls] || options[:ssl] || {}
+    @proxy = options[:proxy]
+
+    uri = uri.kind_of?(Addressable::URI) ? uri : Addressable::URI::parse(uri.to_s)
+    uri.port = (uri.scheme == "https" ? (uri.port || 443) : (uri.port || 80))
+
+    if proxy = options[:proxy]
+      @host = proxy[:host]
+      @port = proxy[:port]
+    else
+      @host = uri.host
+      @port = uri.port
+    end
+  end
+end

data/lib/em-http/http_encoding.rb

@@ -63,7 +63,7 @@ module EventMachine
         query.to_s
       end
 
-      if !uri.query.to_s.empty?
+      if uri && !uri.query.to_s.empty?
         encoded_query = [encoded_query, uri.query].reject {|part| part.empty?}.join("&")
       end
       encoded_query.to_s.empty? ? uri.path : "#{uri.path}?#{encoded_query}"

data/lib/em-http/middleware/cookie_jar.rb

@@ -0,0 +1,38 @@
+require 'cookiejar'
+
+module EventMachine
+  module Middleware
+    class CookieJar
+      class << self
+        attr_reader :cookiejar
+
+        def cookiejar=(val)
+          @cookiejar = val
+        end
+
+        def set_cookie(url, cookie)
+          @cookiejar.set_cookie url, cookie
+        end
+      end
+
+      def request(c, h, r)
+        raise ArgumentError, "You may not set cookies outside of the cookie jar" if h.delete('cookie')
+        cookies = CookieJar::cookiejar.get_cookie_header(c.last_effective_url)
+        h['cookie'] = cookies unless cookies.empty?
+        [h, r]
+      end
+
+      def response(r)
+        cookies = r.response_header.cookie
+        if cookies
+          [cookies].flatten.each { |c|
+            EventMachine::Middleware::CookieJar.cookiejar.set_cookie r.last_effective_url, c
+          }
+        end
+        r.response
+     end
+    end
+  end
+end
+
+EventMachine::Middleware::CookieJar.cookiejar = CookieJar::Jar.new

data/lib/em-http/middleware/json_response.rb

@@ -0,0 +1,15 @@
+require 'yajl'
+
+module EventMachine
+  module Middleware
+    class JSONResponse
+      def response(resp)
+        begin
+          body = Yajl::Parser.parse(resp.response)
+          resp.response = body
+        rescue Exception => e
+        end
+      end
+    end
+  end
+end

data/lib/em-http/middleware/oauth.rb

@@ -0,0 +1,21 @@
+require 'oauth'
+require 'oauth/client/em_http'
+
+module EventMachine
+  module Middleware
+
+    class OAuth
+      def initialize(opts = {})
+        @consumer = ::OAuth::Consumer.new(opts[:consumer_key], opts[:consumer_secret])
+        @access_token = ::OAuth::AccessToken.new(@consumer, opts[:access_token], opts[:access_token_secret])
+      end
+
+      def request(client, head, body)
+        @consumer.sign!(client, @access_token)
+        head.merge!(client.options[:head])
+
+        [head,body]
+      end
+    end
+  end
+end

data/lib/em-http/multi.rb

@@ -8,17 +8,17 @@ module EventMachine
   #
   #  EventMachine.run {
   #
-  #   multi = EventMachine::MultiRequest.new
+  #    multi = EventMachine::MultiRequest.new
   #
-  #   # add multiple requests to the multi-handler
-  #   multi.add(EventMachine::HttpRequest.new('http://www.google.com/').get)
-  #   multi.add(EventMachine::HttpRequest.new('http://www.yahoo.com/').get)
+  #    # add multiple requests to the multi-handler
+  #    multi.add(:a, EventMachine::HttpRequest.new('http://www.google.com/').get)
+  #    multi.add(:b, EventMachine::HttpRequest.new('http://www.yahoo.com/').get)
   #
-  #    multi.callback  {
-  #       p multi.responses[:succeeded]
-  #       p multi.responses[:failed]
+  #    multi.callback {
+  #      p multi.responses[:callback]
+  #      p multi.responses[:errback]
   #
-  #       EventMachine.stop
+  #      EventMachine.stop
   #    }
   #  }
   #
@@ -28,27 +28,27 @@ module EventMachine
 
     attr_reader :requests, :responses
 
-    def initialize(conns=[], &block)
+    def initialize
       @requests  = []
-      @responses = {:succeeded => [], :failed => []}
-
-      conns.each {|conn| add(conn)}
-      callback(&block) if block_given?
+      @responses = {:callback => {}, :errback => {}}
     end
 
-    def add(conn)
+    def add(name, conn)
       @requests.push(conn)
 
-      conn.callback { @responses[:succeeded].push(conn); check_progress }
-      conn.errback  { @responses[:failed].push(conn); check_progress }
+      conn.callback { @responses[:callback][name] = conn; check_progress }
+      conn.errback  { @responses[:errback][name]  = conn; check_progress }
+    end
+
+    def finished?
+      (@responses[:callback].size + @responses[:errback].size) == @requests.size
     end
 
     protected
 
     # invoke callback if all requests have completed
     def check_progress
-      succeed(self) if (@responses[:succeeded].size +
-                        @responses[:failed].size) == @requests.size
+      succeed(self) if finished?
     end
 
   end

data/lib/em-http/request.rb

@@ -3,38 +3,16 @@ module EventMachine
     @middleware = []
 
     def self.new(uri, options={})
-      begin
-        req = HttpOptions.new(uri, options)
+      connopt = HttpConnectionOptions.new(uri, options)
 
-        EventMachine.connect(req.host, req.port, HttpConnection) do |c|
-          c.opts = req
-
-          c.pending_connect_timeout = req.options[:connect_timeout]
-          c.comm_inactivity_timeout = req.options[:inactivity_timeout]
-        end
-
-      rescue EventMachine::ConnectionError => e
-        #
-        # Currently, this can only fire on initial connection setup
-        # since #connect is a synchronous method. Hence, rescue the
-        # exception, and return a failed deferred which will immediately
-        # fail any client request.
-        #
-        # Once there is async-DNS, then we'll iterate over the outstanding
-        # client requests and fail them in order.
-        #
-        # Net outcome: failed connection will invoke the same ConnectionError
-        # message on the connection deferred, and on the client deferred.
-        #
-        conn = EventMachine::FailedConnection.new(req)
-        conn.error = e.message
-        conn.fail
-        conn
-      end
+      c = HttpConnection.new
+      c.connopts = connopt
+      c.uri = uri
+      c
     end
 
-    def self.use(klass)
-      @middleware << klass
+    def self.use(klass, *args, &block)
+      @middleware << klass.new(*args, &block)
     end
 
     def self.middleware

data/lib/em-http/version.rb

@@ -1,5 +1,5 @@
 module EventMachine
   class HttpRequest
-    VERSION = "1.0.0.beta.3"
+    VERSION = "1.0.0.beta.4"
   end
 end

data/spec/client_spec.rb

@@ -228,6 +228,25 @@ describe EventMachine::HttpRequest do
     }
   end
 
+  it "should return peer's IP address" do
+     EventMachine.run {
+
+       conn = EventMachine::HttpRequest.new('http://127.0.0.1:8090/')
+       conn.peer.should be_nil
+
+       http = conn.get
+       http.peer.should be_nil
+
+       http.errback { failed(http) }
+       http.callback {
+         conn.peer.should == '127.0.0.1'
+         http.peer.should == '127.0.0.1'
+
+         EventMachine.stop
+       }
+     }
+   end
+
   it "should remove all newlines from long basic auth header" do
     EventMachine.run {
       auth = {'authorization' => ['aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa', 'zzzzzzzzzzzzzzzzzzzzzzzzzzzzzz']}
@@ -305,6 +324,26 @@ describe EventMachine::HttpRequest do
     }
   end
 
+  it "should not decode the response when configured so" do
+    EventMachine.run {
+
+      http = EventMachine::HttpRequest.new('http://127.0.0.1:8090/gzip').get :head => {
+        "accept-encoding" => "gzip, compressed"
+      }, :decoding => false
+
+      http.errback { failed(http) }
+      http.callback {
+        http.response_header.status.should == 200
+        http.response_header["CONTENT_ENCODING"].should == "gzip"
+
+        raw = http.response
+        Zlib::GzipReader.new(StringIO.new(raw)).read.should == "compressed"
+
+        EventMachine.stop
+      }
+    }
+  end
+
   it "should timeout after 0.1 seconds of inactivity" do
     EventMachine.run {
       t = Time.now.to_i

data/spec/external_spec.rb

@@ -79,6 +79,22 @@ requires_connection do
       }
     end
 
+    it "should detect deflate encoding" do
+      EventMachine.run {
+
+        options = {:head => {"accept-encoding" => "deflate"}, :redirects => 5}
+        http = EventMachine::HttpRequest.new('http://www.msn.com').get options
+
+        http.errback { failed(http) }
+        http.callback {
+          http.response_header.status.should == 200
+          http.response_header["CONTENT_ENCODING"].should == "deflate"
+
+          EventMachine.stop
+        }
+      }
+    end
+
     context "keepalive" do
       it "should default to non-keepalive" do
         EventMachine.run {
@@ -88,7 +104,7 @@ requires_connection do
           http.errback { fail }
           start = Time.now.to_i
           http.callback {
-            (start - Time.now.to_i).should be_within(1).of(0)
+            (Time.now.to_i - start).should be_within(2).of(0)
             EventMachine.stop
           }
         }

data/spec/helper.rb

@@ -14,4 +14,16 @@ end
 
 def requires_connection(&blk)
   blk.call if system('ping -t1 -c1 google.com &> /dev/null')
+end
+
+def requires_port(port, &blk)
+  port_open = true
+  begin
+    s = TCPSocket.new('localhost', port)
+    s.close()
+  rescue
+    port_open = false
+  end
+
+  blk.call if port_open
 end

data/spec/middleware_spec.rb

@@ -1,11 +1,12 @@
 require 'helper'
+require 'em-http/middleware/cookie_jar'
 
 describe EventMachine::HttpRequest do
 
-  module EmptyMiddleware; end
+  class EmptyMiddleware; end
 
   class GlobalMiddleware
-    def self.response(resp)
+    def response(resp)
       resp.response_header['X-Global'] = 'middleware'
     end
   end
@@ -22,15 +23,44 @@ describe EventMachine::HttpRequest do
     }
   end
 
+  context "configuration" do
+    class ConfigurableMiddleware
+      def initialize(conf, &block)
+        @conf = conf
+        @block = block
+      end
+
+      def response(resp)
+        resp.response_header['X-Conf'] = @conf
+        resp.response_header['X-Block'] = @block.call
+      end
+    end
+
+    it "should accept middleware initialization parameters" do
+      EventMachine.run {
+        conn = EM::HttpRequest.new('http://127.0.0.1:8090')
+        conn.use ConfigurableMiddleware, 'conf-value' do
+          'block-value'
+        end
+
+        req = conn.get
+        req.callback {
+          req.response_header['X-Conf'].should match('conf-value')
+          req.response_header['X-Block'].should match('block-value')
+          EM.stop
+        }
+      }
+    end
+  end
+
   context "request" do
     class ResponseMiddleware
-      def self.response(resp)
+      def response(resp)
         resp.response_header['X-Header'] = 'middleware'
         resp.response = 'Hello, Middleware!'
       end
     end
 
-
     it "should execute response middleware before user callbacks" do
       EventMachine.run {
         conn = EM::HttpRequest.new('http://127.0.0.1:8090')
@@ -62,7 +92,7 @@ describe EventMachine::HttpRequest do
 
   context "request" do
     class RequestMiddleware
-      def self.request(head, body)
+      def request(client, head, body)
         head['X-Middleware'] = 'middleware'   # insert new header
         body += ' modified'                   # modify post body
 
@@ -87,11 +117,11 @@ describe EventMachine::HttpRequest do
 
   context "jsonify" do
     class JSONify
-      def self.request(head, body)
+      def request(client, head, body)
         [head, Yajl::Encoder.encode(body)]
       end
 
-      def self.response(resp)
+      def response(resp)
         resp.response = Yajl::Parser.parse(resp.response)
       end
     end
@@ -111,4 +141,52 @@ describe EventMachine::HttpRequest do
     end
   end
 
+  context "CookieJar" do
+    it "should use the cookie jar as opposed to any other method when in use" do
+      lambda {
+        EventMachine.run {
+          conn = EventMachine::HttpRequest.new('http://127.0.0.1:8090/')
+          middleware = EventMachine::Middleware::CookieJar
+          conn.use middleware
+          middleware.set_cookie('http://127.0.0.1:8090/', 'id=1')
+          req = conn.get :head => {'cookie' => 'id=2;'}
+          req.callback { failed(req) }
+          req.errback  { failed(req) }
+        }
+      }.should raise_error(ArgumentError)
+    end
+
+    it "should send cookies" do
+      EventMachine.run {
+        uri = 'http://127.0.0.1:8090/cookie_parrot'
+        conn = EventMachine::HttpRequest.new(uri)
+        middleware = EventMachine::Middleware::CookieJar
+        conn.use middleware
+        middleware.set_cookie(uri, 'id=1')
+        req = conn.get
+        req.callback {
+          req.response_header.cookie.should == 'id=1'
+          EventMachine.stop
+        }
+      }
+    end
+
+    it "should store cookies and send them" do
+      EventMachine.run {
+        uri = 'http://127.0.0.1:8090/set_cookie'
+        conn = EventMachine::HttpRequest.new(uri)
+        middleware = EventMachine::Middleware::CookieJar
+        conn.use middleware
+        req = conn.get
+        req.callback {
+          req.response_header.cookie[0..3].should == 'id=1'
+          cookies = middleware.cookiejar.get_cookies(uri)
+          cookies.length.should == 1
+          cookies[0].to_s.should == "id=1"
+          EventMachine.stop
+        }
+      }
+    end
+  end
+
 end