rjr 0.17.1 → 0.18.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: df6830242efa865dde4af4008827688172011746
-  data.tar.gz: 33c559f6fa14957b7aa5929f3030ab4455e93b8e
+  metadata.gz: f5a404d0bde0749357c01f0e57696e73ff39ea6d
+  data.tar.gz: 0c5394cf7df7774def9553b772c1cb92c53504de
 SHA512:
-  metadata.gz: 240533c8a5aafa5980337b18fae10bf4f24a9e72e93ce6e88f42c82169ee81fbb5f850a5817a6ed1091f9ed62e96145e3b478f67b2122c15c39dbf13a29ff131
-  data.tar.gz: 56ef3f372c94eead71df0d5b534122a244c3602b4aab84c3c181d40711066c8ab7da303f3cb8f676531d6150e0f1c6be0c2836320bbda749a53f3451cdc7f5f0
+  metadata.gz: cf24b7e0fc705957af5ffe74879ab053a78393f33b28070cde205cb04a3879282d492dec85efd29938a6f51c27bee5a1ec3b6b6294e683d6bed7ed1cc0dfb1bb
+  data.tar.gz: ed2bf6a3203387e00aeb5c84f0d836c50833ddd4901c581085ae66c8b286cddbba356ea0023bf8cbd6221c5b693a5508675ad9697f70023cdc319dd6f1f58335

data/examples/unix.rb

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

data/lib/rjr/nodes/file.rb

@@ -0,0 +1 @@
+# TODO read/write jsonrpc from a watched file (eg EM's inotify interface)

data/lib/rjr/nodes/tcp.rb

@@ -16,7 +16,7 @@ module RJR
 module Nodes
 
 # @private
-# Helper class intialized by eventmachine encapsulating a socket connection
+# Helper class intialized by eventmachine encapsulating a tcp socket connection
 class TCPConnection < EventMachine::Connection
   attr_reader :host
   attr_reader :port
@@ -209,7 +209,7 @@ class TCP < RJR::Node
     #sleep 0.01 until conn.get_outbound_data_size == 0
     nil
   end
-end
+end # class TCP
 
 end # module Nodes
 end # module RJR

data/lib/rjr/nodes/template.rb

@@ -0,0 +1,66 @@
+# RJR Template Node
+#
+# Just serves as a minimal example of a node, should
+# not be used. Developers can copy / base additional
+# transport types off this template
+#
+# Copyright (C) 2013 Mohammed Morsi <mo@morsi.org>
+# Licensed under the Apache License, Version 2.0
+
+require 'rjr/node'
+
+module RJR
+module Nodes
+
+class Template < RJR::Node
+  RJR_NODE_TYPE = :tpl
+
+  # Template Node Initializer
+  def initialize(args = {})
+     super(args)
+  end
+
+  def to_s
+    "RJR::Nodes::Template<>"
+  end
+
+  # Send data using specified connection
+  #
+  # Implementation of {RJR::Node#send_msg}
+  def send_msg(data, connection)
+    # TODO
+  end
+
+  # Instruct Node to start listening for and dispatching rpc requests
+  #
+  # Implementation of {RJR::Node#listen}
+  def listen
+    # TODO
+    self
+  end
+
+  # Instructs node to send rpc request, and wait for / return response.
+  #
+  # Implementation of {RJR::Node#invoke}
+  # @param [String] optional_destination if the transport requires it, param
+  #   to specify the target of this request, if not remove this param
+  # @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 invoke(optional_destination, rpc_method, *args)
+    # TODO
+  end
+
+  # Instructs node to send rpc notification (immadiately returns / no response is generated)
+  #
+  # Implementation of {RJR::Node#notify}
+  # @param [String] optional_destination if the transport requires it, param
+  #   to specify the target of this request, if not remove this param
+  # @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(optional_destination, rpc_method, *args)
+    # TODO
+  end
+end # class Template
+
+end # module Nodes
+end # module RJR

data/lib/rjr/nodes/unix.rb

@@ -0,0 +1,192 @@
+# RJR Unix Socket Node
+#
+# Implements the RJR::Node interface to issue and satisty JSON-RPC requests
+# via Unix Sockets
+#
+# Copyright (C) 2013 Mohammed Morsi <mo@morsi.org>
+# Licensed under the Apache License, Version 2.0
+
+# TODO extract common bits between here &
+# tcp node into common base socked module
+
+require 'thread'
+require 'eventmachine'
+
+require 'rjr/node'
+require 'rjr/message'
+
+module RJR
+module Nodes
+
+# @private
+# Helper class intialized by eventmachine encapsulating a unix socket connection
+class UnixConnection < EventMachine::Connection
+  attr_reader :socketname
+
+  # UnixConnection intializer
+  #
+  # Specify the Unix Node establishing the connection and
+  # optionaly socketname which this connection is connected to
+  def initialize(args = {})
+    @rjr_node   = args[:rjr_node]
+    @socketname = args[:socketname]
+
+    @send_lock = Mutex.new
+    @data      = ""
+  end
+
+  # {EventMachine::Connection#receive_data} callback, handle request / response messages
+  def receive_data(data)
+    # a large json-rpc message may be split over multiple packets
+    #   (invocations of receive_data)
+    # and multiple messages may be concatinated into one packet
+    @data += data
+    while extracted = MessageUtil.retrieve_json(@data)
+      msg, @data = *extracted
+      @rjr_node.send(:handle_message, msg, self) # XXX private method
+    end
+  end
+
+  # Send data safely using local connection
+  def send_msg(data)
+    @send_lock.synchronize{
+      Unix.em.schedule { send_data(data) }
+    }
+  end
+end
+
+# Unix node definition, listen for and invoke json-rpc requests via Unix Sockets
+#
+# Clients should specify the socketname when listening for requests and
+# when invoking them.
+#
+# TODO client / server examples
+#
+class Unix < RJR::Node
+  RJR_NODE_TYPE = :unix
+
+  attr_accessor :connections
+
+  private
+  # Internal helper, initialize new client
+  def init_client(args={}, &on_init)
+    socketname = args[:socketname]
+    connection = nil
+    @connections_lock.synchronize {
+      connection = @connections.find { |c|
+                     socketname == c.socketname
+                   }
+      if connection.nil?
+        connection =
+          EventMachine::connect_unix_domain socketname,
+                      nil, UnixConnection, args
+        @connections << connection
+      end
+    }
+    on_init.call(connection) # TODO move to unixnode event ?
+  end
+
+  public
+
+  # Unix initializer
+  # @param [Hash] args the options to create the unix node with
+  # @option args [String] :socketname the name of the socket which to listen on
+  def initialize(args = {})
+     super(args)
+     @socketname = args[:socketname]
+
+     @connections = []
+     @connections_lock = Mutex.new
+  end
+
+  def to_s
+    "RJR::Nodes::Unix<#{@node_id},#{@socketname}>"
+  end
+
+  # Send data using specified connection
+  #
+  # Implementation of {RJR::Node#send_msg}
+  def send_msg(data, connection)
+    connection.send_msg(data)
+  end
+
+  # Instruct Node to start listening for and dispatching rpc requests
+  #
+  # Implementation of {RJR::Node#listen}
+  def listen
+    @@em.schedule {
+      @@em.start_unix_domain_server @socketname, nil, UnixConnection, { :rjr_node => self }
+    }
+    self
+  end
+
+  # Instructs node to send rpc request, and wait for / return response.
+  #
+  # Implementation of {RJR::Node#invoke}
+  #
+  # Do not invoke directly from em event loop or callback as will block the message
+  # subscription used to receive responses
+  #
+  # @param [String] socketname name of socket which destination node is
+  #   listening on
+  # @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 invoke(socketname, rpc_method, *args)
+    message = RequestMessage.new :method => rpc_method,
+                                 :args   => args,
+                                 :headers => @message_headers
+    connection = nil
+    @@em.schedule {
+      init_client(:socketname => socketname,
+                  :rjr_node => self) { |c|
+        connection = c
+        c.send_msg message.to_s
+      }
+    }
+
+    # TODO optional timeout for response ?
+    result = wait_for_result(message)
+
+    if result.size > 2
+      raise Exception, result[2]
+    end
+    return result[1]
+  end
+
+  # Instructs node to send rpc notification (immadiately returns / no response is generated)
+  #
+  # Implementation of {RJR::Node#notify}
+  #
+  # @param [String] socketname name of socket which
+  # destination node is listening on
+  # @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(socketname, rpc_method, *args)
+    # will block until message is published
+    published_l = Mutex.new
+    published_c = ConditionVariable.new
+
+    invoked = false
+    conn    = nil
+    message = NotificationMessage.new :method => rpc_method,
+                                      :args   => args,
+                                      :headers => @message_headers
+    @@em.schedule {
+      init_client(:socketname => socketname,
+                  :rjr_node => self) { |c|
+        conn = c
+        c.send_msg message.to_s
+        # XXX, this should be invoked only when we are sure event
+        # machine sent message. Shouldn't pose a problem unless event
+        # machine is killed immediately after
+        published_l.synchronize { invoked = true ; published_c.signal }
+      }
+    }
+    published_l.synchronize { published_c.wait published_l unless invoked }
+    #sleep 0.01 until conn.get_outbound_data_size == 0
+    nil
+  end
+end # class Unix
+
+end # module Nodes
+end # module RJR

data/lib/rjr/nodes/web.rb

@@ -8,6 +8,8 @@
 # Copyright (C) 2012-2013 Mohammed Morsi <mo@morsi.org>
 # Licensed under the Apache License, Version 2.0
 
+# TODO rename to HTTP
+
 skip_module = false
 begin
 require 'evma_httpserver'

data/lib/rjr/nodes/xmpp.rb

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

data/lib/rjr/version.rb

@@ -1,3 +1,3 @@
 module RJR
-  VERSION = '0.17.1'
+  VERSION = '0.18.1'
 end

data/site/jrw.js

@@ -65,19 +65,80 @@ RJR.JRMessage.convert_params = function(params){
   for(var p = 0; p < params.length; p++){
     var param = params[p];
     if(RJR.is_jr_object(param)){
-      // FIXME need to check each param property as well (converting if necessary)
-      var json_class = param['json_class'];
-      delete param['json_class'];
-      jrparams.push({json_class: json_class,
-                     data      :      param});
-    }else if(RJR.is_array(param))
+      jrparams.push(RJR.JRMessage.convert_obj_to_jr_obj(param));
+    }else if(RJR.is_array(param)){
+      /// TODO s/convert_params/convert_array_to_jr_array here ?
+      /// (or could the whole convert_params method could be
+      ///  consolidated with that one ?)
       jrparams.push(RJR.JRMessage.convert_params(param));
-    else
+    }else
       jrparams.push(param);
   }
   return jrparams;
 }
 
+// Convert single json object to jr object
+RJR.JRMessage.convert_obj_to_jr_obj= function(obj){
+  var jr_obj = $.extend(true, {}, obj)
+  var json_class = jr_obj['json_class'];
+  delete jr_obj['json_class'];
+
+  /// iterate over object properties
+  for(var p in jr_obj){
+    if(RJR.is_jr_object(jr_obj[p]))
+      jr_obj[p] = RJR.JRMessage.convert_obj_to_jr_obj(jr_obj[p]);
+    else if(RJR.is_array(jr_obj[p]))
+      jr_obj[p] = RJR.JRMessage.convert_array_to_jr_array(jr_obj[p]);
+  }
+
+  return {json_class: json_class,
+          data      :    jr_obj};
+}
+
+// Convert single json object from jr object
+RJR.JRMessage.convert_obj_from_jr_obj = function(jr_obj){
+  var obj = $.extend(true, {}, jr_obj)
+  if(obj.data){
+    $.extend(obj, obj.data);
+    delete obj['data'];
+  }
+
+  for(var p in obj){
+    if(RJR.is_jr_object(obj[p]))
+      obj[p] = RJR.JRMessage.convert_obj_from_jr_obj(obj[p]);
+    else if(RJR.is_array(obj[p]))
+      obj[p] = RJR.JRMessage.convert_array_from_jr_array(obj[p]);
+  }
+
+  return obj;
+}
+
+// Recursively convert array to jr object array
+RJR.JRMessage.convert_array_to_jr_array = function(array){
+  var jr_array = $.extend(true, [], array)
+  for(var a = 0; a < jr_array.length; a++){
+    if(RJR.is_jr_object(jr_array[a]))
+      jr_array[a] = RJR.JRMessage.convert_obj_to_jr_obj(jr_array[a]);
+    else if(RJR.is_array(jr_array[a]))
+      jr_array[a] = RJR.JRMesage.convert_array_to_jr_array(jr_array[a]);
+  }
+
+  return jr_array;
+}
+
+// Convert json object array from jr object array
+RJR.JRMessage.convert_array_from_jr_array = function(jr_array){
+  var array = $.extend(true, [], jr_array)
+  for(var a = 0; a < array.length; a++){
+    if(RJR.is_jr_object(array[a]))
+      array[a] = RJR.JRMessage.convert_obj_from_jr_obj(array[a]);
+    else if(RJR.is_array(jr_array[a]))
+      array[a] = RJR.JRMessage.convert_array_from_jr_array(array[a]);
+  }
+
+  return array;
+}
+
 // Parse a json string to a JRMessage
 RJR.JRMessage.parse = function(json){
   var data = $.evalJSON(json);

data/specs/nodes/unix_spec.rb

@@ -0,0 +1,71 @@
+require 'rjr/nodes/unix'
+
+module RJR::Nodes
+  describe Unix do
+    describe "#send_msg" do
+      it "should send message using the specifed connection"
+    end
+
+    describe "#listen" do
+      it "should listen for messages" do
+        rn = rni = rnt = p = invoked = nil
+        server  = Unix.new :node_id => 'unix',
+                           :socketname => './test.sock'
+        server.dispatcher.handle('foobar') { |param|
+          rn  = @rjr_node
+          rni = @rjr_node_id
+          rnt = @rjr_node_type
+          p   = param
+          invoked = true
+        }
+        server.listen
+
+        # issue request
+        Unix.new.invoke './test.sock', 'foobar', 'myparam'
+        server.halt.join
+        rn.should == server
+        rni.should == 'unix'
+        rnt.should == :unix
+        p.should == 'myparam'
+        invoked.should == true
+      end
+    end
+
+    describe "#invoke" do
+      it "should invoke request" do
+        server  = Unix.new :node_id => 'unix',
+                           :socketname => './test.sock'
+        server.dispatcher.handle('foobar') { |param|
+          'retval'
+        }
+        server.listen
+
+        client = Unix.new
+        res = client.invoke './test.sock', 'foobar', 'myparam'
+        server.halt.join
+        res.should == 'retval'
+      end
+    end
+
+    describe "#notify" do
+      it "should send notification" do
+        server  = Unix.new :node_id => 'unix',
+                           :socketname => './test.sock'
+        server.dispatcher.handle('foobar') { |param|
+          'retval'
+        }
+        server.listen
+
+        client = Unix.new
+        res = client.notify './test.sock', 'foobar', 'myparam'
+        server.halt.join
+        res.should == nil
+      end
+    end
+
+    # TODO test callbacks over unix interface
+    # TODO ensure closed / error event handlers are invoked
+  end
+end
+
+

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rjr
 version: !ruby/object:Gem::Version
-  version: 0.17.1
+  version: 0.18.1
 platform: ruby
 authors:
 - Mo Morsi
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-12-17 00:00:00.000000000 Z
+date: 2013-12-31 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
@@ -69,6 +69,7 @@ files:
 - examples/complete.rb
 - examples/amqp.rb
 - examples/client.rb
+- examples/unix.rb
 - lib/rjr/semaphore.rb
 - lib/rjr/em_adapter.rb
 - lib/rjr/errors.rb
@@ -86,7 +87,11 @@ files:
 - lib/rjr/nodes/tcp2.rb
 - lib/rjr/nodes/local.rb
 - lib/rjr/nodes/amqp.rb
+- lib/rjr/nodes/xmpp.rb
+- lib/rjr/nodes/file.rb
+- lib/rjr/nodes/template.rb
 - lib/rjr/nodes/easy.rb
+- lib/rjr/nodes/unix.rb
 - lib/rjr/nodes/missing.rb
 - lib/rjr/nodes/multi.rb
 - lib/rjr/dispatcher.rb
@@ -99,6 +104,7 @@ files:
 - README.md
 - specs/dispatcher_spec.rb
 - specs/node_spec.rb
+- specs/nodes/unix_spec.rb
 - specs/nodes/multi_spec.rb
 - specs/nodes/tcp_spec.rb
 - specs/nodes/web_spec.rb
@@ -149,6 +155,7 @@ summary: JSON RPC server and client library over amqp, websockets, http, etc
 test_files:
 - specs/dispatcher_spec.rb
 - specs/node_spec.rb
+- specs/nodes/unix_spec.rb
 - specs/nodes/multi_spec.rb
 - specs/nodes/tcp_spec.rb
 - specs/nodes/web_spec.rb