rjr 0.12.2 → 0.15.1

data/lib/rjr/multi_node.rb

@@ -1,65 +0,0 @@
-# RJR MultiNode Endpoint
-#
-# Implements the RJR::Node interface to satisty JSON-RPC requests over multiple protocols
-#
-# Copyright (C) 2012 Mohammed Morsi <mo@morsi.org>
-# Licensed under the Apache License, Version 2.0
-
-require 'eventmachine'
-require 'rjr/node'
-require 'rjr/message'
-
-module RJR
-
-# Multiple node definition, allows a developer to easily multiplex transport
-# mechanisms to serve JSON-RPC requests over.
-#
-# @example Listening for json-rpc requests over amqp, tcp, http, and websockets
-#   # register rjr dispatchers (see RJR::Dispatcher)
-#   RJR::Dispatcher.add_handler('hello') { |name|
-#     # optionally use @rjr_node_type to handle different transport types
-#     "Hello #{name}!"
-#   }
-#
-#   amqp_server = RJR::TCPNode.new :node_id => 'amqp_server', :broker => 'localhost'
-#   tcp_server  = RJR::TCPNode.new :node_id => 'tcp_server',  :host => 'localhost', :port => '7777'
-#   web_server  = RJR::WebNode.new :node_id => 'tcp_server',  :host => 'localhost', :port => '80'
-#   ws_server   = RJR::WebNode.new :node_id => 'tcp_server',  :host => 'localhost', :port => '8080'
-#
-#   server = RJR::MultiNode.new :node_id => 'server',
-#                               :nodes   => [amqp_server, tcp_server, web_server, ws_server]
-#   server.listen
-#   server.join
-#
-#   # 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
-  def initialize(args = {})
-    super(args)
-    @nodes = args[:nodes]
-  end
-
-  # Add node to multinode
-  # @param [RJR::Node] node the node to add
-  def <<(node)
-    @nodes << node
-  end
-
-
-  # Instruct Node to start listening for and dispatching rpc requests
-  #
-  # Implementation of {RJR::Node#listen}
-  def listen
-    @nodes.each { |node|
-      node.listen
-    }
-  end
-end
-
-end

data/lib/rjr/tcp_node.rb

@@ -1,323 +0,0 @@
-# RJR TCP Endpoint
-#
-# Implements the RJR::Node interface to satisty JSON-RPC requests over the TCP protocol
-#
-# Copyright (C) 2012 Mohammed Morsi <mo@morsi.org>
-# Licensed under the Apache License, Version 2.0
-
-require 'uri'
-require 'socket'
-require 'eventmachine'
-
-require 'rjr/node'
-require 'rjr/message'
-require 'rjr/message'
-require 'rjr/dispatcher'
-require 'rjr/errors'
-require 'rjr/thread_pool2'
-
-module RJR
-
-# TCP node callback interface, used to invoke json-rpc methods
-# against a remote node via a tcp socket connection previously opened
-#
-# After a node sends a json-rpc request to another, the either node may send
-# additional requests to each other via the socket already established until
-# it is closed on either end
-class TCPNodeCallback
-
-  # TCPNodeCallback initializer
-  # @param [Hash] args the options to create the tcp node callback with
-  # @option args [TCPNodeEndpoint] :endpoint tcp node endpoint used to send/receive messages
-  # @option args [Hash] :headers hash of rjr message headers present in client request when callback is established
-  def initialize(args = {})
-    @endpoint        = args[:endpoint]
-    @message_headers = args[:headers]
-  end
-
-  # Implementation of {RJR::NodeCallback#invoke}
-  def invoke(callback_method, *data)
-    msg = NotificationMessage.new :method => callback_method, :args => data, :headers => @message_headers
-    # TODO surround w/ begin/rescue block incase of socket errors / raise RJR::ConnectionError
-    @endpoint.safe_send msg.to_s
-  end
-end
-
-# @private
-# Helper class intialized by eventmachine encapsulating a socket connection
-class TCPNodeEndpoint < EventMachine::Connection
-
-  attr_reader :host
-  attr_reader :port
-
-  # TCPNodeEndpoint intializer
-  #
-  # specify the TCPNode establishing the connection
-  def initialize(args = {})
-    @rjr_node = args[:rjr_node]
-    @host = args[:host]
-    @port = args[:port]
-
-    # used to serialize requests to send data via a connection
-    @send_lock = Mutex.new
-  end
-
-  # {EventMachine::Connection#receive_data} callback, handle request / response messages
-  def receive_data(data)
-    # a large json-rpc message may be split over multiple packets (invocations of receive_data)
-    # and multiple messages may be concatinated into one packet
-    @data ||= ""
-    @data += data
-    while extracted = MessageUtil.retrieve_json(@data)
-      msg, @data = *extracted
-      if RequestMessage.is_request_message?(msg)
-        ThreadPool2Manager << ThreadPool2Job.new(msg) { |m| handle_request(m, false) }
-
-      elsif NotificationMessage.is_notification_message?(msg)
-        ThreadPool2Manager << ThreadPool2Job.new(msg) { |m| handle_request(m, true) }
-
-      elsif ResponseMessage.is_response_message?(msg)
-        handle_response(msg)
-
-      end
-    end
-  end
-
-  # {EventMachine::Connection#unbind} callback, connection was closed
-  def unbind
-  end
-
-  # Helper to send data safely, this should be invoked instead of send_data
-  # in all cases
-  def safe_send(data)
-    @send_lock.synchronize{
-      send_data(data)
-    }
-  end
-
-
-  private
-
-  # Internal helper, handle request message received
-  def handle_request(data, notification=false)
-    # XXX hack to handle client disconnection (should grap port/ip immediately on connection and use that)
-    client_port,client_ip = nil,nil
-    begin
-      client_port, client_ip = Socket.unpack_sockaddr_in(get_peername)
-    rescue Exception=>e
-    end
-
-    msg    = notification ? NotificationMessage.new(:message => data, :headers => @rjr_node.message_headers) :
-                            RequestMessage.new(:message => data, :headers => @rjr_node.message_headers)
-    headers = @rjr_node.message_headers.merge(msg.headers)
-    result = Dispatcher.dispatch_request(msg.jr_method,
-                                         :method_args => msg.jr_args,
-                                         :headers => headers,
-                                         :client_ip     => client_ip,
-                                         :client_port   => client_port,
-                                         :rjr_node      => @rjr_node,
-                                         :rjr_node_id   => @rjr_node.node_id,
-                                         :rjr_node_type => TCPNode::RJR_NODE_TYPE,
-                                         :rjr_callback =>
-                                           TCPNodeCallback.new(:endpoint => self,
-                                                               :headers => headers))
-    unless notification
-      response = ResponseMessage.new(:id => msg.msg_id, :result => result, :headers => headers)
-      safe_send(response.to_s)
-    end
-  end
-
-  # Internal helper, handle response message received
-  def handle_response(data)
-    msg    = ResponseMessage.new(:message => data, :headers => @rjr_node.message_headers)
-    res = err = nil
-    begin
-      res = Dispatcher.handle_response(msg.result)
-    rescue Exception => e
-      err = e
-    end
-
-    @rjr_node.response_lock.synchronize {
-      result = [msg.msg_id, res]
-      result << err if !err.nil?
-      @rjr_node.responses << result
-      @rjr_node.response_cv.signal
-    }
-  end
-end
-
-# TCP node definition, listen for and invoke json-rpc requests via TCP sockets
-#
-# Clients should specify the hostname / port when listening for requests and
-# when invoking them.
-#
-# @example Listening for json-rpc requests over tcp
-#   # register rjr dispatchers (see RJR::Dispatcher)
-#   RJR::Dispatcher.add_handler('hello') { |name|
-#     "Hello #{name}!"
-#   }
-#
-#   # initialize node, listen, and block
-#   server = RJR::TCPNode.new :node_id => 'server', :host => 'localhost', :port => '7777'
-#   server.listen
-#   server.join
-#
-# @example Invoking json-rpc requests over tcp
-#   client = RJR::TCPNode.new :node_id => 'client', :host => 'localhost', :port => '8888'
-#   puts client.invoke_request('jsonrpc://localhost:7777', 'hello', 'mo')
-#
-class TCPNode < RJR::Node
-  RJR_NODE_TYPE = :tcp
-
-  attr_accessor :connections
-
-  attr_accessor :response_lock
-  attr_accessor :response_cv
-  attr_accessor :responses
-
-  private
-  # Internal helper, initialize new connection
-  def init_node(args={}, &on_init)
-    host,port = args[:host], args[:port]
-    connection = nil
-    @connections_lock.synchronize {
-      connection = @connections.find { |c|
-                     port == c.port && host == c.host
-                   }
-      if connection.nil?
-        connection =
-          EventMachine::connect host, port,
-                      TCPNodeEndpoint, args
-        @connections << connection
-      end
-    }
-    on_init.call(connection)
-  end
-
-  # Internal helper, block until response matching message id is received
-  def wait_for_result(message)
-    res = nil
-    while res.nil?
-      @response_lock.synchronize{
-        # FIXME throw err if more than 1 match found
-        res = @responses.select { |response| message.msg_id == response.first }.first
-        if !res.nil?
-          @responses.delete(res)
-
-        else
-          @response_cv.signal
-          @response_cv.wait @response_lock
-
-        end
-      }
-    end
-    return res
-  end
-
-  public
-  # TCPNode initializer
-  # @param [Hash] args the options to create the tcp node with
-  # @option args [String] :host the hostname/ip which to listen on
-  # @option args [Integer] :port the port which to listen on
-  def initialize(args = {})
-     super(args)
-     @host      = args[:host]
-     @port      = args[:port]
-
-     @connections = []
-     @connections_lock = Mutex.new
-
-     @response_lock = Mutex.new
-     @response_cv   = ConditionVariable.new
-     @responses     = []
-
-     @connection_event_handlers = {:closed => [], :error => []}
-  end
-
-  # 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
-  # @yield [TCPNode] 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
-  end
-
-  # Instruct Node to start listening for and dispatching rpc requests
-  #
-  # Implementation of {RJR::Node#listen}
-  def listen
-    em_run {
-      EventMachine::start_server @host, @port, TCPNodeEndpoint, { :rjr_node => self }
-    }
-  end
-
-  # Instructs node to send rpc request, and wait for / return response.
-  #
-  # Do not invoke directly from em event loop or callback as will block the message
-  # subscription used to receive responses
-  #
-  # @param [String] uri location of node to send request to, should be
-  #   in format of jsonrpc://hostname:port
-  # @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_request(uri, rpc_method, *args)
-    uri = URI.parse(uri)
-    host,port = uri.host, uri.port
-
-    message = RequestMessage.new :method => rpc_method,
-                                 :args   => args,
-                                 :headers => @message_headers
-    em_run{
-      init_node(:host => host, :port => port,
-                :rjr_node => self) { |c|
-        c.safe_send message.to_s
-      }
-    }
-
-    # TODO optional timeout for response ?
-    result = wait_for_result(message)
-
-    if result.size > 2
-      raise Exception, result[2]
-    end
-    return result[1]
-  end
-
-  # Instructs node to send rpc notification (immadiately returns / no response is generated)
-  #
-  # @param [String] uri location of node to send notification to, should be
-  #   in format of jsonrpc://hostname:port
-  # @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 send_notification(uri, rpc_method, *args)
-    # will block until message is published
-    published_l = Mutex.new
-    published_c = ConditionVariable.new
-
-    uri = URI.parse(uri)
-    host,port = uri.host, uri.port
-
-    invoked = false
-    conn    = nil
-    message = NotificationMessage.new :method => rpc_method,
-                                      :args   => args,
-                                      :headers => @message_headers
-    em_run{
-      init_node(:host => host, :port => port,
-                :rjr_node => self) { |c|
-        conn = c
-        c.safe_send message.to_s
-        # XXX big bug w/ tcp node, this should be invoked only when
-        # we are sure event machine sent message
-        published_l.synchronize { invoked = true ; published_c.signal }
-      }
-    }
-    published_l.synchronize { published_c.wait published_l unless invoked }
-    #sleep 0.01 until conn.get_outbound_data_size == 0
-    nil
-  end
-end
-
-end # module RJR

data/lib/rjr/thread_pool2.rb

@@ -1,272 +0,0 @@
-# Thread Pool (second implementation)
-#
-# Copyright (C) 2010-2012 Mohammed Morsi <mo@morsi.org>
-# Licensed under the Apache License, Version 2.0
-
-require 'singleton'
-
-# Work item to be executed in a thread launched by {ThreadPool2}.
-#
-# The end user just need to initialize this class with the handle
-# to the job to be executed and the params to pass to it, before
-# handing it off to the thread pool that will take care of the rest.
-class ThreadPool2Job
-  attr_accessor :handler
-  attr_accessor :params
-
-  # used internally by the thread pool system, these shouldn't
-  # be set or used by the end user
-  attr_accessor :timestamp
-  attr_accessor :thread
-  attr_accessor :pool_lock
-  attr_reader   :being_executed
-
-  # ThreadPoolJob initializer
-  # @param [Array] params arguments to pass to the job when it is invoked
-  # @param [Callable] block handle to callable object corresponding to job to invoke
-  def initialize(*params, &block)
-    @params = params
-    @handler = block
-    @being_executed = false
-    @timestamp = nil
-  end
-
-  # Return string representation of thread pool job
-  def to_s
-    "thread_pool2_job-#{@handler.source_location}-#{@params}"
-  end
-
-  def being_executed?
-    @being_executed
-  end
-
-  def completed?
-    !@timestamp.nil? && !@being_executed
-  end
-
-  # Set job metadata and execute job with specified params
-  def exec
-    # synchronized so that both timestamp is set and being_executed
-    # set to true before the possiblity of a timeout management
-    # check (see handle_timeout! below)
-    @pool_lock.synchronize{
-      @thread = Thread.current
-      @being_executed = true
-      @timestamp = Time.now
-    }
-
-    @handler.call *@params
-
-    # synchronized so as to ensure that a timeout check does not
-    # occur until before (in which case thread is killed during
-    # the check as one atomic operation) or after (in which case
-    # job is marked as completed, and thread is not killed / goes
-    # onto pull anther job)
-    @pool_lock.synchronize{
-      @being_executed = false
-    }
-  end
-
-  # Check timeout and kill thread if it exceeded.
-  def handle_timeout!(timeout)
-    # Synchronized so that check and kill operation occur as an
-    # atomic operation, see exec above
-    @pool_lock.synchronize { 
-      if @being_executed && (Time.now - @timestamp) > timeout
-        RJR::Logger.debug "timeout detected on thread #{@thread} started at #{@timestamp}"
-        @thread.kill
-        return true
-      end
-      return false
-    }
-  end
-end
-
-# Utility to launches a specified number of threads on instantiation,
-# assigning work to them in order as it arrives.
-#
-# Supports optional timeout which allows the developer to kill and restart
-# threads if a job is taking too long to run.
-#
-# Second (and hopefully better) thread pool implementation.
-#
-# TODO move to the RJR namespace
-class ThreadPool2
-  private
-
-  # Internal helper, launch worker thread
-  #
-  # Should only be launched from within the pool_lock
-  def launch_worker
-    @worker_threads << Thread.new {
-      while work = @work_queue.pop
-        begin
-          #RJR::Logger.debug "launch thread pool job #{work}"
-          work.pool_lock = @pool_lock
-          @running_queue << work
-          work.exec
-          # TODO cleaner / more immediate way to pop item off running_queue
-          #RJR::Logger.debug "finished thread pool job #{work}"
-        rescue Exception => e
-          # FIXME also send to rjr logger at a critical level
-          puts "Thread raised Fatal Exception #{e}"
-          puts "\n#{e.backtrace.join("\n")}"
-        end
-      end
-    } unless @worker_threads.size == @num_threads
-  end
-
-  # Internal helper, performs checks on workers
-  def check_workers
-    if @terminate
-      @pool_lock.synchronize { 
-        @worker_threads.each { |t| 
-          t.kill
-        }
-        @worker_threads = []
-      }
-
-    elsif @timeout
-      readd = []
-      while @running_queue.size > 0 && work = @running_queue.pop
-        if @timeout && work.handle_timeout!(@timeout)
-          @pool_lock.synchronize { 
-            @worker_threads.delete(work.thread)
-            launch_worker
-          }
-        elsif !work.completed?
-          readd << work
-        end
-      end
-      readd.each { |work| @running_queue << work }
-    end
-  end
-
-  # Internal helper, launch management thread
-  #
-  # Should only be launched from within the pool_lock
-  def launch_manager
-    @manager_thread = Thread.new {
-      until @terminate
-        # sleep needs to occur b4 check workers so
-        # workers are guaranteed to be terminated on @terminate
-        # !FIXME! this enforces a mandatory setting of @timeout which was never intended:
-        sleep @timeout
-        check_workers
-      end
-      check_workers
-      @pool_lock.synchronize { @manager_thread = nil }
-    } unless @manager_thread
-  end
-
-  public
-  # Create a thread pool with a specified number of threads
-  # @param [Integer] num_threads the number of worker threads to create
-  # @param [Hash] args optional arguments to initialize thread pool with
-  # @option args [Integer] :timeout optional timeout to use to kill long running worker jobs
-  def initialize(num_threads, args = {})
-    @work_queue  = Queue.new
-    @running_queue  = Queue.new
-
-    @num_threads = num_threads
-    @pool_lock = Mutex.new
-    @worker_threads = []
-
-    @timeout     = args[:timeout]
-
-    ObjectSpace.define_finalizer(self, self.class.finalize(self))
-  end
-
-  # Return internal thread pool state in string
-  def inspect
-    "wq#{@work_queue.size}/\
-rq#{@running_queue.size}/\
-nt#{@num_threads.size}/\
-wt#{@worker_threads.select { |wt| ['sleep', 'run'].include?(wt.status) }.size}ok-\
-#{@worker_threads.select { |wt| ['aborting', false, nil].include?(wt.status) }.size}nok/\
-to#{@timeout}"
-  end
-
-  # Start the thread pool
-  def start
-    # clear work and timeout queues?
-    @pool_lock.synchronize {
-      @terminate = false
-      launch_manager
-      0.upto(@num_threads) { |i| launch_worker }
-    }
-  end
-
-  # Ruby ObjectSpace finalizer to ensure that thread pool terminates all
-  # threads when object is destroyed
-  def self.finalize(thread_pool)
-    proc { thread_pool.stop ; thread_pool.join }
-  end
-
-  # Return boolean indicating if thread pool is running.
-  #
-  # If at least one worker thread isn't terminated, the pool is still considered running
-  def running?
-    @pool_lock.synchronize { @worker_threads.size != 0 && @worker_threads.all? { |t| t.status } }
-  end
-
-  # Add work to the pool
-  # @param [ThreadPool2Job] work job to execute in first available thread
-  def <<(work)
-    # TODO option to increase worker threads if work queue gets saturated
-    @work_queue.push work
-  end
-
-  # Terminate the thread pool, stopping all worker threads
-  def stop
-    @pool_lock.synchronize {
-      @terminate = true
-
-      # wakeup management thread so it can kill workers
-      # before terminating on its own
-      begin
-        @manager_thread.wakeup
-
-      # incase thread wakes up / terminates on its own
-      rescue ThreadError
-
-      end
-    }
-    join
-  end
-
-  # Block until all worker threads have finished executing
-  def join
-    #@pool_lock.synchronize { @worker_threads.each { |t| t.join unless @terminate } }
-    th = nil
-    @pool_lock.synchronize { th = @manager_thread if @manager_thread }
-    th.join if th
-  end
-end
-
-# Providers an interface to access a shared thread pool.
-#
-# Thread pool operations may be invoked on this class after
-# the 'init' method is called
-#
-#     ThreadPool2Manager.init
-#     ThreadPool2Manager << ThreadPool2Job(:foo) { "do something" }
-class ThreadPool2Manager
-  # Initialize thread pool if it doesn't exist
-  def self.init(num_threads, params = {})
-    if @thread_pool.nil?
-      @thread_pool = ThreadPool2.new(num_threads, params)
-    end
-    @thread_pool.start
-  end
-
-  # Return shared thread pool
-  def self.thread_pool
-    @thread_pool
-  end
-
-  # Delegates all methods invoked on calls to thread pool
-  def self.method_missing(method_id, *args, &bl)
-    @thread_pool.send method_id, *args, &bl
-  end
-end