rjr 0.12.2 → 0.15.1

data/README.md

@@ -1,6 +1,6 @@
 ## RJR - Ruby Json Rpc Library ##
 
-Copyright (C) 2012 Mo Morsi <mo@morsi.org>
+Copyright (C) 2012-2013 Mo Morsi <mo@morsi.org>
 
 RJR is made available under the Apache License, Version 2.0
 
@@ -10,7 +10,9 @@ method handlers which may be invoked simultaneously over a variety of transport
 mechanisms.
 
 Currently supported transports include:
-    tcp, amqp, http (post), websockets, local method calls, (udp coming soon)
+    tcp, amqp, http (post), websockets, local method calls, (others coming soon)
+
+Note some transports require additional dependencies, see rjr.gemspec for more info.
 
 ### Intro ###
 To install rjr simply run:
@@ -21,36 +23,45 @@ Source code is available via:
 
 ### Using ###
 
-Simply require rubygems and the rjr library
+Simply require the transports which you would
+like to use:
 
-    require 'rubygems'
-    require 'rjr'
+    require 'rjr/nodes/tcp'
+    require 'rjr/nodes/amqp'
+    require 'rjr/nodes/ws'
+    require 'rjr/nodes/web'
+    require 'rjr/nodes/local'
+    require 'rjr/nodes/multi'
 
 server.rb:
 
+    # listen for methods via amqp, websockets, http, and via local calls
+    amqp_node  = RJR::Nodes::AMQP.new  :node_id => 'server', :broker => 'localhost'
+    ws_node    = RJR::Nodes::WS.new    :node_id => 'server', :host   => 'localhost', :port => 8080
+    www_node   = RJR::Nodes::Web.new   :node_id => 'server', :host   => 'localhost', :port => 8888
+    local_node = RJR::Nodes::Local.new :node_id => 'server'
+    multi_node = RJR::Nodes::Multi.new :nodes => [amqp_node, ws_node, www_node, local_node]
+
     # define a rpc method called 'hello' which takes
     # one argument and returns it in upper case
-    RJR::Dispatcher.add_handler("hello") { |arg|
+    multi_node.dispatcher.handle("hello") { |arg|
       arg.upcase
     }
 
-    # listen for this method via amqp, websockets, http, and via local calls
-    amqp_node  = RJR::AMQPNode.new  :node_id => 'server', :broker => 'localhost'
-    ws_node    = RJR::WSNode.new    :node_id => 'server', :host   => 'localhost', :port => 8080
-    www_node   = RJR::WebNode.new   :node_id => 'server', :host   => 'localhost', :port => 8888
-    local_node = RJR::LocalNode.new :node_id => 'server'
-
     # start the server and block
-    multi_node = RJR::MultiNode.new :nodes => [amqp_node, ws_node, www_node, local_node]
     multi_node.listen
     multi_node.join
 
 
 amqp_client.rb:
 
-    # invoke the method over amqp
-    amqp_node = RJR::AMQPNode.new :node_id => 'client', :broker => 'localhost'
-    puts amqp_node.invoke_request('server-queue', 'hello', 'world')
+    # invoke the method over amqp and return result
+    amqp_node = RJR::Nodes::AMQP.new :node_id => 'client', :broker => 'localhost'
+    puts amqp_node.invoke('server-queue', 'hello', 'world')
+
+    # send a notification via amqp,
+    # notifications immediately return and always return nil
+    amqp_node.notify('server-queue', 'hello', 'world')
 
 
 ws_client.js:
@@ -60,12 +71,15 @@ ws_client.js:
     <script type="text/javascript" src="site/json.js" />
     <script type="text/javascript" src="site/jrw.js" />
     <script type="text/javascript">
-    var node = new WSNode('127.0.0.1', '8080');
+    var node = new Nodes::WS('127.0.0.1', '8080');
     node.onopen = function(){
-      node.invoke_request('hello', 'rjr');
-    };
-    node.onsuccess = function(result){
-      alert(result);
+      node.invoke_request('hello', 'rjr',
+        function(res){
+          if(res.success)
+            alert(res.result);
+          else
+            alert(res.error);
+        });
     };
     node.open();
     </script>
@@ -80,7 +94,7 @@ Generate documentation via
 
     rake yard
 
-Also see specs for detailed usage.
+Also see examples and specs for detailed usage.
 
 ### Advanced ###
 
@@ -93,28 +107,27 @@ Various metadata fields are made available to json-rpc method handlers through
 instance variables. These include:
 
 
-<pre>* @rjr_node
+* @rjr_node
 * @rjr_node_id
 * @rjr_node_type
 * @rjr_callback
-* @headers
-* @client_ip
-* @client_port
-* @method
-* @method_args
-* @handler
-</pre>
+* @rjr_headers
+* @rjr_client_ip
+* @rjr_client_port
+* @rjr_method
+* @rjr_method_args
+* @rjr_handler
 
 RJR implements a callback interface through which methods may be invoked on a client
 after an initial server connection is established. Store and/or invoke @rjr_callback to make
 use of this.
 
-    RJR::Dispatcher.add_handler("register_callback") { |*args|
+    node.dispatcher.handle("register_callback") do |*args|
       $my_registry.invoke_me_later {
         # rjr callback will already be setup to send messages to the correct client
         @rjr_callback.invoke 'callback_method', 'with', 'custom', 'params'
       }
-    }
+    end
 
 RJR also permits arbitrary headers being set on JSON-RPC requests and responses. These
 will be stored in the json send to/from nodes, at the same level/scope as the message
@@ -122,18 +135,18 @@ will be stored in the json send to/from nodes, at the same level/scope as the me
 in their registered handlers to store additional metadata to extend the JSON-RPC protocol and
 support any custom subsystems (an auth subsystem for example)
 
-    RJR::Dispatcher.add_handler("login") { |*args|
+    node.dispatcher.handle("login") do |*args|
       if $my_user_registry.find(:user => args.first, :pass => args.last)
         @headers['session-id'] = $my_user_registry.create_session.id
       end
-    }
+    done
 
-    RJR::Dispatcher.add_handler("do_secure_action") { |*args|
+    node.dispatcher.add_handler("do_secure_action") do |*args|
       if $my_user_registry.find(:session_id => @headers['session-id']).nil?
         raise PermissionError, "invalid session"
       end
       # ...
-    }
+    end
 
 Of course any custom headers set/used will only be of use to JSON-RPC nodes running
 RJR as this is not standard JSON-RPC.

data/Rakefile

@@ -6,6 +6,8 @@
 require "yard"
 require "rspec/core/rake_task"
 
+# TODO CI - jenkins/travis/other (also test rjr on jruby)
+
 desc "Run all specs"
 RSpec::Core::RakeTask.new(:spec) do |spec|
   spec.pattern = 'specs/**/*_spec.rb'

data/bin/rjr-client

@@ -4,9 +4,10 @@
 # Copyright (C) 2013 Mohammed Morsi <mo@morsi.org>
 # Licensed under the Apache License, Version 2.0
 
-require 'rubygems'
 require 'optparse'
-require 'rjr'
+require 'rjr/common'
+require 'rjr/messages'
+require 'rjr/nodes/easy'
 
 RJR::Logger.log_level = ::Logger::DEBUG
 
@@ -93,13 +94,12 @@ NODES = {config[:transport] => {:node_id    => config[:node_id],
                                 :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
+client_path   = File.join(ENV['RJR_LOAD_PATH'] || File.join(cdir, '..', 'examples', 'client'))
 
 ##########################################################
 
-node = RJR::EasyNode.new(NODES)
+node = RJR::Nodes::Easy.new(NODES)
+node.dispatcher.add_modules(client_path)
 
 if config[:disconnect]
   disconnect_thread = Thread.new {
@@ -115,8 +115,8 @@ end
   # 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]))
+  msg = (config[:msg_id] == :rand ? RJR::MessageUtil.rand_msg(config[:transport]) :
+                                    RJR::MessageUtil.message(config[:msg_id]))
 
   if msg.nil?
     puts "Invalid message id"
@@ -136,9 +136,11 @@ end
   } if msg[:params]
 
   # invoke request
-  res = node.invoke_request(config[:dst], msg[:method], *params)
+  res = node.invoke(config[:dst], msg[:method], *params)
 
   # verify and output result
+puts res
+puts msg[:result]
   ress = (msg[:result].nil? ? "" : (msg[:result].call(res) ? "passed" : "failed"))
   RJR::Logger.info "#{msg[:method]} result #{res} #{ress}"
 

data/bin/rjr-server

@@ -4,12 +4,12 @@
 # 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'
+#require 'rjr/stats'
+require 'rjr/common'
+require 'rjr/nodes/easy'
 
 ##########################################################
 
@@ -17,7 +17,7 @@ config = { :node_id  =>  'rjr_test_server',
            :broker   =>        'localhost',
            :host     =>        'localhost',
            :tcp_port =>               8181,
-           :www_port =>               8888,
+           :web_port =>               8888,
            :ws_port  =>               8080 }
 
 optparse = OptionParser.new do |opts|
@@ -42,8 +42,8 @@ optparse = OptionParser.new do |opts|
     config[:tcp_port] = p
   end
 
-  opts.on('--www port', 'Port to listen on for www requests') do |p|
-    config[:www_port] = p
+  opts.on('--web port', 'Port to listen on for web requests') do |p|
+    config[:web_port] = p
   end
 
   opts.on('--ws port', 'Websocket Port to listen on') do |p|
@@ -58,12 +58,11 @@ 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]},
+         :web   =>  {:node_id => config[:node_id], :host   => config[:host], :port => config[:web_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
+server_path   = File.join(ENV['RJR_LOAD_PATH'] || File.join(cdir, '..', 'examples', 'server'))
 
 ##########################################################
 
@@ -71,4 +70,7 @@ $messages = StringIO.new
 
 RJR::Logger.log_level = ::Logger::DEBUG
 RJR::Logger.log_to $messages
-RJR::EasyNode.new(NODES).stop_on("INT").listen.join
+
+node = RJR::Nodes::Easy.new(NODES)
+node.dispatcher.add_modules(server_path)
+node.stop_on("INT").listen.join

data/examples/amqp.rb

@@ -0,0 +1,29 @@
+#!/usr/bin/ruby
+# A RJR AMQP-node example
+#
+# Copyright (C) 2013 Mohammed Morsi <mo@morsi.org>
+# Licensed under the Apache License, Version 2.0
+
+require 'rjr/nodes/amqp'
+
+server = RJR::Nodes::AMQP.new :node_id => 'server', :broker => 'localhost'
+server.dispatcher.handle('method') { |i|
+  puts "server: #{i}"
+  @rjr_callback.notify "callback", i.downcase
+  "#{i}".upcase
+}
+server.listen
+
+client = RJR::Nodes::AMQP.new :node_id => "client", :broker => 'localhost'
+client.dispatcher.handle('callback') { |i|
+  puts "callback: #{i}"
+  #client.halt
+}
+
+client.notify "server-queue", "method", "Hello World"
+# => nil
+
+client.invoke "server-queue", "method", "Hello World"
+# => HELLO WORLD
+
+#client.join

data/examples/client.rb

@@ -0,0 +1,32 @@
+# default client definitions loaded by bin/rjr-client
+#
+# Copyright (C) 2013 Mohammed Morsi <mo@morsi.org>
+# Licensed under the Apache License, Version 2.0
+
+include RJR::MessageMixins
+
+def dispatch_client(dispatcher)
+  dispatcher.handle "client_callback" do |p|
+    RJR::Logger.info "invoked client_callback method #{p}"
+    #amqp_node.invoke_request('stress_test-queue', 'stress', "foozmoney#{client_id}")
+    #amqp_node.stop
+    nil
+  end
+
+  define_message "stress" do
+    { :method => 'stress',
+      :params => ["<CLIENT_ID>"],
+      :result => lambda { |r| r =~ /foobar.*/ } }
+  end
+
+  define_message "stress_callback" do
+    { :method => 'stress_callback',
+      :params => ["<CLIENT_ID>"],
+      :transports => [:tcp, :ws, :amqp],
+      :result => lambda { |r| r =~ /barfoo.*/ } }
+  end
+
+  define_message "messages" do
+    { :method => 'messages'}
+  end
+end

data/examples/complete.rb

@@ -0,0 +1,36 @@
+#!/usr/bin/ruby
+# A RJR multi-node example
+#
+# Copyright (C) 2013 Mohammed Morsi <mo@morsi.org>
+# Licensed under the Apache License, Version 2.0
+
+require 'rjr/nodes/amqp'
+require 'rjr/nodes/tcp'
+require 'rjr/nodes/ws'
+require 'rjr/nodes/web'
+require 'rjr/nodes/local'
+require 'rjr/nodes/multi'
+require 'rjr/nodes/easy'
+
+server1 = RJR::Nodes::AMQP.new :node_id => 'server', :broker => 'localhost'
+server2 = RJR::Nodes::TCP.new :host => 'localhost', :port => 9789, :node_id => 'server'
+server3 = RJR::Nodes::WS.new :host => 'localhost', :port => 9788, :node_id => 'server'
+server4 = RJR::Nodes::Web.new :host => 'localhost', :port => 9787, :node_id => 'server'
+server5 = RJR::Nodes::Local.new
+server = RJR::Nodes::Multi.new :nodes => [server1, server2, server3, server4, server5]
+server.dispatcher.handle('method') { |i|
+  puts "server: #{i}"
+  "#{i}".upcase
+}
+server.listen
+
+client = RJR::Nodes::Easy.new :node_id => 'client',
+                              :tcp  => { :host => 'localhost', :port => 9666 },
+                              :ws   => { :host => 'localhost', :port => 9665 },
+                              :web  => { :host => 'localhost', :port => 9664},
+                              :amqp => { :broker => 'localhost' }
+
+puts client.invoke 'tcp://localhost:9789', 'method', 'Hello World'
+puts client.invoke 'http://localhost:9787', 'method', 'Hello World'
+puts client.invoke 'ws://localhost:9788', 'method', 'Hello World'
+puts client.invoke 'server-queue', 'method', 'Hello World'

data/examples/local.rb

@@ -0,0 +1,29 @@
+#!/usr/bin/ruby
+# A RJR local-node example
+#
+# Copyright (C) 2013 Mohammed Morsi <mo@morsi.org>
+# Licensed under the Apache License, Version 2.0
+require 'rjr/nodes/local'
+
+server = RJR::Nodes::Local.new
+server.dispatcher.handle('method') { |i|
+  puts "server: #{i}"
+  @rjr_callback.notify "callback", i.downcase
+  "#{i}".upcase
+}
+server.listen
+
+# local dispatches to whatever methods are registered at hand
+client = RJR::Nodes::Local.new :dispatcher => server.dispatcher
+client.dispatcher.handle('callback') { |i|
+  puts "callback: #{i}"
+  #client.halt
+}
+
+client.notify "method", "Hello World"
+# => nil
+
+puts client.invoke "method", "Hello World"
+# => HELLO WORLD
+
+#client.join

data/examples/server.rb

@@ -0,0 +1,26 @@
+# default server definitions loaded by bin/rjr-server
+#
+# Copyright (C) 2013 Mohammed Morsi <mo@morsi.org>
+# Licensed under the Apache License, Version 2.0
+
+def dispatch_server(dispatcher)
+  dispatcher.handle "messages" do |p|
+    $messages.string.split("\n")
+  end
+
+  dispatcher.handle "failed" do |p|
+    RJR::Logger.info "invoked failed method #{p}"
+   raise ArgumentError, "err #{p}"
+  end
+
+  dispatcher.handle "stress" do |p|
+    RJR::Logger.info "invoked stress method #{p}"
+   "foobar #{p}"
+  end
+
+  dispatcher.handle "stress_callback" do |p|
+    RJR::Logger.info "invoked stress_callback method #{p}"
+    @rjr_callback.notify 'client_callback', p
+    "barfoo #{p}"
+  end
+end

data/examples/tcp.rb

@@ -0,0 +1,29 @@
+#!/usr/bin/ruby
+# A RJR tcp-node example
+#
+# Copyright (C) 2013 Mohammed Morsi <mo@morsi.org>
+# Licensed under the Apache License, Version 2.0
+
+require 'rjr/nodes/tcp'
+
+server = RJR::Nodes::TCP.new :host => 'localhost', :port => 9789, :node_id => "server"
+server.dispatcher.handle('method') { |i|
+  puts "server: #{i}"
+  @rjr_callback.notify "callback", i.downcase
+  "#{i}".upcase
+}
+server.listen
+
+client = RJR::Nodes::TCP.new :node_id => "client", :host => 'localhost', :port => 9666
+client.dispatcher.handle('callback') { |i|
+  puts "callback: #{i}"
+  #client.halt
+}
+
+client.notify "jsonrpc://localhost:9789", "method", "Hello World"
+# => nil
+
+client.invoke "jsonrpc://localhost:9789", "method", "Hello World"
+# => HELLO WORLD
+
+#client.join

data/examples/web.rb

@@ -0,0 +1,22 @@
+#!/usr/bin/ruby
+# A RJR web-node example
+#
+# Copyright (C) 2013 Mohammed Morsi <mo@morsi.org>
+# Licensed under the Apache License, Version 2.0
+
+require 'rjr/nodes/web'
+
+server = RJR::Nodes::Web.new :host => 'localhost', :port => 9789, :node_id => "server"
+server.dispatcher.handle('method') { |i|
+  puts "server: #{i}"
+  "#{i}".upcase
+}
+server.listen
+
+client = RJR::Nodes::Web.new :node_id => "client", :host => 'localhost', :port => 9666
+client.notify "http://localhost:9789", "method", "Hello World"
+# => nil
+
+client.invoke "http://localhost:9789", "method", "Hello World"
+# => HELLO WORLD
+#client.join

data/examples/ws.rb

@@ -0,0 +1,29 @@
+#!/usr/bin/ruby
+# A RJR ws-node example
+#
+# Copyright (C) 2013 Mohammed Morsi <mo@morsi.org>
+# Licensed under the Apache License, Version 2.0
+
+require 'rjr/nodes/ws'
+
+server = RJR::Nodes::WS.new :host => 'localhost', :port => 9789, :node_id => "server"
+server.dispatcher.handle('method') { |i|
+  puts "server: #{i}"
+  @rjr_callback.notify "callback", i.downcase
+  "#{i}".upcase
+}
+server.listen
+
+client = RJR::Nodes::WS.new :node_id => "client", :host => 'localhost', :port => 9666
+client.dispatcher.handle('callback') { |i|
+  puts "callback: #{i}"
+  #client.halt
+}
+
+client.notify "ws://localhost:9789", "method", "Hello World"
+# => nil
+
+client.invoke "ws://localhost:9789", "method", "Hello World"
+# => HELLO WORLD
+
+#client.join

data/lib/rjr/common.rb

@@ -2,11 +2,17 @@
 #
 # Assortment of helper methods and methods that don't fit elsewhere
 #
-# Copyright (C) 2011-2012 Mohammed Morsi <mo@morsi.org>
+# Copyright (C) 2011-2013 Mohammed Morsi <mo@morsi.org>
 # Licensed under the Apache License, Version 2.0
 
 require 'logger'
 
+# Return a random uuid
+def gen_uuid
+  ["%02x"*4, "%02x"*2, "%02x"*2, "%02x"*2, "%02x"*6].join("-") %
+      Array.new(16) {|x| rand(0xff) }
+end
+
 module RJR
 
 # Logger helper class.
@@ -97,17 +103,6 @@ class Object
   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'
 #