m2r 1.0.0 → 2.0.0

data/lib/m2r/response/always_close.rb

@@ -0,0 +1,26 @@
+require 'm2r/response'
+
+module M2R
+  class Response
+    # Use to disable persisent connections even though
+    # your client would prefer otherwise.
+    #
+    # @api public
+    module AlwaysClose
+      def close?
+        true
+      end
+
+      def headers(value = GETTER)
+        if value == GETTER
+          h = super
+          h['Connection'] = 'close'
+          h
+        else
+          super
+        end
+      end
+    end
+  end
+end
+

data/lib/m2r/response/content_length.rb

@@ -10,8 +10,14 @@ module M2R
     #
     # @api public
     module ContentLength
-      def headers
-        super.merge('Content-Length' => body.bytesize)
+      def headers(value = GETTER)
+        if value == GETTER
+          h = super
+          h['Content-Length'] ||= body.bytesize
+          h
+        else
+          super
+        end
       end
     end
   end

data/lib/m2r/response/to_request.rb

@@ -0,0 +1,26 @@
+require 'm2r/response'
+
+module M2R
+  class Response
+
+    # Handles the logic of having response with proper
+    # http version and 'Connection' header in relation to
+    # given request
+    #
+    # @api public
+    module ToRequest
+      # params [Request] request Request that response handles
+      # params [true, false] identical Whether http version in response should be identical
+      #   to the received one.
+      # @return [self] Response object
+      # @api public
+      def to(request, identical = false)
+        # http://www.ietf.org/rfc/rfc2145.txt
+        # 2.3 Which version number to send in a message
+        http_version(request.http_version) if identical
+        headers['Connection'] = 'close' if request.close?
+        self
+      end
+    end
+  end
+end

data/lib/m2r/version.rb

@@ -1,5 +1,5 @@
 module M2R
   # m2r gem version
   # @api public
-  VERSION = '1.0.0'
+  VERSION = '2.0.0'
 end

data/lib/rack/handler/mongrel2.rb

@@ -14,8 +14,8 @@ module Rack
 
       def self.run(app, options = {})
         options = OpenStruct.new( DEFAULT_OPTIONS.merge(options) )
-        factory = M2R::ConnectionFactory.new(options.sender_id, options.recv_addr, options.send_addr)
-        adapter = M2R::RackHandler.new(app, factory)
+        parser  = M2R::Request
+        adapter = M2R::RackHandler.new(app, connection_factory(options), parser)
         adapter.listen
       end
 
@@ -23,9 +23,23 @@ module Rack
         {
           'recv_addr=RECV_ADDR' => 'Receive address',
           'send_addr=SEND_ADDR' => 'Send address',
-          'sender_id=UUID' => 'Sender UUID'
+          'sender_id=UUID'      => 'Sender UUID'
         }
       end
+
+      def self.connection_factory(options)
+        klass = if custom = options.connection_factory
+          begin
+            M2R::ConnectionFactory.const_get(custom.classify)
+          rescue NameError
+            require "m2r/connection_factory/#{custom.underscore}"
+            M2R::ConnectionFactory.const_get(custom.classify)
+          end
+        else
+          M2R::ConnectionFactory
+        end
+        klass.new(options)
+      end
     end
 
     register :mongrel2, ::Rack::Handler::Mongrel2

data/test/support/test_handler.rb

@@ -2,7 +2,7 @@ require 'm2r/handler'
 
 class TestHandler < M2R::Handler
   attr_reader :called_methods
-  def initialize(connection)
+  def initialize(connection, parser)
     super
     @called_methods = []
   end
@@ -48,4 +48,8 @@ class TestHandler < M2R::Handler
   def after_all(request, response)
     @called_methods << :all
   end
+
+  def on_error(request, response, error)
+    @called_methods << :error
+  end
 end

data/test/unit/connection_factory_test.rb

@@ -7,7 +7,6 @@ module M2R
       sender_id = "sid"
       request_addr = "req"
       response_addr = "req"
-      request_parser = Object.new
 
       pull    = stub(:pull)
       pub     = stub(:pub)
@@ -21,9 +20,10 @@ module M2R
       pub.expects(:connect).with(response_addr)
       pub.expects(:setsockopt).with(ZMQ::IDENTITY, sender_id)
 
-      Connection.expects(:new).with(pull, pub, request_parser)
-      cf = ConnectionFactory.new sender_id, request_addr, response_addr, request_parser, context
+      Connection.expects(:new).with(pull, pub)
+      cf = ConnectionFactory.new ConnectionFactory::Options.new(sender_id, request_addr, response_addr), context
       cf.connection
     end
+
   end
 end

data/test/unit/connection_test.rb

@@ -13,6 +13,7 @@ module M2R
 
       @sub = M2R.zmq_context.socket(ZMQ::SUB)
       assert_equal 0, @sub.bind(@response_addr), "Could not bind sub socket in tests"
+      @sub.setsockopt(ZMQ::SUBSCRIBE, "")
 
 
       @request_socket = M2R.zmq_context.socket(ZMQ::PULL)
@@ -32,17 +33,67 @@ module M2R
 
     def test_receive_message
       connection = Connection.new(@request_socket, @response_socket)
-      @push.send_string("1c5fd481-1121-49d8-a706-69127975db1a ebb407b2-49aa-48a5-9f96-9db121051484 / 2:{},0:,", ZMQ::NOBLOCK)
-      assert_instance_of Request, connection.receive
+      @push.send_string(msg = "1c5fd481-1121-49d8-a706-69127975db1a ebb407b2-49aa-48a5-9f96-9db121051484 / 2:{},0:,", ZMQ::NOBLOCK)
+      assert_equal msg, connection.receive
     end
 
-    def test_different_parser
-      msg = "1c5fd481-1121-49d8-a706-69127975db1a ebb407b2-49aa-48a5-9f96-9db121051484 / 2:{},0:,"
-      parser = stub(:parser)
-      parser.expects(:parse).with(msg).returns(request = Object.new)
-      connection = Connection.new(@request_socket, @response_socket, parser)
-      @push.send_string(msg = "1c5fd481-1121-49d8-a706-69127975db1a ebb407b2-49aa-48a5-9f96-9db121051484 / 2:{},0:,", ZMQ::NOBLOCK)
-      assert_equal request, connection.receive
+    def test_deliver_message
+      connection = Connection.new(@request_socket, @response_socket)
+      connection.deliver('uuid', ['conn1', 'conn2'], 'ddaattaa')
+      assert_equal 0, @sub.recv_string(msg = "")
+      assert_equal "uuid 11:conn1 conn2, ddaattaa", msg
+    end
+
+    def test_string_replay_non_close
+      connection = Connection.new(@request_socket, @response_socket)
+      connection.reply( stub(sender: 'uuid', conn_id: 'conn1', close?: false), 'ddaattaa')
+      assert_equal 0, @sub.recv_string(msg = "")
+      assert_equal "uuid 5:conn1, ddaattaa", msg
+      assert_equal -1, @sub.recv_string(msg = "", ZMQ::NOBLOCK)
+    end
+
+    def test_string_replay_close
+      connection = Connection.new(@request_socket, @response_socket)
+      connection.reply( stub(sender: 'uuid', conn_id: 'conn1', close?: true), 'ddaattaa')
+      assert_equal 0, @sub.recv_string(msg = "")
+      assert_equal "uuid 5:conn1, ddaattaa", msg
+      assert_equal 0, @sub.recv_string(msg = "")
+      assert_equal "uuid 5:conn1, ", msg
+    end
+
+    def test_response_replay_non_close
+      connection = Connection.new(@request_socket, @response_socket)
+      connection.reply( stub(sender: 'uuid', conn_id: 'conn1'), mock(to_s: 'ddaattaa', close?: false))
+      assert_equal 0, @sub.recv_string(msg = "")
+      assert_equal "uuid 5:conn1, ddaattaa", msg
+      assert_equal -1, @sub.recv_string(msg = "", ZMQ::NOBLOCK)
+    end
+
+    def test_response_replay_close
+      connection = Connection.new(@request_socket, @response_socket)
+      connection.reply( stub(sender: 'uuid', conn_id: 'conn1'), mock(to_s: 'ddaattaa', close?: true))
+      assert_equal 0, @sub.recv_string(msg = "")
+      assert_equal "uuid 5:conn1, ddaattaa", msg
+      assert_equal 0, @sub.recv_string(msg = "")
+      assert_equal "uuid 5:conn1, ", msg
+    end
+
+    def test_exception_when_receiving
+      request_socket = mock(:recv_string => -1)
+      connection = Connection.new request_socket, nil
+      assert_raises(Connection::Error) { connection.receive }
+    end
+
+    def test_exception_when_deliverying
+      response_socket = mock(:send_string => -1)
+      connection = Connection.new nil, response_socket
+      assert_raises(Connection::Error) { connection.deliver('uuid', ['connection_ids'], 'data') }
+    end
+
+    def test_exception_when_replying
+      response_socket = mock(:send_string => -1)
+      connection = Connection.new nil, response_socket
+      assert_raises(Connection::Error) { connection.reply( Struct.new(:sender, :conn_id).new('sender', 'conn_id') , 'data' ) }
     end
 
   end

data/test/unit/handler_test.rb

@@ -2,40 +2,77 @@ require 'test_helper'
 
 module M2R
   class HandlerTest < MiniTest::Unit::TestCase
+
     def test_lifecycle_for_disconnect
-      connection = stub(:receive => disconnect_request)
+      connection = stub(:receive => "")
       connection.stubs(:connection).returns(connection)
-      h = TestHandler.new(connection)
+      parser = stub(:parse => disconnect_request)
+      h = TestHandler.new(connection, parser)
       h.listen
       assert_equal [:wait, :request, :disconnect, :all], h.called_methods
     end
 
     def test_lifecycle_for_upload_start
-      connection = stub(:receive => upload_start_request)
+      connection = stub(:receive => "")
       connection.stubs(:connection).returns(connection)
-      h = TestHandler.new(connection)
+      parser = stub(:parse => upload_start_request)
+      h = TestHandler.new(connection, parser)
       h.listen
       assert_equal [:wait, :request, :start, :all], h.called_methods
     end
 
     def test_lifecycle_for_upload_done
-      connection = stub(:receive => upload_done_request, :reply => nil)
+      connection = stub(:receive => "", :reply => nil)
       connection.stubs(:connection).returns(connection)
-      h = TestHandler.new(connection)
+      parser = stub(:parse => upload_done_request)
+      h = TestHandler.new(connection, parser)
       h.listen
       assert_equal [:wait, :request, :done, :process, :after, :reply, :all], h.called_methods
     end
 
+    def test_lifecycle_for_exception_when_getting_request
+      connection = stub()
+      connection.stubs(:receive).raises(StandardError)
+      connection.stubs(:connection).returns(connection)
+      h = TestHandler.new(connection, nil)
+      h.listen
+      assert_equal [:wait, :error], h.called_methods
+    end
+
+    def test_lifecycle_for_exception_when_processing
+      connection = stub(:receive => "", :reply => nil)
+      connection.stubs(:connection).returns(connection)
+      parser = stub(:parse => request)
+      h = TestHandler.new(connection, parser)
+      h.extend(Module.new(){
+        def process(request)
+          super
+          raise StandardError
+        end
+      })
+      h.listen
+      assert_equal [:wait, :request, :process, :all, :error], h.called_methods
+    end
+
+
+    private
+
+
     def disconnect_request
-      Request.new("sender", "conn_id", "/path", Headers.new({"METHOD" => "JSON"}), '{"type":"disconnect"}')
+      Request.new("sender", "conn_id", "/path", Headers.new({}), Headers.new({"METHOD" => "JSON"}), '{"type":"disconnect"}')
     end
 
     def upload_start_request
-      Request.new("sender", "conn_id", "/path", Headers.new({"x-mongrel2-upload-start" => "/tmp/file"}), '')
+      Request.new("sender", "conn_id", "/path", Headers.new({}), Headers.new({"x-mongrel2-upload-start" => "/tmp/file"}), '')
     end
 
     def upload_done_request
-      Request.new("sender", "conn_id", "/path", Headers.new({"x-mongrel2-upload-start" => "/tmp/file", "x-mongrel2-upload-done" => "/tmp/file"}), '')
+      Request.new("sender", "conn_id", "/path", Headers.new({}), Headers.new({"x-mongrel2-upload-start" => "/tmp/file", "x-mongrel2-upload-done" => "/tmp/file"}), '')
     end
+
+    def request
+      Request.new("sender", "conn_id", "/path", Headers.new({}), Headers.new({}), '')
+    end
+
   end
 end

data/test/unit/headers_test.rb

@@ -46,5 +46,18 @@ module M2R
       }, env)
     end
 
+    def test_compatibility_trust
+      headers = Headers.new({"Content-Type" => "CT"}, true)
+      assert_equal nil, headers['content-type']
+    end
+
+    def test_compatibility_direct_access
+      headers = Headers.new(source = {"content-type" => "CT"}, true)
+      assert_equal "CT", headers['content-type']
+      headers['Content-type'] = "NEW"
+      assert_equal "NEW", headers['content-Type']
+      assert_equal "NEW", source['content-type']
+    end
+
   end
 end

data/test/unit/rack_handler_test.rb

@@ -1,5 +1,6 @@
 require 'test_helper'
 require 'm2r/rack_handler'
+require 'm2r/connection_factory'
 
 class HelloWorld
   def call(env)
@@ -8,6 +9,13 @@ class HelloWorld
 end
 
 module M2R
+  class ConnectionFactory
+    class Custom
+      def initialize(*)
+      end
+    end
+  end
+
   class RackHandlerTest < MiniTest::Unit::TestCase
     def test_discoverability
       handler = ::Rack::Handler.get(:mongrel2)
@@ -26,20 +34,36 @@ module M2R
         'sender_id' => id   = SecureRandom.uuid
       }
       cf = mock(:connection)
-      ConnectionFactory.expects(:new).with(id, recv, send).returns(cf)
+      ConnectionFactory.expects(:new).with(responds_with(:sender_id, id)).returns(cf)
       RackHandler.any_instance.stubs(:stop? => true)
       handler.run(HelloWorld.new, options)
     end
 
     def test_lint_rack_adapter
       factory    = stub(:connection)
-      handler    = RackHandler.new(app, factory)
+      handler    = RackHandler.new(app, factory, Request)
       response   = handler.process(root_request)
 
       assert_equal "Hello world!", response.body
       assert_equal 200, response.status
     end
 
+    def test_custom_connection_factory
+      require 'rack/handler/mongrel2'
+      handler = ::Rack::Handler::Mongrel2
+      options = {
+        'connection_factory' => 'custom'
+      }
+      cf = mock(:connection)
+      ConnectionFactory::Custom.expects(:new).with(responds_with(:connection_factory, 'custom')).returns(cf)
+      RackHandler.any_instance.stubs(:stop? => true)
+      handler.run(HelloWorld.new, options)
+    end
+
+
+    private
+
+
     def root_request
       data = %q("1c5fd481-1121-49d8-a706-69127975db1a ebb407b2-49aa-48a5-9f96-9db121051484 / 96:{"PATH":"/","host":"127.0.0.1:6767","PATTERN":"/","METHOD":"GET","VERSION":"HTTP/1.1","URI":"/"},0:,)
       Request.parse(data)

data/test/unit/request_test.rb

@@ -12,6 +12,7 @@ module M2R
       assert_equal nil, request.query
       assert_equal nil, request.pattern
       assert_equal "https", request.scheme
+      assert_equal false, request.close?
     end
 
     def test_scheme

data/test/unit/response_test.rb

@@ -3,28 +3,99 @@ require 'test_helper'
 module M2R
   class ResponseTest < MiniTest::Unit::TestCase
     def test_response_with_nil_body
-      ok = Response.new(200, {"Transfer-Encoding" => "chunked"}, nil)
+      ok = Response.new.status(200).headers({"Transfer-Encoding" => "chunked"}).body(nil)
       http = "HTTP/1.1 200 OK\r\nTransfer-Encoding: chunked\r\n\r\n"
       assert_equal http, ok.to_s
     end
 
     def test_response_with_empty_body
-      ok = Response.new(200, {"Transfer-Encoding" => "chunked"}, "")
+      ok = Response.new.status(200).headers({"Transfer-Encoding" => "chunked"}).body("")
       http = "HTTP/1.1 200 OK\r\nTransfer-Encoding: chunked\r\n\r\n"
       assert_equal http, ok.to_s
     end
 
     def test_response_with_no_body
-      ok = Response.new(200, {"Transfer-Encoding" => "chunked"})
+      ok = Response.new.status(200).headers({"Transfer-Encoding" => "chunked"})
       http = "HTTP/1.1 200 OK\r\nTransfer-Encoding: chunked\r\n\r\n"
       assert_equal http, ok.to_s
     end
 
     def test_response_with_content_length
-      ok = Response.new(200, {}, 'data')
+      ok = Response.new.body('data')
       ok.extend Response::ContentLength
-      http = "HTTP/1.1 200 OK\r\nContent-Length: 4\r\n\r\ndata"
+      http = "HTTP/1.1 200 OK\r\ncontent-length: 4\r\n\r\ndata"
       assert_equal http, ok.to_s
     end
+
+    def test_response_with_header
+      ok = Response.new.body('data').header('X-Man', 'Wolverine')
+      ok.extend Response::ContentLength
+      http = "HTTP/1.1 200 OK\r\nx-man: Wolverine\r\ncontent-length: 4\r\n\r\ndata"
+      assert_equal http, ok.to_s
+    end
+
+    def test_response_with_old_version
+      ok = Response.new.http_version('HTTP/1.0').body('data')
+      ok.extend Response::ContentLength
+      http = "HTTP/1.0 200 OK\r\ncontent-length: 4\r\n\r\ndata"
+      assert_equal http, ok.to_s
+    end
+
+    def test_getters
+      ok = Response.new.http_version(v = 'HTTP/1.0').status(s = 300).headers({'X-Man' => xman = 'Summers'}).header("X-Angel", angel = "Warren").body(data = 'data')
+      assert_equal v,     ok.http_version
+      assert_equal s,     ok.status
+      assert_equal xman,  ok.header("X-Man")
+      assert_equal angel, ok.header("X-Angel")
+      assert_equal data , ok.body
+      assert_equal 2,     ok.headers.size
+    end
+
+    def test_default_close
+      ok = Response.new
+      refute ok.close?
+    end
+
+    def test_http10_close
+      ok = Response.new.http_version('HTTP/1.0')
+      assert ok.close?
+    end
+
+    def test_header_close
+      ok = Response.new.header('Connection', 'close')
+      assert ok.close?
+    end
+
+    def test_response_to_http10_identical
+      ok = Response.new
+      ok.extend(Response::ToRequest)
+      ok.to(stub(http_version: 'HTTP/1.0', close?:true), true)
+      assert_equal 'HTTP/1.0', ok.http_version
+      assert_equal 'close', ok.header('Connection')
+    end
+
+    def test_response_to_http10_rfc2145
+      ok = Response.new
+      ok.extend(Response::ToRequest)
+      ok.to(stub(http_version: 'HTTP/1.0', close?:true))
+      assert_equal 'HTTP/1.1', ok.http_version
+      assert_equal 'close', ok.header('Connection')
+    end
+
+    def test_response_to_http11
+      ok = Response.new
+      ok.extend(Response::ToRequest)
+      ok.to(stub(http_version: 'HTTP/1.1', close?:false))
+      assert_equal 'HTTP/1.1', ok.http_version
+      assert_equal nil, ok.header('Connection')
+    end
+
+    def test_response_to_http11_with_close
+      ok = Response.new
+      ok.extend(Response::ToRequest)
+      ok.to(stub(http_version: 'HTTP/1.1', close?:true))
+      assert_equal 'HTTP/1.1', ok.http_version
+      assert_equal 'close', ok.header('Connection')
+    end
   end
 end