m2r 2.0.2 → 2.1.0.pre

data/lib/m2r/parser.rb

@@ -0,0 +1,44 @@
+require 'm2r/request'
+
+module M2R
+  # Mongrel2 Request Parser
+  # @api public
+  class Parser
+    # Parse Mongrel2 request received via ZMQ message
+    #
+    # @param [String] msg Monrel2 Request message formatted according to rules
+    #   of creating it described it m2 manual.
+    # @return [Request]
+    #
+    # @api public
+    # @threadsafe true
+    def parse(msg)
+      sender, conn_id, path, rest = msg.split(' ', 4)
+
+      headers, rest = TNetstring.parse(rest)
+      body, _       = TNetstring.parse(rest)
+      headers       = MultiJson.load(headers)
+      headers, mong = split_headers(headers)
+      headers       = Headers.new headers, true
+      mong          = Headers.new mong, true
+      Request.new(sender, conn_id, path, headers, mong, body)
+    end
+
+    private
+
+    def split_headers(headers)
+      http    = {}
+      mongrel = {}
+      headers.each do |header, value|
+        if Request::MONGREL2_HEADERS.include?(header)
+          mongrel[header.downcase] = value
+        else
+          http[header] = value
+        end
+      end
+      return http, mongrel
+    end
+
+  end
+end
+

data/lib/m2r/rack_handler.rb

@@ -10,8 +10,6 @@ module M2R
     def initialize(app, connection_factory, parser)
       @app = app
       super(connection_factory, parser)
-
-      trap('INT') { stop }
     end
 
     def process(request)

data/lib/m2r/request.rb

@@ -57,16 +57,9 @@ module M2R
     # @return [Request]
     #
     # @api public
+    # @deprecated
     def self.parse(msg)
-      sender, conn_id, path, rest = msg.split(' ', 4)
-
-      headers, rest = TNetstring.parse(rest)
-      body, _       = TNetstring.parse(rest)
-      headers       = MultiJson.load(headers)
-      headers, mong = split_headers(headers)
-      headers       = Headers.new headers, true
-      mong          = Headers.new mong, true
-      self.new(sender, conn_id, path, headers, mong, body)
+      Parser.new.parse(msg)
     end
 
     # @return [M2R::Headers] HTTP headers
@@ -120,17 +113,5 @@ module M2R
       method == 'JSON'
     end
 
-    def self.split_headers(headers)
-      http    = {}
-      mongrel = {}
-      headers.each do |header, value|
-        if MONGREL2_HEADERS.include?(header)
-          mongrel[header.downcase] = value
-        else
-          http[header] = value
-        end
-      end
-      return http, mongrel
-    end
   end
 end

data/lib/m2r/version.rb

@@ -1,5 +1,5 @@
 module M2R
   # m2r gem version
   # @api public
-  VERSION = '2.0.2'
+  VERSION = '2.1.0.pre'
 end

data/lib/rack/handler/mongrel2.rb

@@ -13,10 +13,14 @@ module Rack
       }
 
       def self.run(app, options = {})
-        options = OpenStruct.new( DEFAULT_OPTIONS.merge(options) )
-        parser  = M2R::Request
-        adapter = M2R::RackHandler.new(app, connection_factory(options), parser)
+        options  = OpenStruct.new( DEFAULT_OPTIONS.merge(options) )
+        threadsafe_parser = M2R::Parser.new
+        adapter  = M2R::RackHandler.new(app, connection_factory(options), threadsafe_parser)
+        graceful = Proc.new { adapter.stop }
+        trap("INT",  &graceful)
+        trap("TERM", &graceful)
         adapter.listen
+        M2R.zmq_context.terminate
       end
 
       def self.valid_options

data/m2r.gemspec

@@ -18,15 +18,15 @@ Gem::Specification.new do |gem|
   gem.require_paths    = ["lib"]
   gem.version          = M2R::VERSION
 
-  gem.add_dependency "ffi-rzmq", "~> 0.9.3"
-  gem.add_dependency "ffi", ">= 1.0.0"
+  gem.add_dependency "ffi-rzmq", ">= 1.0.1"
+  gem.add_dependency "ffi",      ">= 1.0.0"
   gem.add_dependency "multi_json"
   gem.add_dependency "tnetstring"
 
   gem.add_development_dependency "rack"
   gem.add_development_dependency "rake"
   gem.add_development_dependency "minitest",            "= 3.2.0"
-  gem.add_development_dependency "mocha",               "~> 0.12.1"
+  gem.add_development_dependency "mocha",               ">= 0.14.0"
   gem.add_development_dependency "bbq",                 "= 0.0.4"
   gem.add_development_dependency "capybara-mechanize",  "= 0.3.0"
   gem.add_development_dependency "activesupport",       "~> 3.2.7"

data/test/support/test_handler.rb

@@ -1,55 +1,72 @@
+require 'thread'
 require 'm2r/handler'
 
 class TestHandler < M2R::Handler
   attr_reader :called_methods
-  def initialize(connection, parser)
+  def initialize(connection_factory, parser)
     super
+    @mutex = Mutex.new
     @called_methods = []
+    Thread.current[:called_methods] = []
   end
 
   def on_wait()
-    unless @called_methods.empty?
+    unless Thread.current[:called_methods].empty?
       stop
       return
     end
-    @called_methods << :wait
+    called_method :wait
   end
 
   def on_request(request)
-    @called_methods << :request
+    called_method :request
   end
 
   def process(request)
-    @called_methods << :process
+    called_method :process
     return "response"
   end
 
   def on_disconnect(request)
-    @called_methods << :disconnect
+    called_method :disconnect
   end
 
   def on_upload_start(request)
-    @called_methods << :start
+    called_method :start
   end
 
   def on_upload_done(request)
-    @called_methods << :done
+    called_method :done
   end
 
   def after_process(request, response)
-    @called_methods << :after
+    called_method :after
     return response
   end
 
   def after_reply(request, response)
-    @called_methods << :reply
+    called_method :reply
   end
 
   def after_all(request, response)
-    @called_methods << :all
+    called_method :all
   end
 
   def on_error(request, response, error)
-    @called_methods << :error
+    called_method :error
   end
+
+  def on_interrupted
+    called_method :interrupted
+  end
+
+  private
+
+  def called_method(mth)
+    Thread.current[:called_methods] << mth
+    @mutex.synchronize do
+      @called_methods << mth
+    end
+  end
+
 end

data/test/test_helper.rb

@@ -1,5 +1,5 @@
 require 'minitest/autorun'
-require 'mocha'
+require 'mocha/setup'
 require 'm2r'
 
 Dir[File.expand_path(File.join(__FILE__, '../support/*.rb'))].each { |m| require m }

data/test/unit/connection_test.rb

@@ -11,17 +11,16 @@ module M2R
       @push = M2R.zmq_context.socket(ZMQ::PUSH)
       assert_equal 0, @push.bind(@request_addr), "Could not bind push socket in tests"
 
-      @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)
       @request_socket.connect(@request_addr)
 
       @response_socket = M2R.zmq_context.socket(ZMQ::PUB)
-      @response_socket.connect(@response_addr)
+      @response_socket.bind(@response_addr)
       @response_socket.setsockopt(ZMQ::IDENTITY, @sender_id = SecureRandom.uuid)
+
+      @sub = M2R.zmq_context.socket(ZMQ::SUB)
+      assert_equal 0, @sub.connect(@response_addr), "Could not connect sub socket in tests"
+      @sub.setsockopt(ZMQ::SUBSCRIBE, "")
     end
 
     def teardown
@@ -33,48 +32,48 @@ module M2R
 
     def test_receive_message
       connection = Connection.new(@request_socket, @response_socket)
-      @push.send_string(msg = "1c5fd481-1121-49d8-a706-69127975db1a ebb407b2-49aa-48a5-9f96-9db121051484 / 2:{},0:,", ZMQ::NOBLOCK)
+      @push.send_string(msg = "1c5fd481-1121-49d8-a706-69127975db1a ebb407b2-49aa-48a5-9f96-9db121051484 / 2:{},0:,", ZMQ::NonBlocking)
       assert_equal msg, connection.receive
     end
 
     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 @sub.recv_string(msg = "") > 0
       assert_equal "uuid 11:conn1 conn2, ddaattaa", msg
     end
 
     def test_string_reply_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 @sub.recv_string(msg = "") > 0
       assert_equal "uuid 5:conn1, ddaattaa", msg
-      assert_equal -1, @sub.recv_string(msg = "", ZMQ::NOBLOCK)
+      assert_equal -1, @sub.recv_string(msg = "", ZMQ::NonBlocking)
     end
 
     def test_string_reply_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 @sub.recv_string(msg = "") > 0
       assert_equal "uuid 5:conn1, ddaattaa", msg
-      assert_equal 0, @sub.recv_string(msg = "")
+      assert @sub.recv_string(msg = "") > 0
       assert_equal "uuid 5:conn1, ", msg
     end
 
     def test_response_reply_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 @sub.recv_string(msg = "") > 0
       assert_equal "uuid 5:conn1, ddaattaa", msg
-      assert_equal -1, @sub.recv_string(msg = "", ZMQ::NOBLOCK)
+      assert_equal -1, @sub.recv_string(msg = "", ZMQ::NonBlocking)
     end
 
     def test_response_reply_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 @sub.recv_string(msg = "") > 0
       assert_equal "uuid 5:conn1, ddaattaa", msg
-      assert_equal 0, @sub.recv_string(msg = "")
+      assert @sub.recv_string(msg = "") > 0
       assert_equal "uuid 5:conn1, ", msg
     end
 
@@ -84,6 +83,42 @@ module M2R
       assert_raises(Connection::Error) { connection.receive }
     end
 
+    def test_exception_erron_when_receiving
+      request_socket = mock(:recv_string => -1)
+      ZMQ::Util.expects(:errno).at_least_once.returns(4)
+      connection = Connection.new request_socket, nil
+      begin
+        connection.receive
+        flunk "exception expected"
+      rescue => er
+        assert_equal 4, er.errno
+        assert er.signal?
+      end
+    end
+
+    def test_exception_when_deliverying
+      ZMQ::Util.expects(:errno).at_least_once.returns(1)
+      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_signal_retry
+      ZMQ::Util.expects(:errno).at_least_once.returns(4)
+      response_socket = mock
+      response_socket.expects(:send_string).times(3).returns(-1)
+      connection = Connection.new nil, response_socket
+      assert_raises(Connection::Error) { connection.deliver('uuid', ['connection_ids'], 'data') }
+    end
+
+    def test_exception_signal_retry_ok
+      ZMQ::Util.expects(:errno).at_least_once.returns(4)
+      response_socket = mock
+      response_socket.expects(:send_string).twice.returns(-1).then.returns(0)
+      connection = Connection.new nil, response_socket
+      assert connection.deliver('uuid', ['connection_ids'], 'data').size > 0
+    end
+
     def test_exception_when_deliverying
       response_socket = mock(:send_string => -1)
       connection = Connection.new nil, response_socket

data/test/unit/handler_test.rb

@@ -4,7 +4,7 @@ module M2R
   class HandlerTest < MiniTest::Unit::TestCase
 
     def test_lifecycle_for_disconnect
-      connection = stub(:receive => "")
+      connection = stub(:receive => "", :close => nil)
       connection.stubs(:connection).returns(connection)
       parser = stub(:parse => disconnect_request)
       h = TestHandler.new(connection, parser)
@@ -13,7 +13,7 @@ module M2R
     end
 
     def test_lifecycle_for_upload_start
-      connection = stub(:receive => "")
+      connection = stub(:receive => "", :close => nil)
       connection.stubs(:connection).returns(connection)
       parser = stub(:parse => upload_start_request)
       h = TestHandler.new(connection, parser)
@@ -22,7 +22,7 @@ module M2R
     end
 
     def test_lifecycle_for_upload_done
-      connection = stub(:receive => "", :reply => nil)
+      connection = stub(:receive => "", :reply => nil, :close => nil)
       connection.stubs(:connection).returns(connection)
       parser = stub(:parse => upload_done_request)
       h = TestHandler.new(connection, parser)
@@ -31,7 +31,7 @@ module M2R
     end
 
     def test_lifecycle_for_exception_when_getting_request
-      connection = stub()
+      connection = stub(:close => nil)
       connection.stubs(:receive).raises(StandardError)
       connection.stubs(:connection).returns(connection)
       h = TestHandler.new(connection, nil)
@@ -40,7 +40,7 @@ module M2R
     end
 
     def test_lifecycle_for_exception_when_processing
-      connection = stub(:receive => "", :reply => nil)
+      connection = stub(:receive => "", :reply => nil, :close => nil)
       connection.stubs(:connection).returns(connection)
       parser = stub(:parse => request)
       h = TestHandler.new(connection, parser)
@@ -54,6 +54,34 @@ module M2R
       assert_equal [:wait, :request, :process, :all, :error], h.called_methods
     end
 
+    def test_signal_when_receive
+      e = Connection::Error.new.tap{|x| x.errno = 4}
+      connection = stub(:reply => nil, :close => nil)
+      connection.stubs(:connection).returns(connection)
+      connection.expects(:receive).raises(e).then.returns("").twice
+      parser = stub(:parse => request)
+      h = TestHandler.new(connection, parser)
+      h.extend(Module.new(){
+        def on_wait
+          if @called_methods.size > 2
+            stop
+            return
+          end
+          @called_methods << :wait
+        end
+      })
+      h.listen
+      assert_equal [:wait, :interrupted, :wait, :request, :process, :after, :reply, :all], h.called_methods
+    end
+
+    def test_connection_closed
+      connection = mock(:close => nil)
+      connection.expects(:connection).returns(connection)
+      h = TestHandler.new(connection, nil)
+      h.stop
+      h.listen
+    end
+
 
     private
 

data/test/unit/m2r_test.rb

@@ -34,6 +34,8 @@ module M2R
       Timeout.timeout(5) do
         threads.each(&:join)
       end
+
+      M2R.zmq_context = nil
     end
 
   end

data/test/unit/multithread_handler_test.rb

@@ -0,0 +1,75 @@
+require 'test_helper'
+
+module M2R
+  class MultithreadHandlerTest < MiniTest::Unit::TestCase
+    SLEEP_TIME  = 3
+    MARGIN_TIME = 1
+    WAIT_TIME   = 1
+
+    class ThreadTestHandler < TestHandler
+      def process(request)
+        sleep(SLEEP_TIME)
+        super
+        return Thread.current.object_id.to_s
+      end
+    end
+
+    class TestSinglethreadHandlerFactory
+      def initialize(connection_factory, parser)
+        @connection_factory = connection_factory
+        @parser             = parser
+      end
+
+      def new
+        ThreadTestHandler.new(@connection_factory, @parser)
+      end
+    end
+
+    def setup
+      @request_addr  = "inproc://#{SecureRandom.hex}"
+      @response_addr = "inproc://#{SecureRandom.hex}"
+
+      @push = M2R.zmq_context.socket(ZMQ::PUSH)
+      assert_equal 0, @push.bind(@request_addr), "Could not bind push socket in tests"
+
+      @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, "")
+    end
+
+    def teardown
+      @push.close            if @push
+      @sub.close             if @sub
+    end
+
+    def test_threads_are_processing_request_simultaneously
+      cf  = ConnectionFactory.new(ConnectionFactory::Options.new(nil, @request_addr, @response_addr))
+      par = Parser.new
+      mth = MultithreadHandler.new(TestSinglethreadHandlerFactory.new(cf, par))
+      mth.listen
+      sleep(WAIT_TIME)
+
+      start = Time.now
+      8.times do |i|
+        @push.send_string(msg = "1c5fd481-1121-49d8-a706-69127975db1a ebb407b2-49aa-48a5-9f96-9db12105148#{i} / 2:{},1:#{i},", ZMQ::NonBlocking)
+      end
+      responses = 16.times.map do
+        @sub.recv_string(msg = "")
+        msg
+      end
+      finish = Time.now
+
+      mth.threads.each do |t|
+        t.join
+      end
+
+      blob = responses.join("\n")
+      mth.threads.each do |t|
+        assert blob.include?(", #{t.object_id}")
+      end
+
+      delta  = finish - start
+      assert_in_delta(SLEEP_TIME, delta, MARGIN_TIME)
+    end
+  end
+end