rjr 0.18.2 → 0.19.1

data/lib/rjr/dispatcher.rb

@@ -1,181 +1,17 @@
-# RJR Request / Response Dispatcher
+# RJR Dispatcher
 #
-# Representation of a json-rpc request, response and mechanisms which to
-# register methods to handle requests and return responses
+# Mechanisms which to register methods to handle requests
+# and return responses
 #
-# 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 'json'
-require 'rjr/common'
+require 'rjr/request'
+require 'rjr/result'
+require 'rjr/util/logger'
 
 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
-
-# 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
-
-  # Headers which came w/ request
-  attr_accessor :rjr_headers
-
-  # 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
-
-  # RJR Request initializer
-  # @param [Hash] args options to set on request
-  # @option args [String] :rjr_method name of the method which request is for
-  # @option args [Array]  :rjr_method_args array of arguments which to pass to the rpc method handler
-  # @option args [Hash]   :rjr_headers hash of keys/values corresponding to optional headers received as part of of the request
-  # @option args [String] :rjr_client_ip ip address of client which invoked the request (if applicable)
-  # @option args [String] :rjr_client_port port of client which invoked the request (if applicable)
-  # @option args [RJR::Callback] :rjr_callback callback through which requests/notifications can be sent to remote node
-  # @option args [RJR::Node] :rjr_node rjr node which request was received on
-  # @option args [String] :rjr_node_id id of the rjr node which request was received on
-  # @option args [Symbol] :rjr_node_type type of the rjr node which request was received on
-  # @option args [Callable] :rjr_handler callable object registered to the specified method which to invoke request on with arguments
-  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]
-
-    @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}"
-
-    retval = instance_exec(*@rjr_method_args, &@rjr_handler)
-
-    RJR::Logger.info \
-      "#{node_sig}<-#{method_sig}<-#{retval.nil? ? "nil" : retval}"
-
-    return retval
-  end
-
-  # Convert request to json representation and return it
-  def to_json(*a)
-    {
-      'json_class' => self.class.name,
-      'data'       =>
-        {: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 },
-
-         :result  => { :result          => @result.result,
-                       :error_code      => @result.error_code,
-                       :error_msg       => @result.error_msg,
-                       :error_class     => @result.error_class } }
-    }.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
-
 # Primary RJR JSON-RPC method dispatcher.
 class Dispatcher
   # Registered json-rpc request signatures and corresponding handlers
@@ -188,7 +24,14 @@ class Dispatcher
   attr_accessor :keep_requests
 
   # Requests which have been dispatched
-  def requests ; @requests_lock.synchronize { Array.new(@requests) } ; end
+  def requests
+    @requests_lock.synchronize { Array.new(@requests) }
+  end
+
+  # Store request if configured to do so
+  def store_request(request)
+    @requests_lock.synchronize { @requests << request } if @keep_requests
+  end
 
   # RJR::Dispatcher intializer
   def initialize(args = {})
@@ -226,8 +69,8 @@ class Dispatcher
   # Register json-rpc handler with dispatcher
   #
   # @param [String,Regex] signature request signature to match
-  # @param [Callable] callable callable object which to bind to signature
-  # @param [Callable] &bl block parameter will be set to callback if specified
+  # @param [Callable] callback callable object which to bind to signature
+  # @param [Callable] bl block parameter will be set to callback if specified
   # @return self
   def handle(signature, callback = nil, &bl)
     if signature.is_a?(Array)
@@ -239,16 +82,28 @@ class Dispatcher
     self
   end
 
+  # Return handler for specified method.
+  #
+  # Currently we match method name string or regex against signature
+  # @param [String] rjr_method string rjr method to match
+  # @return [Callable, nil] callback proc registered to handle rjr_method
+  #   or nil if not found
+  def handler_for(rjr_method)
+    # look for exact match first
+    handler = @handlers.find { |k,v| k == rjr_method }
+
+    # if not found try to match regex's
+    handler ||= @handlers.find { |k,v| k.is_a?(Regexp) && (k =~ rjr_method) }
+
+    handler.nil? ? nil : handler.last
+  end
+
   # Return boolean indicating if dispatcher can handle method
   #
-  # @param [String] string rjr method to match
+  # @param [String] rjr_method string rjr method to match
   # @return [true,false] indicating if requests to specified method will be matched
   def handles?(rjr_method)
-     !@handlers.find { |k,v|
-       k.is_a?(String)         ?
-       k == rjr_method :
-       k =~ rjr_method
-     }.nil?
+    !handler_for(rjr_method).nil?
   end
 
   # Register environment to run json-rpc handler w/ dispatcher.
@@ -257,7 +112,7 @@ class Dispatcher
   # will extend before executing handler
   #
   # @param [String,Regex] signature request signature to match
-  # @param [Module] module which to extend requests with
+  # @param [Module] environment module which to extend requests with
   # @return self
   def env(signature, environment)
     if signature.is_a?(Array)
@@ -268,51 +123,52 @@ class Dispatcher
     self
   end
 
+  # Return the environment registered for the specified method
+  def env_for(rjr_method)
+     # look for exact match first
+     env = @environments.find { |k,v| k == rjr_method }
+
+     # if not found try to match regex's
+     env ||= @environments.find { |k,v| k.is_a?(Regexp) && (k =~ rjr_method) }
+
+     env.nil? ? nil : env.last
+  end
+
   # Dispatch received request. (used internally by nodes).
   #
   # Arguments should include :rjr_method and other parameters
   # required to construct a valid Request instance
   def dispatch(args = {})
-     # currently we match method name string or regex against signature
-     # TODO not using concurrent access protection, assumes all handlers are registered
-     #      before first dispatch occurs
-     handler = @handlers.find { |k,v|
-       k.is_a?(String)         ?
-       k == args[:rjr_method] :
-       k =~ args[:rjr_method] }
-
-     # TODO currently just using last environment that matches,
-     #      allow multiple environments to be used?
-     environment = @environments.keys.select { |k|
-       k.is_a?(String)         ?
-       k == args[:rjr_method] :
-       k =~ args[:rjr_method]
-     }.last
-
-     return Result.method_not_found(args[:rjr_method]) if handler.nil?
-
-     # TODO compare arity of handler to number of method_args passed in
-     request = Request.new args.merge(:rjr_handler  => handler.last)
-
-     # set request environment
-     request.extend(@environments[environment]) unless environment.nil?
-
-     begin
-       retval  = request.handle
-       request.result  = Result.new(:result => retval)
-
-     rescue Exception => e
-       RJR::Logger.warn ["Exception Raised in #{args[:rjr_method]} handler #{e}"] +
-                         e.backtrace
-       request.result =
-         Result.new(:error_code => -32000,
-                    :error_msg  => e.to_s,
-                    :error_class => e.class)
+    rjr_method = args[:rjr_method]
 
-     end
+    # *note* not using concurrent access protection,
+    # assumes all handlers/enviroments are registered
+    # before first dispatch occurs
+    handler     = handler_for(rjr_method)
+    environment = env_for(rjr_method)
+
+    return Result.method_not_found(rjr_method) if handler.nil?
+
+    request = Request.new args.merge(:rjr_handler  => handler)
+
+    # set request environment
+    request.extend(environment) unless environment.nil?
+
+    begin
+      retval = request.handle
+      request.result  = Result.new(:result => retval)
+
+    rescue Exception => e
+      warning = "Exception Raised in #{rjr_method} handler #{e}"
+      RJR::Logger.warn [warning] + e.backtrace
+
+      request.result = Result.new(:error_code  => -32000,
+                                  :error_msg   => e.to_s,
+                                  :error_class => e.class)
+    end
 
-     @requests_lock.synchronize { @requests << request } if @keep_requests
-     return request.result
+    store_request request
+    return request.result
   end
 
   # Handle responses received from rjr requests. (used internally by nodes)

data/lib/rjr/messages.rb

@@ -0,0 +1,8 @@
+# RJR Messages
+#
+# Copyright (C) 2014 Mohammed Morsi <mo@morsi.org>
+# Licensed under the Apache License, Version 2.0
+
+require 'rjr/messages/request'
+require 'rjr/messages/response'
+require 'rjr/messages/notification'

data/lib/rjr/messages/compressed.rb

@@ -0,0 +1,264 @@
+# RJR Compressed Messages
+#
+# *Note* this module is still expiremental
+#
+# Copyright (C) 2014 Mohammed Morsi <mo@morsi.org>
+# Licensed under the Apache License, Version 2.0
+
+# TODO split up into seperate modules
+# (under lib/rjr/messages/compressed/ w/ this file including all)
+
+require 'zlib'
+require 'base64'
+
+require 'rjr/messages'
+
+module RJR
+module Messages
+  # Make backups of original class references
+  module Uncompressed
+    Request      = RJR::Messages::Request
+    Response     = RJR::Messages::Response
+    Notification = RJR::Messages::Notification
+  end
+
+  # Subclass original message classes w/ versions that first
+  #   check for compressed messages before dispatching to superclass
+  module Compressed
+    class Request < Uncompressed::Request
+      COMPRESSED = true
+
+      def initialize(args = {})
+        parse_args(args)
+      end
+
+      private
+
+      def parse_args(args)
+        args = Hash[args]
+        if args[:message]
+          message = args.delete(:message)
+          parse_message(message, args)
+        else
+          super(args)
+        end
+      end
+
+      def parse_message(message, args={})
+        @json_message = message
+        request       = JSONParser.parse(@json_message)
+
+        if request.has_key?('m')
+          decoded   = Base64.decode64(request['p'])
+          inflated  = Zlib::Inflate.inflate(decoded)
+          converted = JSONParser.parse(inflated)
+
+          parse_args({:method => request['m'],
+                      :id     => request['i'],
+                      :args   => converted}.merge(args))
+
+        else
+          parse_args({:method => request['method'],
+                      :args   => request['params'],
+                      :id     => request['id']}.merge(args))
+        end
+      end
+
+      public
+
+      def self.is_compressed_request_message?(message)
+        begin
+           parsed = JSONParser.parse(message)
+           parsed.has_key?('m') && parsed.has_key?('i')
+        rescue Exception => e
+          false
+        end
+      end
+
+      def self.is_request_message?(message)
+        is_compressed_request_message?(message) || super(message)
+      end
+
+      def to_json(*a)
+        deflated = Zlib::Deflate.deflate(@jr_args.to_json.to_s)
+        encoded  = Base64.encode64(deflated)
+
+        {'j' => 2.0,
+         'i' => @msg_id,
+         'm' => @jr_method,
+         'p' => encoded}.merge(@headers).to_json(*a)
+      end
+    end
+
+    class Response < Uncompressed::Response
+      def initialize(args = {})
+        parse_args(args)
+      end
+
+      private
+
+      def parse_args(args)
+        args = Hash[args]
+        @request = args[:request]
+
+        if args[:message]
+          message = args.delete(:message)
+          parse_message(message, args)
+        else
+          super(args)
+        end
+      end
+
+      def parse_message(message, args={})
+        @json_message = message
+        response      = JSONParser.parse(@json_message)
+
+        if response.has_key?('r') || response.has_key?('e')
+          result = parse_compressed_result(response)
+          parse_args({:id     => response['i'],
+                      :result => result}.merge(args))
+
+        else
+          result = parse_result(response)
+          parse_args({:id     => response['id'],
+                      :result => result}.merge(args))
+        end
+      end
+
+      def parse_compressed_result(response)
+        @result         = Result.new
+        @result.success = response.has_key?('r')
+        @result.failed  = !@result.success
+
+        if @result.success
+          decoded   = Base64.decode64(response['r'])
+          inflated  = Zlib::Inflate.inflate(decoded)
+          converted = JSONParser.parse(inflated).first
+          @result.result = converted
+
+        elsif response.has_key?('e')
+          @result.error_code  = response['e']['co']
+          @result.error_msg   = response['e']['m']
+          @result.error_class = response['e']['cl']
+        end
+
+        @result
+      end
+
+      public
+
+      def has_compressed_request?
+        !!@request && @request.class.const_defined?(:COMPRESSED)
+      end
+
+      def has_uncompressed_request?
+        !!@request && !@request.class.const_defined?(:COMPRESSED)
+      end
+
+      def self.is_compressed_response_message?(message)
+        begin
+          json = JSONParser.parse(message)
+          json.has_key?('r') || json.has_key?('e')
+        rescue Exception => e
+          puts e.to_s
+          false
+        end
+      end
+
+      def self.is_response_message?(message)
+        is_compressed_response_message?(message) || super(message)
+      end
+
+      def compressed_success_json
+        # XXX encapsulate in array & extract above so as to
+        # guarantee to be able to be parsable JSON
+        deflated = Zlib::Deflate.deflate([@result.result].to_json.to_s)
+        encoded  = Base64.encode64(deflated)
+        {'r' => encoded}
+      end
+
+      def compressed_error_json
+        {'e' => {'co' => @result.error_code,
+                 'm'  => @result.error_msg,
+                 'cl' => @result.error_class}}
+      end
+
+      def to_json(*a)
+        return super(*a) if has_uncompressed_request?
+
+        result_json = @result.success ?
+                      compressed_success_json : compressed_error_json
+
+        response = {'j' => 2.0,
+                    'i' => @msg_id}.merge(@headers).
+                                    merge(result_json).to_json(*a)
+      end
+    end
+
+    class Notification < Uncompressed::Notification
+      def initialize(args = {})
+        parse_args(args)
+      end
+
+      private
+
+      def parse_args(args)
+        args = Hash[args]
+        if args[:message]
+          message = args.delete(:message)
+          parse_message(message, args)
+        else
+          super(args)
+        end
+      end
+
+      def parse_message(message, args={})
+        @json_message = message
+        request       = JSONParser.parse(@json_message)
+
+        if request.has_key?('m')
+          decoded   = Base64.decode64(request['p'])
+          inflated  = Zlib::Inflate.inflate(decoded)
+          converted = JSONParser.parse(inflated)
+          parse_args({:method => request['m'],
+                      :args   => converted}.merge(args))
+
+        else
+          parse_args({:method => request['method'],
+                      :args   => request['params']}.merge(args))
+        end
+      end
+
+      public
+
+      def self.is_compressed_notification_message?(message)
+        begin
+           parsed = JSONParser.parse(message)
+           parsed.has_key?('m') && !parsed.has_key?('i')
+        rescue Exception => e
+          false
+        end
+      end
+
+      def self.is_notification_message?(message)
+        is_compressed_notification_message?(message) || super(message)
+      end
+
+      def to_json(*a)
+        deflated = Zlib::Deflate.deflate(@jr_args.to_json.to_s)
+        encoded  = Base64.encode64(deflated)
+
+        {'j' => 2.0,
+         'm' => @jr_method,
+         'p' => encoded}.merge(@headers).to_json(*a)
+      end
+    end
+  end
+
+  # Override original classes w/ subclasses
+  Request      = Compressed::Request
+  Response     = Compressed::Response
+  Notification = Compressed::Notification
+
+end # module Messages
+end # module RJR