rjr 0.15.1 → 0.16.1

data/bin/rjr-client

@@ -6,7 +6,7 @@
 
 require 'optparse'
 require 'rjr/common'
-require 'rjr/messages'
+require 'rjr/message'
 require 'rjr/nodes/easy'
 
 RJR::Logger.log_level = ::Logger::DEBUG
@@ -59,7 +59,7 @@ optparse = OptionParser.new do |opts|
     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|
+  opts.on('-n', '--num number_of_messages', 'Number of messages to send to server (may be a number, :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 ;-)'
@@ -99,7 +99,9 @@ client_path   = File.join(ENV['RJR_LOAD_PATH'] || File.join(cdir, '..', 'example
 ##########################################################
 
 node = RJR::Nodes::Easy.new(NODES)
-node.dispatcher.add_modules(client_path)
+client_path.split(':').each { |cp|
+  node.dispatcher.add_modules(cp)
+}
 
 if config[:disconnect]
   disconnect_thread = Thread.new {

data/lib/rjr/common.rb

@@ -4,7 +4,6 @@
 #
 # Copyright (C) 2011-2013 Mohammed Morsi <mo@morsi.org>
 # Licensed under the Apache License, Version 2.0
-
 require 'logger'
 
 # Return a random uuid
@@ -34,24 +33,51 @@ class Logger
          @logger = ::Logger.new(output)
          @logger.level = @log_level || ::Logger::FATAL
          @logger_mutex = Mutex.new
+         @filters = []
+         @highlights = []
        end 
     end 
 
   public
 
+    # Add method which to call on every log message to determine
+    # if messages should be included/excluded
+    def self.add_filter(filter)
+      @logger_mutex.synchronize{
+        @filters << filter
+      }
+    end
+
+    # Add a method which to call on every log message to determine
+    # if message should be highlighted
+    def self.highlight(hlight)
+      @logger_mutex.synchronize{
+        @highlights << hlight
+      }
+    end
+
     def self.method_missing(method_id, *args)
        _instantiate_logger
        @logger_mutex.synchronize {
-         if args.first.is_a?(Array)
-           args.first.each{ |a|
-             @logger.send(method_id, a)
-           }
-         else
-           @logger.send(method_id, args)
-         end
+         args = args.first if args.first.is_a?(Array)
+         args.each { |a|
+           # run highlights / filters against output before
+           # sending formatted output to logger
+           # TODO allow user to customize highlight mechanism/text
+           na = @highlights.any? { |h| h.call a } ?
+                  "\e[1m\e[31m#{a}\e[0m\e[0m" : a
+           @logger.send(method_id, na) if @filters.all? { |f| f.call a }
+         }
        }
     end 
 
+    def self.safe_exec(*args, &bl)
+      _instantiate_logger
+      @logger_mutex.synchronize {
+        bl.call *args
+      }
+    end
+
     def self.logger
        _instantiate_logger
        @logger
@@ -95,6 +121,13 @@ end
 
 end # module RJR
 
+# Serialized puts, uses logger lock to serialize puts output
+def sputs(*args)
+  ::RJR::Logger.safe_exec {
+    puts *args
+  }
+end
+
 class Object
   def eigenclass
     class << self

data/lib/rjr/dispatcher.rb

@@ -135,9 +135,16 @@ class Request
   # Invoke the request by calling the registered handler with the registered
   # method parameters in the local scope
   def handle
-    RJR::Logger.info "Dispatching '#{@rjr_method}' request with parameters (#{@rjr_method_args.join(',')}) on #{@rjr_node_type}-node(#{@rjr_node_id})"
+    node_sig   = "#{@rjr_node_id}(#{@rjr_node_type})"
+    method_sig = "#{@rjr_method}(#{@rjr_method_args.join(',')})"
+
+    RJR::Logger.info "#{node_sig}->#{method_sig}"
+
     retval = instance_exec(*@rjr_method_args, &@rjr_handler)
-    RJR::Logger.info "#{@rjr_method} request with parameters (#{@rjr_method_args.join(',')}) returning #{retval}"
+
+    RJR::Logger.info \
+      "#{node_sig}<-#{method_sig}<-#{retval.nil? ? "nil" : retval}"
+
     return retval
   end
 
@@ -174,12 +181,16 @@ class Dispatcher
   # Registered json-rpc request signatures and corresponding handlers
   attr_reader :handlers
 
+  # Registered json-rpc request signatures and environments which to execute handlers in
+  attr_reader :environments
+
   # Requests which have been dispatched
   def requests ; @requests_lock.synchronize { Array.new(@requests) } ; end
 
   # RJR::Dispatcher intializer
   def initialize
     @handlers = Hash.new()
+    @environments = Hash.new()
 
     @requests_lock = Mutex.new
     @requests = []
@@ -194,57 +205,88 @@ class Dispatcher
   #   a file, directory, or path specification (dirs seperated with ':')
   # @return self
   def add_module(name)
-    name.split(':').each { |p|
-      if File.directory?(p)
-        # TODO also .so files? allow user to specify suffix
-        Dir.glob(File.join(p, '*.rb')).all? { |m|
-          require m
-        }
+    require name
 
-      else
-        require p
+    m = name.downcase.gsub(File::SEPARATOR, '_')
+    method("dispatch_#{m}".intern).call(self)
 
-      end
-
-      m = p.split(File::SEPARATOR).last
-      method("dispatch_#{m}".intern).call(self)
-    }
     self
   end
   alias :add_modules :add_module
 
   # Register json-rpc handler with dispatcher
   #
-  # @param [String] signature request signature to match
+  # @param [String,Regex] signature request signature to match
   # @param [Callable] callable callable object which to bind to signature
   # @param [Callable] &bl block parameter will be set to callback if specified
   # @return self
   def handle(signature, callback = nil, &bl)
     if signature.is_a?(Array)
       signature.each { |s| handle(s, callback, &bl) }
-      return
+      return self
     end
     @handlers[signature] = callback unless callback.nil?
     @handlers[signature] = bl       unless bl.nil?
     self
   end
 
+  # Return boolean indicating if dispatcher can handle method
+  #
+  # @param [String] string rjr method to match
+  # @return [true,false] indicating if requests to specified method will be matched
+  def handles?(rjr_method)
+     !@handlers.find { |k,v|
+       k.is_a?(String)         ?
+       k == rjr_method :
+       k =~ rjr_method
+     }.nil?
+  end
+
+  # Register environment to run json-rpc handler w/ dispatcher.
+  #
+  # Currently environments may be set to modules which requests
+  # will extend before executing handler
+  #
+  # @param [String,Regex] signature request signature to match
+  # @param [Module] module which to extend requests with
+  # @return self
+  def env(signature, environment)
+    if signature.is_a?(Array)
+      signature.each { |s| env(s, environment) }
+      return self
+    end
+    @environments[signature] = environment
+    self
+  end
+
   # Dispatch received request. (used internally by nodes).
   #
   # Arguments should include :rjr_method and other parameters
   # required to construct a valid Request instance
   def dispatch(args = {})
-     # currently we just match method name against signature
-     # TODO if signature if a regex, match against method name
-     #      or if callable, invoke it w/ request checking boolean return value for match
-     # TODO not using concurrent access portection, assumes all handlers are registered
+     # currently we match method name string or regex against signature
+     # TODO not using concurrent access protection, assumes all handlers are registered
      #      before first dispatch occurs
-     handler = @handlers[args[:rjr_method]]
+     handler = @handlers.find { |k,v|
+       k.is_a?(String)         ?
+       k == args[:rjr_method] :
+       k =~ args[:rjr_method] }
+
+     # TODO currently just using last environment that matches,
+     #      allow multiple environments to be used?
+     environment = @environments.keys.select { |k|
+       k.is_a?(String)         ?
+       k == args[:rjr_method] :
+       k =~ args[:rjr_method]
+     }.last
 
      return Result.method_not_found(args[:rjr_method]) if handler.nil?
 
      # TODO compare arity of handler to number of method_args passed in
-     request = Request.new args.merge(:rjr_handler  => handler)
+     request = Request.new args.merge(:rjr_handler  => handler.last)
+
+     # set request environment
+     request.extend(@environments[environment]) unless environment.nil?
 
      begin
        retval  = request.handle

data/lib/rjr/em_adapter.rb

@@ -3,7 +3,6 @@
 # Copyright (C) 2012-2013 Mohammed Morsi <mo@morsi.org>
 # Licensed under the Apache License, Version 2.0
 
-require 'singleton'
 require 'eventmachine'
 
 module RJR
@@ -11,8 +10,6 @@ module RJR
 # EventMachine adapater interface, ties reactor
 # lifecycle to an instance of this class.
 class EMAdapter
-  include Singleton
-
   # Run reactor in its own interally managed thread
   attr_accessor :reactor_thread
 

data/lib/rjr/{stats.rb → inspect.rb}

@@ -8,6 +8,14 @@
 # Copyright (C) 2013 Mohammed Morsi <mo@morsi.org>
 # Licensed under the Apache License, Version 2.0
 
+# TODO
+# - data received/sent (on different interfaces)
+# - messages received/sent (on different interfaces)
+# - dispatches on a per node basis
+# - unresolved/invalid dispatches/messages
+# - em jobs
+# - thread pool jobs (started / completed / etc)
+
 require 'eventmachine'
 
 # Helper method to process user params / select stats
@@ -37,34 +45,51 @@ def select_stats(dispatcher, *filter)
   dispatcher.requests.select { |ds| lf.all? { |lfi| lfi.call(ds) } }
 end
 
-# Add stats methods to specified dispatcher
-def dispatch_stats(dispatcher)
+# Add inspection methods to specified dispatcher
+def dispatch_rjr_inspect(dispatcher)
   # Retrieve all the dispatches this node served matching the specified criteri
   dispatcher.handle "rjr::dispatches" do |filter|
-    select_stats(*filter) 
+    select_stats(dispatcher, *filter) 
   end
 
   # Retrieve the number of dispatches this node served matching the specified criteria
   dispatcher.handle "rjr::num_dispatches" do |filter|
-    select_stats(*filter).size
+    select_stats(dispatcher, *filter).size
   end
 
   # Retrieve the internal status of this node
   dispatcher.handle "rjr::status" do
+    nodes = []
+    ObjectSpace.each_object RJR::Node do |node|
+      nodes << node.to_s
+    end
+
     {
+      # nodes
+      :nodes => nodes,
+
+      # dispatcher
+      :dispatcher => {
+        :requests => dispatcher.requests.size,
+        :handlers =>
+          dispatcher.handlers.keys,
+          #dispatcher.handlers.collect { |k,v|
+          #  [k, v.source_location] },
+        :environments => dispatcher.environments
+      },
+
       # event machine
       :event_machine => { :running => EventMachine.reactor_running?,
-                          :thread_status => RJR::EMAdapter.instance.rector_thread ?
-                                            RJR::EMAdapter.instance.reactor_thread.status :
-                                                                    nil,
+                          :thread_status =>
+                           (RJR::Node.em && RJR::Node.em.reactor_thread) ?
+                                RJR::Node.em.reactor_thread.status : nil,
                           :connections => EventMachine.connection_count },
 
       # thread pool
-      :thread_pool => { :running => RJR::ThreadPool.instance.running? }
+      :thread_pool => { :running => RJR::Node.tp ? RJR::Node.tp.running? : nil }
     }
   end
 
   #:log =>
   #  lambda {},
 end
-

data/lib/rjr/message.rb

@@ -5,8 +5,9 @@
 # Copyright (C) 2012-2013 Mohammed Morsi <mo@morsi.org>
 # Licensed under the Apache License, Version 2.0
 
-# establish client connection w/ specified args and invoke block w/ 
-# newly created client, returning it after block terminates
+# FIXME https://github.com/flori/json/issues/179
+#   if pull request doesn't get accepted implement
+#   one of the workarounds in rjr
 
 require 'json'
 require 'rjr/common'

data/lib/rjr/node.rb

@@ -44,6 +44,15 @@ class Node
   # Dispatcher to use to satisfy requests
   attr_accessor :dispatcher
 
+  # alias of RJR_NODE_TYPE
+  def node_type
+    self.class::RJR_NODE_TYPE
+  end
+
+  # XXX used by debugging / stats interface
+  def self.em ; defined?(@@em) ? @@em : nil end
+  def self.tp ; defined?(@@tp) ? @@tp : nil end
+
   # RJR::Node initializer
   #
   # @param [Hash] args options to set on request
@@ -60,16 +69,20 @@ class Node
      @dispatcher      = args[:dispatcher] || RJR::Dispatcher.new
      @message_headers = args.has_key?(:headers) ? {}.merge(args[:headers]) : {}
 
-     @tp = ThreadPool.instance.start
-     @em = EMAdapter.instance.start
+     @@tp ||= ThreadPool.new
+     @@em ||= EMAdapter.new
+
+     # will do nothing if already started
+     @@tp.start
+     @@em.start
   end
 
   # Block until the eventmachine reactor and thread pool have both completed running
   #
   # @return self
   def join
-    @tp.join
-    @em.join
+    @@tp.join
+    @@em.join
     self
   end
 
@@ -80,8 +93,8 @@ class Node
   #
   # @return self
   def halt
-    @em.stop_event_loop
-    @tp.stop
+    @@em.stop_event_loop
+    @@tp.stop
     self
   end
 
@@ -113,10 +126,10 @@ class Node
   # Internal helper, handle message received
   def handle_message(msg, connection = {})
     if RequestMessage.is_request_message?(msg)
-      @tp << ThreadPoolJob.new(msg) { |m| handle_request(m, false, connection) }
+      @@tp << ThreadPoolJob.new(msg) { |m| handle_request(m, false, connection) }
 
     elsif NotificationMessage.is_notification_message?(msg)
-      @tp << ThreadPoolJob.new(msg) { |m| handle_request(m, true, connection) }
+      @@tp << ThreadPoolJob.new(msg) { |m| handle_request(m, true, connection) }
 
     elsif ResponseMessage.is_response_message?(msg)
       handle_response(msg)
@@ -142,12 +155,12 @@ class Node
       NotificationMessage.new(:message => data,
                               :headers => @message_headers) :
             RequestMessage.new(:message => data,
-                              :headers => @message_headers)
+                               :headers => @message_headers)
 
     result =
       @dispatcher.dispatch(:rjr_method      => msg.jr_method,
                            :rjr_method_args => msg.jr_args,
-                           :headers         => msg.headers,
+                           :rjr_headers     => msg.headers,
                            :rjr_client_ip   => client_ip,
                            :rjr_client_port => client_port,
                            :rjr_node        => self,
@@ -164,6 +177,8 @@ class Node
       self.send_msg(response.to_s, connection)
       return response
     end
+
+    nil
   end
 
   # Internal helper, handle response message received

data/lib/rjr/nodes/amqp.rb

@@ -61,30 +61,33 @@ class AMQP < RJR::Node
        return
      end
 
-     @conn = ::AMQP.connect(:host => @broker) do |*args|
-       on_init.call
-     end
-     @conn.on_tcp_connection_failure { puts "OTCF #{@node_id}" }
+     @conn = ::AMQP.connect(:host => @broker) do |conn|
+       ::AMQP.connection = conn # XXX not sure why this is needed but the amqp
+                                # em interface won't shut down cleanly otherwise
+
+       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)
 
-     ### connect to qpid broker
-     @channel = ::AMQP::Channel.new(@conn)
+       # qpid constructs that will be created for node
+       @queue_name  = "#{@node_id.to_s}-queue"
+       @queue       = @channel.queue(@queue_name, :auto_delete => true)
+       @exchange    = @channel.default_exchange
 
-     # qpid constructs that will be created for node
-     @queue_name  = "#{@node_id.to_s}-queue"
-     @queue       = @channel.queue(@queue_name, :auto_delete => true)
-     @exchange    = @channel.default_exchange
+       @listening = false
+       #@disconnected = false
 
-     @listening = false
-     #@disconnected = false
+       @exchange.on_return do |basic_return, metadata, payload|
+           puts "#{payload} was returned! reply_code = #{basic_return.reply_code}, reply_text = #{basic_return.reply_text}"
+           #@disconnected = true # FIXME member will be set on wrong class
+           # TODO these are only run when we fail to send message to queue,
+           # need to detect when that queue is shutdown & other events
+           connection_event(:error)
+           connection_event(:closed)
+       end
 
-     @exchange.on_return do |basic_return, metadata, payload|
-         puts "#{payload} was returned! reply_code = #{basic_return.reply_code}, reply_text = #{basic_return.reply_text}"
-         #@disconnected = true # FIXME member will be set on wrong class
-         # TODO these are only run when we fail to send message to queue, need to detect when that queue is shutdown & other events
-         connection_event(:error)
-         connection_event(:closed)
+       on_init.call
      end
   end
 
@@ -116,6 +119,10 @@ class AMQP < RJR::Node
      @amqp_lock     = Mutex.new
   end
 
+  def to_s
+    "RJR::Nodes::AMQP<#{@node_id},#{@broker},#{@queue_name}>"
+  end
+
   # Publish a message using the amqp exchange
   #
   # Implementation of {RJR::Node#send_msg}
@@ -137,7 +144,7 @@ class AMQP < RJR::Node
   #
   # Implementation of {RJR::Node#listen}
   def listen
-    @em.schedule do
+    @@em.schedule do
       init_node {
         subscribe # start receiving messages
       }
@@ -161,7 +168,7 @@ class AMQP < RJR::Node
     message = RequestMessage.new :method => rpc_method,
                                  :args   => args,
                                  :headers => @message_headers
-    @em.schedule do
+    @@em.schedule do
       init_node {
         subscribe # begin listening for result
         send_msg(message.to_s, :routing_key => routing_key, :reply_to => @queue_name)
@@ -197,7 +204,7 @@ class AMQP < RJR::Node
     message = NotificationMessage.new :method => rpc_method,
                                       :args   => args,
                                       :headers => @message_headers
-    @em.schedule do
+    @@em.schedule do
       init_node {
         send_msg(message.to_s, :routing_key => routing_key, :reply_to => @queue_name){
           published_l.synchronize { invoked = true ; published_c.signal }

data/lib/rjr/nodes/local.rb

@@ -26,7 +26,7 @@ module Nodes
 #
 # @example Listening for and dispatching json-rpc requests locally
 #   # initialize node
-#   node = RJR::LocalNode.new :node_id => 'node'
+#   node = RJR::Nodes::Local.new :node_id => 'node'
 #
 #   node.dispatcher.handle('hello') do |name|
 #     @rjr_node_type == :local ? "Hello superuser #{name}" : "Hello #{name}!"
@@ -41,13 +41,17 @@ class Local < RJR::Node
   # allows clients to override the node type for the local node
   attr_accessor :node_type
 
-  # LocalNode initializer
+  # Nodes::Local initializer
   # @param [Hash] args the options to create the local node with
   def initialize(args = {})
      super(args)
      @node_type = RJR_NODE_TYPE
   end
 
+  def to_s
+    "RJR::Nodes::Local<#{@node_id}>"
+  end
+
   # Send data using specified connection.
   #
   # Simply dispatch local notification.
@@ -55,8 +59,8 @@ class Local < RJR::Node
   # Implementation of {RJR::Node#send_msg}
   def send_msg(msg, connection)
     # ignore response message
-    unless msg.is_a?(ResponseMessage)
-      handle_request(msg, true, nil)
+    unless ResponseMessage.is_response_message?(msg)
+      launch_request(msg, true) # .join?
     end
   end
 
@@ -68,6 +72,18 @@ class Local < RJR::Node
     self
   end
 
+  # Helper to launch request in new thread
+  #
+  # This needs to happen so that each request runs in its own context
+  # (or close to it, globals will still be available, but locks will
+  #  not be locally held, etc)
+  def launch_request(req, notification)
+    Thread.new(req,notification) { |req,notification|
+      res = handle_request(req, notification, nil)
+      handle_response(res.to_s) unless res.nil?
+    }
+  end
+
   # Instructs node to send rpc request, and wait for and return response
   #
   # Implementation of {RJR::Node#invoke}
@@ -85,9 +101,16 @@ class Local < RJR::Node
     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).to_s
-    res = handle_request(message, false, nil)
-    return @dispatcher.handle_response(res.result)
+                                 :headers => @message_headers)
+    launch_request(message.to_s, false)
+
+    # TODO optional timeout for response ?
+    res = wait_for_result(message)
+
+    if res.size > 2
+      raise Exception, res[2]
+    end
+    return res[1]
   end
 
   # Instructs node to send rpc notification (immediately returns / no response is generated)
@@ -99,15 +122,11 @@ class Local < 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 notify(rpc_method, *args)
-    # TODO run in thread & immediately return?
-    begin
-      0.upto(args.size).each { |i| args[i] = args[i].to_s if args[i].is_a?(Symbol) }
-      message = NotificationMessage.new(:method => rpc_method,
-                                        :args   => args,
-                                        :headers => @message_headers).to_s
-      handle_request(message, true, nil)
-    rescue
-    end
+    0.upto(args.size).each { |i| args[i] = args[i].to_s if args[i].is_a?(Symbol) }
+    message = NotificationMessage.new(:method => rpc_method,
+                                      :args   => args,
+                                      :headers => @message_headers)
+    launch_request(message.to_s, true) #.join ?
     nil
   end
 

data/lib/rjr/nodes/multi.rb

@@ -56,6 +56,10 @@ class Multi < RJR::Node
     } if args[:nodes]
   end
 
+  def to_s
+    "RJR::Nodes::Multi<#{@node_id}>"
+  end
+
   # Add node to multinode
   # @param [RJR::Node] node the node to add
   def <<(node)

data/lib/rjr/nodes/ssh.rb

@@ -0,0 +1 @@
+# TODO

data/lib/rjr/nodes/tcp.rb

@@ -116,6 +116,10 @@ class TCP < RJR::Node
      @connections_lock = Mutex.new
   end
 
+  def to_s
+    "RJR::Nodes::TCP<#{@node_id},#{@host},#{@port}>"
+  end
+
   # Send data using specified connection
   #
   # Implementation of {RJR::Node#send_msg}
@@ -127,8 +131,8 @@ class TCP < RJR::Node
   #
   # Implementation of {RJR::Node#listen}
   def listen
-    @em.schedule {
-      @em.start_server @host, @port, TCPConnection, { :rjr_node => self }
+    @@em.schedule {
+      @@em.start_server @host, @port, TCPConnection, { :rjr_node => self }
     }
     self
   end
@@ -152,7 +156,7 @@ class TCP < RJR::Node
                                  :args   => args,
                                  :headers => @message_headers
     connection = nil
-    @em.schedule {
+    @@em.schedule {
       init_client(:host => host, :port => port,
                   :rjr_node => self) { |c|
         connection = c
@@ -190,7 +194,7 @@ class TCP < RJR::Node
     message = NotificationMessage.new :method => rpc_method,
                                       :args   => args,
                                       :headers => @message_headers
-    @em.schedule {
+    @@em.schedule {
       init_client(:host => host, :port => port,
                   :rjr_node => self) { |c|
         conn = c

data/lib/rjr/nodes/web.rb

@@ -103,6 +103,10 @@ class Web < RJR::Node
      @port      = args[:port]
   end
 
+  def to_s
+    "RJR::Nodes::Web<#{@node_id},#{@host},#{@port}>"
+  end
+
   # Send data using specified http connection
   #
   # Implementation of {RJR::Node#send_msg}
@@ -123,7 +127,7 @@ class Web < RJR::Node
   #
   # Implementation of {RJR::Node#listen}
   def listen
-    @em.schedule do
+    @@em.schedule do
       EventMachine::start_server(@host, @port, WebConnection, :rjr_node => self)
     end
     self
@@ -149,7 +153,7 @@ class Web < RJR::Node
       handle_message(http.response, http)
     }
 
-    @em.schedule do
+    @@em.schedule do
       http = EventMachine::HttpRequest.new(uri).post :body => message.to_s
       http.errback  &cb
       http.callback &cb
@@ -182,7 +186,7 @@ class Web < RJR::Node
                                       :args   => args,
                                       :headers => @message_headers
     cb = lambda { |arg| published_l.synchronize { invoked = true ; published_c.signal }}
-    @em.schedule do
+    @@em.schedule do
       http = EventMachine::HttpRequest.new(uri).post :body => message.to_s
       http.errback  &cb
       http.callback &cb

data/lib/rjr/nodes/ws.rb

@@ -93,6 +93,10 @@ class WS < RJR::Node
      @connections_lock = Mutex.new
   end
 
+  def to_s
+    "RJR::Nodes::WS<#{@node_id},#{@host},#{@port}>"
+  end
+
   # Send data using specified websocket safely
   #
   # Implementation of {RJR::Node#send_msg}
@@ -104,8 +108,8 @@ class WS < RJR::Node
   #
   # Implementation of {RJR::Node#listen}
   def listen
-    @em.schedule do
-      EventMachine::WebSocket.start(:host => @host, :port => @port) do |ws|
+    @@em.schedule do
+      EventMachine::WebSocket.run(: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 } }
@@ -131,7 +135,7 @@ class WS < RJR::Node
                                  :args   => args,
                                  :headers => @message_headers
 
-    @em.schedule {
+    @@em.schedule {
       init_client(uri) do |c|
         c.stream { |msg| handle_message(msg, c) }
 
@@ -165,7 +169,7 @@ class WS < RJR::Node
     message = NotificationMessage.new :method => rpc_method,
                                       :args   => args,
                                       :headers => @message_headers
-    @em.schedule {
+    @@em.schedule {
       init_client(uri) do |c|
         c.stream { |msg| handle_message(msg, c) }
 

data/lib/rjr/thread_pool.rb

@@ -3,8 +3,6 @@
 # Copyright (C) 2010-2013 Mohammed Morsi <mo@morsi.org>
 # Licensed under the Apache License, Version 2.0
 
-require 'singleton'
-
 module RJR
 
 # Work item to be executed in a thread launched by {ThreadPool}.
@@ -81,8 +79,6 @@ end
 # Supports optional timeout which allows the user to kill and restart
 # threads if a job is taking too long to run.
 class ThreadPool
-  include Singleton
-
   class << self
     # @!group Config options (must be set before first node is instantiated)
 

data/site/jrw.js

@@ -120,7 +120,7 @@ function JRObject (type, value, ignore_properties){
   this.type  = type;
   this.value = value;
   this.ignore_properties = (typeof(ignore_properties) != 'undefined') ?
-                            ignore_properties : ["toJSON"];
+                            ignore_properties : ["toJSON", "json_class"];
   this.toJSON = function(){
      var data = {};
      for(p in this.value)
@@ -169,6 +169,7 @@ JRObject.from_json_array = function(json){
 // Main json-rpc client websocket interface
 function WSNode (host, port){
   var node      = this;
+  this.opening  = false;
   this.opened   = false;
   this.node_id  = null;
   this.headers  = {};
@@ -176,6 +177,8 @@ function WSNode (host, port){
 
   // Open socket connection
   this.open = function(){
+    if(this.opening) return;
+    this.opening = true;
     node.socket = new WebSocket("ws://" + host + ":" + port);
 
     node.socket.onclose   = function (){
@@ -197,14 +200,14 @@ function WSNode (host, port){
           if(node.onerror)
             node.onerror(msg)
 
-      }else{
-        // relying on clients to handle notifications via message_received
-        // TODO add notification (and request?) handler support here
-        //node.invoke_method(msg.rpc_method, msg.params)
-        if(node.message_received)
-          node.message_received(msg);
-
       }
+
+      // relying on clients to handle notifications via message_received
+      // TODO add notification (and request?) handler support here
+      // clients may user this to register additional handlers to be invoked
+      // upon request responses
+      if(node.message_received)
+        node.message_received(msg);
     };
 
     node.socket.onerror = function(e){
@@ -213,12 +216,13 @@ function WSNode (host, port){
     }
 
     node.socket.onopen = function (){
+      node.opened = true;
+      node.opening = false;
+
       // send queued messages
       for(var m in node.messages)
         node.socket.send(node.messages[m].to_json());
 
-      node.opened = true;
-
       // invoke client callback
       if(node.onopen)
         node.onopen();
@@ -270,9 +274,10 @@ function WebNode (uri){
 
             success: function(data){
               var msg = JRMessage.from_msg(data);
-              // js web client doesn't support notifications
-              //if(node.message_received)
-                //node.message_received(msg);
+              // clients may register additional callbacks
+              // to handle web node responses
+              if(node.message_received)
+                node.message_received(msg);
 
               req.handle_response(msg)
 

data/specs/dispatcher_spec.rb

@@ -145,6 +145,7 @@ module RJR
         h = proc {}
         d.handle('foobar', h)
         d.handlers['foobar'].should == h
+        d.handles?('foobar').should be_true
       end
 
       it "should set handler from block param" do
@@ -152,6 +153,7 @@ module RJR
         h = proc {}
         d.handle('foobar', &h)
         d.handlers['foobar'].should == h
+        d.handles?('foobar').should be_true
       end
 
       it "should register handler for multiple methods" do
@@ -160,6 +162,8 @@ module RJR
         d.handle(['foobar', 'barfoo'], &h)
         d.handlers['foobar'].should == h
         d.handlers['barfoo'].should == h
+        d.handles?('foobar').should be_true
+        d.handles?('barfoo').should be_true
       end
     end
 
@@ -183,6 +187,10 @@ module RJR
           invoked.should be_true
         end
 
+        context "handler is regex" do
+          it "should match method"
+        end
+
         it "should pass params to handler" do
           param = nil
           d = Dispatcher.new

data/specs/em_adapter_spec.rb

@@ -3,49 +3,43 @@ require 'rjr/em_adapter'
 
 module RJR
   describe EMAdapter do
-    after(:each) do
-      EMAdapter.instance.halt
-      EMAdapter.instance.join
+    before(:each) do
+      @em = EMAdapter.new
     end
 
-    it "should be a singleton" do
-      em = EMAdapter.instance
-      EMAdapter.instance.should == em
+    after(:each) do
+      @em.halt.join
     end
 
     it "should start the reactor" do
-      em = EMAdapter.instance
-      em.start
-      em.reactor_running?.should be_true
-      ['sleep', 'run'].should include(em.reactor_thread.status)
+      @em.start
+      @em.reactor_running?.should be_true
+      ['sleep', 'run'].should include(@em.reactor_thread.status)
     end
 
     it "should only start the reactor once" do
-      em = EMAdapter.instance
-      em.start
+      @em.start
 
-      ot = em.reactor_thread
-      em.start
-      em.reactor_thread.should == ot
+      ot = @em.reactor_thread
+      @em.start
+      @em.reactor_thread.should == ot
     end
 
     it "should halt the reactor" do
-      em = EMAdapter.instance
-      em.start
+      @em.start
 
-      em.halt
-      em.join
-      em.reactor_running?.should be_false
-      em.reactor_thread.should be_nil
+      @em.halt
+      @em.join
+      @em.reactor_running?.should be_false
+      @em.reactor_thread.should be_nil
     end
 
     it "should dispatch all requests to eventmachine" do
-      em = EMAdapter.instance
-      em.start
+      @em.start
 
       invoked = false
       m,c = Mutex.new, ConditionVariable.new
-      em.schedule {
+      @em.schedule {
         invoked = true
         m.synchronize { c.signal }
       }

data/specs/{stats_spec.rb → inspect_spec.rb}

@@ -1,5 +1,5 @@
 require 'rjr/dispatcher'
-require 'rjr/stats'
+require 'rjr/inspect'
 
 describe "#select_stats" do
   before(:each) do

data/specs/node_spec.rb

@@ -21,27 +21,26 @@ module RJR
     end
 
     it "should start the thread pool" do
-      ThreadPool.instance.stop.join
       node = Node.new
-      ThreadPool.instance.should be_running
+      node.class.class_variable_get(:@@tp).should be_running
     end
 
     it "should start event machine" do
-      EMAdapter.instance.halt.join
+      EventMachine.stop_event_loop
       node = Node.new
-      EMAdapter.instance.reactor_running?.should be_true
+      EventMachine.reactor_running?.should be_true
     end
 
     it "should halt the thread pool" do
       node = Node.new
       node.halt.join
-      ThreadPool.instance.should_not be_running
+      node.class.class_variable_get(:@@tp).should_not be_running
     end
 
     it "should halt event machine" do
       node = Node.new
       node.halt.join
-      EMAdapter.instance.reactor_running?.should be_false
+      EventMachine.reactor_running?.should be_false
     end
 
     it "should handle connection events" do

data/specs/nodes/local_spec.rb

@@ -32,16 +32,22 @@ module RJR::Nodes
 
     describe "#notify" do
       it "should dispatch local notification" do
+        # notify will most likely return before
+        # handler is executed (in seperate thread), wait
+        m,c = Mutex.new, ConditionVariable.new
+
         invoked = nil
         node = Local.new :node_id => 'aaa'
         node.dispatcher.handle('foobar') { |param|
           invoked = true
+          m.synchronize { c.signal }
           'retval'
         }
 
         res = node.notify 'foobar', 'myparam'
-        invoked.should == true
         res.should == nil
+        m.synchronize { c.wait m, 0.1 } unless invoked
+        invoked.should == true
       end
     end
 

data/specs/thread_pool_spec.rb

@@ -5,40 +5,35 @@ require 'rjr/thread_pool'
 
 module RJR
   describe ThreadPool do
-    after(:each) do
-      ThreadPool.instance.stop
-      ThreadPool.instance.join
+    before(:each) do
+      @tp = ThreadPool.new
     end
 
-    it "should be a singleton" do
-      tp = ThreadPool.instance
-      ThreadPool.instance.should == tp
+    after(:each) do
+      @tp.stop.join
     end
 
     it "should start the thread pool" do
-      tp = ThreadPool.instance
-      tp.start
-      tp.instance_variable_get(:@worker_threads).size.should == ThreadPool.num_threads
-      tp.should be_running
+      @tp.start
+      @tp.instance_variable_get(:@worker_threads).size.should == ThreadPool.num_threads
+      @tp.should be_running
     end
 
     it "should stop the thread pool" do
-      tp = ThreadPool.instance
-      tp.start
-      tp.stop
-      tp.join
-      tp.instance_variable_get(:@worker_threads).size.should == 0
-      tp.should_not be_running
+      @tp.start
+      @tp.stop
+      @tp.join
+      @tp.instance_variable_get(:@worker_threads).size.should == 0
+      @tp.should_not be_running
     end
 
     it "should run work" do
-      tp = ThreadPool.instance
-      tp.start
+      @tp.start
 
       jobs_executed = []
       m,c = Mutex.new, ConditionVariable.new
-      tp << ThreadPoolJob.new { jobs_executed << 1 ; m.synchronize { c.signal } }
-      tp << ThreadPoolJob.new { jobs_executed << 2 ; m.synchronize { c.signal }  }
+      @tp << ThreadPoolJob.new { jobs_executed << 1 ; m.synchronize { c.signal } }
+      @tp << ThreadPoolJob.new { jobs_executed << 2 ; m.synchronize { c.signal }  }
 
       m.synchronize { c.wait m, 0.1 } unless jobs_executed.include?(1)
       m.synchronize { c.wait m, 0.1 } unless jobs_executed.include?(2)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rjr
 version: !ruby/object:Gem::Version
-  version: 0.15.1
+  version: 0.16.1
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-05-19 00:00:00.000000000 Z
+date: 2013-09-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
@@ -79,14 +79,15 @@ files:
 - lib/rjr/semaphore.rb
 - lib/rjr/em_adapter.rb
 - lib/rjr/errors.rb
+- lib/rjr/inspect.rb
 - lib/rjr/node.rb
 - lib/rjr/common.rb
 - lib/rjr/thread_pool.rb
 - lib/rjr/message.rb
-- lib/rjr/stats.rb
 - lib/rjr/nodes/web.rb
 - lib/rjr/nodes/udp.rb
 - lib/rjr/nodes/tcp.rb
+- lib/rjr/nodes/ssh.rb
 - lib/rjr/nodes/ws.rb
 - lib/rjr/nodes/tcp2.rb
 - lib/rjr/nodes/local.rb
@@ -97,7 +98,6 @@ files:
 - lib/rjr/dispatcher.rb
 - specs/dispatcher_spec.rb
 - specs/node_spec.rb
-- specs/stats_spec.rb
 - specs/nodes/multi_spec.rb
 - specs/nodes/tcp_spec.rb
 - specs/nodes/web_spec.rb
@@ -105,6 +105,7 @@ files:
 - specs/nodes/amqp_spec.rb
 - specs/nodes/ws_spec.rb
 - specs/nodes/easy_spec.rb
+- specs/inspect_spec.rb
 - specs/thread_pool_spec.rb
 - specs/message_spec.rb
 - specs/em_adapter_spec.rb