rjr 0.18.2 → 0.19.1

data/lib/rjr/messages/notification.rb

@@ -0,0 +1,95 @@
+# RJR Notification Message
+#
+# Copyright (C) 2012-2014 Mohammed Morsi <mo@morsi.org>
+# Licensed under the Apache License, Version 2.0
+
+require 'json'
+require 'rjr/util/json_parser'
+
+module RJR
+module Messages
+
+# Message sent to a JSON-RPC server to invoke a rpc method but
+# indicate the result should _not_ be returned
+class Notification
+  # Message string received from the source
+  attr_accessor :json_message
+
+  # Method source is invoking on the destination
+  attr_accessor :jr_method
+
+  # Arguments source is passing to destination method
+  attr_accessor :jr_args
+
+  # Optional headers to add to json outside of standard json-rpc request
+  attr_accessor :headers
+
+  # RJR Notification Message initializer
+  #
+  # No message id will be generated in accordance w/ the jsonrpc standard
+  #
+  # @param [Hash] args options to set on request
+  # @option args [String] :message json string received from sender
+  # @option args [Hash] :headers optional headers to set in request and subsequent messages
+  # @option args [String] :method method to invoke on server
+  # @option args [Array<Object>] :args to pass to server method, all must be convertable to/from json
+  def initialize(args = {})
+    parse_args(args)
+  end
+
+  private
+
+  def parse_args(args)
+    @jr_method = args[:method]
+    @jr_args   = args[:args]    || []
+    @headers   = args[:headers] || {}
+
+    parse_message(args[:message]) if args.has_key?(:message)
+  end
+
+  def parse_message(message)
+    @json_message = message
+    notification  = JSONParser.parse(@json_message)
+    @jr_method    = notification['method']
+    @jr_args      = notification['params']
+
+    parse_headers(notification)
+  end
+
+  def parse_headers(notification)
+    notification.keys.select { |k|
+      !['jsonrpc', 'method', 'params'].include?(k)
+    }.each { |k| @headers[k] = notification[k] }
+  end
+
+  public
+
+  # Class helper to determine if the specified string is a valid json-rpc
+  # 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
+  end
+
+  # Convert notification message to json
+  def to_json(*a)
+    {'jsonrpc' => '2.0',
+     'method'  => @jr_method,
+     'params'  => @jr_args}.merge(@headers).to_json(*a)
+  end
+
+  # Convert request to string format
+  def to_s
+    to_json.to_s
+  end
+end # class Notification
+end # module Messages
+end # module RJR

data/lib/rjr/messages/request.rb

@@ -0,0 +1,99 @@
+# RJR Request Message
+#
+# Copyright (C) 2012-2014 Mohammed Morsi <mo@morsi.org>
+# Licensed under the Apache License, Version 2.0
+
+require 'json'
+require 'rjr/util/json_parser'
+
+module RJR
+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
+
+  # Method source is invoking on the destination
+  attr_accessor :jr_method
+
+  # Arguments source is passing to destination method
+  attr_accessor :jr_args
+
+  # ID of the message in accordance w/ json-rpc specification
+  attr_accessor :msg_id
+
+  # Optional headers to add to json outside of standard json-rpc request
+  attr_accessor :headers
+
+  # RJR Request Message initializer
+  #
+  # @param [Hash] args options to set on request
+  # @option args [String] :message json string received from sender
+  # @option args [Hash] :headers optional headers to set in request
+  #   and subsequent messages
+  # @option args [String] :method method to invoke on server
+  # @option args [Array<Object>] :args to pass to server method, all
+  #   must be convertable to/from json
+  def initialize(args = {})
+    parse_args(args)
+  end
+
+  private
+
+  def parse_args(args)
+    @jr_method = args[:method]
+    @jr_args   = args[:args]    || []
+    @headers   = args[:headers] || {}
+    @msg_id    = args[:id]      || gen_uuid
+
+    parse_message(args[:message]) if args.has_key?(:message)
+  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']
+
+    parse_headers(request)
+  end
+
+  def parse_headers(request)
+    request.keys.select { |k|
+      !['jsonrpc', 'id', 'method', 'params'].include?(k)
+    }.each { |k| @headers[k] = request[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
+  # @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
+  end
+
+  # Convert request message to json
+  def to_json(*a)
+    {'jsonrpc' => '2.0',
+     'id'      => @msg_id,
+     'method'  => @jr_method,
+     'params'  => @jr_args}.merge(@headers).to_json(*a)
+  end
+
+  # Convert request to string format
+  def to_s
+    to_json.to_s
+  end
+end # class Request
+end # module Messages
+end # module RJR

data/lib/rjr/messages/response.rb

@@ -0,0 +1,128 @@
+# RJR Response Message
+#
+# Copyright (C) 2012-2014 Mohammed Morsi <mo@morsi.org>
+# Licensed under the Apache License, Version 2.0
+
+require 'json'
+require 'rjr/result'
+require 'rjr/util/json_parser'
+
+module RJR
+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
+
+  # ID of the message in accordance w/ json-rpc specification
+  attr_accessor :msg_id
+
+  # Result encapsulated in the response message
+  # @see RJR::Result
+  attr_accessor :result
+
+  # Optional headers to add to json outside of standard json-rpc request
+  attr_accessor :headers
+
+  # ResponseMessage initializer
+  #
+  # @param [Hash] args options to set on request
+  # @option args [String] :message json string received from sender
+  # @option args [Hash] :headers optional headers to set in request
+  #   and subsequent messages
+  # @option args [String] :id id to set in response message, should
+  #   be same as that in received message
+  # @option args [RJR::Result] :result result of json-rpc method invocation
+  def initialize(args = {})
+    parse_args(args)
+  end
+
+  private
+
+  def parse_args(args)
+    @msg_id  = args[:id]
+    @result  = args[:result]
+    @headers = args[:headers] || {}
+
+    parse_message(args[:message]) if args.has_key?(:message)
+  end
+
+  def parse_message(message)
+    @json_message = message
+    response      = JSONParser.parse(@json_message)
+    @msg_id       = response['id']
+
+    parse_result(response)
+    parse_headers(response)
+  end
+
+  def parse_result(response)
+    @result         = Result.new
+    @result.success = response.has_key?('result')
+    @result.failed  = !@result.success
+
+    if @result.success
+      @result.result = response['result']
+
+    elsif response.has_key?('error')
+      @result.error_code  = response['error']['code']
+      @result.error_msg   = response['error']['message']
+
+      # TODO can we safely constantize this ?
+      @result.error_class = response['error']['class']
+    end
+
+    @result
+  end
+
+  def parse_headers(request)
+    request.keys.select { |k|
+      !['jsonrpc', 'id', 'method', 'result', 'error'].include?(k)
+    }.each { |k| @headers[k] = request[k] }
+  end
+
+  public
+
+  # 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
+  end
+
+  def success_json
+    {'result' => @result.result}
+  end
+
+  def error_json
+    {'error' => {'code'    => @result.error_code,
+                 'message' => @result.error_msg,
+                 'class'   => @result.error_class}}
+  end
+
+  # Convert request message to json
+  def to_json(*a)
+    result_json = @result.success ? success_json : error_json
+
+    {'jsonrpc' => '2.0',
+     'id'      => @msg_id}.merge(@headers).
+                           merge(result_json).to_json(*a)
+  end
+
+  # Convert request to string format
+  def to_s
+    to_json.to_s
+  end
+
+end # class Response
+end # module Messages
+end # module RJR

data/lib/rjr/node.rb

@@ -1,15 +1,14 @@
 # RJR Base Node Interface
 #
-# Copyright (C) 2012-2013 Mohammed Morsi <mo@morsi.org>
+# Copyright (C) 2012-2014 Mohammed Morsi <mo@morsi.org>
 # Licensed under the Apache License, Version 2.0
 
-require 'thread'
 require 'socket'
-require 'rjr/common'
-require 'rjr/message'
+require 'rjr/messages'
 require 'rjr/dispatcher'
-require 'rjr/em_adapter'
-require 'rjr/thread_pool'
+require 'rjr/util/em_adapter'
+require 'rjr/util/thread_pool'
+require 'rjr/node_callback'
 
 module RJR
 
@@ -21,7 +20,8 @@ module RJR
 # Each subclass should define 
 #  * RJR_NODE_TYPE - unique id of the transport
 #  * listen method - begin listening for new requests and return
-#  * send_message(msg, connection) - send message using the specified connection (transport dependent)
+#  * send_message(msg, connection) - send message using the specified connection
+#    (transport dependent)
 #  * invoke - establish connection, send message, and wait for / return result
 #  * notify - establish connection, send message, and immediately return
 #
@@ -44,12 +44,21 @@ class Node
   # Dispatcher to use to satisfy requests
   attr_accessor :dispatcher
 
+  # Handlers for various connection events
+  attr_reader :connection_event_handlers
+
   class <<self
     # Bool indiciting if this node is persistent
     def persistent?
       self.const_defined?(:PERSISTENT_NODE) &&
       self.const_get(:PERSISTENT_NODE)
     end
+
+    # Bool indiciting if this node is indirect
+    def indirect?
+      self.const_defined?(:INDIRECT_NODE) &&
+      self.const_get(:INDIRECT_NODE)
+    end
   end
 
   # Bool indicating if this node class is persistent
@@ -57,20 +66,39 @@ class Node
     self.class.persistent?
   end
 
+  # Bool indicating if this node class is indirect
+  def indirect?
+    self.class.indirect?
+  end
+
   # alias of RJR_NODE_TYPE
   def node_type
-    self.class::RJR_NODE_TYPE
+    self.class.const_defined?(:RJR_NODE_TYPE) ?
+    self.class.const_get(:RJR_NODE_TYPE) : nil
+  end
+
+  def self.em
+    defined?(@@em) ? @@em : nil
+  end
+
+  def em
+    self.class.em
   end
 
-  # XXX used by debugging / stats interface
-  def self.em ; defined?(@@em) ? @@em : nil end
-  def self.tp ; defined?(@@tp) ? @@tp : nil end
+  def self.tp
+    defined?(@@tp) ? @@tp : nil
+  end
+
+  def tp
+    self.class.tp
+  end
 
   # RJR::Node initializer
   #
   # @param [Hash] args options to set on request
   # @option args [String] :node_id unique id of the node
-  # @option args [Hash<String,String>] :headers optional headers to set on all json-rpc messages
+  # @option args [Hash<String,String>] :headers optional headers to set
+  #   on all json-rpc messages
   # @option args [Dispatcher] :dispatcher dispatcher to assign to the node
   def initialize(args = {})
      clear_event_handlers
@@ -86,28 +114,29 @@ class Node
      @@em ||= EMAdapter.new
 
      # will do nothing if already started
-     @@tp.start
-     @@em.start
+     tp.start
+     em.start
   end
 
-  # Block until the eventmachine reactor and thread pool have both completed running
+  # Block until the eventmachine reactor and thread pool have both
+  # completed running.
   #
   # @return self
   def join
-    @@tp.join
-    @@em.join
+    tp.join
+    em.join
     self
   end
 
   # Immediately terminate the node
   #
-  # *Warning* this does what it says it does. All running threads, and reactor
-  # jobs are immediately killed
+  # *Warning* this does what it says it does. All running threads,
+  # and reactor jobs are immediately killed
   #
   # @return self
   def halt
-    @@em.stop_event_loop
-    @@tp.stop
+    em.stop_event_loop
+    tp.stop
     self
   end
 
@@ -119,36 +148,48 @@ class Node
 
   # 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
+  # @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
   def on(event, &handler)
-    if @connection_event_handlers.keys.include?(event)
-      @connection_event_handlers[event] << handler
-    end
+    return unless @connection_event_handlers.keys.include?(event)
+    @connection_event_handlers[event] << handler
   end
 
   private
 
   # Internal helper, run connection event handlers for specified event
   def connection_event(event)
-    if @connection_event_handlers.keys.include?(event)
-      @connection_event_handlers[event].each { |h|
-        h.call self
-      }
-    end
+    return unless @connection_event_handlers.keys.include?(event)
+    @connection_event_handlers[event].each { |h|
+      h.call self
+    }
   end
 
   ##################################################################
 
+  # Internal helper, extract client info from connection
+  def client_for(connection)
+    # skip if an indirect node type or local
+    return nil, nil if self.indirect? || self.node_type == :local
+
+    begin
+      return Socket.unpack_sockaddr_in(connection.get_peername)
+    rescue Exception=>e
+    end
+
+    return nil, nil
+  end
+
   # Internal helper, handle message received
   def handle_message(msg, connection = {})
-    if RequestMessage.is_request_message?(msg)
-      @@tp << ThreadPoolJob.new(msg) { |m| handle_request(m, false, connection) }
+    if Messages::Request.is_request_message?(msg)
+      tp << ThreadPoolJob.new(msg) { |m| handle_request(m, false, connection) }
 
-    elsif NotificationMessage.is_notification_message?(msg)
-      @@tp << ThreadPoolJob.new(msg) { |m| handle_request(m, true, connection) }
+    elsif Messages::Notification.is_notification_message?(msg)
+      tp << ThreadPoolJob.new(msg) { |m| handle_request(m, true, connection) }
 
-    elsif ResponseMessage.is_response_message?(msg)
+    elsif Messages::Response.is_response_message?(msg)
       handle_response(msg)
 
     end
@@ -158,39 +199,32 @@ class Node
   def handle_request(data, notification=false, connection={})
     # get client for the specified connection
     # TODO should grap port/ip immediately on connection and use that
-    client_port,client_ip = nil,nil
-    begin
-      # XXX skip if an 'indirect' node type or local
-      unless [:amqp, :local].include?(self.class::RJR_NODE_TYPE)
-        client_port, client_ip =
-          Socket.unpack_sockaddr_in(connection.get_peername)
-      end
-    rescue Exception=>e
-    end
+    client_port,client_ip = client_for(connection)
 
     msg = notification ?
-      NotificationMessage.new(:message => data,
-                              :headers => @message_headers) :
-            RequestMessage.new(:message => data,
-                               :headers => @message_headers)
-
-    result =
-      @dispatcher.dispatch(:rjr_method      => msg.jr_method,
-                           :rjr_method_args => msg.jr_args,
-                           :rjr_headers     => msg.headers,
-                           :rjr_client_ip   => client_ip,
-                           :rjr_client_port => client_port,
-                           :rjr_node        => self,
-                           :rjr_node_id     => @node_id,
-                           :rjr_node_type   => self.class::RJR_NODE_TYPE,
-                           :rjr_callback    =>
-                             NodeCallback.new(:node       => self,
-                                              :connection => connection))
+      Messages::Notification.new(:message => data,
+                                 :headers => @message_headers) :
+           Messages::Request.new(:message => data,
+                                 :headers => @message_headers)
+
+    callback = NodeCallback.new(:node       => self,
+                                :connection => connection)
+
+    result = @dispatcher.dispatch(:rjr_method      => msg.jr_method,
+                                  :rjr_method_args => msg.jr_args,
+                                  :rjr_headers     => msg.headers,
+                                  :rjr_client_ip   => client_ip,
+                                  :rjr_client_port => client_port,
+                                  :rjr_node        => self,
+                                  :rjr_node_id     => node_id,
+                                  :rjr_node_type   => self.node_type,
+                                  :rjr_callback    => callback)
 
     unless notification
-      response = ResponseMessage.new(:id => msg.msg_id,
-                                     :result => result,
-                                     :headers => msg.headers)
+      response = Messages::Response.new(:id      => msg.msg_id,
+                                        :result  => result,
+                                        :headers => msg.headers,
+                                        :request => msg)
       self.send_msg(response.to_s, connection)
       return response
     end
@@ -200,7 +234,8 @@ class Node
 
   # Internal helper, handle response message received
   def handle_response(data)
-    msg    = ResponseMessage.new(:message => data, :headers => self.message_headers)
+    msg    = Messages::Response.new(:message => data,
+                                    :headers => self.message_headers)
     res = err = nil
     begin
       res = @dispatcher.handle_response(msg.result)
@@ -243,37 +278,5 @@ class Node
     end
     return res
   end
-
 end # class Node
-
-# Node callback interface, used to invoke json-rpc methods
-# against a remote node via node connection previously established
-#
-# After a node sends a json-rpc request to another, the either node may send
-# additional requests to each other via the connection already established until
-# it is closed on either end
-class NodeCallback
-
-  # NodeCallback initializer
-  # @param [Hash] args the options to create the node callback with
-  # @option args [node] :node node used to send messages
-  # @option args [connection] :connection connection to be used in channel selection
-  def initialize(args = {})
-    @node        = args[:node]
-    @connection  = args[:connection]
-  end
-
-  def notify(callback_method, *data)
-    # XXX return if node type does not support
-    # pesistent conntections (throw err instead?)
-    return if @node.class::RJR_NODE_TYPE == :web
-
-    msg = NotificationMessage.new :method => callback_method,
-                                  :args => data, :headers => @node.message_headers
-
-    # TODO surround w/ begin/rescue block incase of socket errors / raise RJR::ConnectionError
-    @node.send_msg msg.to_s, @connection
-  end
-end
-
 end # module RJR