rjr 0.11.7 → 0.12.2

data/bin/rjr-client

@@ -67,7 +67,7 @@ optparse = OptionParser.new do |opts|
   end
 
   opts.on('--message ID', 'Message to send to server (rand to select random)') do |mid|
-    config[:msg_id] = mid
+    config[:msg_id] = mid.intern
   end
 
   opts.on('--interval seconds', 'Number of seconds after which to wait between requests (or rand)') do |s|

data/bin/rjr-client-launcher

@@ -8,12 +8,12 @@ ID_OFFSET   = ARGV.shift.to_i || 100
 
 NUM_CLIENTS = 5
 NUM_MSGS    = 20 # per client
+MSG_ID      = :rand
 NODE_ID     = 'rjr_test_launcher-'
-MSG_IDS     = ['stress', 'stress_callback']
-TRANSPORTS  = {#:amqp =>     'rjr_test_server-queue',
-               #:tcp  => 'jsonrpc://localhost:8181',
+TRANSPORTS  = {:amqp =>    'rjr_test_server-queue',
+               :tcp  => 'jsonrpc://localhost:8181',
                :ws   => 'jsonrpc://localhost:8080',
-               #:www  =>     'http://localhost:8888'
+               :www  =>    'http://localhost:8888'
               }
 BROKER      = 'localhost' # only used for amqp
 MSG_INTERVAL= 3
@@ -27,11 +27,10 @@ threads = []
   dst       = TRANSPORTS[transport]
   mode      = rand(2) == 0 ? :msg : :rand
   node_id   = NODE_ID + (i + ID_OFFSET).to_s
-  msg_id    = MSG_IDS[rand(MSG_IDS.size)]
 
   threads <<
     Thread.new{
-      system("#{CLIENT} -m #{mode} -t #{transport} -i #{node_id} -b #{BROKER} --dst #{dst} -n #{NUM_MSGS} --message #{msg_id} --interval #{MSG_INTERVAL}")
+      system(ENV, "#{CLIENT} -m #{mode} -t #{transport} -i #{node_id} -b #{BROKER} --dst #{dst} -n #{NUM_MSGS} --message #{MSG_ID} --interval #{MSG_INTERVAL}")
     }
 }
 

data/lib/rjr/amqp_node.rb

@@ -21,6 +21,7 @@ else
 require 'rjr/node'
 require 'rjr/message'
 require 'rjr/dispatcher'
+require 'rjr/errors'
 require 'rjr/thread_pool2'
 
 module RJR
@@ -309,17 +310,18 @@ class  AMQPNode < RJR::Node
     published_l = Mutex.new
     published_c = ConditionVariable.new
 
+    invoked = false
     message = NotificationMessage.new :method => rpc_method,
                                       :args   => args,
                                       :headers => @message_headers
     em_run do
       init_node {
         publish(message.to_s, :routing_key => routing_key, :reply_to => @queue_name){
-          published_l.synchronize { published_c.signal }
+          published_l.synchronize { invoked = true ; published_c.signal }
         }
       }
     end
-    published_l.synchronize { published_c.wait published_l }
+    published_l.synchronize { published_c.wait published_l unless invoked }
     nil
   end
 

data/lib/rjr/inspect.rb

@@ -52,9 +52,8 @@ rjr_method \
       {
         # event machine
         :event_machine => { :running => EMAdapter.running?,
-                            :has_jobs => EMAdapter.has_jobs?,
                             :thread_status => EMAdapter.reactor_thread.status,
-                            :jobs => EMAdapter.em_jobs },
+                            :connections => EventMachine.connection_count },
 
         # thread pool
         :thread_pool => { :running => ThreadPool2Manager.thread_pool.running?,

data/lib/rjr/local_node.rb

@@ -8,6 +8,7 @@
 require 'rjr/node'
 require 'rjr/message'
 require 'rjr/dispatcher'
+require 'rjr/errors'
 
 module RJR
 
@@ -23,8 +24,11 @@ class LocalNodeCallback
   # Implementation of {RJR::NodeCallback#invoke}
   def invoke(callback_method, *data)
     # TODO any exceptions from handler will propagate here, surround w/ begin/rescue block
-    @node.invoke_request(callback_method, *data)
-    # TODO support local_node 'disconnections'
+    # TODO support local_node 'disconnections' via RJR::ConnectionError & triggering mechanism
+    ThreadPool2Manager <<
+      ThreadPool2Job.new(callback_method, data) { |m|
+        @node.local_dispatch(callback_method, *data)
+      }
   end
 end
 
@@ -50,6 +54,43 @@ class LocalNode < RJR::Node
   # allows clients to override the node type for the local node
   attr_accessor :node_type
 
+  # Helper method to locally dispatch method/args
+  #
+  # TODO would like to make private but needed in LocalNodeCallback
+  def local_dispatch(rpc_method, *args)
+    # create request from args
+    0.upto(args.size).each { |i| args[i] = args[i].to_s if args[i].is_a?(Symbol) }
+    message = RequestMessage.new :method => rpc_method,
+                                 :args   => args,
+                                 :headers => @message_headers
+
+    # here we serialize / unserialze messages to/from json to
+    # ensure local node complies to same json-rpc restrictions as other nodes
+    message = RequestMessage.new :message => message.to_s,
+                                 :headers => @message_headers
+
+    result = Dispatcher.dispatch_request(message.jr_method,
+                                         :method_args => message.jr_args,
+                                         :headers => @message_headers,
+                                         :rjr_node      => self,
+                                         :rjr_node_id   => @node_id,
+                                         :rjr_node_type => @node_type,
+                                         :rjr_callback =>
+                                           LocalNodeCallback.new(:node => self,
+                                                                 :headers => @message_headers))
+
+    # create response message from result
+    response = ResponseMessage.new(:id => message.msg_id,
+                                   :result => result,
+                                   :headers => @message_headers)
+
+    # same comment on serialization/unserialization as above
+    response = ResponseMessage.new(:message => response.to_s,
+                                   :headers => @message_headers)
+
+    response
+  end
+
   # LocalNode initializer
   # @param [Hash] args the options to create the local node with
   def initialize(args = {})
@@ -71,44 +112,39 @@ class LocalNode < RJR::Node
   #
   # Currently does nothing as method handlers can be invoked directly upon invoke_request
   def listen
-    em_run do
-    end
   end
 
   # Instructs node to send rpc request, and wait for and return response
+  #
+  # If strictly confirming to other nodes, use event machine to launch
+  # a thread pool job to dispatch request and block on result.
+  # Optimized for performance reasons but recognize the semantics of using
+  # the local node will be somewhat different.
+  #
   # @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
   # @return [Object] the json result retrieved from destination converted to a ruby object
   # @raise [Exception] if the destination raises an exception, it will be converted to json and re-raised here 
   def invoke_request(rpc_method, *args)
-    0.upto(args.size).each { |i| args[i] = args[i].to_s if args[i].is_a?(Symbol) }
-    message = RequestMessage.new :method => rpc_method,
-                                 :args   => args,
-                                 :headers => @message_headers
-
-    # we serialize / unserialze messages to ensure local node complies
-    # to same json-rpc restrictions as other nodes
-    message = RequestMessage.new :message => message.to_s,
-                                 :headers => @message_headers
-
-    result = Dispatcher.dispatch_request(message.jr_method,
-                                         :method_args => message.jr_args,
-                                         :headers => @message_headers,
-                                         :rjr_node      => self,
-                                         :rjr_node_id   => @node_id,
-                                         :rjr_node_type => @node_type,
-                                         :rjr_callback =>
-                                           LocalNodeCallback.new(:node => self,
-                                                                 :headers => @message_headers))
-    response = ResponseMessage.new(:id => message.msg_id,
-                                   :result => result,
-                                   :headers => @message_headers)
+    res = local_dispatch(rpc_method, *args) 
+    return Dispatcher.handle_response(res.result)
+  end
 
-    # same comment on serialization/unserialization as above
-    response = ResponseMessage.new(:message => response.to_s,
-                                   :headers => @message_headers)
-    return Dispatcher.handle_response(response.result)
+  # Instructs node to send rpc notification (immediately returns / no response is generated)
+  #
+  # Same performance comment as invoke_request above
+  #
+  # @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(rpc_method, *args)
+    # TODO run in thread & immediately return?
+    begin
+      local_dispatch(rpc_method, *args)
+    rescue
+    end
+    nil
   end
 
+
 end
 end

data/lib/rjr/message.rb

@@ -176,7 +176,7 @@ class ResponseMessage
       json.has_key?('result') || json.has_key?('error')
     rescue Exception => e
       # FIXME log error
-      #puts e.to_s
+      puts e.to_s
       false
     end
   end

data/lib/rjr/tcp_node.rb

@@ -13,6 +13,7 @@ require 'rjr/node'
 require 'rjr/message'
 require 'rjr/message'
 require 'rjr/dispatcher'
+require 'rjr/errors'
 require 'rjr/thread_pool2'
 
 module RJR
@@ -37,7 +38,7 @@ class TCPNodeCallback
   # Implementation of {RJR::NodeCallback#invoke}
   def invoke(callback_method, *data)
     msg = NotificationMessage.new :method => callback_method, :args => data, :headers => @message_headers
-    # TODO surround w/ begin/rescue block incase of socket errors
+    # TODO surround w/ begin/rescue block incase of socket errors / raise RJR::ConnectionError
     @endpoint.safe_send msg.to_s
   end
 end
@@ -298,6 +299,7 @@ class TCPNode < RJR::Node
     uri = URI.parse(uri)
     host,port = uri.host, uri.port
 
+    invoked = false
     conn    = nil
     message = NotificationMessage.new :method => rpc_method,
                                       :args   => args,
@@ -309,10 +311,10 @@ class TCPNode < RJR::Node
         c.safe_send message.to_s
         # XXX big bug w/ tcp node, this should be invoked only when
         # we are sure event machine sent message
-        published_l.synchronize { published_c.signal }
+        published_l.synchronize { invoked = true ; published_c.signal }
       }
     }
-    published_l.synchronize { published_c.wait published_l }
+    published_l.synchronize { published_c.wait published_l unless invoked }
     #sleep 0.01 until conn.get_outbound_data_size == 0
     nil
   end

data/lib/rjr/thread_pool2.rb

@@ -213,6 +213,7 @@ to#{@timeout}"
   # Add work to the pool
   # @param [ThreadPool2Job] work job to execute in first available thread
   def <<(work)
+    # TODO option to increase worker threads if work queue gets saturated
     @work_queue.push work
   end
 

data/lib/rjr/util.rb

@@ -32,7 +32,7 @@ module Definitions
       }
       nil
     else
-      RJR::Definitions.message(args)
+      RJR::Definitions.message(args.to_s)
     end
   end
 

data/lib/rjr/web_node.rb

@@ -247,16 +247,17 @@ class WebNode < RJR::Node
     published_l = Mutex.new
     published_c = ConditionVariable.new
 
+    invoked = false
     message = NotificationMessage.new :method => rpc_method,
                                       :args   => args,
                                       :headers => @message_headers
-    cb = lambda { |arg| published_l.synchronize { published_c.signal }}
+    cb = lambda { |arg| published_l.synchronize { invoked = true ; published_c.signal }}
     em_run do
       http = EventMachine::HttpRequest.new(uri).post :body => message.to_s
       http.errback  &cb
       http.callback &cb
     end
-    published_l.synchronize { published_c.wait published_l }
+    published_l.synchronize { published_c.wait published_l unless invoked }
     nil
   end
 end

data/lib/rjr/ws_node.rb

@@ -23,6 +23,7 @@ require 'socket'
 require 'rjr/node'
 require 'rjr/message'
 require 'rjr/dispatcher'
+require 'rjr/errors'
 require 'rjr/thread_pool2'
 
 module RJR
@@ -265,6 +266,7 @@ class WSNode < RJR::Node
     published_l = Mutex.new
     published_c = ConditionVariable.new
 
+    invoked = false
     message = NotificationMessage.new :method => rpc_method,
                                       :args   => args,
                                       :headers => @message_headers
@@ -275,10 +277,10 @@ class WSNode < RJR::Node
         # 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 }
+        published_l.synchronize { invoked = true ; published_c.signal }
       end
     }
-    published_l.synchronize { published_c.wait published_l }
+    published_l.synchronize { published_c.wait published_l unless invoked }
     nil
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rjr
 version: !ruby/object:Gem::Version
-  version: 0.11.7
+  version: 0.12.2
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-04-12 00:00:00.000000000 Z
+date: 2013-04-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec