rjr 0.9.0 → 0.11.7

data/bin/rjr-client

@@ -0,0 +1,150 @@
+#!/usr/bin/ruby
+# RJR client
+#
+# Copyright (C) 2013 Mohammed Morsi <mo@morsi.org>
+# Licensed under the Apache License, Version 2.0
+
+require 'rubygems'
+require 'optparse'
+require 'rjr'
+
+RJR::Logger.log_level = ::Logger::DEBUG
+
+##########################################################
+
+
+MAX_MESSAGES   =  5 # only used when generating random number of messages
+MAX_INTERVAL   = 20 # only used when generating random interval
+MAX_DISCONNECT = 30 # only used when generating random disconnect
+
+config = { :mode       =>                    :msg,
+           :node_id    =>       'rjr_test_client',
+           :transport  =>                   :amqp,
+           :broker     =>             'localhost',
+           :dst        => 'rjr_test_server-queue',
+           :num_msg    =>                       1,
+           :msg_id     =>                   :rand,
+           :block      =>                   false,
+           :interval   =>                       0,
+           :disconnect =>                   false}
+
+optparse = OptionParser.new do |opts|
+  opts.on('-h', '--help', 'Display this help screen') do
+    puts opts
+    exit
+  end
+
+  opts.on('-m', '--mode mode', 'Mode of operation, default "msg" to send message, may be "rand" to send sequences of random bytes') do |mode|
+    config[:mode] = mode.intern
+  end
+
+  opts.on('-i', '--id ID', 'Node ID to assign to client') do |id|
+    config[:node_id] = id
+  end
+
+  opts.on('-t', '--transport type', 'Type of transport to connect to server') do |t|
+    config[:transport] = t.intern
+  end
+
+  opts.on('-b', '--broker broker', 'AMQP Broker (only needed if transport is amqp)') do |b|
+    config[:broker] = b
+  end
+
+  opts.on('--dst  dst', 'Destination which to connect to/send messages to') do |dst|
+    config[:dst] = dst
+  end
+
+  opts.on('-r', '--[no-]return', 'Boolean indicating if client should block/wait for server messages (default false)') do |ret|
+    config[:block] = !ret
+  end
+
+  opts.on('-n', '--num number_of_messages', 'Number of messages to send to server (may be :rand or indefinite)') do |n|
+    config[:num_msg] = case n.to_s.intern
+                       when :rand       then rand(MAX_MESSAGES)
+                       when :indefinite then 1000000000 # XXX 'indefinite ;-)'
+                       else n.to_i
+                       end
+  end
+
+  opts.on('--message ID', 'Message to send to server (rand to select random)') do |mid|
+    config[:msg_id] = mid
+  end
+
+  opts.on('--interval seconds', 'Number of seconds after which to wait between requests (or rand)') do |s|
+    config[:interval] = s.to_s.intern
+  end
+
+  opts.on('-d', '--disconnect seconds', OptionParser::DecimalNumeric, 'Number of seconds after which to disconnect client (or rand)') do |d|
+    config[:disconnect] = d.to_s.intern
+  end
+end
+
+optparse.parse!
+
+if config[:num_msg] < 1
+  puts "At least one message must be specified"
+  exit 1
+end
+
+##########################################################
+
+NODES = {config[:transport] => {:node_id    => config[:node_id],
+                                :broker     => config[:broker], # XXX only needed for amqp
+                                :keep_alive => true} }          # conditionally set keep alive?
+
+cdir          = File.dirname(__FILE__)
+client_path   = File.join(ENV['RJR_LOAD_PATH'] || File.join(cdir, '..', 'tests', 'harness'), "client")
+
+require_path client_path
+
+##########################################################
+
+node = RJR::EasyNode.new(NODES)
+
+if config[:disconnect]
+  disconnect_thread = Thread.new {
+    seconds = config[:disconnect] == :rand ? rand(MAX_DISCONNECT) : config[:disconnect].to_s.to_i
+    sleep seconds
+    # node.halt ?
+    exit 1
+  }
+end
+
+# invoke request(s)
+0.upto(config[:num_msg]-1) { |i|
+  # TODO implement mode == :rand
+
+  # grab message (or rand message)
+  msg = (config[:msg_id] == :rand ? RJR::Definitions.rand_msg(config[:transport]) :
+                                    RJR::Definitions.rjr_message(config[:msg_id]))
+
+  if msg.nil?
+    puts "Invalid message id"
+    exit 1
+  end
+
+  # manipulate msg params
+  parmas = []
+  params = msg[:params].collect { |p|
+    if p.is_a?(String)
+      p.gsub('<CLIENT_ID>', config[:node_id]) # TODO other substitutions
+    elsif p.is_a?(Proc)
+      p.call
+    else
+      p
+    end
+  } if msg[:params]
+
+  # invoke request
+  res = node.invoke_request(config[:dst], msg[:method], *params)
+
+  # verify and output result
+  ress = (msg[:result].nil? ? "" : (msg[:result].call(res) ? "passed" : "failed"))
+  RJR::Logger.info "#{msg[:method]} result #{res} #{ress}"
+
+  if msg[:interval] && i < (config[:num_msg] - 1)
+    sleep(msg[:interval] == :rand ? rand(MAX_INTERVAL) : msg[:interval].to_s.to_i)
+  end
+}
+
+node.join if config[:block]

data/bin/rjr-client-launcher

@@ -0,0 +1,38 @@
+#!/usr/bin/ruby
+# Launches a series of clients
+#
+# Copyright (C) 2013 Mohammed Morsi <mo@morsi.org>
+# Licensed under the Apache License, Version 2.0
+
+ID_OFFSET   = ARGV.shift.to_i || 100
+
+NUM_CLIENTS = 5
+NUM_MSGS    = 20 # per client
+NODE_ID     = 'rjr_test_launcher-'
+MSG_IDS     = ['stress', 'stress_callback']
+TRANSPORTS  = {#:amqp =>     'rjr_test_server-queue',
+               #:tcp  => 'jsonrpc://localhost:8181',
+               :ws   => 'jsonrpc://localhost:8080',
+               #:www  =>     'http://localhost:8888'
+              }
+BROKER      = 'localhost' # only used for amqp
+MSG_INTERVAL= 3
+
+CLIENT = File.join(File.dirname(__FILE__), 'rjr-client')
+
+threads = []
+
+0.upto(NUM_CLIENTS) { |i|
+  transport = TRANSPORTS.keys[rand(TRANSPORTS.keys.size)]
+  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}")
+    }
+}
+
+threads.each { |t| t.join }

data/bin/rjr-server

@@ -1,52 +1,74 @@
 #!/usr/bin/ruby
-# A rjr server executable
-# Executable to launch registered rjr methods 
+# RJR server
 #
-# Flags:
-#  -h --help
-#
-# Copyright (C) 2011-2012 Mohammed Morsi <mo@morsi.org>
+# Copyright (C) 2013 Mohammed Morsi <mo@morsi.org>
 # Licensed under the Apache License, Version 2.0
 
 require 'rubygems'
 require 'optparse'
 require 'rjr'
+require 'stringio'
 
-######################
+require 'rjr/inspect'
 
+##########################################################
 
-def main()
-  # setup cmd line options
-  opts = OptionParser.new do |opts|
-    opts.on("-h", "--help", "Print help message") do
-       puts opts
-       exit
-    end
-  end
+config = { :node_id  =>  'rjr_test_server',
+           :broker   =>        'localhost',
+           :host     =>        'localhost',
+           :tcp_port =>               8181,
+           :www_port =>               8888,
+           :ws_port  =>               8080 }
 
-  # parse cmd line
-  begin
-    opts.parse!(ARGV)
-  rescue OptionParser::InvalidOption
+optparse = OptionParser.new do |opts|
+  opts.on('-h', '--help', 'Display this help screen') do
     puts opts
     exit
   end
 
-  amqp_node = RJR::AMQPNode.new :node_id => 'rjr', :broker => 'localhost'
-  ws_node   = RJR::WSNode.new   :node_id => 'rjr', :host   => 'localhost', :port => 8080
-  www_node  = RJR::WebNode.new  :node_id => 'rjr', :host   => 'localhost', :port => 8888
+  opts.on('-i', '--id ID', 'Node ID to assign to server') do |id|
+    config[:node_id] = id
+  end
 
-  RJR::Dispatcher.add_handler('hello') { |msg|
-    #raise Exception.new("foobar")
-    puts "hello #{msg}"
-    "world"
-  }
+  opts.on('-b', '--broker broker', 'AMQP Broker') do |b|
+    config[:broker] = b
+  end
 
-  rjr_node = RJR::MultiNode.new :nodes => [amqp_node, ws_node, www_node]
+  opts.on('-h', '--host host', 'Host (or ip) which to listen on') do |h|
+    config[:host] = host
+  end
+
+  opts.on('--tcp port', 'TCP Port to listen on') do |p|
+    config[:tcp_port] = p
+  end
+
+  opts.on('--www port', 'Port to listen on for www requests') do |p|
+    config[:www_port] = p
+  end
+
+  opts.on('--ws port', 'Websocket Port to listen on') do |p|
+    config[:ws_port] = p
+  end
 
-  rjr_node.listen
-  rjr_node.join
-  rjr_node.stop # TODO run in signal handler
 end
 
-main()
+optparse.parse!
+
+##########################################################
+
+NODES = {:amqp  =>  {:node_id => config[:node_id], :broker => config[:broker]},
+         :ws    =>  {:node_id => config[:node_id], :host   => config[:host], :port => config[:ws_port]},
+         :www   =>  {:node_id => config[:node_id], :host   => config[:host], :port => config[:www_port]},
+         :tcp   =>  {:node_id => config[:node_id], :host   => config[:host], :port => config[:tcp_port]}}
+
+cdir          = File.dirname(__FILE__)
+server_path   = File.join(ENV['RJR_LOAD_PATH'] || File.join(cdir, '..', 'tests', 'harness'), 'server')
+require_path  server_path
+
+##########################################################
+
+$messages = StringIO.new
+
+RJR::Logger.log_level = ::Logger::DEBUG
+RJR::Logger.log_to $messages
+RJR::EasyNode.new(NODES).stop_on("INT").listen.join

data/lib/rjr/amqp_node.rb

@@ -5,10 +5,23 @@
 # Copyright (C) 2012 Mohammed Morsi <mo@morsi.org>
 # Licensed under the Apache License, Version 2.0
 
+skip_module = false
+begin
 require 'amqp'
-require 'thread'
+rescue LoadError
+  skip_module = true
+end
+
+if skip_module
+# TODO output: "amqp gem could not be loaded, skipping amqp node definition"
+require 'rjr/missing_node'
+RJR::AMQPNode = RJR::MissingNode
+
+else
 require 'rjr/node'
 require 'rjr/message'
+require 'rjr/dispatcher'
+require 'rjr/thread_pool2'
 
 module RJR
 
@@ -31,8 +44,8 @@ class AMQPNodeCallback
 
   # Implementation of {RJR::NodeCallback#invoke}
   def invoke(callback_method, *data)
-    msg = RequestMessage.new :method => callback_method, :args => data, :headers => @message_headers
-    @node.publish msg.to_s, :routing_key => @destination, :mandatory => true
+    msg = NotificationMessage.new :method => callback_method, :args => data, :headers => @message_headers
+    @node.publish(msg.to_s, :routing_key => @destination, :mandatory => true) { }
   end
 end
 
@@ -66,7 +79,11 @@ class  AMQPNode < RJR::Node
   def handle_message(metadata, msg)
     if RequestMessage.is_request_message?(msg)
       reply_to = metadata.reply_to
-      @thread_pool << ThreadPoolJob.new { handle_request(reply_to, msg) }
+      ThreadPool2Manager << ThreadPool2Job.new { handle_request(reply_to, msg, false) }
+
+    elsif NotificationMessage.is_notification_message?(msg)
+      reply_to = metadata.reply_to
+      ThreadPool2Manager << ThreadPool2Job.new { handle_request(reply_to, msg, true) }
 
     elsif ResponseMessage.is_response_message?(msg)
       handle_response(msg)
@@ -75,8 +92,9 @@ class  AMQPNode < RJR::Node
   end
 
   # Internal helper, handle request message pulled off queue
-  def handle_request(reply_to, message)
-    msg    = RequestMessage.new(:message => message, :headers => @message_headers)
+  def handle_request(reply_to, message, notification=false)
+    msg    = notification ? NotificationMessage.new(:message => message, :headers => @message_headers) :
+                            RequestMessage.new(:message => message, :headers => @message_headers)
     headers = @message_headers.merge(msg.headers) # append request message headers
     result = Dispatcher.dispatch_request(msg.jr_method,
                                          :method_args => msg.jr_args,
@@ -91,8 +109,10 @@ class  AMQPNode < RJR::Node
                                                                 :exchange => @exchange,
                                                                 :destination => reply_to,
                                                                 :headers => headers))
-    response = ResponseMessage.new(:id => msg.msg_id, :result => result, :headers => headers)
-    publish response.to_s, :routing_key => reply_to
+    unless notification
+      response = ResponseMessage.new(:id => msg.msg_id, :result => result, :headers => headers)
+      publish(response.to_s, :routing_key => reply_to) { }
+    end
   end
 
   # Internal helper, handle response message pulled off queue
@@ -102,7 +122,7 @@ class  AMQPNode < RJR::Node
     begin
       res = Dispatcher.handle_response(msg.result)
     rescue Exception => e
-      err = e
+      err = e.to_s
     end
 
     @response_lock.synchronize{
@@ -114,11 +134,20 @@ class  AMQPNode < RJR::Node
   end
 
   # Initialize the amqp subsystem
-  def init_node
-     return unless @conn.nil? || !@conn.connected?
-     @conn = AMQP.connect(:host => @broker)
+  def init_node(&on_init)
+     if !@conn.nil? && @conn.connected?
+       on_init.call
+       return
+     end
+
+     super
+     @conn = AMQP.connect(:host => @broker) do |*args|
+       on_init.call
+     end
      @conn.on_tcp_connection_failure { puts "OTCF #{@node_id}" }
 
+     # TODO move the rest into connect callback ?
+
      ### connect to qpid broker
      @channel = AMQP::Channel.new(@conn)
 
@@ -143,18 +172,15 @@ class  AMQPNode < RJR::Node
     res = nil
     while res.nil?
       @response_lock.synchronize{
-        @response_cv.wait @response_lock
         # FIXME throw err if more than 1 match found
         res = @responses.select { |response| message.msg_id == response.first }.first
-        unless res.nil?
+        if !res.nil?
           @responses.delete(res)
+
         else
-          # we can't just go back to waiting for message here, need to give
-          # other nodes a chance to check it first
           @response_cv.signal
-          @response_check_cv.wait @response_lock
+          @response_cv.wait @response_lock
         end
-        @response_check_cv.signal
       }
     end
     return res
@@ -194,7 +220,6 @@ class  AMQPNode < RJR::Node
      @connection_event_handlers = {:closed => [], :error => []}
      @response_lock = Mutex.new
      @response_cv   = ConditionVariable.new
-     @response_check_cv   = ConditionVariable.new
      @responses     = []
      @amqp_lock     = Mutex.new
   end
@@ -202,10 +227,12 @@ class  AMQPNode < RJR::Node
   # Publish a message using the amqp exchange (*do* *not* *use*).
   #
   # XXX hack should be private, declared publically so as to be able to be used by {RJR::AMQPNodeCallback}
-  def publish(*args)
+  def publish(*args, &on_publish)
     @amqp_lock.synchronize {
       #raise RJR::Errors::ConnectionError.new("client unreachable") if @disconnected
-      @exchange.publish *args
+      @exchange.publish *args do |*cargs|
+        on_publish.call
+      end
     }
     nil
   end
@@ -225,16 +252,20 @@ class  AMQPNode < RJR::Node
   # Implementation of {RJR::Node#listen}
   def listen
     em_run do
-      init_node
-
-      # start receiving messages
-      subscribe { |metadata, msg|
-        handle_message(metadata, msg)
+      init_node {
+        # start receiving messages
+        subscribe { |metadata, msg|
+          handle_message(metadata, msg)
+        }
       }
     end
   end
 
-  # Instructs node to send rpc request, and wait for and return response
+  # Instructs node to send rpc request, and wait for and return response.
+  #
+  # Do not invoke directly from em event loop or callback as will block the message
+  # subscription used to receive responses
+  #
   # @param [String] routing_key destination queue to send request to
   # @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
@@ -245,26 +276,53 @@ class  AMQPNode < RJR::Node
                                  :args   => args,
                                  :headers => @message_headers
     em_run do
-      init_node
+      init_node {
+        # begin listening for result
+        subscribe { |metadata, msg|
+          handle_message(metadata, msg)
+        }
 
-      # begin listening for result
-      subscribe { |metadata, msg|
-        handle_message(metadata, msg)
+        publish(message.to_s, :routing_key => routing_key, :reply_to => @queue_name) { }
       }
-
-      publish message.to_s, :routing_key => routing_key, :reply_to => @queue_name
     end
 
-    # TODO optional timeout for response ?
+    # TODO optional timeout for response
     result = wait_for_result(message)
-    #self.stop
-    #self.join unless self.em_running?
 
     if result.size > 2
-      raise result[2]
+      raise Exception, result[2]
     end
     return result[1]
   end
 
+  # FIXME add method to instruct node to send rpc request, and immediately
+  #        return / ignoring response & also add method to collect response
+  #        at a later time
+
+  # Instructs node to send rpc notification (immadiately returns / no response is generated)
+  #
+  # @param [String] routing_key destination queue to send request to
+  # @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(routing_key, 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 do
+      init_node {
+        publish(message.to_s, :routing_key => routing_key, :reply_to => @queue_name){
+          published_l.synchronize { published_c.signal }
+        }
+      }
+    end
+    published_l.synchronize { published_c.wait published_l }
+    nil
+  end
+
+end
 end
 end

data/lib/rjr/common.rb

@@ -1,4 +1,4 @@
-# RJR Utility Methods
+# Low level RJR Utility Methods
 #
 # Assortment of helper methods and methods that don't fit elsewhere
 #
@@ -14,17 +14,20 @@ module RJR
 # Encapsulates the standard ruby logger in a thread safe manner. Dispatches
 # class methods to an internally tracked logger to provide global access.
 #
+# TODO handle logging errors (log size too big, logrotate, etc)
+#
 # @example
 #   RJR::Logger.info 'my message'
 #   RJR::Logger.warn 'my warning'
 class Logger
   private
     def self._instantiate_logger
-       unless defined? @@logger
+       if @logger.nil?
          #STDOUT.sync = true
-         @@logger = ::Logger.new(STDOUT)
-         @@logger.level = ::Logger::FATAL
-         @@logger_mutex = Mutex.new
+         output = @log_to || ENV['RJR_LOG'] || STDOUT
+         @logger = ::Logger.new(output)
+         @logger.level = @log_level || ::Logger::FATAL
+         @logger_mutex = Mutex.new
        end 
     end 
 
@@ -32,32 +35,79 @@ class Logger
 
     def self.method_missing(method_id, *args)
        _instantiate_logger
-       @@logger_mutex.synchronize {
+       @logger_mutex.synchronize {
          if args.first.is_a?(Array)
            args.first.each{ |a|
-             @@logger.send(method_id, a)
+             @logger.send(method_id, a)
            }
          else
-           @@logger.send(method_id, args)
+           @logger.send(method_id, args)
          end
        }
     end 
 
     def self.logger
        _instantiate_logger
-       @@logger
+       @logger
+    end
+
+    # Set log destination
+    # @param dst destination which to log to (file name, STDOUT, etc)
+    def self.log_to(dst)
+      @log_to = dst
+      @logger = nil
+      _instantiate_logger
     end
 
     # Set log level.
     # @param level one of the standard rails log levels (default fatal)
     def self.log_level=(level)
       _instantiate_logger
-      @@logger.level = level
+      if level.is_a?(String)
+        level = case level
+                when 'debug' then
+                  ::Logger::DEBUG
+                when 'info' then
+                  ::Logger::INFO
+                when 'warn' then
+                  ::Logger::WARN
+                when 'error' then
+                  ::Logger::ERROR
+                when 'fatal' then
+                  ::Logger::FATAL
+                end
+      end
+      @log_level    = level
+      @logger.level = level
+    end
+
+    # Return true if log level is set to debug, else false
+    def self.debug?
+      @log_level == ::Logger::DEBUG
     end
 end
 
 end # module RJR
 
+class Object
+  def eigenclass
+    class << self
+      self
+    end
+  end
+end
+
+module Kernel
+  def require_path(path)
+    path.split(':').all? { |dir|
+      # TODO also all .so files? allow user to specify suffix or omit?
+      Dir.glob(File.join(dir, '*.rb')).all? { |rb|
+        require rb
+      }
+    }
+  end
+end
+
 if RUBY_VERSION < "1.9"
 # We extend object in ruby 1.9 to define 'instance_exec'
 #