rjr 0.18.2 → 0.19.1

data/lib/rjr/nodes/web.rb

@@ -30,7 +30,7 @@ require 'thread'
 require 'eventmachine'
 
 require 'rjr/node'
-require 'rjr/message'
+require 'rjr/messages'
 
 module RJR
 module Nodes
@@ -57,7 +57,7 @@ class WebConnection < EventMachine::Connection
     # 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 NotificationMessage.is_notification_message?(msg)
+    @rjr_node.send_msg "", self if Messages::Notification.is_notification_message?(msg)
   end
 end
 
@@ -87,13 +87,14 @@ end
 #   puts client.invoke('http://localhost:7777', 'hello', 'mo')
 #
 # @example Invoking json-rpc requests over http using curl
-#   $ curl -X POST http://localhost:7777 -d '{"jsonrpc":"2.0","method":"hello","params":["mo"],"id":"123"}'
-#   > {"jsonrpc":"2.0","id":"123","result":"Hello mo!"}
+#   sh> curl -X POST http://localhost:7777 -d '{"jsonrpc":"2.0","method":"hello","params":["mo"],"id":"123"}'
+#     > {"jsonrpc":"2.0","id":"123","result":"Hello mo!"}
 #
 class Web < RJR::Node
 
   RJR_NODE_TYPE = :web
   PERSISTENT_NODE = false
+  INDIRECT_NODE = false
 
   public
 
@@ -113,7 +114,7 @@ class Web < RJR::Node
 
   # Send data using specified http connection
   #
-  # Implementation of {RJR::Node#send_msg}
+  # Implementation of RJR::Node#send_msg
   def send_msg(data, connection)
     # we are assuming that since http connections
     # are not persistant, we should be sending a
@@ -131,7 +132,7 @@ class Web < RJR::Node
 
   # Instruct Node to start listening for and dispatching rpc requests
   #
-  # Implementation of {RJR::Node#listen}
+  # Implementation of RJR::Node#listen
   def listen
     @@em.schedule do
       EventMachine::start_server(@host, @port, WebConnection, :rjr_node => self)
@@ -141,7 +142,7 @@ class Web < RJR::Node
 
   # Instructs node to send rpc request, and wait for / return response
   #
-  # Implementation of {RJR::Node#invoke}
+  # 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
@@ -151,9 +152,9 @@ class Web < RJR::Node
   # @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(uri, rpc_method, *args)
-    message = RequestMessage.new :method => rpc_method,
-                                 :args   => args,
-                                 :headers => @message_headers
+    message = Messages::Request.new :method => rpc_method,
+                                    :args   => args,
+                                    :headers => @message_headers
     cb = lambda { |http|
       # TODO handle errors
       handle_message(http.response, http)
@@ -177,7 +178,7 @@ class Web < RJR::Node
 
   # Instructs node to send rpc notification (immadiately returns / no response is generated)
   #
-  # Implementation of {RJR::Node#notify}
+  # Implementation of RJR::Node#notify
   #
   # @param [String] uri location of node to send request to, should be
   #   in format of http://hostname:port
@@ -189,9 +190,9 @@ class Web < RJR::Node
     published_c = ConditionVariable.new
 
     invoked = false
-    message = NotificationMessage.new :method => rpc_method,
-                                      :args   => args,
-                                      :headers => @message_headers
+    message = Messages::Notification.new :method => rpc_method,
+                                         :args   => args,
+                                         :headers => @message_headers
     cb = lambda { |arg| published_l.synchronize { invoked = true ; published_c.signal }}
     @@em.schedule do
       http = EventMachine::HttpRequest.new(uri).post :body => message.to_s,

data/lib/rjr/nodes/ws.rb

@@ -23,7 +23,7 @@ else
 require 'thread'
 
 require 'rjr/node'
-require 'rjr/message'
+require 'rjr/messages'
 
 module RJR
 module Nodes
@@ -55,6 +55,7 @@ module Nodes
 class WS < RJR::Node
   RJR_NODE_TYPE = :ws
   PERSISTENT_NODE = true
+  INDIRECT_NODE = false
 
   private
 
@@ -100,14 +101,14 @@ class WS < RJR::Node
 
   # Send data using specified websocket safely
   #
-  # Implementation of {RJR::Node#send_msg}
+  # Implementation of RJR::Node#send_msg
   def send_msg(data, ws)
     @@em.schedule { ws.send(data) }
   end
 
   # Instruct Node to start listening for and dispatching rpc requests
   #
-  # Implementation of {RJR::Node#listen}
+  # Implementation of RJR::Node#listen
   def listen
     @@em.schedule do
       EventMachine::WebSocket.run(:host => @host, :port => @port) do |ws|
@@ -122,7 +123,7 @@ class WS < RJR::Node
 
   # Instructs node to send rpc request, and wait for / return response
   #
-  # Implementation of {RJR::Node#invoke}
+  # 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
@@ -132,9 +133,9 @@ class WS < RJR::Node
   # @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(uri, rpc_method, *args)
-    message = RequestMessage.new :method => rpc_method,
-                                 :args   => args,
-                                 :headers => @message_headers
+    message = Messages::Request.new :method => rpc_method,
+                                    :args   => args,
+                                    :headers => @message_headers
 
     @@em.schedule {
       init_client(uri) do |c|
@@ -155,7 +156,7 @@ class WS < RJR::Node
 
   # Instructs node to send rpc notification (immadiately returns / no response is generated)
   #
-  # Implementation of {RJR::Node#notify}
+  # Implementation of RJR::Node#notify
   #
   # @param [String] uri location of node to send notification to, should be
   #   in format of ws://hostname:port
@@ -167,9 +168,9 @@ class WS < RJR::Node
     published_c = ConditionVariable.new
 
     invoked = false
-    message = NotificationMessage.new :method => rpc_method,
-                                      :args   => args,
-                                      :headers => @message_headers
+    message = Messages::Notification.new :method => rpc_method,
+                                         :args   => args,
+                                         :headers => @message_headers
     @@em.schedule {
       init_client(uri) do |c|
         c.stream { |msg| handle_message(msg.data, c) }

data/lib/rjr/request.rb

@@ -0,0 +1,128 @@
+# RJR Request Representation
+#
+# Copyright (C) 2012-2014 Mohammed Morsi <mo@morsi.org>
+# Licensed under the Apache License, Version 2.0
+
+require 'json'
+require 'rjr/result'
+require 'rjr/core_ext'
+require 'rjr/util/args'
+require 'rjr/util/logger'
+
+module RJR
+
+# JSON-RPC request representation.
+#
+# Registered request handlers will be invoked in the context of
+# instances of this class, meaning all member variables will be available
+# for use in the handler.
+class Request
+  # Result of the request operation, set by dispatcher
+  attr_accessor :result
+
+  # Method which request is for
+  attr_accessor :rjr_method
+
+  # Arguments be passed to method
+  attr_accessor :rjr_method_args
+
+  # Argument object encapsulating arguments
+  attr_accessor :rjr_args
+
+  # Headers which came w/ request
+  attr_accessor :rjr_headers
+
+  # Client IP which request came in on (only for direct nodes)
+  attr_accessor :rjr_client_ip
+
+  # Port which request came in on (only for direct nodes)
+  attr_accessor :rjr_client_port
+
+  # RJR callback which may be used to push data to client
+  attr_accessor :rjr_callback
+
+  # Node which the request came in on
+  attr_accessor :rjr_node
+
+  # Type of node which request came in on
+  attr_accessor :rjr_node_type
+
+  # ID of node which request came in on
+  attr_accessor :rjr_node_id
+
+  # Actual proc registered to handle request
+  attr_accessor :rjr_handler
+
+  # RJR Request initializer
+  #
+  # @param [Hash] args options to set on request,
+  #   see Request accessors for valid keys
+  def initialize(args = {})
+    @rjr_method      = args[:rjr_method]      || args['rjr_method']
+    @rjr_method_args = args[:rjr_method_args] || args['rjr_method_args'] || []
+    @rjr_headers     = args[:rjr_headers]     || args['rjr_headers']
+
+    @rjr_client_ip   = args[:rjr_client_ip]
+    @rjr_client_port = args[:rjr_client_port]
+
+    @rjr_callback    = args[:rjr_callback]
+    @rjr_node        = args[:rjr_node]
+    @rjr_node_id     = args[:rjr_node_id]     || args['rjr_node_id']
+    @rjr_node_type   = args[:rjr_node_type]   || args['rjr_node_type']
+
+    @rjr_handler     = args[:rjr_handler]
+
+    @rjr_args        = Arguments.new :args => @rjr_method_args
+    @result = nil
+  end
+
+  # Invoke the request by calling the registered handler with the registered
+  # method parameters in the local scope
+  def handle
+    node_sig   = "#{@rjr_node_id}(#{@rjr_node_type})"
+    method_sig = "#{@rjr_method}(#{@rjr_method_args.join(',')})"
+
+    RJR::Logger.info "#{node_sig}->#{method_sig}"
+
+    # TODO option to compare arity of handler to number
+    # of method_args passed in ?
+    retval = instance_exec(*@rjr_method_args, &@rjr_handler)
+
+    RJR::Logger.info \
+      "#{node_sig}<-#{method_sig}<-#{retval.nil? ? "nil" : retval}"
+
+    return retval
+  end
+
+  def request_json
+    {:request => { :rjr_method      => @rjr_method,
+                   :rjr_method_args => @rjr_method_args,
+                   :rjr_headers     => @rjr_headers,
+                   :rjr_node_type   => @rjr_node_type,
+                   :rjr_node_id     => @rjr_node_id }}
+  end
+
+  def result_json
+    return {} unless !!@result
+    {:result  => { :result          => @result.result,
+                   :error_code      => @result.error_code,
+                   :error_msg       => @result.error_msg,
+                   :error_class     => @result.error_class }}
+  end
+
+  # Convert request to json representation and return it
+  def to_json(*a)
+    {'json_class' => self.class.name,
+     'data'       => request_json.merge(result_json)}.to_json(*a)
+  end
+
+  # Create new request from json representation
+  def self.json_create(o)
+    result  = Result.new(o['data']['result'])
+    request = Request.new(o['data']['request'])
+    request.result = result
+    return request
+  end
+
+end # class Request
+end # module RJR

data/lib/rjr/result.rb

@@ -0,0 +1,75 @@
+# RJR Result Representation
+#
+# Copyright (C) 2012-2014 Mohammed Morsi <mo@morsi.org>
+# Licensed under the Apache License, Version 2.0
+
+module RJR
+
+# JSON-RPC Result Representation
+class Result
+  # Boolean indicating if request was successfully invoked
+  attr_accessor :success
+
+  # Boolean indicating if request failed in some manner
+  attr_accessor :failed
+
+  # Return value of the json-rpc call if successful
+  attr_accessor :result
+
+  # Code corresponding to json-rpc error if problem occured during request invocation
+  attr_accessor :error_code
+
+  # Message corresponding to json-rpc error if problem occured during request invocation
+  attr_accessor :error_msg
+
+  # Class of error raised (if any) during request invocation (this is extra metadata beyond standard json-rpc)
+  attr_accessor :error_class
+
+  # RJR result intializer
+  # @param [Hash] args options to set on result
+  # @option args [Object] :result result of json-rpc method handler if successfully returned
+  # @option args [Integer] :error_code code corresponding to json-rpc error if problem occured during request invocation
+  # @option args [String] :error_msg message corresponding to json-rpc error if problem occured during request invocation
+  # @option args [Class] :error_class class of error raised (if any) during request invocation (this is extra metadata beyond standard json-rpc)
+  def initialize(args = {})
+    @result        = args[:result]      || args['result']
+    @error_code    = args[:error_code]  || args['error_code']
+    @error_msg     = args[:error_msg]   || args['error_msg']
+    @error_class   = args[:error_class] || args['error_class']
+
+    @success       =  @error_code.nil?
+    @failed        = !@error_code.nil?
+  end
+
+  # Compare Result against other result, returning true if both correspond
+  # to equivalent json-rpc results else false
+  def ==(other)
+    @success     == other.success    &&
+    @failed      == other.failed     &&
+    @result      == other.result     &&
+    @error_code  == other.error_code &&
+    @error_msg   == other.error_msg  &&
+    @error_class == other.error_class
+  end
+
+  # Convert Response to human consumable string
+  def to_s
+    "#{@success} #{@result} #{@error_code} #{@error_msg} #{@error_class}"
+  end
+
+  ######### Specific request types
+
+  # JSON-RPC -32600 / Invalid Request
+  def self.invalid_request
+     return Result.new(:error_code => -32600,
+                       :error_msg => 'Invalid Request')
+  end
+
+  # JSON-RPC -32602 / Method not found
+  def self.method_not_found(name)
+     return Result.new(:error_code => -32602,
+                       :error_msg => "Method '#{name}' not found")
+  end
+
+end # class Result
+end # module RJR

data/lib/rjr/util/args.rb

@@ -0,0 +1,145 @@
+# RJR JSON-RPC Argument Representation
+#
+# Copyright (C) 2014 Mohammed Morsi <mo@morsi.org>
+# Licensed under the Apache License, Version 2.0
+
+require 'forwardable'
+
+module RJR
+
+# Encapsulates a list of JSON-RPC method arguments as sent
+# from the client to the server, in addition to providing
+# various helper / utility methods.
+class Arguments
+  include Enumerable
+  extend Forwardable
+
+  attr_accessor :args
+
+  def_delegators :@args, :each, :<<, :length, :[], :index
+
+  def initialize(args={})
+    @args = args[:args] || []
+  end
+
+  # Validate arguments against acceptable values.
+  #
+  # Raises error if value is found which is not on
+  # list of acceptable values.
+  #
+  # If acceptable values are hash's, keys are compared
+  # and on matches the values are used as the # of following
+  # arguments to skip in the validator
+  #
+  # *Note* args / acceptable params are converted to strings
+  # before comparison
+  #
+  # @example
+  #   args = Arguments.new :args => ['custom', 'another']
+  #   args.validate! 'custom', 'another'  #=> nil
+  #   args.validate! 'something'          #=> ArgumentError
+  #
+  #   args = Arguments.new :args => ['with_id', 123, 'another']
+  #   args.validate! :with_id => 1, :another => 0 #=> nil
+  #   args.validate! :with_id => 1                #=> ArgumentError
+  def validate!(*acceptable)
+    i = 0
+    if acceptable.first.is_a?(Hash)
+      # clone acceptable hash, swap keys for string
+      acceptable = Hash[acceptable.first]
+      acceptable.keys.each { |k|
+        acceptable[k.to_s] = acceptable[k]
+        acceptable.delete(k) unless k.is_a?(String)
+      }
+
+      # compare acceptable against arguments, raising error if issue found
+      while(i < length) do
+        val = self[i]
+        passed = acceptable.has_key?(val)
+        raise ArgumentError, "#{val} not an acceptable arg" unless passed
+        skip = acceptable[val]
+        i += (skip + 1)
+      end
+
+    else
+      # clone acceptable array, swap values for string
+      acceptable = Array.new(acceptable).map { |a| a.to_s }
+
+      # compare acceptable against arguments, raising error if issue found
+      while(i < length) do
+        val = self[i].to_s
+        passed = acceptable.include?(val)
+        raise ArgumentError, "#{val} not an acceptable arg" unless passed
+        i += 1
+      end
+    end
+
+    nil
+  end
+
+  # Extract groups of values from argument list
+  #
+  # Groups are generated by comparing arguments to keys in the
+  # specified map and on matches extracting the # of following
+  # arguments specified by the map values
+  #
+  # Note arguments / keys are converted to strings before comparison
+  #
+  # @example
+  #   args = Arguments.new :args => ['with_id', 123, 'custom', 'another']
+  #   args.extract :with_id => 1, :custom => 0
+  #     # => [['with_id', 123], ['custom']]
+  #
+  def extract(map)
+    # clone map hash, swap keys for string
+    map = Hash[map]
+    map.keys.each { |k|
+      map[k.to_s] = map[k]
+      map.delete(k) unless k.is_a?(String)
+    }
+
+    groups = []
+    i = 0
+    while(i < length) do
+      val = self[i]
+      i += 1
+      next unless !!map.has_key?(val)
+
+      num = map[val]
+      group = [val]
+      0.upto(num-1) do |j|
+        group << self[i]
+        i += 1
+      end
+      groups << group
+    end
+
+    groups
+  end
+
+  # Return boolean if tag appears in argument list.
+  # Simple wrapper around includes setting up the scope
+  # of argument 'specifiers'
+  #
+  # @example
+  #   args = Arguments.new :args => ['foobar']
+  #   args.specifies?('foobar') #=> true
+  #   args.specifies?('barfoo') #=> false
+  def specifies?(tag)
+    include?(tag)
+  end
+
+  # Return specifier corresponding given tag. The specifier
+  # is defined as the value appearing in the argument list
+  # immediately after the tag
+  #
+  # @example
+  #   args = Argument.new :args => ['with_id', 123]
+  #   args.specifier_for('with_id') #=> 123
+  #   args.specifier_for('other')   #=> nil
+  def specifier_for(tag)
+    return nil unless specifies?(tag)
+    self[index(tag) + 1]
+  end
+end
+end