rjr 0.9.0 → 0.11.7

data/lib/rjr/node.rb

@@ -7,7 +7,8 @@
 # newly created client, returning it after block terminates
 
 require 'eventmachine'
-require 'rjr/thread_pool'
+require 'rjr/em_adapter'
+require 'rjr/thread_pool2'
 
 module RJR
 
@@ -38,103 +39,114 @@ class Node
   # requests and responses received and sent by node
   attr_accessor :message_headers
 
-  # Nodes use internal thread pools to handle requests and free
-  # up the eventmachine reactor to continue processing requests
-  # @see ThreadPool
-  attr_reader :thread_pool
-
   # RJR::Node initializer
+  #
   # @param [Hash] args options to set on request
   # @option args [String] :node_id unique id of the node *required*!!!
   # @option args [Hash<String,String>] :headers optional headers to set on all json-rpc messages
   # @option args [Integer] :threads number of handler to threads to instantiate in local worker pool
   # @option args [Integer] :timeout timeout after which worker thread being run is killed
   def initialize(args = {})
-     RJR::Node.default_threads ||=  10
-     RJR::Node.default_timeout ||=  5
+     RJR::Node.default_threads ||=  20
+     RJR::Node.default_timeout ||=  10
 
      @node_id     = args[:node_id]
      @num_threads = args[:threads]  || RJR::Node.default_threads
      @timeout     = args[:timeout]  || RJR::Node.default_timeout
+     EMAdapter.init
 
      @message_headers = {}
      @message_headers.merge!(args[:headers]) if args.has_key?(:headers)
-
-     ObjectSpace.define_finalizer(self, self.class.finalize(self))
   end
 
-  # Ruby ObjectSpace finalizer to ensure that node terminates all
-  # operations when object is destroyed
-  def self.finalize(node)
-    proc { node.halt ; node.join }
+  # Initialize the node, should be called from the event loop
+  # before any operation
+  def init_node
+    EM.error_handler { |e|
+      puts "EventMachine raised critical error #{e} #{e.backtrace}"
+      # TODO dispatch to registered event handlers (unify events system)
+    }
   end
 
   # Run a job in event machine.
+  # @param [Callable] bl callback to be invoked by eventmachine
+  def em_run(&bl)
+    # Nodes use shared thread pool to handle requests and free
+    # up the eventmachine reactor to continue processing requests
+    # @see ThreadPool2, ThreadPool2Manager
+    ThreadPool2Manager.init @num_threads, :timeout => @timeout
+
+    # Nodes make use of an EM helper interface to schedule operations
+    EMAdapter.init
+
+    EMAdapter.schedule &bl
+  end
+
+  # Run a job async in event machine immediately
+  def em_run_async(&bl)
+    # same init as em_run
+    ThreadPool2Manager.init @num_threads, :timeout => @timeout
+    EMAdapter.init
+    EMAdapter.schedule {
+      ThreadPool2Manager << ThreadPool2Job.new { bl.call }
+    }
+  end
+
+  # TODO em_schedule
+
+  # Run an job async in event machine.
   #
-  # This will start the eventmachine reactor and thread pool if not already
-  # running, schedule the specified block to be run and immediately return.
+  # This schedules a thread to be run once after a specified
+  # interval via eventmachine
   #
-  # For use by subclasses to start listening and sending operations within
-  # the context of event machine.
+  # @param [Integer] seconds interval which to wait before invoking block
+  # @param [Callable] bl callback to be periodically invoked by eventmachine
+  def em_schedule_async(seconds, &bl)
+    # same init as em_run
+    ThreadPool2Manager.init @num_threads, :timeout => @timeout
+    EMAdapter.init
+    EMAdapter.add_timer(seconds) {
+      ThreadPool2Manager << ThreadPool2Job.new { bl.call }
+    }
+  end
+
+  # Run a job periodically via an event machine timer
   #
-  # Keeps track of an internal counter of how many times this was invoked so
-  # a specific node can be shutdown / started up without affecting the
-  # eventmachine reactor (@see #stop)
-  def em_run(&bl)
-    @@em_jobs ||= 0
-    @@em_jobs += 1
-
-    @@em_thread  ||= nil
-
-    unless !@thread_pool.nil? && @thread_pool.running?
-      # threads pool to handle incoming requests
-      @thread_pool = ThreadPool.new(@num_threads, :timeout => @timeout)
-    end
-
-    if @@em_thread.nil?
-      @@em_thread  =
-        Thread.new{
-          begin
-            EventMachine.run
-          rescue Exception => e
-            puts "Critical exception #{e}\n#{e.backtrace.join("\n")}"
-          ensure
-          end
-        }
-#sleep 0.5 until EventMachine.reactor_running? # XXX hacky way to do this
-    end
-    EventMachine.schedule bl
+  # @param [Integer] seconds interval which to invoke block
+  # @param [Callable] bl callback to be periodically invoked by eventmachine
+  def em_repeat(seconds, &bl)
+    # same init as em_run
+    ThreadPool2Manager.init @num_threads, :timeout => @timeout
+    EMAdapter.init
+    EMAdapter.add_periodic_timer seconds, &bl
   end
 
-  # Returns boolean indicating if this node is still running or not
-  def em_running?
-    @@em_jobs > 0 && EventMachine.reactor_running?
+  # Run an job async via an event machine timer.
+  #
+  # This schedules a thread to be run in the thread pool on
+  # every invocation of a periodic event machine timer.
+  #
+  # @param [Integer] seconds interval which to invoke block
+  # @param [Callable] bl callback to be periodically invoked by eventmachine
+  def em_repeat_async(seconds, &bl)
+    # same init as em_schedule
+    ThreadPool2Manager.init @num_threads, :timeout => @timeout
+    EMAdapter.init
+    EMAdapter.add_periodic_timer(seconds){
+      ThreadPool2Manager << ThreadPool2Job.new { bl.call }
+    }
   end
 
   # Block until the eventmachine reactor and thread pool have both completed running
   def join
-    @@em_thread.join if @@em_thread
-    @@em_thread = nil
-    @thread_pool.join if @thread_pool
-    @thread_pool = nil
-  end
-
-  # Decrement the event machine job counter and if equal to zero,
-  # immediately terminate the node
-  def stop
-    @@em_jobs -= 1
-    if @@em_jobs == 0
-      EventMachine.stop_event_loop
-      @thread_pool.stop
-    end
+    ThreadPool2Manager.join
+    EMAdapter.join
   end
 
-  # Immediately terminate the node, halting the eventmachine reactor and
-  # terminating the thread pool
+  # Immediately terminate the node
   def halt
-    @@em_jobs = 0
-    EventMachine.stop
-    @thread_pool.stop unless @thread_pool.nil?
+    EMAdapter.halt
+    ThreadPool2Manager.stop
   end
 
 end

data/lib/rjr/tcp_node.rb

@@ -6,10 +6,14 @@
 # Licensed under the Apache License, Version 2.0
 
 require 'uri'
+require 'socket'
 require 'eventmachine'
 
 require 'rjr/node'
 require 'rjr/message'
+require 'rjr/message'
+require 'rjr/dispatcher'
+require 'rjr/thread_pool2'
 
 module RJR
 
@@ -32,9 +36,9 @@ class TCPNodeCallback
 
   # Implementation of {RJR::NodeCallback#invoke}
   def invoke(callback_method, *data)
-    msg = RequestMessage.new :method => callback_method, :args => data, :headers => @message_headers
+    msg = NotificationMessage.new :method => callback_method, :args => data, :headers => @message_headers
     # TODO surround w/ begin/rescue block incase of socket errors
-    @endpoint.send_data msg.to_s
+    @endpoint.safe_send msg.to_s
   end
 end
 
@@ -42,42 +46,68 @@ end
 # Helper class intialized by eventmachine encapsulating a socket connection
 class TCPNodeEndpoint < EventMachine::Connection
 
+  attr_reader :host
+  attr_reader :port
+
   # TCPNodeEndpoint intializer
   #
-  # specify the TCPNode establishing the connection and an optional first message to send
+  # specify the TCPNode establishing the connection
   def initialize(args = {})
-    @rjr_node        = args[:rjr_node]
-
-    # these params should be set for clients
-    @send_message    = args[:init_message]
-  end
+    @rjr_node = args[:rjr_node]
+    @host = args[:host]
+    @port = args[:port]
 
-  # {EventMachine::Connection#post_init} callback, sends first message if specified
-  def post_init
-    unless @send_message.nil?
-      send_data @send_message.to_s
-      @send_message = nil
-    end
+    # used to serialize requests to send data via a connection
+    @send_lock = Mutex.new
   end
 
   # {EventMachine::Connection#receive_data} callback, handle request / response messages
   def receive_data(data)
-    if RequestMessage.is_request_message?(data)
-      @rjr_node.thread_pool << ThreadPoolJob.new { handle_request(data) }
+    # a large json-rpc message may be split over multiple packets (invocations of receive_data)
+    # and multiple messages may be concatinated into one packet
+    @data ||= ""
+    @data += data
+    while extracted = MessageUtil.retrieve_json(@data)
+      msg, @data = *extracted
+      if RequestMessage.is_request_message?(msg)
+        ThreadPool2Manager << ThreadPool2Job.new(msg) { |m| handle_request(m, false) }
+
+      elsif NotificationMessage.is_notification_message?(msg)
+        ThreadPool2Manager << ThreadPool2Job.new(msg) { |m| handle_request(m, true) }
 
-    elsif ResponseMessage.is_response_message?(data)
-      handle_response(data)
+      elsif ResponseMessage.is_response_message?(msg)
+        handle_response(msg)
 
+      end
     end
   end
 
+  # {EventMachine::Connection#unbind} callback, connection was closed
+  def unbind
+  end
+
+  # Helper to send data safely, this should be invoked instead of send_data
+  # in all cases
+  def safe_send(data)
+    @send_lock.synchronize{
+      send_data(data)
+    }
+  end
+
 
   private
 
   # Internal helper, handle request message received
-  def handle_request(data)
-    client_port, client_ip = Socket.unpack_sockaddr_in(get_peername)
-    msg    = RequestMessage.new(:message => data, :headers => @rjr_node.message_headers)
+  def handle_request(data, 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(get_peername)
+    rescue Exception=>e
+    end
+
+    msg    = notification ? NotificationMessage.new(:message => data, :headers => @rjr_node.message_headers) :
+                            RequestMessage.new(:message => data, :headers => @rjr_node.message_headers)
     headers = @rjr_node.message_headers.merge(msg.headers)
     result = Dispatcher.dispatch_request(msg.jr_method,
                                          :method_args => msg.jr_args,
@@ -90,8 +120,10 @@ class TCPNodeEndpoint < EventMachine::Connection
                                          :rjr_callback =>
                                            TCPNodeCallback.new(:endpoint => self,
                                                                :headers => headers))
-    response = ResponseMessage.new(:id => msg.msg_id, :result => result, :headers => headers)
-    send_data(response.to_s)
+    unless notification
+      response = ResponseMessage.new(:id => msg.msg_id, :result => result, :headers => headers)
+      safe_send(response.to_s)
+    end
   end
 
   # Internal helper, handle response message received
@@ -105,8 +137,9 @@ class TCPNodeEndpoint < EventMachine::Connection
     end
 
     @rjr_node.response_lock.synchronize {
-      @rjr_node.responses << [msg.msg_id, res]
-      @rjr_node.responses.last << err unless err.nil?
+      result = [msg.msg_id, res]
+      result << err if !err.nil?
+      @rjr_node.responses << result
       @rjr_node.response_cv.signal
     }
   end
@@ -135,13 +168,49 @@ end
 class TCPNode < RJR::Node
   RJR_NODE_TYPE = :tcp
 
+  attr_accessor :connections
+
   attr_accessor :response_lock
   attr_accessor :response_cv
   attr_accessor :responses
 
   private
-  # Initialize the tcp subsystem
-  def init_node
+  # Internal helper, initialize new connection
+  def init_node(args={}, &on_init)
+    host,port = args[:host], args[:port]
+    connection = nil
+    @connections_lock.synchronize {
+      connection = @connections.find { |c|
+                     port == c.port && host == c.host
+                   }
+      if connection.nil?
+        connection =
+          EventMachine::connect host, port,
+                      TCPNodeEndpoint, args
+        @connections << connection
+      end
+    }
+    on_init.call(connection)
+  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
@@ -154,10 +223,11 @@ class TCPNode < RJR::Node
      @host      = args[:host]
      @port      = args[:port]
 
+     @connections = []
+     @connections_lock = Mutex.new
+
      @response_lock = Mutex.new
      @response_cv   = ConditionVariable.new
-     @response_cv   = ConditionVariable.new
-     @response_check_cv   = ConditionVariable.new
      @responses     = []
 
      @connection_event_handlers = {:closed => [], :error => []}
@@ -178,12 +248,15 @@ class TCPNode < RJR::Node
   # Implementation of {RJR::Node#listen}
   def listen
     em_run {
-      init_node
       EventMachine::start_server @host, @port, TCPNodeEndpoint, { :rjr_node => self }
     }
   end
 
-  # Instructs node to send rpc request, and wait for / return response
+  # Instructs node to send rpc request, and wait for / return response.
+  #
+  # Do not invoke directly from em event loop or callback as will block the message
+  # subscription used to receive responses
+  #
   # @param [String] uri location of node to send request to, should be
   #   in format of jsonrpc://hostname:port
   # @param [String] rpc_method json-rpc method to invoke on destination
@@ -196,32 +269,52 @@ class TCPNode < RJR::Node
                                  :args   => args,
                                  :headers => @message_headers
     em_run{
-      init_node
-      EventMachine::connect host, port, TCPNodeEndpoint, { :rjr_node     => self,
-                                                           :init_message => message }
+      init_node(:host => host, :port => port,
+                :rjr_node => self) { |c|
+        c.safe_send message.to_s
+      }
     }
 
-    # wait for matching response
-    res = nil
-    while res.nil?
-      @response_lock.synchronize {
-        @response_cv.wait response_lock
-        res = @responses.select { |response| message.msg_id == response.first }.first
-        unless res.nil?
-          @responses.delete(res)
-        else
-          @response_cv.signal
-          @response_check_cv.wait @response_lock
-        end
-        @response_check_cv.signal
-      }
-    end
+    # TODO optional timeout for response ?
+    result = wait_for_result(message)
 
-    # raise error or return result
-    if res.size > 2
-      raise res[2]
+    if result.size > 2
+      raise Exception, result[2]
     end
-    return res[1]
+    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 jsonrpc://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
+
+    uri = URI.parse(uri)
+    host,port = uri.host, uri.port
+
+    conn    = nil
+    message = NotificationMessage.new :method => rpc_method,
+                                      :args   => args,
+                                      :headers => @message_headers
+    em_run{
+      init_node(:host => host, :port => port,
+                :rjr_node => self) { |c|
+        conn = c
+        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 { published_c.wait published_l }
+    #sleep 0.01 until conn.get_outbound_data_size == 0
+    nil
   end
 end
 

data/lib/rjr/tcp_node2.rb

@@ -0,0 +1,4 @@
+# TODO alternate tcp node that uses client other than
+# event machine to guarantee messages being sent to server but
+# forsaking client side request callbacks as a tradeoff (if necessary?)
+# (not to replace first tcp node, to be used in conjunction)