rjr 0.19.1 → 0.19.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 517f79e571aae798dcc24be8feacd2ef5cbc3606
-  data.tar.gz: 340a496e1f47092a7b01a4b1363bac1db87b9e81
+  metadata.gz: 67d23eb4f09f94c96a7d601c338b4d5088605c24
+  data.tar.gz: 53bbd5973ce99fa089c5d4bf560e2e9fe6c9005c
 SHA512:
-  metadata.gz: 6b5e056c47862523e346cf2a47923146e0b15a3fb856071f20a4fa226d55fdb6046e5ec463c8aea4e356d96d49e707279d5b477549df2537041943aaa04513f7
-  data.tar.gz: 325453d870c227bd35826a3bab5933fc6a62e644f1efbb2d5de3f762e917b24e38908aa15cfad2d7d3aae2d6d2f8af8da57a7bf527f9558570a78412747c5b60
+  metadata.gz: 9b8a199e88e55fd824cdabaeebf750cd234624ade0b9fc2acd9640aec729d5a3ab4339f5ef0769f707916a830f987d7a95c680e7e0ea07b4f526bd97b1394d3c
+  data.tar.gz: 55e17f0513fedef6f3e5dccae5673317bf5943988ae5d2146c7c2d76fa7aaee0ce003495c774ad3b623421efdff5127338d88cbf78792f3ecde9434dd9629f31

data/README.md

@@ -166,3 +166,6 @@ RJR as this is not standard JSON-RPC.
 ### Authors ###
 * Mo Morsi <mo@morsi.org>
 * Ladislav Smola <ladislav.smola@it-logica.cz>
+* André Dieb Martins <andre.dieb@gmail.com>
+* Eric Bakan <eric@ebakan.com>
+* Jonas Collberg <jonas.collberg@gmail.com>

data/Rakefile

@@ -3,8 +3,6 @@
 # Copyright (C) 2010-2012 Mohammed Morsi <mo@morsi.org>
 # Licensed under the Apache License, Version 2.0
 
-# TODO fix travis build
-
 require "rspec/core/rake_task"
 
 desc "Run all specs"

data/examples/timeout.rb

@@ -0,0 +1,23 @@
+#!/usr/bin/ruby
+# A RJR timeout example
+#
+# Copyright (C) 2015 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|
+  sleep 2
+}
+server.listen
+
+client = RJR::Nodes::TCP.new :node_id => "client",
+                             :host    => 'localhost',
+                             :port    => 9666,
+                             :timeout => 1 # causes error, change to 3 to wait for server response
+
+client.invoke "jsonrpc://localhost:9789", "method", "Hello World"
+# => exception
+
+#client.join

data/lib/rjr/dispatcher.rb

@@ -152,7 +152,7 @@ class Dispatcher
     request = Request.new args.merge(:rjr_handler  => handler)
 
     # set request environment
-    request.extend(environment) unless environment.nil?
+    request.set_env(environment) unless environment.nil?
 
     begin
       retval = request.handle

data/lib/rjr/messages/intermediate.rb

@@ -0,0 +1,50 @@
+# RJR Intermediate Message
+#
+# Copyright (C) 2014-2015 Mohammed Morsi <mo@morsi.org>
+# Licensed under the Apache License, Version 2.0
+
+require 'json'
+require 'rjr/util/json_parser'
+
+module RJR
+module Messages
+
+# Intermediate representation of a JSON-RPC data containing
+# extracted/parsed data which has not been analysed.
+class Intermediate
+  # JSON from which data is extracted from
+  attr_accessor :json
+
+  # Data extracted from message
+  attr_accessor :data
+
+  def initialize(args = {})
+    @json = args[:json] || nil
+    @data = args[:data] ||  {}
+  end
+
+  def keys
+    data.keys
+  end
+
+  def [](key)
+    data[key.to_s]
+  end
+
+  def has?(key)
+    data.key?(key)
+  end
+
+  def self.parse(json)
+    parsed = nil
+
+    #allow parsing errs to propagate up
+    parsed = JSONParser.parse(json)
+
+    self.new :json => json,
+             :data => parsed
+  end
+
+end # class Intermediate
+end # module Messages
+end # module RJR

data/lib/rjr/messages/notification.rb

@@ -13,7 +13,7 @@ module Messages
 # indicate the result should _not_ be returned
 class Notification
   # Message string received from the source
-  attr_accessor :json_message
+  attr_accessor :message
 
   # Method source is invoking on the destination
   attr_accessor :jr_method
@@ -48,18 +48,17 @@ class Notification
   end
 
   def parse_message(message)
-    @json_message = message
-    notification  = JSONParser.parse(@json_message)
-    @jr_method    = notification['method']
-    @jr_args      = notification['params']
+    @message   = message
+    @jr_method = message['method']
+    @jr_args   = message['params']
 
-    parse_headers(notification)
+    parse_headers(message)
   end
 
-  def parse_headers(notification)
-    notification.keys.select { |k|
+  def parse_headers(message)
+    message.keys.select { |k|
       !['jsonrpc', 'method', 'params'].include?(k)
-    }.each { |k| @headers[k] = notification[k] }
+    }.each { |k| @headers[k] = message[k] }
   end
 
   public
@@ -70,13 +69,7 @@ class Notification
   # @param [String] message string message to check
   # @return [true,false] indicating if message is a notification message
   def self.is_notification_message?(message)
-    begin
-       # FIXME log error
-       parsed = JSONParser.parse(message)
-       parsed.has_key?('method') && !parsed.has_key?('id')
-    rescue Exception => e
-      false
-    end
+    message.has?('method') && !message.has?('id')
   end
 
   # Convert notification message to json

data/lib/rjr/messages/request.rb

@@ -12,7 +12,7 @@ module Messages
 # Message sent from client to server to invoke a JSON-RPC method
 class Request
   # Message string received from the source
-  attr_accessor :json_message
+  attr_accessor :message
 
   # Method source is invoking on the destination
   attr_accessor :jr_method
@@ -51,35 +51,29 @@ class Request
   end
 
   def parse_message(message)
-    @json_message = message
-    request       = JSONParser.parse(@json_message)
-    @jr_method    = request['method']
-    @jr_args      = request['params']
-    @msg_id       = request['id']
+    @message      = message
+    @jr_method    = message['method']
+    @jr_args      = message['params']
+    @msg_id       = message['id']
 
-    parse_headers(request)
+    parse_headers(message)
   end
 
-  def parse_headers(request)
-    request.keys.select { |k|
+  def parse_headers(message)
+    message.keys.select { |k|
       !['jsonrpc', 'id', 'method', 'params'].include?(k)
-    }.each { |k| @headers[k] = request[k] }
+    }.each { |k| @headers[k] = message[k] }
   end
 
   public
 
-  # Class helper to determine if the specified string is a valid json-rpc
-  # method request
-  # @param [String] message string message to check
+  # Class helper to determine if the specified message is a valid
+  # json-rpc method request message.
+  #
+  # @param [Message] message to check
   # @return [true,false] indicating if message is request message
   def self.is_request_message?(message)
-    begin
-       # FIXME log error
-       parsed = JSONParser.parse(message)
-       parsed.has_key?('method') && parsed.has_key?('id')
-    rescue Exception => e
-      false
-    end
+     message.has?('method') && message.has?('id')
   end
 
   # Convert request message to json

data/lib/rjr/messages/response.rb

@@ -13,7 +13,7 @@ module Messages
 # Message sent from server to client in response to a JSON-RPC request
 class Response
   # Message string received from the source
-  attr_accessor :json_message
+  attr_accessor :message
 
   # ID of the message in accordance w/ json-rpc specification
   attr_accessor :msg_id
@@ -49,54 +49,47 @@ class Response
   end
 
   def parse_message(message)
-    @json_message = message
-    response      = JSONParser.parse(@json_message)
-    @msg_id       = response['id']
+    @message = message
+    @msg_id  = message['id']
 
-    parse_result(response)
-    parse_headers(response)
+    parse_result(message)
+    parse_headers(message)
   end
 
-  def parse_result(response)
+  def parse_result(message)
     @result         = Result.new
-    @result.success = response.has_key?('result')
+    @result.success = message.has?('result')
     @result.failed  = !@result.success
 
     if @result.success
-      @result.result = response['result']
+      @result.result = message['result']
 
-    elsif response.has_key?('error')
-      @result.error_code  = response['error']['code']
-      @result.error_msg   = response['error']['message']
+    elsif message.has?('error')
+      @result.error_code  = message['error']['code']
+      @result.error_msg   = message['error']['message']
 
       # TODO can we safely constantize this ?
-      @result.error_class = response['error']['class']
+      @result.error_class = message['error']['class']
     end
 
     @result
   end
 
-  def parse_headers(request)
-    request.keys.select { |k|
+  def parse_headers(message)
+    message.keys.select { |k|
       !['jsonrpc', 'id', 'method', 'result', 'error'].include?(k)
-    }.each { |k| @headers[k] = request[k] }
+    }.each { |k| @headers[k] = message[k] }
   end
 
   public
 
-  # Class helper to determine if the specified string is a valid json-rpc
-  # method response
+  # Class helper to determine if the specified string is a
+  # valid json-rpc method response
+  #
   # @param [String] message string message to check
   # @return [true,false] indicating if message is response message
   def self.is_response_message?(message)
-    begin
-      # FIXME log error
-      json = JSONParser.parse(message)
-      json.has_key?('result') || json.has_key?('error')
-    rescue Exception => e
-      puts e.to_s
-      false
-    end
+    message.has?('result') || message.has?('error')
   end
 
   def success_json

data/lib/rjr/messages.rb

@@ -6,3 +6,4 @@
 require 'rjr/messages/request'
 require 'rjr/messages/response'
 require 'rjr/messages/notification'
+require 'rjr/messages/intermediate'

data/lib/rjr/node.rb

@@ -104,9 +104,12 @@ class Node
      clear_event_handlers
      @response_lock = Mutex.new
      @response_cv   = ConditionVariable.new
+     @pending       = {}
      @responses     = []
 
      @node_id         = args[:node_id]
+     @timeout         = args[:timeout]
+     @wait_interval   = args[:wait_interval] || 0.01
      @dispatcher      = args[:dispatcher] || RJR::Dispatcher.new
      @message_headers = args.has_key?(:headers) ? {}.merge(args[:headers]) : {}
 
@@ -143,14 +146,20 @@ class Node
   ##################################################################
   # Reset connection event handlers
   def clear_event_handlers
-    @connection_event_handlers = {:closed => [], :error => []}
+    @connection_event_handlers = {
+      :opened => [],
+      :closed => [],
+      :error  => []
+    }
   end
 
   # Register connection event handler
-  # @param [:error, :close] event the event to register the handler for
-  # @param [Callable] handler block param to be added to array of handlers
-  #   that are called when event occurs
-  # @yield [Node] self is passed to each registered handler when event occurs
+  # @param event [:opened, :closed, :error] the event to register the handler
+  #                                         for
+  # @param handler [Callable] block param to be added to array of handlers
+  #                           that are called when event occurs
+  # @yield [Node, *args] self and event-specific *args are passed to each
+  #                      registered handler when event occurs
   def on(event, &handler)
     return unless @connection_event_handlers.keys.include?(event)
     @connection_event_handlers[event] << handler
@@ -158,12 +167,11 @@ class Node
 
   private
 
-  # Internal helper, run connection event handlers for specified event
-  def connection_event(event)
+  # Internal helper, run connection event handlers for specified event, passing
+  # self and args to handler
+  def connection_event(event, *args)
     return unless @connection_event_handlers.keys.include?(event)
-    @connection_event_handlers[event].each { |h|
-      h.call self
-    }
+    @connection_event_handlers[event].each { |h| h.call(self, *args) }
   end
 
   ##################################################################
@@ -183,28 +191,36 @@ class Node
 
   # Internal helper, handle message received
   def handle_message(msg, connection = {})
-    if Messages::Request.is_request_message?(msg)
-      tp << ThreadPoolJob.new(msg) { |m| handle_request(m, false, connection) }
+    intermediate = Messages::Intermediate.parse(msg)
+
+    if Messages::Request.is_request_message?(intermediate)
+      tp << ThreadPoolJob.new(intermediate) { |i|
+              handle_request(i, false, connection)
+            }
 
-    elsif Messages::Notification.is_notification_message?(msg)
-      tp << ThreadPoolJob.new(msg) { |m| handle_request(m, true, connection) }
+    elsif Messages::Notification.is_notification_message?(intermediate)
+      tp << ThreadPoolJob.new(intermediate) { |i|
+              handle_request(i, true, connection)
+            }
 
-    elsif Messages::Response.is_response_message?(msg)
-      handle_response(msg)
+    elsif Messages::Response.is_response_message?(intermediate)
+      handle_response(intermediate)
 
     end
+
+    intermediate
   end
 
   # Internal helper, handle request message received
-  def handle_request(data, notification=false, connection={})
+  def handle_request(message, notification=false, connection={})
     # get client for the specified connection
     # TODO should grap port/ip immediately on connection and use that
     client_port,client_ip = client_for(connection)
 
     msg = notification ?
-      Messages::Notification.new(:message => data,
+      Messages::Notification.new(:message => message,
                                  :headers => @message_headers) :
-           Messages::Request.new(:message => data,
+           Messages::Request.new(:message => message,
                                  :headers => @message_headers)
 
     callback = NodeCallback.new(:node       => self,
@@ -233,8 +249,8 @@ class Node
   end
 
   # Internal helper, handle response message received
-  def handle_response(data)
-    msg    = Messages::Response.new(:message => data,
+  def handle_response(message)
+    msg    = Messages::Response.new(:message => message,
                                     :headers => self.message_headers)
     res = err = nil
     begin
@@ -254,25 +270,25 @@ class Node
   # Internal helper, block until response matching message id is received
   def wait_for_result(message)
     res = nil
+    message_id = message.msg_id
+    @pending[message_id] = Time.now
     while res.nil?
       @response_lock.synchronize{
-        # FIXME throw err if more than 1 match found
+        # Prune messages that timed out
+        if @timeout
+          now = Time.now
+          @pending.delete_if { |_, start_time| (now - start_time) > @timeout }
+        end
+        pending_ids = @pending.keys
+        raise Exception, 'Timed out' unless pending_ids.include? message_id
+
+        # Prune invalid responses
+        @responses.keep_if { |response| @pending.has_key? response.first }
         res = @responses.find { |response| message.msg_id == response.first }
         if !res.nil?
           @responses.delete(res)
-
         else
-          # FIXME if halt is invoked while this is sleeping, all other threads
-          # may be deleted resulting in this sleeping indefinetly and a deadlock
-
-          # TODO wait for a finite # of seconds, record time we started waiting
-          # before while loop and on every iteration check to see if we've been
-          # waiting longer than an optional timeout. If so throw an error (also
-          # need mechanism to discard result if it comes in later).
-          # finite # of seconds we wait and optional timeout should be
-          # configurable on node class
-          @response_cv.wait @response_lock
-
+          @response_cv.wait @response_lock, @wait_interval
         end
       }
     end

data/lib/rjr/nodes/amqp.rb

@@ -56,6 +56,17 @@ class AMQP < RJR::Node
 
   private
 
+  def amqp_options
+    opts = {}
+    opts[:host]  = @host  if @host
+    opts[:port]  = @port  if @port
+    opts[:vhost] = @vhost if @vhost
+    opts[:user]  = @user  if @user
+    opts[:pass]  = @pass  if @pass
+    opts[:ssl]   = @ssl   if @ssl
+    opts
+  end
+
   # Internal helper, initialize the amqp subsystem
   def init_node(&on_init)
      if !@conn.nil? && @conn.connected?
@@ -63,7 +74,7 @@ class AMQP < RJR::Node
        return
      end
 
-     @conn = ::AMQP.connect(:host => @broker) do |conn|
+     @conn = ::AMQP.connect(amqp_options) do |conn|
        ::AMQP.connection = conn # XXX not sure why this is needed but the amqp
                                 # em interface won't shut down cleanly otherwise
 
@@ -117,12 +128,17 @@ class AMQP < RJR::Node
   # @option args [String] :broker the amqp message broker which to connect to
   def initialize(args = {})
      super(args)
-     @broker        = args[:broker]
+     @host          = args[:host] || args[:broker]
+     @port          = args[:port]
+     @vhost         = args[:vhost]
+     @user          = args[:user] || args[:username]
+     @pass          = args[:pass] || args[:password]
+     @ssl           = args[:ssl]
      @amqp_lock     = Mutex.new
   end
 
   def to_s
-    "RJR::Nodes::AMQP<#{@node_id},#{@broker},#{@queue_name}>"
+    "RJR::Nodes::AMQP<#{@node_id},#{@host},#{@port},#{@vhost},#{@queue_name}>"
   end
 
   # Publish a message using the amqp exchange

data/lib/rjr/nodes/local.rb

@@ -61,8 +61,9 @@ class Local < RJR::Node
   # Implementation of RJR::Node#send_msg
   def send_msg(msg, connection)
     # ignore response message
-    unless Messages::Response.is_response_message?(msg)
-      launch_request(msg, true) # .join?
+    inter = Messages::Intermediate.parse(msg)
+    unless Messages::Response.is_response_message?(inter)
+      launch_request(inter, true) # .join?
     end
   end
 
@@ -80,9 +81,15 @@ class Local < RJR::Node
   # (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?
+    Thread.new(req, notification) { |req, notification|
+      inter = req.is_a?(Messages::Intermediate) ?    req :
+                        Messages::Intermediate.parse(req)
+      res = handle_request(inter, notification, nil)
+
+      unless res.nil?
+        inter = Messages::Intermediate.parse(res.to_s)
+        handle_response(inter)
+      end
     }
   end
 

data/lib/rjr/nodes/tcp.rb

@@ -33,6 +33,11 @@ class TCPConnection < EventMachine::Connection
 
     @send_lock = Mutex.new
     @data      = ""
+    @rjr_node.add_connection(self)
+  end
+
+  def post_init
+    @rjr_node.send(:connection_event, :opened, self)
   end
 
   # EventMachine::Connection#receive_data callback, handle request / response messages
@@ -54,6 +59,10 @@ class TCPConnection < EventMachine::Connection
     }
   end
 
+  def unbind
+    @rjr_node.remove_connection(self)
+    @rjr_node.send(:connection_event, :closed, self)
+  end
 end
 
 # TCP node definition, listen for and invoke json-rpc requests via TCP sockets
@@ -89,18 +98,8 @@ class TCP < RJR::Node
   # Internal helper, initialize new client
   def init_client(args={}, &on_init)
     host,port = args[:host], args[:port]
-    connection = nil
-    @connections_lock.synchronize {
-      connection = @connections.find { |c|
-                     port == c.port && host == c.host
-                   }
-      if connection.nil?
-        connection =
-          EventMachine::connect host, port,
-                      TCPConnection, args
-        @connections << connection
-      end
-    }
+    connection = @connections.find { |c| port == c.port && host == c.host }
+    connection ||= EventMachine::connect(host, port, TCPConnection, args)
     on_init.call(connection) # TODO move to tcpnode event ?
   end
 
@@ -140,6 +139,20 @@ class TCP < RJR::Node
     self
   end
 
+  # Called by TCPConnection::initialize
+  def add_connection(connection)
+    @connections_lock.synchronize do
+      connections << connection
+    end
+  end
+
+  # Called by TCPConnection::unbind
+  def remove_connection(connection)
+    @connections_lock.synchronize do
+      connections.delete(connection)
+    end
+  end
+
   # Instructs node to send rpc request, and wait for / return response.
   #
   # Implementation of RJR::Node#invoke

data/lib/rjr/nodes/web.rb

@@ -52,12 +52,13 @@ class WebConnection < EventMachine::Connection
   def process_http_request
     # TODO support http protocols other than POST
     msg = @http_post_content.nil? ? '' : @http_post_content
-    @rjr_node.send(:handle_message, msg, self) # XXX private method
+    inter = @rjr_node.send(:handle_message, msg, self) # XXX private method
 
     # XXX we still have to send a response back to client to satisfy 
     # the http standard, even if this is a notification. handle_message
     # does not do this.
-    @rjr_node.send_msg "", self if Messages::Notification.is_notification_message?(msg)
+    notification = Messages::Notification.is_notification_message?(inter)
+    @rjr_node.send_msg "", self if notification
   end
 end
 

data/lib/rjr/request.rb

@@ -50,6 +50,9 @@ class Request
   # ID of node which request came in on
   attr_accessor :rjr_node_id
 
+  # Environment handler will be run in
+  attr_accessor :rjr_env
+
   # Actual proc registered to handle request
   attr_accessor :rjr_handler
 
@@ -73,7 +76,14 @@ class Request
     @rjr_handler     = args[:rjr_handler]
 
     @rjr_args        = Arguments.new :args => @rjr_method_args
-    @result = nil
+    @rjr_env         = nil
+    @result          = nil
+  end
+
+  # Set the environment by extending Request instance with the specified module
+  def set_env(env)
+    @rjr_env = env
+    self.extend(env)
   end
 
   # Invoke the request by calling the registered handler with the registered