rjr 0.5.3

data/lib/rjr/message.rb

@@ -0,0 +1,146 @@
+# RJR Message
+#
+# Copyright (C) 2012 Mohammed Morsi <mo@morsi.org>
+# Licensed under the AGPLv3+ http://www.gnu.org/licenses/agpl.txt
+
+# establish client connection w/ specified args and invoke block w/ 
+# newly created client, returning it after block terminates
+
+require 'json'
+
+module RJR
+
+# Message sent from client to server to invoke a json-rpc method
+class RequestMessage
+  # Helper method to generate a random id
+  def self.gen_uuid
+    ["%02x"*4, "%02x"*2, "%02x"*2, "%02x"*2, "%02x"*6].join("-") %
+        Array.new(16) {|x| rand(0xff) }
+  end
+
+  attr_accessor :json_message
+  attr_accessor :jr_method
+  attr_accessor :jr_args
+  attr_accessor :msg_id
+  attr_accessor :headers
+
+  def initialize(args = {})
+    if args.has_key?(:message)
+      begin
+        request = JSON.parse(args[:message])
+        @json_message = args[:message]
+        @jr_method = request['method']
+        @jr_args   = request['params']
+        @msg_id    = request['id']
+        @headers   = args.has_key?(:headers) ? {}.merge!(args[:headers]) : {}
+
+        request.keys.select { |k|
+          !['jsonrpc', 'id', 'method', 'params'].include?(k)
+        }.each { |k| @headers[k] = request[k] }
+
+      rescue Exception => e
+        #puts "Exception Parsing Request #{e}"
+        # TODO
+        raise e
+      end
+
+    elsif args.has_key?(:method)
+      @jr_method = args[:method]
+      @jr_args   = args[:args]
+      @headers   = args[:headers]
+      @msg_id    = RequestMessage.gen_uuid
+
+    end
+  end
+
+  def self.is_request_message?(message)
+    begin
+       JSON.parse(message).has_key?('method')
+    rescue Exception => e
+      false
+    end
+  end
+
+  def to_s
+    request = { 'jsonrpc' => '2.0',
+                'method' => @jr_method,
+                'params' => @jr_args }
+    request['id'] = @msg_id unless @msg_id.nil?
+    request.merge!(@headers) unless @headers.nil?
+    request.to_json.to_s
+  end
+
+end
+
+# Message sent from server to client in response to request message
+class ResponseMessage
+  attr_accessor :json_message
+  attr_accessor :msg_id
+  attr_accessor :result
+  attr_accessor :headers
+
+  def initialize(args = {})
+    if args.has_key?(:message)
+      response = JSON.parse(args[:message])
+      @json_message  = args[:message]
+      @msg_id  = response['id']
+      @result   = Result.new
+      @result.success   = response.has_key?('result')
+      @result.failed    = !response.has_key?('result')
+      @headers   = args.has_key?(:headers) ? {}.merge!(args[:headers]) : {}
+
+      if @result.success
+        @result.result = response['result']
+
+      elsif response.has_key?('error')
+        @result.error_code = response['error']['code']
+        @result.error_msg  = response['error']['message']
+        @result.error_class = response['error']['class']  # TODO safely constantize this
+
+      end
+
+      response.keys.select { |k|
+        !['jsonrpc', 'id', 'result', 'error'].include?(k)
+      }.each { |k| @headers[k] = response[k] }
+
+    elsif args.has_key?(:result)
+      @msg_id  = args[:id]
+      @result  = args[:result]
+      @headers = args[:headers]
+
+    #else
+    #  raise ArgumentError, "must specify :message or :result"
+
+    end
+
+  end
+
+  def self.is_response_message?(message)
+    begin
+      JSON.parse(message).has_key?('result')
+    rescue Exception => e
+      false
+    end
+  end
+
+  def to_s
+    s = ''
+    if result.success
+      s =    {'jsonrpc' => '2.0',
+              'id'      => @msg_id,
+              'result'  => @result.result}
+
+    else
+      s =    {'jsonrpc' => '2.0',
+              'id'      => @msg_id,
+              'error'   => { 'code'    => @result.error_code,
+                             'message' => @result.error_msg,
+                             'class'   => @result.error_class}}
+    end
+
+    s.merge! @headers unless headers.nil?
+    return s.to_json.to_s
+  end
+end
+
+end

data/lib/rjr/multi_node.rb

@@ -0,0 +1,35 @@
+# RJR MultiNode Endpoint
+#
+# Copyright (C) 2012 Mohammed Morsi <mo@morsi.org>
+# Licensed under the AGPLv3+ http://www.gnu.org/licenses/agpl.txt
+
+# establish client connection w/ specified args and invoke block w/ 
+# newly created client, returning it after block terminates
+
+require 'eventmachine'
+require 'rjr/node'
+require 'rjr/message'
+
+module RJR
+
+class MultiNode < RJR::Node
+  # initialize the node w/ the specified params
+  def initialize(args = {})
+    super(args)
+    @nodes = args[:nodes]
+  end
+
+  def <<(node)
+    @nodes << node
+  end
+
+
+  # Instruct Node to start listening for and dispatching rpc requests
+  def listen
+    @nodes.each { |node|
+      node.listen
+    }
+  end
+end
+
+end

data/lib/rjr/node.rb

@@ -0,0 +1,81 @@
+# RJR Node
+#
+# Copyright (C) 2012 Mohammed Morsi <mo@morsi.org>
+# Licensed under the AGPLv3+ http://www.gnu.org/licenses/agpl.txt
+
+# establish client connection w/ specified args and invoke block w/ 
+# newly created client, returning it after block terminates
+
+require 'eventmachine'
+require 'rjr/thread_pool'
+
+module RJR
+
+# Defines a node which can be used to dispatch rpc requests and/or register
+# handlers for incomping requests.
+class Node
+  # node always has a node id
+  attr_reader :node_id
+
+  # attitional parameters to set on messages
+  attr_accessor :message_headers
+
+  def initialize(args = {})
+     @node_id = args[:node_id]
+
+     @message_headers = {}
+     @message_headers.merge!(args[:headers]) if args.has_key?(:headers)
+
+     # threads pool to handle incoming requests
+     # FIXME make the # of threads and timeout configurable)
+     @thread_pool = ThreadPool.new(10, :timeout => 5)
+  end
+
+  # run job in event machine
+  def em_run(&bl)
+    @@em_jobs ||= 0
+    @@em_jobs += 1
+
+    @@em_thread  ||= nil
+
+    if @@em_thread.nil?
+      @@em_thread  =
+        Thread.new{
+          begin
+            EventMachine.run
+          rescue Exception => e
+            puts "Critical exception #{e}"
+          ensure
+          end
+        }
+#sleep 0.5 until EventMachine.reactor_running? # XXX hacky way to do this
+    end
+    EventMachine.schedule bl
+  end
+
+  def em_running?
+    EventMachine.reactor_running?
+  end
+
+  def join
+    if @@em_thread
+      @@em_thread.join
+      @@em_thread = nil
+    end
+  end
+
+  def stop
+    @@em_jobs -= 1
+    if @@em_jobs == 0
+      EventMachine.stop
+      @thread_pool.stop
+    end
+  end
+
+  def halt
+    @@em_jobs = 0
+    EventMachine.stop
+  end
+
+end
+end # module RJR

data/lib/rjr/semaphore.rb

@@ -0,0 +1,58 @@
+#
+# $Id: semaphore.rb,v 1.2 2003/03/15 20:10:10 fukumoto Exp $
+#
+# Copied unmodified from:
+#   http://www.imasy.or.jp/~fukumoto/ruby/semaphore.rb
+# Originally licensed under The Ruby License:
+#   http://raa.ruby-lang.org/project/semaphore/
+
+class CountingSemaphore
+
+  def initialize(initvalue = 0)
+    @counter = initvalue
+    @waiting_list = []
+  end
+
+  def wait
+    Thread.critical = true
+    if (@counter -= 1) < 0
+      @waiting_list.push(Thread.current)
+      Thread.stop
+    end
+    self
+  ensure
+    Thread.critical = false
+  end
+
+  def signal
+    Thread.critical = true
+    begin
+      if (@counter += 1) <= 0
+	t = @waiting_list.shift
+	t.wakeup if t
+      end
+    rescue ThreadError
+      retry
+    end
+    self
+  ensure
+    Thread.critical = false
+  end
+
+  alias down wait
+  alias up signal
+  alias P wait
+  alias V signal
+
+  def exclusive
+    wait
+    yield
+  ensure
+    signal
+  end
+
+  alias synchronize exclusive
+
+end
+
+Semaphore = CountingSemaphore

data/lib/rjr/tcp_node.rb

@@ -0,0 +1 @@
+# TODO

data/lib/rjr/thread_pool.rb

@@ -0,0 +1,165 @@
+# Thread Pool
+#
+# Copyright (C) 2010 Mohammed Morsi <movitto@yahoo.com>
+#
+# Permission is hereby granted, free of charge, to any person
+# obtaining a copy of this software and associated documentation
+# files (the "Software"), to deal in the Software without
+# restriction, including without limitation the rights to use,
+# copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the
+# Software is furnished to do so, subject to the following
+# conditions:
+#
+# The above copyright notice and this permission notice shall be
+# included in all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+# OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+# HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+# WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+# FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+# OTHER DEALINGS IN THE SOFTWARE.
+
+# Work item to be executed in thread pool
+class ThreadPoolJob
+  attr_accessor :handler
+  attr_accessor :params
+
+  def initialize(*params, &block)
+    @params = params
+    @handler = block
+  end
+end
+
+
+# Launches a specified number of threads on instantiation,
+# assigning work to them as it arrives
+class ThreadPool
+
+  # Encapsulate each thread pool thread in object
+  class ThreadPoolJobRunner
+    attr_accessor :time_started
+
+    def initialize(thread_pool)
+      @thread_pool = thread_pool
+      @timeout_lock = Mutex.new
+      @thread_lock  = Mutex.new
+    end
+
+    def run
+      @thread_lock.synchronize {
+        @thread = Thread.new {
+          until @thread_pool.terminate
+            @timeout_lock.synchronize { @time_started = nil }
+            work = @thread_pool.next_job
+            @timeout_lock.synchronize { @time_started = Time.now }
+            unless work.nil?
+              begin
+                work.handler.call *work.params
+              rescue Exception => e
+                puts "Thread raised Fatal Exception #{e}"
+                puts "\n#{e.backtrace.join("\n")}"
+              end
+            end
+          end
+        }
+      }
+    end
+
+    def running?
+      res = nil
+      @thread_lock.synchronize{
+        res = (@thread.status != false)
+      }
+      res
+    end
+
+    # TODO should not invoke after stop is called
+    def check_timeout(timeout)
+      @timeout_lock.synchronize {
+        if !@time_started.nil? && Time.now - @time_started > timeout
+          stop
+          run
+        end
+      }
+    end
+
+    def stop
+      @thread_lock.synchronize {
+        if @thread.alive?
+          @thread.kill
+          @thread.join
+        end
+      }
+    end
+  end
+
+  # Create a thread pool with a specified number of threads
+  def initialize(num_threads, args = {})
+    @num_threads = num_threads
+    @timeout     = args[:timeout]
+    @job_runners = []
+    @job_runners_lock = Mutex.new
+    @terminate = false
+    @terminate_lock = Mutex.new
+
+    @work_queue  = Queue.new
+
+    0.upto(@num_threads) { |i| 
+      runner = ThreadPoolJobRunner.new(self)
+      @job_runners << runner
+      runner.run
+    }
+
+    # optional timeout thread
+    unless @timeout.nil?
+      @timeout_thread = Thread.new {
+        until terminate
+          sleep @timeout
+          @job_runners_lock.synchronize {
+            @job_runners.each { |jr|
+              jr.check_timeout(@timeout)
+            }
+          }
+        end
+      }
+    end
+  end
+
+  def running?
+    !terminate && (@timeout.nil? || @timeout_thread.status) &&
+    @job_runners.all? { |r| r.running? }
+  end
+
+  # terminate reader
+  def terminate
+    @terminate_lock.synchronize { @terminate }
+  end
+
+  # terminate setter
+  def terminate=(val)
+    @terminate_lock.synchronize { @terminate = val }
+  end
+
+  # Add work to the pool
+  def <<(work)
+    @work_queue.push work
+  end
+
+  # Return the next job queued up
+  def next_job
+    @work_queue.pop
+  end
+
+  # Terminate the thread pool
+  def stop
+    terminate = true
+    @timeout_thread.join unless @timout_thread.nil?
+    @work_queue.clear
+    @job_runners_lock.synchronize { @job_runners.each { |jr| jr.stop } }
+  end
+end
+

data/lib/rjr/udp_node.rb

@@ -0,0 +1 @@
+# TODO

data/lib/rjr/web_node.rb

@@ -0,0 +1,112 @@
+# RJR WWW Endpoint
+#
+# Copyright (C) 2012 Mohammed Morsi <mo@morsi.org>
+# Licensed under the AGPLv3+ http://www.gnu.org/licenses/agpl.txt
+
+# establish client connection w/ specified args and invoke block w/ 
+# newly created client, returning it after block terminates
+
+require 'curb'
+
+require 'evma_httpserver'
+#require 'em-http-request'
+
+require 'rjr/node'
+require 'rjr/message'
+
+module RJR
+
+# Web client node callback interface,
+# currently does nothing as web connections aren't persistant
+class WebNodeCallback
+  def initialize()
+  end
+
+  def invoke(callback_method, *data)
+  end
+end
+
+# Web node definition, listen for and invoke json-rpc requests via web requests
+class WebRequestHandler < EventMachine::Connection
+  include EventMachine::HttpServer
+
+  RJR_NODE_TYPE = :web
+
+  def initialize(*args)
+    @web_node = args[0]
+  end
+
+  def handle_request(message)
+    msg    = nil
+    result = nil
+    begin
+      msg    = RequestMessage.new(:message => message, :headers => @web_node.message_headers)
+      headers = @web_node.message_headers.merge(msg.headers)
+      result = Dispatcher.dispatch_request(msg.jr_method,
+                                           :method_args => msg.jr_args,
+                                           :headers => headers,
+                                           :rjr_node_id   => @web_node.node_id,
+                                           :rjr_node_type => RJR_NODE_TYPE,
+                                           :rjr_callback => WebNodeCallback.new())
+    rescue JSON::ParserError => e
+      result = Result.invalid_request
+    end
+
+    msg_id = msg.nil? ? nil : msg.msg_id
+    response = ResponseMessage.new(:id => msg_id, :result => result, :headers => headers)
+
+    resp = EventMachine::DelegatedHttpResponse.new(self)
+    #resp.status  = response.result.success ? 200 : 500
+    resp.status = 200
+    resp.content = response.to_s
+    resp.content_type "application/json"
+    resp.send_response
+  end
+
+  def process_http_request
+    # TODO support http protocols other than POST
+    # TODO should delete handler threads as they complete & should handle timeout
+    msg = @http_post_content.nil? ? '' : @http_post_content
+    #@thread_pool << ThreadPoolJob.new { handle_request(msg) }
+    handle_request(msg)
+  end
+
+  #def receive_data(data)
+  #  puts "~~~~ #{data}"
+  #end
+end
+
+class WebNode < RJR::Node
+  # initialize the node w/ the specified params
+  def initialize(args = {})
+     super(args)
+     @host      = args[:host]
+     @port      = args[:port]
+  end
+
+  # Initialize the web subsystem
+  def init_node
+  end
+
+  # Instruct Node to start listening for and dispatching rpc requests
+  def listen
+    em_run do
+      init_node
+      EventMachine::start_server(@host, @port, WebRequestHandler, self)
+    end
+  end
+
+  # Instructs node to send rpc request, and wait for / return response
+  def invoke_request(uri, rpc_method, *args)
+    init_node
+    message = RequestMessage.new :method => rpc_method,
+                                 :args   => args,
+                                 :headers => @message_headers
+    res = Curl::Easy.http_post uri, message.to_s
+    msg    = ResponseMessage.new(:message => res.body_str, :headers => @message_headers)
+    headers = @message_headers.merge(msg.headers)
+    return Dispatcher.handle_response(msg.result)
+  end
+end
+
+end # module RJR