rjr 0.9.0 → 0.11.7

data/lib/rjr/dispatcher.rb

@@ -7,6 +7,7 @@
 # Licensed under the Apache License, Version 2.0
 
 require 'rjr/common'
+require 'json'
 
 module RJR
 
@@ -14,9 +15,11 @@ module RJR
 class Request
   # name of the method which request is for
   attr_accessor :method
+  alias :rjr_method :method
 
   # array of arguments which to pass to the rpc method handler
   attr_accessor :method_args
+  alias :rjr_method_args :method_args
 
   # hash of keys/values corresponding to optional headers received as part of of the request
   attr_accessor :headers
@@ -46,15 +49,17 @@ class Request
   # @option args [Symbol] :rjr_node_type type of the rjr node which request was received on
   # @option args [Callable] :handler callable object registered to the specified method which to invoke request on with arguments
   def initialize(args = {})
-    @method       = args[:method]
-    @method_args  = args[:method_args]
-    @headers      = args[:headers]
+    @method       = args[:method]  || args['method']
+    @rjr_method   = @method
+    @method_args  = args[:method_args] || args['method_args']
+    @rjr_method_args = @method_args
+    @headers      = args[:headers] || args['headers']
     @client_ip    = args[:client_ip]
     @client_port  = args[:client_port]
     @rjr_callback = args[:rjr_callback]
     @rjr_node      = args[:rjr_node]
-    @rjr_node_id   = args[:rjr_node_id]
-    @rjr_node_type = args[:rjr_node_type]
+    @rjr_node_id   = args[:rjr_node_id] || args['rjr_node_id']
+    @rjr_node_type = args[:rjr_node_type] || args['rjr_node_type']
     @handler       = args[:handler]
   end
 
@@ -62,6 +67,7 @@ class Request
   # method parameters in the local scope
   def handle
     RJR::Logger.info "Dispatching '#{@method}' request with parameters (#{@method_args.join(',')}) on #{@rjr_node_type}-node(#{@rjr_node_id})"
+    # TODO compare arity of method to number of args ?
     retval = instance_exec(*@method_args, &@handler)
     RJR::Logger.info "#{@method} request with parameters (#{@method_args.join(',')}) returning #{retval}"
     return retval
@@ -100,17 +106,17 @@ class Result
     @error_message = nil
     @error_class = nil
 
-    if args.has_key?(:result)
+    if args.has_key?(:result) || args.has_key?('result')
       @success = true
       @failed  = false
-      @result  = args[:result]
+      @result  = args[:result] || args['result']
 
-    elsif args.has_key?(:error_code)
+    elsif args.has_key?(:error_code) || args.has_key?('error_code')
       @success = false
       @failed  = true
-      @error_code  = args[:error_code]
-      @error_msg   = args[:error_msg]
-      @error_class = args[:error_class]
+      @error_code  = args[:error_code] || args['error_code']
+      @error_msg   = args[:error_msg]  || args['error_msg']
+      @error_class = args[:error_class] || args['error_class']
 
     end
   end
@@ -177,20 +183,79 @@ class Handler
   def handle(args = {})
     return Result.method_not_found(args[:missing_name]) if @method_name.nil?
 
+    result = nil
     begin
       request = Request.new args.merge(:method          => @method_name,
                                        :handler         => @handler_proc)
       retval = request.handle
-      return Result.new(:result => retval)
+      result = Result.new(:result => retval)
 
     rescue Exception => e
       RJR::Logger.warn ["Exception Raised in #{method_name} handler #{e}"] + e.backtrace
-
-      return Result.new(:error_code => -32000,
-                        :error_msg  => e.to_s,
-                        :error_class => e.class)
+      result = Result.new(:error_code => -32000,
+                          :error_msg  => e.to_s,
+                          :error_class => e.class)
 
     end
+
+    DispatcherStat << DispatcherStat.new(request, result)
+    return result
+  end
+end
+
+# Tracks high level dispatcher states
+class DispatcherStat
+  # Request invoked
+  attr_reader :request
+
+  # Result returned
+  attr_reader :result
+
+  # Initialized the stat w/ the corresponding request/result
+  def initialize(request, result)
+    @request = request
+    @result  = result
+  end
+
+  # Global stats registry
+  def self.stats
+    @stats ||= []
+  end
+
+  # Reinit the stats registry
+  def self.reset
+    @stats = []
+  end
+
+  # Add stat to the global registry
+  def self.<<(s)
+    @stats ||= []
+    @stats << s
+    self
+  end
+
+  # Convert stat to json representation and return it
+  def to_json(*a)
+    {
+      'json_class' => self.class.name,
+      'data'       =>
+        {:request => {:method        => request.method,
+                      :method_args   => request.method_args,
+                      :headers       => request.headers,
+                      :rjr_node_type => request.rjr_node_type,
+                      :rjr_node_id   => request.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 stat from json representation
+  def self.json_create(o)
+    stat = new(Request.new(o['data']['request']), Result.new(o['data']['result']))
+    return stat
   end
 end
 
@@ -231,11 +296,28 @@ class Dispatcher
     method_names = Array(method_names) unless method_names.is_a?(Array)
     @@handlers  ||= {}
     method_names.each { |method_name|
+      # TODO support registering multiple handlers per method? (and in dispatch_request below)
       @@handlers[method_name] = Handler.new args.merge(:method  => method_name,
                                                        :handler => handler)
     }
   end
 
+  # Clear registered method handlers
+  def self.clear!
+    @@handlers = {}
+  end
+
+  # Return boolean indicating if handler for the specifed method has been registered
+  def self.has_handler_for?(method_name)
+    @@handlers  ||= {}
+    !@@handlers.find { |k,v| k == method_name }.nil?
+  end
+
+  # Return the handler for the specified method
+  def self.handler_for(method_name)
+    @@handlers[method_name]
+  end
+
   # Helper used by RJR nodes to dispatch requests received via transports to
   # registered handlers.
   def self.dispatch_request(method_name, args = {})

data/lib/rjr/em_adapter.rb

@@ -0,0 +1,110 @@
+# EventMachine Adapter
+#
+# Copyright (C) 2012 Mohammed Morsi <mo@morsi.org>
+# Licensed under the Apache License, Version 2.0
+
+require 'singleton'
+require 'eventmachine'
+
+# EventMachine wrapper / helper interface, ties reactor
+# lifecycle to an instance of this class.
+#
+# TODO move to the RJR namespace
+class EMManager
+
+  # Run reactor in its own interally managed thread
+  attr_accessor :reactor_thread
+
+  # EMManager initializer
+  def initialize
+    @em_lock = Mutex.new
+  end
+
+  # Start the eventmachine reactor thread if not running
+  def start
+    @em_lock.synchronize{
+      # TODO on event of the process ending this thread will be
+      # shutdown before a local finalizer can be run,
+      # would be good to gracefully shut this down / wait for completion
+      @reactor_thread  = Thread.new {
+        begin
+          EventMachine.run
+        rescue Exception => e
+          # TODO option to autorestart the reactor on errors ?
+          puts "Critical exception #{e}\n#{e.backtrace.join("\n")}"
+        ensure
+          @reactor_thread = nil
+        end
+       } unless @reactor_thread
+     }
+     sleep 0.01 until EventMachine.reactor_running? # XXX hack but needed
+   end
+
+  # Schedule a new job to be run in event machine
+  # @param [Callable] bl callback to be invoked by eventmachine
+  def schedule(&bl)
+    EventMachine.schedule &bl
+  end
+
+  # Schedule a job to be run once after a specified interval in event machine
+  # @param [Integer] seconds int interval which to wait before invoking specified block
+  # @param [Callable] bl callback to be invoked by eventmachine
+  def add_timer(seconds, &bl)
+    EventMachine.add_timer(seconds, &bl)
+  end
+
+  # Schedule a block to be run periodically in event machine
+  # @param [Integer] seconds int interval which to invoke specified block
+  # @param [Callable] bl callback to be invoked by eventmachine
+  def add_periodic_timer(seconds, &bl)
+    EventMachine.add_periodic_timer(seconds, &bl)
+  end
+
+  # Return boolean indicating if event machine reactor is running
+  def running?
+    @em_lock.synchronize{
+      EventMachine.reactor_running?
+    }
+  end
+
+  # Block until reactor thread is terminated
+  def join
+    th = nil
+    @em_lock.synchronize{
+      th = @reactor_thread
+    }
+    th.join unless th.nil?
+  end
+
+  # Terminate the event machine reactor under all conditions
+  def halt
+    @em_lock.synchronize{
+      EventMachine.stop_event_loop
+    }
+  end
+end
+
+
+# Provides an interface which to access a shared EMManager
+#
+# EMManager operations may be invoked on this class after
+# the 'init' method is called
+#
+#     EMAdapter.init
+#     EMAdapter.start
+class EMAdapter
+  # Initialize EM subsystem
+  def self.init
+    if @em_manager.nil?
+      @em_manager = EMManager.new
+    end
+
+    @em_manager.start
+  end
+
+  # Delegates all methods invoked on calls to EMManager
+  def self.method_missing(method_id, *args, &bl)
+    @em_manager.send method_id, *args, &bl
+  end
+
+end

data/lib/rjr/inspect.rb

@@ -0,0 +1,66 @@
+# JSON-RPC method definitions providing access to inspect the internal
+# node state.
+#
+# Note this isn't included in the top level rjr module by default,
+# manually include this module to incorporate these additional rjr method
+# definitions into your node
+#
+# Copyright (C) 2013 Mohammed Morsi <mo@morsi.org>
+# Licensed under the Apache License, Version 2.0
+
+require 'rjr/util'
+include RJR::Definitions
+
+# Helper method to process user params / select stats
+def select_stats(*filter)
+  lf = []
+  while q = filter.shift
+    lf << 
+      case q
+      when 'on_node'    then
+        n = filter.shift 
+        lambda { |ds| ds.request.rjr_node_type.to_s == n}
+
+      when "for_method" then
+        m = filter.shift
+        lambda { |ds| ds.request.rjr_method == m}
+
+      when 'successful' then
+        lambda { |ds| ds.result.success }
+
+      when 'failed'     then
+        lambda { |ds| ds.result.failed  }
+
+      end
+  end
+
+  RJR::DispatcherStat.stats.select { |ds| lf.all? { |lf| lf.call(ds) } }
+end
+ 
+rjr_method \
+  "rjr::dispatches" =>
+    # Retrieve all the dispatches this node served matching the specified criteri
+    lambda { |*filter| select_stats(*filter) },
+
+  "rjr::num_dispatches" =>
+    # Retrieve the number of dispatches this node served matching the specified criteria
+    lambda { |*filter| select_stats(*filter).size },
+
+  "rjr::status" =>
+    # Retrieve the overall status of this node
+    lambda {
+      {
+        # event machine
+        :event_machine => { :running => EMAdapter.running?,
+                            :has_jobs => EMAdapter.has_jobs?,
+                            :thread_status => EMAdapter.reactor_thread.status,
+                            :jobs => EMAdapter.em_jobs },
+
+        # thread pool
+        :thread_pool => { :running => ThreadPool2Manager.thread_pool.running?,
+                          :inspect => ThreadPool2Manager.thread_pool.inspect },
+      }
+    }
+
+  #:log =>
+  #  lambda {},

data/lib/rjr/local_node.rb

@@ -7,6 +7,7 @@
 
 require 'rjr/node'
 require 'rjr/message'
+require 'rjr/dispatcher'
 
 module RJR
 

data/lib/rjr/message.rb

@@ -82,8 +82,9 @@ class RequestMessage
   # @return [true,false] indicating if message is request message
   def self.is_request_message?(message)
     begin
-       # TODO log error
-       JSON.parse(message).has_key?('method')
+       # FIXME log error
+       parsed = JSON.parse(message)
+       parsed.has_key?('method') && parsed.has_key?('id')
     rescue Exception => e
       false
     end
@@ -174,7 +175,8 @@ class ResponseMessage
       json = JSON.parse(message)
       json.has_key?('result') || json.has_key?('error')
     rescue Exception => e
-      # TODO log error
+      # FIXME log error
+      #puts e.to_s
       false
     end
   end
@@ -200,4 +202,122 @@ class ResponseMessage
   end
 end
 
+# Message sent to a jsonrpc node to invoke a rpc method but
+# indicate the result should _not_ be returned
+class NotificationMessage
+  # 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
+  #
+  # This should be invoked with one of two argument sets. If creating a new message
+  # to send to the server, specify :method, :args, and :headers to include in the message
+  # If handling an new request message sent from the client, simply specify :message and
+  # optionally any additional headers (they will be merged with the headers contained in
+  # the message)
+  # 
+  # 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 = {})
+    if args.has_key?(:message)
+      begin
+        notification = JSON.parse(args[:message])
+        @json_message = args[:message]
+        @jr_method = notification['method']
+        @jr_args   = notification['params']
+        @headers   = args.has_key?(:headers) ? {}.merge!(args[:headers]) : {}
+
+        notification.keys.select { |k|
+          !['jsonrpc', 'method', 'params'].include?(k)
+        }.each { |k| @headers[k] = notification[k] }
+
+      rescue Exception => e
+        #puts "Exception Parsing Notification #{e}"
+        raise e
+      end
+
+    elsif args.has_key?(:method)
+      @jr_method = args[:method]
+      @jr_args   = args[:args]
+      @headers   = args[:headers]
+
+    end
+  end
+
+  # 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 = JSON.parse(message)
+       parsed.has_key?('method') && !parsed.has_key?('id')
+    rescue Exception => e
+      false
+    end
+  end
+
+  # Convert notification message to string json format
+  def to_s
+    notification = { 'jsonrpc' => '2.0',
+                     'method' => @jr_method,
+                     'params' => @jr_args }
+    notification.merge!(@headers) unless @headers.nil?
+    notification.to_json.to_s
+  end
+
+end
+
+# Helper utilities for messages
+class MessageUtil
+  # Retrieve and return a single json message from a data string.
+  #
+  # Returns the message and remaining portion of the data string,
+  # if message is found, else nil
+  #
+  # XXX really don't like having to do this, but a quick solution
+  # to the issue of multiple messages appearing in one tcp data packet.
+  #
+  # TODO efficiency can probably be optimized
+  #   in the case closing '}' hasn't arrived yet
+  def self.retrieve_json(data) 
+    return nil if data.nil? || data.empty?
+    start  = 0
+    start += 1 until start == data.length || data[start] == '{'
+    on = mi = 0 
+    start.upto(data.length - 1).each { |i|
+      if data[i] == '{'
+        on += 1
+      elsif data[i] == '}'
+        on -= 1
+      end
+
+      if on == 0
+        mi = i
+        break
+      end
+    }
+    
+    return nil if mi == 0
+    return data[start..mi], data[(mi+1)..-1]
+  end
+
+end
+
 end

data/lib/rjr/missing_node.rb

@@ -0,0 +1,17 @@
+# RJR Missing Node Endpoint
+#
+# Provides a entity able to be associated with a rjr endpoint
+# if the corresponding node cannot be loaded for whatever reason
+#
+# Copyright (C) 2012 Mohammed Morsi <mo@morsi.org>
+# Licensed under the Apache License, Version 2.0
+
+require 'rjr/node'
+
+module RJR
+class MissingNode < RJR::Node
+  def method_missing(method_id, *args, &bl)
+    raise "rjr node #{node_id} is missing a dependency - cannot invoke #{method_id}"
+  end
+end
+end

data/lib/rjr/multi_node.rb

@@ -34,6 +34,9 @@ module RJR
 #   # invoke requests as you normally would via any protocol
 #
 class MultiNode < RJR::Node
+  # Return the nodes
+  attr_reader :nodes
+
   # MultiNode initializer
   # @param [Hash] args the options to create the tcp node with
   # @option args [Array<RJR::Node>] :nodes array of nodes to use to listen to new requests on