rjr 0.5.4 → 0.6.1

data/Rakefile

@@ -5,11 +5,6 @@
 
 require 'rdoc/task'
 require "rspec/core/rake_task"
-require 'rubygems/package_task'
-
-
-GEM_NAME="rjr"
-PKG_VERSION='0.5.4'
 
 desc "Run all specs"
 RSpec::Core::RakeTask.new(:spec) do |spec|
@@ -37,28 +32,7 @@ Rake::RDocTask.new do |rd|
     rd.rdoc_files.include("README.rdoc", "lib/**/*.rb")
 end
 
-PKG_FILES = FileList['lib/**/*.rb', 
-  'LICENSE', 'Rakefile', 'README.rdoc', 'spec/**/*.rb' ]
-
-SPEC = Gem::Specification.new do |s|
-    s.name = GEM_NAME
-    s.version = PKG_VERSION
-    s.files = PKG_FILES
-    s.executables << 'rjr-server'
-
-    s.required_ruby_version = '>= 1.8.1'
-    s.required_rubygems_version = Gem::Requirement.new(">= 1.3.3")
-    s.add_development_dependency('rspec', '~> 1.3.0')
-
-    s.author = "Mohammed Morsi"
-    s.email = "mo@morsi.org"
-    s.date = %q{2012-04-25}
-    s.description = %q{Ruby Json Rpc library}
-    s.summary = %q{JSON RPC server and client library over amqp, websockets}
-    s.homepage = %q{http://github.com/movitto/rjr}
-end
-
-Gem::PackageTask.new(SPEC) do |pkg|
-    pkg.need_tar = true
-    pkg.need_zip = true
+desc "build the rjr gem"
+task :build do
+  system "gem build rjr.gemspec"
 end

data/lib/rjr/amqp_node.rb

@@ -17,27 +17,13 @@ module RJR
 # send data back to client via AMQP.
 class AMQPNodeCallback
   def initialize(args = {})
-    @exchange    = args[:exchange]
-    @exchange_lock = args[:exchange_lock]
+    @node        = args[:node]
     @destination = args[:destination]
-    @message_headers = args[:headers]
-    @disconnected = false
-
-    @exchange_lock.synchronize{
-      # FIXME should disconnect all callbacks on_return
-      @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
-      end
-    }
   end
 
   def invoke(callback_method, *data)
     msg = RequestMessage.new :method => callback_method, :args => data, :headers => @message_headers
-    raise RJR::Errors::ConnectionError.new("client unreachable") if @disconnected
-    @exchange_lock.synchronize{
-      @exchange.publish(msg.to_s, :routing_key => @destination, :mandatory => true)
-    }
+    @node.publish msg.to_s, :routing_key => @destination, :mandatory => true
   end
 end
 
@@ -45,25 +31,14 @@ end
 class AMQPNode < RJR::Node
   RJR_NODE_TYPE = :amqp
 
-
   private
   def handle_message(metadata, msg)
     if RequestMessage.is_request_message?(msg)
       reply_to = metadata.reply_to
-
-      # TODO should delete handler threads as they complete & should handle timeout
       @thread_pool << ThreadPoolJob.new { handle_request(reply_to, msg) }
 
     elsif ResponseMessage.is_response_message?(msg)
-      # TODO test message, make sure it is a response message
-      msg    = ResponseMessage.new(:message => msg, :headers => @message_headers)
-      lock   = @message_locks[msg.msg_id]
-      if lock
-        headers = @message_headers.merge(msg.headers)
-        res = Dispatcher.handle_response(msg.result)
-        lock << res
-        lock[0].synchronize { lock[1].signal }
-      end
+      handle_response(msg)
 
     end
   end
@@ -74,16 +49,34 @@ class AMQPNode < RJR::Node
     result = Dispatcher.dispatch_request(msg.jr_method,
                                          :method_args => msg.jr_args,
                                          :headers => headers,
+                                         :client_ip => nil,    # since client doesn't directly connect to server, we can't leverage
+                                         :client_port => nil,  # client ip / port for requests received via the amqp node type
+                                         :rjr_node      => self,
                                          :rjr_node_id   => @node_id,
                                          :rjr_node_type => RJR_NODE_TYPE,
                                          :rjr_callback =>
-                                           AMQPNodeCallback.new(:exchange => @exchange,
-                                                                :exchange_lock => @exchange_lock,
+                                           AMQPNodeCallback.new(:node => self,
+                                                                :exchange => @exchange,
+                                                                :amqp_lock => @amqp_lock,
                                                                 :destination => reply_to,
                                                                 :headers => headers))
     response = ResponseMessage.new(:id => msg.msg_id, :result => result, :headers => headers)
-    @exchange_lock.synchronize{
-      @exchange.publish(response.to_s, :routing_key => reply_to)
+    publish response.to_s, :routing_key => reply_to
+  end
+
+  def handle_response(message)
+    msg    = ResponseMessage.new(:message => message, :headers => @message_headers)
+    res = err = nil
+    begin
+      res = Dispatcher.handle_response(msg.result)
+    rescue Exception => e
+      err = e
+    end
+
+    @response_lock.synchronize{
+      @result = [res]
+      @result << err if !err.nil?
+      @response_cv.signal
     }
   end
 
@@ -93,14 +86,14 @@ class AMQPNode < RJR::Node
   def initialize(args = {})
      super(args)
      @broker    = args[:broker]
-
-     # tuple of message ids to locks/condition variables for the responses
-     # of those messages with optional result response
-     @message_locks = {}
+     @connection_event_handlers = {:closed => [], :error => []}
+     @response_lock = Mutex.new
+     @response_cv = ConditionVariable.new
   end
 
   # Initialize the amqp subsystem
   def init_node
+     return unless @conn.nil? || !@conn.connected?
      @conn = AMQP.connect(:host => @broker)
      @conn.on_tcp_connection_failure { puts "OTCF #{@node_id}" }
 
@@ -111,7 +104,57 @@ class AMQPNode < RJR::Node
      @queue_name  = "#{@node_id.to_s}-queue"
      @queue       = @channel.queue(@queue_name, :auto_delete => true)
      @exchange    = @channel.default_exchange
-     @exchange_lock = Mutex.new
+
+     @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
+         connection_event(:error)
+         connection_event(:closed)
+     end
+  end
+
+  # publish a message using the amqp exchange
+  def publish(*args)
+    raise RJR::Errors::ConnectionError.new("client unreachable") if @disconnected
+    @exchange.publish *args
+  end
+
+  # subscribe to messages using the amqp queue
+  def subscribe(*args, &bl)
+    return if @listening
+    @listening = true
+    @queue.subscribe do |metadata, msg|
+      bl.call metadata, msg
+    end
+  end
+
+  def wait_for_result(message)
+    res = nil
+    @response_lock.synchronize{
+      @response_cv.wait @response_lock
+      res = @result
+    }
+    return res
+  end
+
+  # register connection event handler
+  def on(event, &handler)
+    if @connection_event_handlers.keys.include?(event)
+      @connection_event_handlers[event] << handler
+    end
+  end
+
+  # run connection event handlers for specified event
+  # TODO these are only run when we fail to send message to queue, need to detect when that queue is shutdown & other events
+  def connection_event(event)
+    if @connection_event_handlers.keys.include?(event)
+      @connection_event_handlers[event].each { |h|
+        h.call self
+      }
+    end
   end
 
   # Instruct Node to start listening for and dispatching rpc requests
@@ -120,44 +163,36 @@ class AMQPNode < RJR::Node
       init_node
 
       # start receiving messages
-      @queue.subscribe do |metadata, msg|
-         handle_message(metadata, msg)
-      end
+      subscribe { |metadata, msg|
+        handle_message(metadata, msg)
+      }
     end
   end
 
   # Instructs node to send rpc request, and wait for / return response
   def invoke_request(routing_key, rpc_method, *args)
-    req_mutex = Mutex.new
-    req_cv = ConditionVariable.new
-
     message = RequestMessage.new :method => rpc_method,
                                  :args   => args,
                                  :headers => @message_headers
     em_run do
       init_node
 
-      @message_locks[message.msg_id] = [req_mutex, req_cv]
-
       # begin listening for result
-      @queue.subscribe do |metadata, msg|
+      subscribe { |metadata, msg|
         handle_message(metadata, msg)
-      end
-
-      @exchange_lock.synchronize{
-        @exchange.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
 
-    ## wait for result
-    # TODO - make this optional, eg a non-blocking operation mode
-    #        (allowing event handler registration to be run on success / fail / etc)
-    req_mutex.synchronize { req_cv.wait(req_mutex) }
-    result = @message_locks[message.msg_id][2] 
-    @message_locks.delete(message.msg_id)
+    result = wait_for_result(message)
     self.stop
     self.join unless self.em_running?
-    return result
+
+    if result.size > 1
+      raise result[1]
+    end
+    return result.first
   end
 
 end

data/lib/rjr/common.rb

@@ -12,8 +12,10 @@ class Logger
   private
     def self._instantiate_logger
        unless defined? @@logger
+         #STDOUT.sync = true
          @@logger = ::Logger.new(STDOUT)
          @@logger.level = ::Logger::FATAL
+         @@logger_mutex = Mutex.new
        end 
     end 
 
@@ -21,7 +23,15 @@ class Logger
 
     def self.method_missing(method_id, *args)
        _instantiate_logger
-       @@logger.send(method_id, args)
+       @@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
+       }
     end 
 
     def self.logger
@@ -37,6 +47,7 @@ end
 
 end # module RJR
 
+if RUBY_VERSION < "1.9"
 # http://blog.jayfields.com/2006/09/ruby-instanceexec-aka-instanceeval.html
 class Object
   module InstanceExecHelper; end
@@ -58,3 +69,4 @@ class Object
     ret
   end
 end
+end

data/lib/rjr/dispatcher.rb

@@ -24,7 +24,10 @@ class Request
     @method       = args[:method]
     @method_args  = args[:method_args]
     @headers      = args[:headers]
+    @client_ip    = args[:client_ip]
+    @client_port  = args[:client_port]
     @rjr_callback = args[:rjr_callback]
+    @rjr_node      = args[:rjr_node]
     @rjr_node_id   = args[:rjr_node_id]
     @rjr_node_type = args[:rjr_node_type]
     @handler       = args[:handler]
@@ -113,9 +116,7 @@ class Handler
       return Result.new(:result => retval)
 
     rescue Exception => e
-      RJR::Logger.warn "Exception Raised in #{method_name} handler #{e}"
-      e.backtrace.each { |b| RJR::Logger.warn b }
-      # TODO store exception class to be raised later
+      RJR::Logger.warn ["Exception Raised in #{method_name} handler #{e}"] + e.backtrace
 
       return Result.new(:error_code => -32000,
                         :error_msg  => e.to_s,
@@ -132,10 +133,13 @@ class Dispatcher
   end
 
   # register a handler to the specified method
-  def self.add_handler(method_name, args = {}, &handler)
+  def self.add_handler(method_names, args = {}, &handler)
+    method_names = Array(method_names) unless method_names.is_a?(Array)
     @@handlers  ||= {}
-    @@handlers[method_name] = Handler.new args.merge(:method  => method_name,
-                                                     :handler => handler)
+    method_names.each { |method_name|
+      @@handlers[method_name] = Handler.new args.merge(:method  => method_name,
+                                                       :handler => handler)
+    }
   end
 
   # Helper to handle request messages

data/lib/rjr/local_node.rb

@@ -38,6 +38,13 @@ class LocalNode < RJR::Node
      @node_type = RJR_NODE_TYPE
   end
 
+  # register connection event handler,
+  # until we support manual disconnections of the local node, we don't
+  # have to do anything here
+  def on(event, &handler)
+    # TODO raise error (for the time being)?
+  end
+
   # Instruct Node to start listening for and dispatching rpc requests
   def listen
     em_run do
@@ -50,15 +57,29 @@ class LocalNode < RJR::Node
     message = RequestMessage.new :method => rpc_method,
                                  :args   => args,
                                  :headers => @message_headers
-    result = Dispatcher.dispatch_request(rpc_method,
-                                         :method_args => args,
+
+    # 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))
-    return Dispatcher.handle_response(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)
+    return Dispatcher.handle_response(response.result)
   end
 
 end

data/lib/rjr/message.rb

@@ -40,7 +40,6 @@ class RequestMessage
 
       rescue Exception => e
         #puts "Exception Parsing Request #{e}"
-        # TODO
         raise e
       end
 
@@ -55,6 +54,7 @@ class RequestMessage
 
   def self.is_request_message?(message)
     begin
+       # TODO log error
        JSON.parse(message).has_key?('method')
     rescue Exception => e
       false
@@ -95,7 +95,7 @@ class ResponseMessage
       elsif response.has_key?('error')
         @result.error_code = response['error']['code']
         @result.error_msg  = response['error']['message']
-        @result.error_class = response['error']['class']  # TODO safely constantize this
+        @result.error_class = response['error']['class']  # TODO safely constantize this ?
 
       end
 
@@ -117,8 +117,10 @@ class ResponseMessage
 
   def self.is_response_message?(message)
     begin
-      JSON.parse(message).has_key?('result')
+      json = JSON.parse(message)
+      json.has_key?('result') || json.has_key?('error')
     rescue Exception => e
+      # TODO log error
       false
     end
   end

data/lib/rjr/node.rb

@@ -25,10 +25,6 @@ class Node
 
      @message_headers = {}
      @message_headers.merge!(args[:headers]) if args.has_key?(:headers)
-
-     # threads pool to handle incoming requests
-     # FIXME make the # of threads and timeout configurable)
-     @thread_pool = ThreadPool.new(10, :timeout => 5)
   end
 
   # run job in event machine
@@ -38,6 +34,12 @@ class Node
 
     @@em_thread  ||= nil
 
+    unless !@thread_pool.nil? && @thread_pool.running?
+      # threads pool to handle incoming requests
+      # FIXME make the # of threads and timeout configurable)
+      @thread_pool = ThreadPool.new(10, :timeout => 5)
+    end
+
     if @@em_thread.nil?
       @@em_thread  =
         Thread.new{
@@ -54,7 +56,7 @@ class Node
   end
 
   def em_running?
-    EventMachine.reactor_running?
+    @@em_jobs > 0 && EventMachine.reactor_running?
   end
 
   def join
@@ -67,7 +69,7 @@ class Node
   def stop
     @@em_jobs -= 1
     if @@em_jobs == 0
-      EventMachine.stop
+      EventMachine.stop_event_loop
       @thread_pool.stop
     end
   end

data/lib/rjr/thread_pool.rb

@@ -77,7 +77,7 @@ class ThreadPool
       res
     end
 
-    # TODO should not invoke after stop is called
+    # should not invoke after stop is called
     def check_timeout(timeout)
       @timeout_lock.synchronize {
         if !@time_started.nil? && Time.now - @time_started > timeout

data/lib/rjr/web_node.rb

@@ -40,11 +40,15 @@ class WebRequestHandler < EventMachine::Connection
     msg    = nil
     result = nil
     begin
+      client_port, client_ip = Socket.unpack_sockaddr_in(get_peername)
       msg    = RequestMessage.new(:message => message, :headers => @web_node.message_headers)
       headers = @web_node.message_headers.merge(msg.headers)
       result = Dispatcher.dispatch_request(msg.jr_method,
                                            :method_args => msg.jr_args,
                                            :headers => headers,
+                                           :client_ip => client_ip,
+                                           :client_port => client_port,
+                                           :rjr_node      => @web_node,
                                            :rjr_node_id   => @web_node.node_id,
                                            :rjr_node_type => RJR_NODE_TYPE,
                                            :rjr_callback => WebNodeCallback.new())
@@ -65,7 +69,6 @@ class WebRequestHandler < EventMachine::Connection
 
   def process_http_request
     # TODO support http protocols other than POST
-    # TODO should delete handler threads as they complete & should handle timeout
     msg = @http_post_content.nil? ? '' : @http_post_content
     #@thread_pool << ThreadPoolJob.new { handle_request(msg) }
     handle_request(msg)
@@ -88,6 +91,12 @@ class WebNode < RJR::Node
   def init_node
   end
 
+  # register connection event handler,
+  # since web node connections aren't persistant, we don't do anything here
+  def on(event, &handler)
+    # TODO raise error?
+  end
+
   # Instruct Node to start listening for and dispatching rpc requests
   def listen
     em_run do

data/lib/rjr/ws_node.rb

@@ -20,10 +20,6 @@ class WSNodeCallback
   def initialize(args = {})
     @socket    = args[:socket]
     @message_headers = args[:headers]
-
-    # FIXME onclose, invalidate this callback / terminate outstanding handlers
-    #@socket.onclose {}
-    #@socket.onerror { |error|}
   end
 
   def invoke(callback_method, *data)
@@ -40,11 +36,15 @@ class WSNode < RJR::Node
 
   private
   def handle_request(socket, message)
+    client_port, client_ip = Socket.unpack_sockaddr_in(socket.get_peername)
     msg    = 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,
                                          :headers => headers,
+                                         :client_ip => client_ip,
+                                         :client_port => client_port,
+                                         :rjr_node      => self,
                                          :rjr_node_id   => @node_id,
                                          :rjr_node_type => RJR_NODE_TYPE,
                                          :rjr_callback =>
@@ -60,6 +60,15 @@ class WSNode < RJR::Node
      super(args)
      @host      = args[:host]
      @port      = args[:port]
+
+     @connection_event_handlers = {:closed => [], :error => []}
+  end
+
+  # register connection event handler
+  def on(event, &handler)
+    if @connection_event_handlers.keys.include?(event)
+      @connection_event_handlers[event] << handler
+    end
   end
 
   # Initialize the ws subsystem
@@ -71,11 +80,18 @@ class WSNode < RJR::Node
     em_run do
       init_node
       EventMachine::WebSocket.start(:host => @host, :port => @port) do |ws|
-        ws.onopen    {   }
-        ws.onclose   {   }
-        ws.onerror   {|e|}
+        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|
-          # TODO should delete handler threads as they complete & should handle timeout
           @thread_pool << ThreadPoolJob.new { handle_request(ws, msg) }
         }
       end

data/lib/rjr.rb

@@ -3,18 +3,15 @@
 # Copyright (C) 2010 Mohammed Morsi <movitto@yahoo.com>
 # Licensed under the AGPLv3+ http://www.gnu.org/licenses/agpl.txt
 
-lib = File.dirname(__FILE__)
-$: << lib + '/rjr/'
-
-require lib + '/rjr/common'
-require lib + '/rjr/errors'
-require lib + '/rjr/thread_pool'
-require lib + '/rjr/semaphore'
-require lib + '/rjr/node'
-require lib + '/rjr/dispatcher'
-require lib + '/rjr/message'
-require lib + '/rjr/local_node'
-require lib + '/rjr/amqp_node'
-require lib + '/rjr/ws_node'
-require lib + '/rjr/web_node'
-require lib + '/rjr/multi_node'
+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/multi_node'

data/specs/amqp_node_spec.rb

@@ -0,0 +1,31 @@
+require 'rjr/amqp_node'
+require 'rjr/dispatcher'
+
+describe RJR::AMQPNode do
+  it "should invoke and satisfy amqp requests" do
+    server = RJR::AMQPNode.new :node_id => 'amqp', :broker => 'localhost'
+    client = RJR::AMQPNode.new :node_id => 'client', :broker => 'localhost'
+
+    foozbar_invoked = false
+    RJR::Dispatcher.init_handlers
+    RJR::Dispatcher.add_handler('foozbar') { |param|
+      @client_ip.should == nil
+      @client_port.should == nil
+      @rjr_node.should == server
+      @rjr_node_id.should == 'amqp'
+      @rjr_node_type.should == :amqp
+      param.should == 'myparam'
+      foozbar_invoked = true
+      'retval'
+    }
+
+    server.listen
+    res = client.invoke_request 'amqp-queue', 'foozbar', 'myparam'
+    server.halt
+    server.join
+    res.should == 'retval'
+    foozbar_invoked.should == true
+  end
+
+  # TODO ensure closed / error event handlers are invoked
+end

data/specs/dispatcher_spec.rb

@@ -0,0 +1,144 @@
+require 'rjr/dispatcher'
+
+describe RJR::Request do
+  it "invokes registered handler in request context" do
+    invoked = false
+    rjr_callback = Object.new
+    request = RJR::Request.new :method => 'foobar',
+                               :method_args => ['a', 123],
+                               :headers     => {'qqq' => 'www'},
+                               :rjr_callback => rjr_callback,
+                               :rjr_node_id  => 'test',
+                               :rjr_node_type => 'test_type',
+                               :handler => lambda { |p1, p2|
+                                 invoked = true
+                                 @method.should == 'foobar'
+                                 p1.should == 'a'
+                                 p2.should == 123
+                                 @headers['qqq'].should == 'www'
+                                 @rjr_callback.should == rjr_callback
+                                 @rjr_node_id.should == 'test'
+                                 @rjr_node_type.should == 'test_type'
+                               }
+    request.handle
+    invoked.should == true
+  end
+end
+
+describe RJR::Result do
+  it "should handle successful results" do
+    result = RJR::Result.new :result => 'foobar'
+    result.success.should == true
+    result.failed.should  == false
+    result.result.should  == 'foobar'
+    result.error_code.should == nil
+    result.error_msg.should == nil
+    result.error_class.should == nil
+  end
+
+  it "should handle errors" do
+    result = RJR::Result.new :error_code => 123, :error_msg => 'abc', :error_class => ArgumentError
+    result.success.should == false
+    result.failed.should  == true
+    result.result.should  == nil
+    result.error_code.should == 123
+    result.error_msg.should == 'abc'
+    result.error_class.should == ArgumentError
+  end
+end
+
+
+describe RJR::Handler do
+  it "should return method not found result if method name is not specified" do
+    handler = RJR::Handler.new :method => nil
+    result = handler.handle
+    result.should == RJR::Result.method_not_found(nil)
+  end
+
+  it "should invoke registered handler for request" do
+    invoked = false
+    handler = RJR::Handler.new :method => 'foobar',
+                               :handler => lambda {
+                                 invoked = true
+                               }
+    handler.handle({:method_args => [] })
+    invoked.should == true
+  end
+
+  it "should return handler's return value in successful result" do
+    retval  = Object.new
+    handler = RJR::Handler.new :method => 'foobar',
+                               :handler => lambda {
+                                 retval
+                               }
+    res = handler.handle({:method_args => [] })
+    res.success.should == true
+    res.result.should == retval
+  end
+
+  it "should catch handler errors and return error result" do
+    handler = RJR::Handler.new :method => 'foobar',
+                               :method_args => [],
+                               :handler => lambda {
+                                 raise ArgumentError, "uh oh!"
+                               }
+    res = handler.handle({:method_args => [] })
+    res.failed.should == true
+    res.error_code.should == -32000
+    res.error_msg.should == "uh oh!"
+    res.error_class.should == ArgumentError
+  end
+end
+
+describe RJR::Dispatcher do
+  it "should dispatch request to registered handler" do
+    invoked_foobar = false
+    invoked_barfoo = false
+    RJR::Dispatcher.init_handlers
+    RJR::Dispatcher.add_handler('foobar') { |param1, param2|
+      invoked_foobar = true
+      param1.should == "param1"
+      param2.should == "param2"
+      "retval"
+    }
+    RJR::Dispatcher.add_handler('barfoo') { |param1, param2|
+      invoked_barfoo = true
+    }
+    res = RJR::Dispatcher.dispatch_request('foobar', :method_args => ['param1', 'param2'])
+    res.success.should == true
+    res.result.should == "retval"
+    invoked_foobar.should == true
+    invoked_barfoo.should == false
+  end
+
+  it "should allow a single handler to be subscribed to multiple methods" do
+    invoked_handler = 0
+    RJR::Dispatcher.init_handlers
+    RJR::Dispatcher.add_handler(['foobar', 'barfoo']) { |param1, param2|
+      invoked_handler += 1
+    }
+    RJR::Dispatcher.dispatch_request('foobar', :method_args => ['param1', 'param2'])
+    RJR::Dispatcher.dispatch_request('barfoo', :method_args => ['param1', 'param2'])
+    invoked_handler.should == 2
+  end
+
+  it "should return method not found result if handler for specified message is missing" do
+    RJR::Dispatcher.init_handlers
+    res = RJR::Dispatcher.dispatch_request('foobar')
+    res.should == RJR::Result.method_not_found('foobar')
+  end
+
+  it "should handle success response" do
+    res = RJR::Result.new :result => 'woot'
+    processed = RJR::Dispatcher.handle_response(res)
+    processed.should == "woot"
+  end
+
+  it "should handle error response" do
+    lambda{
+      res = RJR::Result.new :error_code => 123, :error_msg => "bah", :error_class => ArgumentError
+      RJR::Dispatcher.handle_response(res)
+    }.should raise_error(Exception, "bah")
+    #}.should raise_error(ArgumentError, "bah")
+  end
+end

data/specs/local_node_spec.rb

@@ -0,0 +1,43 @@
+require 'rjr/local_node'
+require 'rjr/dispatcher'
+
+describe RJR::LocalNode do
+  it "should invoke requests against local handler" do
+    node = RJR::LocalNode.new :node_id => 'aaa'
+    foobar_invoked = false
+    RJR::Dispatcher.init_handlers
+    RJR::Dispatcher.add_handler('foobar') { |param|
+      @rjr_node.should == node
+      @rjr_node_id.should == 'aaa'
+      @rjr_node_type.should == :local
+      param.should == 'myparam'
+      foobar_invoked = true
+      'retval'
+    }
+
+    res = node.invoke_request 'foobar', 'myparam'
+    foobar_invoked.should == true
+    res.should == 'retval'
+  end
+
+  it "should invoke callbacks against local handlers" do
+    foobar_invoked = false
+    callback_invoked = false
+    RJR::Dispatcher.init_handlers
+    RJR::Dispatcher.add_handler('foobar') {
+      foobar_invoked = true
+      @rjr_callback.invoke('callback', 'cp')
+    }
+    RJR::Dispatcher.add_handler('callback') { |*params|
+      params.length.should == 1
+      params[0].should == 'cp'
+      callback_invoked = true
+    }
+
+    node = RJR::LocalNode.new
+    node.invoke_request 'foobar', 'myparam'
+  end
+
+  # TODO make sure object attributes not serialized to json
+  # are not available on remote end of local node invocation/response
+end

data/specs/message_spec.rb

@@ -0,0 +1,145 @@
+require 'rjr/dispatcher'
+require 'rjr/message'
+
+describe RJR::RequestMessage do
+  it "should accept request parameters" do
+    msg = RJR::RequestMessage.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
+    msg.msg_id.should =~ /^[a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12}$/
+  end
+
+  it "should produce valid json" do
+    msg = RJR::RequestMessage.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 include('"id":"'+msg.msg_id+'"')
+  end
+
+  it "should parse request message string" do
+    msg_uuid = RJR::RequestMessage.gen_uuid 
+    msg_string = '{"jsonrpc": "2.0", ' +
+                 '"id": "' + msg_uuid + '", ' +
+                 '"method": "test", "params": ["a", 1]}'
+    msg = RJR::RequestMessage.new :message => msg_string
+    msg.json_message.should == msg_string
+    msg.jr_method.should == 'test'
+    msg.jr_args.should =~ ['a', 1]
+    msg.msg_id.should == msg_uuid
+  end
+
+  it "should extract optional headers from message string" do
+    msg_uuid = RJR::RequestMessage.gen_uuid 
+    msg_string = '{"jsonrpc": "2.0", ' +
+                 '"id": "' + msg_uuid + '", ' +
+                 '"method": "test", "params": ["a", 1], ' +
+                 '"h": 2}'
+    msg = RJR::RequestMessage.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::RequestMessage.new :message => 'foobar'
+    }.should raise_error JSON::ParserError
+  end
+end
+
+describe RJR::ResponseMessage do
+  it "should accept response parameters" do
+    msg_id = RJR::RequestMessage.gen_uuid
+    msg = RJR::ResponseMessage.new :id      => msg_id,
+                                   :result  => RJR::Result.new(:result => 'success'),
+                                   :headers => {:h => 2}
+    msg.msg_id.should == msg_id
+    msg.result.result == 'success'
+    msg.headers.should have_key(:h)
+    msg.headers[:h].should == 2
+  end
+
+  it "should produce valid result response json" do
+    msg_id = RJR::RequestMessage.gen_uuid
+    msg = RJR::ResponseMessage.new :id      => msg_id,
+                                   :result  => RJR::Result.new(:result => 'success'),
+                                   :headers => {:h => 2}
+    msg_string = msg.to_s
+    msg_string.should include('"id":"'+msg_id+'"')
+    msg_string.should include('"result":"success"')
+    msg_string.should include('"h":2')
+    msg_string.should include('"jsonrpc":"2.0"')
+  end
+
+  it "should produce valid error response json" do
+    msg_id = RJR::RequestMessage.gen_uuid
+    msg = RJR::ResponseMessage.new :id      => msg_id,
+                                   :result  => RJR::Result.new(:error_code => 404,
+                                                               :error_msg => 'not found',
+                                                               :error_class => ArgumentError),
+                                   :headers => {:h => 2}
+    msg_string = msg.to_s
+    msg_string.should include('"id":"'+msg_id+'"')
+    msg_string.should include('"h":2')
+    msg_string.should include('"jsonrpc":"2.0"')
+    msg_string.should include('"error":{')
+    msg_string.should include('"code":404')
+    msg_string.should include('"message":"not found"')
+  end
+
+
+  it "should parse result response message string" do
+    msg_id = RJR::RequestMessage.gen_uuid
+    msg_string = '{"id":"' + msg_id + '", ' +
+                  '"result":"success","jsonrpc":"2.0"}'
+    msg = RJR::ResponseMessage.new :message => msg_string
+    msg.json_message.should == msg_string
+    msg.msg_id.should == msg_id
+    msg.result.success.should == true
+    msg.result.failed.should == false
+    msg.result.result.should == "success"
+  end
+
+  it "should parse error response message string" do
+
+    msg_id = RJR::RequestMessage.gen_uuid
+    msg_string = '{"id":"' + msg_id + '", ' +
+                  '"error":{"code":404,"message":"not found","class":"ArgumentError"}, "jsonrpc":"2.0"}'
+    msg = RJR::ResponseMessage.new :message => msg_string
+    msg.json_message.should == msg_string
+    msg.msg_id.should == msg_id
+    msg.result.success.should == false
+    msg.result.failed.should == true
+    msg.result.error_code.should == 404
+    msg.result.error_msg.should == "not found"
+    msg.result.error_class.should == 'ArgumentError'
+  end
+
+  it "should extract optional headers from message string" do
+    msg_id = RJR::RequestMessage.gen_uuid
+    msg_string = '{"id":"' + msg_id + '", ' +
+                  '"result":"success","h":2,"jsonrpc":"2.0"}'
+    msg = RJR::ResponseMessage.new :message => msg_string
+    msg.json_message.should == msg_string
+    msg.headers.should have_key 'h'
+    msg.headers['h'].should == 2
+  end
+
+  it "should fail if parsing invalid message string" do
+    lambda {
+      msg = RJR::ResponseMessage.new :message => 'foobar'
+    }.should raise_error JSON::ParserError
+  end
+end

data/specs/multi_node_spec.rb

@@ -0,0 +1,44 @@
+require 'rjr/multi_node'
+require 'rjr/amqp_node'
+require 'rjr/web_node'
+require 'rjr/dispatcher'
+
+describe RJR::AMQPNode do
+  it "should invoke and satisfy amqp requests" do
+    foolbar_invoked = false
+    barfoo_invoked = false
+    RJR::Dispatcher.init_handlers
+    RJR::Dispatcher.add_handler('foolbar') { |param|
+      @rjr_node_id.should == 'amqp'
+      @rjr_node_type.should == :amqp
+      param.should == 'myparam1'
+      foolbar_invoked = true
+      'retval1'
+    }
+    RJR::Dispatcher.add_handler('barfoo') { |param|
+      @rjr_node_id.should == 'web'
+      @rjr_node_type.should == :web
+      param.should == 'myparam2'
+      barfoo_invoked = true
+      'retval2'
+    }
+
+    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.listen
+    amqp_client = RJR::AMQPNode.new :node_id => 'client', :broker => 'localhost'
+    res = amqp_client.invoke_request 'amqp-queue', 'foolbar', 'myparam1'
+    res.should == 'retval1'
+
+    web_client  = RJR::WebNode.new
+    res = web_client.invoke_request 'http://localhost:9876', 'barfoo', 'myparam2'
+    res.should == 'retval2'
+
+    multi.halt
+    multi.join
+    foolbar_invoked.should == true
+    barfoo_invoked.should == true
+  end
+end

data/specs/node_spec.rb

@@ -0,0 +1,33 @@
+require 'rjr/node'
+
+describe RJR::Node do
+  it "should initialize properly from params" do
+    node = RJR::Node.new :node_id => 'foobar',
+                         :headers => {:h => 123}
+    node.node_id.should == 'foobar'
+    node.message_headers[:h].should == 123
+  end
+
+  it "should start eventmachine and allow multiple blocks to be invoked in its context" do
+    block1_called = false
+    block2_called = false
+
+    node = RJR::Node.new :node_id => 'foobar',
+                         :headers => {:h => 123}
+    node.em_run {
+      node.instance_variable_get(:@thread_pool).running?.should be_true
+
+      EventMachine.reactor_running?.should be_true
+      block1_called = true
+      node.em_run {
+        EventMachine.reactor_running?.should be_true
+        block2_called = true
+        node.halt
+      }
+    }
+    node.join
+
+    block1_called.should be_true
+    block2_called.should be_true
+  end
+end

data/specs/web_node_spec.rb

@@ -0,0 +1,31 @@
+require 'rjr/web_node'
+require 'rjr/dispatcher'
+
+describe RJR::WebNode do
+  it "should invoke and satisfy http requests" do
+    server = RJR::WebNode.new :node_id => 'www', :host => 'localhost', :port => 9678
+    client = RJR::WebNode.new
+
+    foobar_invoked = false
+    RJR::Dispatcher.init_handlers
+    RJR::Dispatcher.add_handler('foobar') { |param|
+      @client_ip.should == "127.0.0.1"
+      #@client_port.should == 9678
+      @rjr_node.should == server
+      @rjr_node_id.should == 'www'
+      @rjr_node_type.should == :web
+      param.should == 'myparam'
+      foobar_invoked = true
+      'retval'
+    }
+
+    server.listen
+
+    res = client.invoke_request 'http://localhost:9678', 'foobar', 'myparam'
+    res.should == 'retval'
+    server.halt
+
+    server.join
+    foobar_invoked.should == true
+  end
+end

data/specs/ws_node_spec.rb

@@ -0,0 +1,32 @@
+require 'rjr/ws_node'
+require 'rjr/dispatcher'
+
+describe RJR::WSNode do
+  it "should invoke and satisfy websocket requests" do
+    server = RJR::WSNode.new :node_id => 'ws', :host => 'localhost', :port => 9876
+    client = RJR::WSNode.new
+
+    foobar_invoked = false
+    RJR::Dispatcher.init_handlers
+    RJR::Dispatcher.add_handler('foobar') { |param|
+      @client_ip.should == "127.0.0.1"
+      #@client_port.should == 9678
+      @rjr_node.should == server
+      @rjr_node_id.should == 'ws'
+      @rjr_node_type.should == :websockets
+      param.should == 'myparam'
+      foobar_invoked = true
+      'retval'
+    }
+
+    server.listen
+    sleep 1
+    res = client.invoke_request 'ws://localhost:9876', 'foobar', 'myparam'
+    res.should == 'retval'
+    server.halt
+    server.join
+    foobar_invoked.should == true
+  end
+
+  # TODO ensure closed / error event handlers are invoked
+end

metadata

@@ -1,47 +1,39 @@
---- !ruby/object:Gem::Specification 
+--- !ruby/object:Gem::Specification
 name: rjr
-version: !ruby/object:Gem::Version 
-  hash: 3
+version: !ruby/object:Gem::Version
+  version: 0.6.1
   prerelease: 
-  segments: 
-  - 0
-  - 5
-  - 4
-  version: 0.5.4
 platform: ruby
-authors: 
+authors:
 - Mohammed Morsi
 autorequire: 
 bindir: bin
 cert_chain: []
-
-date: 2012-04-25 00:00:00 Z
-dependencies: 
-- !ruby/object:Gem::Dependency 
+date: 2012-04-25 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
   name: rspec
-  prerelease: false
-  requirement: &id001 !ruby/object:Gem::Requirement 
+  requirement: !ruby/object:Gem::Requirement
     none: false
-    requirements: 
+    requirements:
     - - ~>
-      - !ruby/object:Gem::Version 
-        hash: 27
-        segments: 
-        - 1
-        - 3
-        - 0
+      - !ruby/object:Gem::Version
         version: 1.3.0
   type: :development
-  version_requirements: *id001
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.3.0
 description: Ruby Json Rpc library
 email: mo@morsi.org
-executables: 
+executables:
 - rjr-server
 extensions: []
-
 extra_rdoc_files: []
-
-files: 
+files:
 - lib/rjr/semaphore.rb
 - lib/rjr/udp_node.rb
 - lib/rjr/errors.rb
@@ -58,46 +50,40 @@ files:
 - lib/rjr/dispatcher.rb
 - lib/rjr/amqp_node.rb
 - lib/rjr.rb
+- specs/dispatcher_spec.rb
+- specs/node_spec.rb
+- specs/amqp_node_spec.rb
+- specs/multi_node_spec.rb
+- specs/local_node_spec.rb
+- specs/web_node_spec.rb
+- specs/ws_node_spec.rb
+- specs/message_spec.rb
 - LICENSE
 - Rakefile
 - README.rdoc
 - bin/rjr-server
 homepage: http://github.com/movitto/rjr
 licenses: []
-
 post_install_message: 
 rdoc_options: []
-
-require_paths: 
+require_paths:
 - lib
-required_ruby_version: !ruby/object:Gem::Requirement 
+required_ruby_version: !ruby/object:Gem::Requirement
   none: false
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      hash: 53
-      segments: 
-      - 1
-      - 8
-      - 1
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
       version: 1.8.1
-required_rubygems_version: !ruby/object:Gem::Requirement 
+required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      hash: 29
-      segments: 
-      - 1
-      - 3
-      - 3
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
       version: 1.3.3
 requirements: []
-
 rubyforge_project: 
-rubygems_version: 1.7.2
+rubygems_version: 1.8.24
 signing_key: 
 specification_version: 3
-summary: JSON RPC server and client library over amqp, websockets
+summary: JSON RPC server and client library over amqp, websockets, http, etc
 test_files: []
-