rjr 0.9.0 → 0.11.7

data/lib/rjr/ws_node.rb

@@ -5,11 +5,25 @@
 # Copyright (C) 2012 Mohammed Morsi <mo@morsi.org>
 # Licensed under the Apache License, Version 2.0
 
+skip_module = false
+begin
 require 'em-websocket'
-require 'rjr/web_socket'
+require 'em-websocket-client'
+rescue LoadError
+  skip_module = true
+end
+
+if skip_module
+# TODO output: "ws dependencies could not be loaded, skipping ws node definition"
+require 'rjr/missing_node'
+RJR::WSNode = RJR::MissingNode
 
+else
+require 'socket'
 require 'rjr/node'
 require 'rjr/message'
+require 'rjr/dispatcher'
+require 'rjr/thread_pool2'
 
 module RJR
 
@@ -31,8 +45,7 @@ class WSNodeCallback
 
   # Implementation of {RJR::NodeCallback#invoke}
   def invoke(callback_method, *data)
-    #msg = CallbackMessage.new(:data => data)
-    msg = RequestMessage.new :method => callback_method, :args => data, :headers => @message_headers
+    msg = NotificationMessage.new :method => callback_method, :args => data, :headers => @message_headers
     raise RJR::Errors::ConnectionError.new("websocket closed") if @socket.state == :closed
     # TODO surround w/ begin/rescue block incase of other socket errors?
     @socket.send(msg.to_s)
@@ -62,17 +75,57 @@ end
 #   puts client.invoke_request('ws://localhost:7777', 'hello', 'mo')
 #
 class WSNode < RJR::Node
-  RJR_NODE_TYPE = :websockets
+  RJR_NODE_TYPE = :ws
 
   private
-  # Initialize the ws subsystem
-  def init_node
+
+  # Internal helper initialize new connection
+  def init_node(uri, &on_init)
+    connection = nil
+    @connections_lock.synchronize {
+      connection = @connections.find { |c|
+                     c.url == uri
+                   }
+      if connection.nil?
+        connection = EventMachine::WebSocketClient.connect(uri)
+        connection.callback do
+          on_init.call(connection)
+        end
+        @connections << connection
+        # TODO sleep until connected?
+      else
+        on_init.call(connection)
+      end
+    }
+    connection
+  end
+
+  # Internal helper handle messages
+  def handle_msg(endpoint, msg)
+    # TODO use messageutil incase of large messages?
+    if RequestMessage.is_request_message?(msg)
+      ThreadPool2Manager << ThreadPool2Job.new { handle_request(endpoint, msg, false) }
+
+    elsif NotificationMessage.is_notification_message?(msg)
+      ThreadPool2Manager << ThreadPool2Job.new { handle_request(endpoint, msg, true) }
+
+    elsif ResponseMessage.is_response_message?(msg)
+      handle_response(msg)
+
+    end
   end
 
   # Internal helper, handle request message received
-  def handle_request(socket, message)
-    client_port, client_ip = Socket.unpack_sockaddr_in(socket.get_peername)
-    msg    = RequestMessage.new(:message => message, :headers => @message_headers)
+  def handle_request(endpoint, message, notification=false)
+    # XXX hack to handle client disconnection (should grap port/ip immediately on connection and use that)
+    client_port,client_ip = nil,nil
+    begin
+      client_port, client_ip = Socket.unpack_sockaddr_in(endpoint.get_peername)
+    rescue Exception=>e
+    end
+
+    msg    = notification ? NotificationMessage.new(:message => message, :headers => @message_headers) :
+                            RequestMessage.new(:message => message, :headers => @message_headers)
     headers = @message_headers.merge(msg.headers)
     result = Dispatcher.dispatch_request(msg.jr_method,
                                          :method_args => msg.jr_args,
@@ -83,12 +136,53 @@ class WSNode < RJR::Node
                                          :rjr_node_id   => @node_id,
                                          :rjr_node_type => RJR_NODE_TYPE,
                                          :rjr_callback =>
-                                           WSNodeCallback.new(:socket => socket,
+                                           WSNodeCallback.new(:socket => endpoint,
                                                               :headers => headers))
-    response = ResponseMessage.new(:id => msg.msg_id, :result => result, :headers => headers)
-    socket.send(response.to_s)
+    unless notification
+      response = ResponseMessage.new(:id => msg.msg_id, :result => result, :headers => headers)
+      endpoint.send(response.to_s)
+    end
+  end
+
+  # Internal helper, handle response message received
+  def handle_response(data)
+    msg    = ResponseMessage.new(:message => data, :headers => @message_headers)
+    res = err = nil
+    begin
+      res = Dispatcher.handle_response(msg.result)
+    rescue Exception => e
+      err = e
+    end
+
+    @response_lock.synchronize {
+      result = [msg.msg_id, res]
+      result << err if !err.nil?
+      @responses << result
+      @response_cv.signal
+    }
+  end
+
+  # Internal helper, block until response matching message id is received
+  def wait_for_result(message)
+    res = nil
+    while res.nil?
+      @response_lock.synchronize{
+        # FIXME throw err if more than 1 match found
+        res = @responses.select { |response| message.msg_id == response.first }.first
+        if !res.nil?
+          @responses.delete(res)
+
+        else
+          @response_cv.signal
+          @response_cv.wait @response_lock
+
+        end
+      }
+    end
+    return res
   end
 
+
   public
   # WSNode initializer
   # @param [Hash] args the options to create the web socket node with
@@ -99,6 +193,13 @@ class WSNode < RJR::Node
      @host      = args[:host]
      @port      = args[:port]
 
+     @connections = []
+     @connections_lock = Mutex.new
+
+     @response_lock = Mutex.new
+     @response_cv   = ConditionVariable.new
+     @responses     = []
+
      @connection_event_handlers = {:closed => [], :error => []}
   end
 
@@ -117,22 +218,11 @@ class WSNode < RJR::Node
   # Implementation of {RJR::Node#listen}
   def listen
     em_run do
-      init_node
       EventMachine::WebSocket.start(:host => @host, :port => @port) do |ws|
-        ws.onopen    {}
-        ws.onclose   {
-          @connection_event_handlers[:closed].each { |h|
-            h.call self
-          }
-        }
-        ws.onerror   {|e|
-          @connection_event_handlers[:error].each { |h|
-            h.call self
-          }
-        }
-        ws.onmessage { |msg|
-          @thread_pool << ThreadPoolJob.new { handle_request(ws, msg) }
-        }
+        ws.onopen    { }
+        ws.onclose   {       @connection_event_handlers[:closed].each { |h| h.call self } }
+        ws.onerror   { |e|   @connection_event_handlers[:error].each  { |h| h.call self } }
+        ws.onmessage { |msg| handle_msg(ws, msg) }
       end
     end
   end
@@ -143,17 +233,55 @@ class WSNode < RJR::Node
   # @param [String] rpc_method json-rpc method to invoke on destination
   # @param [Array] args array of arguments to convert to json and invoke remote method wtih
   def invoke_request(uri, rpc_method, *args)
-    init_node
     message = RequestMessage.new :method => rpc_method,
                                  :args   => args,
                                  :headers => @message_headers
-    socket = WebSocket.new(uri)
-    socket.send(message.to_s)
-    res = socket.receive()
-    msg    = ResponseMessage.new(:message => res, :headers => @message_headers)
-    headers = @message_headers.merge(msg.headers)
-    return Dispatcher.handle_response(msg.result)
+
+    em_run{
+      init_node(uri) do |c|
+        c.stream { |msg| handle_msg(c, msg) }
+
+        c.send_msg message.to_s
+      end
+    }
+
+    # TODO optional timeout for response ?
+    result = wait_for_result(message)
+
+    if result.size > 2
+      raise Exception, result[2]
+    end
+    return result[1]
+  end
+
+  # Instructs node to send rpc notification (immadiately returns / no response is generated)
+  #
+  # @param [String] uri location of node to send notification to, should be
+  #   in format of ws://hostname:port
+  # @param [String] rpc_method json-rpc method to invoke on destination
+  # @param [Array] args array of arguments to convert to json and invoke remote method wtih
+  def send_notification(uri, rpc_method, *args)
+    # will block until message is published
+    published_l = Mutex.new
+    published_c = ConditionVariable.new
+
+    message = NotificationMessage.new :method => rpc_method,
+                                      :args   => args,
+                                      :headers => @message_headers
+    em_run{
+      init_node(uri) do |c|
+        c.send_msg message.to_s
+
+        # XXX same bug w/ tcp node, due to nature of event machine
+        # we aren't guaranteed that message is actually written to socket
+        # here, process must be kept alive until data is sent or will be lost
+        published_l.synchronize { published_c.signal }
+      end
+    }
+    published_l.synchronize { published_c.wait published_l }
+    nil
   end
 end
 
 end # module RJR
+end

data/lib/rjr.rb

@@ -6,16 +6,11 @@
 # rjr - Ruby Json Rpc
 module RJR ; end
 
-require 'rjr/common'
-require 'rjr/errors'
-require 'rjr/thread_pool'
-require 'rjr/semaphore'
-require 'rjr/node'
-require 'rjr/dispatcher'
-require 'rjr/message'
-require 'rjr/local_node'
 require 'rjr/amqp_node'
-require 'rjr/ws_node'
-require 'rjr/web_node'
 require 'rjr/tcp_node'
+require 'rjr/web_node'
+require 'rjr/ws_node'
+require 'rjr/local_node'
 require 'rjr/multi_node'
+
+require 'rjr/util'

data/specs/dispatcher_spec.rb

@@ -49,6 +49,10 @@ end
 
 
 describe RJR::Handler do
+  before(:each) do
+    RJR::DispatcherStat.reset
+  end
+
   it "should return method not found result if method name is not specified" do
     handler = RJR::Handler.new :method => nil
     result = handler.handle
@@ -65,6 +69,15 @@ describe RJR::Handler do
     invoked.should == true
   end
 
+  it "should create dispatcher stat when invoking handler" do
+    handler = RJR::Handler.new :method => 'foobar',
+                               :handler => lambda { 42 }
+    handler.handle({:method_args => [] })
+    RJR::DispatcherStat.stats.size.should == 1
+    RJR::DispatcherStat.stats.first.request.method.should == 'foobar'
+    RJR::DispatcherStat.stats.first.result.result.should == 42
+  end
+
   it "should return handler's return value in successful result" do
     retval  = Object.new
     handler = RJR::Handler.new :method => 'foobar',
@@ -90,6 +103,59 @@ describe RJR::Handler do
   end
 end
 
+describe RJR::DispatcherStat do
+  before(:each) do
+    RJR::DispatcherStat.reset
+  end
+
+  it "should store request and result" do
+    req = RJR::Request.new
+    res = RJR::Result.new
+    stat = RJR::DispatcherStat.new req, res
+    (stat.request == req).should be_true
+    stat.result.should == res
+  end
+
+  it "should track global stats" do
+    req = RJR::Request.new
+    res = RJR::Result.new
+    stat = RJR::DispatcherStat.new req, res
+
+    RJR::DispatcherStat << stat
+    RJR::DispatcherStat.stats.should include(stat)
+  end
+
+  it "should be convertable to json" do
+    req = RJR::Request.new :method => 'foobar', :method_args => [:a, :b],
+                           :headers => { :foo => :bar }, :rjr_node_type => :local,
+                           :rjr_node_id => :loc1
+    res = RJR::Result.new :result => 42
+
+    stat = RJR::DispatcherStat.new req, res
+    j = stat.to_json()
+    j.should include('"json_class":"RJR::DispatcherStat"')
+    j.should include('"method":"foobar"')
+    j.should include('"method_args":["a","b"]')
+    j.should include('"headers":{"foo":"bar"}')
+    j.should include('"rjr_node_type":"local"')
+    j.should include('"rjr_node_id":"loc1"')
+    j.should include('"result":42')
+  end
+
+  it "should be convertable from json" do
+    j = '{"json_class":"RJR::DispatcherStat","data":{"request":{"method":"foobar","method_args":["a","b"],"headers":{"foo":"bar"},"rjr_node_type":"local","rjr_node_id":"loc1"},"result":{"result":42,"error_code":null,"error_msg":null,"error_class":null}}}'
+    s = JSON.parse(j)
+
+    s.class.should == RJR::DispatcherStat
+    s.request.method.should == 'foobar'
+    s.request.method_args.should == ['a', 'b']
+    s.request.headers.should == { 'foo' => 'bar' }
+    s.request.rjr_node_type.should == 'local'
+    s.request.rjr_node_id.should == 'loc1'
+    s.result.result.should == 42
+  end
+end
+
 describe RJR::Dispatcher do
   it "should dispatch request to registered handler" do
     invoked_foobar = false
@@ -111,6 +177,21 @@ describe RJR::Dispatcher do
     invoked_barfoo.should == false
   end
 
+  it "should allow user to determine registered handlers" do
+    foobar = lambda {}
+    barfoo = lambda {}
+    RJR::Dispatcher.add_handler('foobar', &foobar)
+    RJR::Dispatcher.add_handler('barfoo', &barfoo)
+
+    RJR::Dispatcher.has_handler_for?('foobar').should be_true
+    RJR::Dispatcher.has_handler_for?('barfoo').should be_true
+    RJR::Dispatcher.has_handler_for?('money').should be_false
+
+    RJR::Dispatcher.handler_for('foobar').handler_proc.should == foobar
+    RJR::Dispatcher.handler_for('barfoo').handler_proc.should == barfoo
+    RJR::Dispatcher.handler_for('money').should be_nil
+  end
+
   it "should allow a single handler to be subscribed to multiple methods" do
     invoked_handler = 0
     RJR::Dispatcher.init_handlers

data/specs/em_adapter_spec.rb

@@ -0,0 +1,85 @@
+require 'rjr/dispatcher'
+require 'rjr/em_adapter'
+
+describe EMManager do
+  it "should start and halt the reactor thread" do
+    manager = EMManager.new
+    manager.start
+    EventMachine.reactor_running?.should be_true
+    manager.running?.should be_true
+    manager.instance_variable_get(:@reactor_thread).should_not be_nil
+    rt = manager.instance_variable_get(:@reactor_thread)
+    ['sleep', 'run'].should include(manager.instance_variable_get(:@reactor_thread).status)
+
+    manager.start
+    rt2 = manager.instance_variable_get(:@reactor_thread)
+    rt.should == rt2
+
+    manager.halt
+    manager.join
+    EventMachine.reactor_running?.should be_false
+    manager.running?.should be_false
+    manager.instance_variable_get(:@reactor_thread).should be_nil
+  end
+
+  it "should allow the user to schedule jobs" do
+    manager = EMManager.new
+    manager.start
+    manager.running?.should be_true
+    block_ran = false
+    manager.schedule {
+      block_ran = true
+    }
+    sleep 0.5
+    block_ran.should == true
+
+    manager.halt
+    manager.join
+    manager.running?.should be_false
+  end
+
+  it "should allow the user to keep the reactor alive until forcibly stopped" do
+    manager = EMManager.new
+    manager.start
+    manager.running?.should be_true
+    manager.schedule { "foo" }
+
+    manager.running?.should be_true
+
+    # forcibly stop the reactor
+    manager.halt
+    manager.join
+    manager.running?.should be_false
+  end
+  
+  it "should allow the user to schedule at job after a specified interval" do
+    manager = EMManager.new
+    manager.start
+    manager.running?.should be_true
+    block_called = false
+    manager.add_timer(1) { block_called = true }
+    sleep 0.5
+    block_called.should == false
+    sleep 1
+    block_called.should == true
+    manager.halt
+    manager.join
+  end
+
+  it "should allow the user to schedule at job repeatidly with a specified interval" do
+    manager = EMManager.new
+    manager.start
+    manager.running?.should be_true
+    times_block_called = 0
+    manager.add_periodic_timer(1) { times_block_called += 1 }
+    sleep 0.6
+    times_block_called.should == 0
+    sleep 0.6
+    times_block_called.should == 1
+    sleep 1.2
+    times_block_called.should == 2
+
+    manager.halt
+    manager.join
+  end
+end

data/specs/inspect_spec.rb

@@ -0,0 +1,60 @@
+require 'rjr/inspect'
+
+describe 'rjr/inspect.rb' do
+  describe "select_stats" do
+    before(:each) do
+      RJR::DispatcherStat.reset
+
+      req1   = RJR::Request.new :rjr_node_type => :local, :method => 'foobar'
+      req2   = RJR::Request.new :rjr_node_type => :tcp,   :method => 'barfoo'
+      req3   = RJR::Request.new :rjr_node_type => :amqp,  :method => 'foobar'
+      res1   = RJR::Result.new :result => true
+      res2   = RJR::Result.new :error_code => 123
+      res3   = RJR::Result.new :error_code => 123
+
+      @stat1 = RJR::DispatcherStat.new req1, res1
+      @stat2 = RJR::DispatcherStat.new req2, res2
+      @stat3 = RJR::DispatcherStat.new req3, res3
+      RJR::DispatcherStat << @stat1 << @stat2 << @stat3
+    end
+
+    it "should get all dispatcherstats" do
+      stats = select_stats
+      stats.size.should == 3
+      stats.first.should == @stat1
+      stats[1].should  == @stat2
+      stats.last.should  == @stat3
+    end
+
+    it "should get all dispatcherstats for a node" do
+      stats = select_stats 'on_node', 'local'
+      stats.size.should == 1
+      stats.first.should == @stat1
+    end
+
+    it "should get all dispatcherstats for a method" do
+      stats = select_stats 'for_method', 'foobar'
+      stats.size.should == 2
+      stats.first.should == @stat1
+      stats.last.should  == @stat3
+    end
+
+    it "should get all successfull/failed dispatcherstats" do
+      stats = select_stats 'successful'
+      stats.size.should == 1
+      stats.first.should == @stat1
+
+      stats = select_stats 'failed'
+      stats.size.should == 2
+      stats.first.should == @stat2
+      stats.last.should  == @stat3
+    end
+
+    it "should get dispatcher stats meeting multiple criteria" do
+      stats = select_stats 'for_method', 'foobar', 'successful'
+      stats.size.should == 1
+      stats.first.should == @stat1
+    end
+  end
+
+end

data/specs/message_spec.rb

@@ -143,3 +143,61 @@ describe RJR::ResponseMessage do
     }.should raise_error JSON::ParserError
   end
 end
+
+describe RJR::NotificationMessage do
+  it "should accept notification parameters" do
+    msg = RJR::NotificationMessage.new :method => 'test',
+                                       :args   => ['a', 1],
+                                       :headers => {:h => 2}
+    msg.jr_method.should == "test"
+    msg.jr_args.should =~ ['a', 1]
+    msg.headers.should have_key(:h)
+    msg.headers[:h].should == 2
+  end
+
+  it "should produce valid json" do
+    msg = RJR::NotificationMessage.new :method => 'test',
+                                       :args   => ['a', 1],
+                                       :headers => {:h => 2}
+
+    msg_string = msg.to_s
+    msg_string.should include('"h":2')
+    msg_string.should include('"method":"test"')
+    msg_string.should include('"params":["a",1]')
+    msg_string.should include('"jsonrpc":"2.0"')
+    msg_string.should_not include('"id":"')
+  end
+
+  it "should parse notification message string" do
+    msg_string = '{"jsonrpc": "2.0", ' +
+                 '"method": "test", "params": ["a", 1]}'
+    msg = RJR::NotificationMessage.new :message => msg_string
+    msg.json_message.should == msg_string
+    msg.jr_method.should == 'test'
+    msg.jr_args.should =~ ['a', 1]
+  end
+
+  it "should extract optional headers from message string" do
+    msg_string = '{"jsonrpc": "2.0", ' +
+                 '"method": "test", "params": ["a", 1], ' +
+                 '"h": 2}'
+    msg = RJR::NotificationMessage.new :message => msg_string, :headers => {'f' => 'g'}
+    msg.json_message.should == msg_string
+    msg.headers.should have_key 'h'
+    msg.headers.should have_key 'f'
+    msg.headers['h'].should == 2
+    msg.headers['f'].should == 'g'
+  end
+
+  it "should fail if parsing invalid message string" do
+    lambda {
+      msg = RJR::NotificationMessage.new :message => 'foobar'
+    }.should raise_error JSON::ParserError
+  end
+end
+
+describe RJR::MessageUtil do
+  it "should extract json messages out of a message stream" do
+    # TODO!
+  end
+end

data/specs/multi_node_spec.rb

@@ -3,8 +3,8 @@ require 'rjr/amqp_node'
 require 'rjr/web_node'
 require 'rjr/dispatcher'
 
-describe RJR::AMQPNode do
-  it "should invoke and satisfy amqp requests" do
+describe RJR::MultiNode do
+  it "should invoke and satisfy requests over multiple protocols" do
     foolbar_invoked = false
     barfoo_invoked = false
     RJR::Dispatcher.init_handlers
@@ -25,10 +25,11 @@ describe RJR::AMQPNode do
 
     amqp = RJR::AMQPNode.new :node_id => 'amqp', :broker => 'localhost'
     web  = RJR::WebNode.new :node_id => 'web', :host => 'localhost', :port => 9876
-    multi = RJR::MultiNode.new :node_id => 'multi', :nodes => [amqp, web]
+    multi = RJR::MultiNode.new :node_id => 'multi', :nodes => [amqp, web], :keep_alive => true
 
     multi.listen
-    amqp_client = RJR::AMQPNode.new :node_id => 'client', :broker => 'localhost'
+
+    amqp_client = RJR::AMQPNode.new :node_id => 'client', :broker => 'localhost', :keep_alive => true # see comment about keepalive in amqp_node_spec
     res = amqp_client.invoke_request 'amqp-queue', 'foolbar', 'myparam1'
     res.should == 'retval1'