rjr 0.9.0 → 0.11.7

data/lib/rjr/thread_pool2.rb

@@ -0,0 +1,271 @@
+# 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)
+    @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

data/lib/rjr/util.rb

@@ -0,0 +1,104 @@
+# High level rjr utility mechanisms
+#
+# Copyright (C) 2013 Mohammed Morsi <mo@morsi.org>
+# Licensed under the Apache License, Version 2.0
+
+require 'rjr/dispatcher'
+
+module RJR
+
+# Mixin providing utility methods to define rjr methods and messages
+module Definitions
+  # Define one or more rjr methods, parameters should be in the form
+  #   :id => Callable
+  #
+  # id may be a single id or an array of them
+  def rjr_method(args = {})
+    args.each { |k, v|
+      RJR::Dispatcher.add_handler(k.to_s, &v)
+    }
+    nil
+  end
+
+  # Define/retrieve rjr messages. When defining pass a hash
+  # of mesasge ids to options to use in the defintions, eg
+  #   :id  => { :foo => :bar }
+  #
+  # When retrieving simply specify the id
+  def rjr_message(args={})
+    if args.is_a?(Hash)
+      args.each { |k,v|
+        RJR::Definitions.message(k.to_s, v)
+      }
+      nil
+    else
+      RJR::Definitions.message(args)
+    end
+  end
+
+  # Helper providing access to messages
+  def self.message(k, v=nil)
+    @rjr_messages ||= {}
+    @rjr_messages[k] = v unless v.nil?
+    @rjr_messages[k]
+  end
+
+  # Reset message registry
+  def self.reset
+    # TODO also invoke 'Dispatcher.init_handlers' ?
+    @rjr_messages = {}
+  end
+
+  # Generate / return random message. Optionally specify the transport which
+  # the message must accept
+  def self.rand_msg(transport = nil)
+    @rjr_messages ||= {}
+    messages = @rjr_messages.select { |mid,m| m[:transports].nil? || transport.nil? ||
+                                              m[:transports].include?(transport)    }
+    messages[messages.keys[rand(messages.keys.size)]]
+  end
+end
+
+# Class to encapsulate any number of rjr nodes
+class EasyNode
+  def initialize(node_args = {})
+    nodes = node_args.keys.collect { |n|
+              case n
+              when :amqp then
+                RJR::AMQPNode.new  node_args[:amqp]
+              when :ws then
+                RJR::WSNode.new    node_args[:ws]
+              when :tcp then
+                RJR::TCPNode.new   node_args[:tcp]
+              when :www then
+                RJR::WebNode.new   node_args[:www]
+              end
+            }
+    @multi_node = RJR::MultiNode.new :nodes => nodes
+  end
+
+  def invoke_request(dst, method, *params)
+    # TODO allow selection of node, eg automatically deduce which node type to use from 'dst'
+    @multi_node.nodes.first.invoke_request(dst, method, *params)
+  end
+
+  # Stop node on the specified signal
+  def stop_on(signal)
+    Signal.trap(signal) {
+      @multi_node.stop
+    }
+    self
+  end
+
+  def listen
+    @multi_node.listen
+    self
+  end
+
+  def join
+    @multi_node.join
+    self
+  end
+end
+
+end # module RJR

data/lib/rjr/web_node.rb

@@ -8,16 +8,27 @@
 # Copyright (C) 2012 Mohammed Morsi <mo@morsi.org>
 # Licensed under the Apache License, Version 2.0
 
-# establish client connection w/ specified args and invoke block w/ 
-# newly created client, returning it after block terminates
+skip_module = false
+begin
+require 'evma_httpserver'
+require 'em-http-request'
+# TODO also support fallback clients ? (curb / net/http / etc)
+rescue LoadError
+  skip_module = true
+end
 
-require 'curb'
+if skip_module
+# TODO output: "curb/evma_httpserver gems could not be loaded, skipping web node definition"
+require 'rjr/missing_node'
+RJR::WebNode = RJR::MissingNode
 
-require 'evma_httpserver'
-#require 'em-http-request'
+else
+require 'socket'
 
 require 'rjr/node'
 require 'rjr/message'
+require 'rjr/dispatcher'
+require 'rjr/thread_pool2'
 
 module RJR
 
@@ -28,6 +39,7 @@ class WebNodeCallback
   end
 
   def invoke(callback_method, *data)
+    # TODO throw error?
   end
 end
 
@@ -49,8 +61,7 @@ class WebRequestHandler < EventMachine::Connection
   def process_http_request
     # TODO support http protocols other than POST
     msg = @http_post_content.nil? ? '' : @http_post_content
-    #@thread_pool << ThreadPoolJob.new { handle_request(msg) }
-    handle_request(msg)
+    ThreadPool2Manager << ThreadPool2Job.new(msg) { |m| handle_request(m) }
   end
 
   private
@@ -59,9 +70,12 @@ class WebRequestHandler < EventMachine::Connection
   def handle_request(message)
     msg    = nil
     result = nil
+    notification = NotificationMessage.is_notification_message?(msg)
+
     begin
       client_port, client_ip = Socket.unpack_sockaddr_in(get_peername)
-      msg    = RequestMessage.new(:message => message, :headers => @web_node.message_headers)
+      msg    = notification ? NotificationMessage.new(:message => message, :headers => @web_node.message_headers) :
+                              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,
@@ -79,12 +93,14 @@ class WebRequestHandler < EventMachine::Connection
     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
+    unless notification
+      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
   end
 end
 
@@ -117,13 +133,48 @@ end
 #
 class WebNode < RJR::Node
   private
-  # Initialize the web subsystem
-  def init_node
+
+  # Internal helper, handle response message received
+  def handle_response(http)
+    msg    = ResponseMessage.new(:message => http.response, :headers => @message_headers)
+    res = err = nil
+    begin
+      res = Dispatcher.handle_response(msg.result)
+    rescue Exception => e
+      err = e
+    end
+
+    @response_lock.synchronize {
+      result = [msg.msg_id, res]
+      result << err if !err.nil?
+      @responses << result
+      @response_cv.signal
+    }
+  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
+  # WebNode 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
@@ -131,6 +182,10 @@ class WebNode < RJR::Node
      super(args)
      @host      = args[:host]
      @port      = args[:port]
+
+     @response_lock = Mutex.new
+     @response_cv   = ConditionVariable.new
+     @responses     = []
   end
 
   # Register connection event handler,
@@ -148,7 +203,6 @@ class WebNode < RJR::Node
   # Implementation of {RJR::Node#listen}
   def listen
     em_run do
-      init_node
       EventMachine::start_server(@host, @port, WebRequestHandler, self)
     end
   end
@@ -159,15 +213,53 @@ class WebNode < 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_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)
+    cb = lambda { |http|
+      # TODO handle errors
+      handle_response(http)
+    }
+
+    em_run do
+      http = EventMachine::HttpRequest.new(uri).post :body => message.to_s
+      http.errback  &cb
+      http.callback &cb
+    end
+
+    # will block until response message is received
+    # 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 request to, should be
+  #   in format of http://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
+
+    message = NotificationMessage.new :method => rpc_method,
+                                      :args   => args,
+                                      :headers => @message_headers
+    cb = lambda { |arg| published_l.synchronize { published_c.signal }}
+    em_run do
+      http = EventMachine::HttpRequest.new(uri).post :body => message.to_s
+      http.errback  &cb
+      http.callback &cb
+    end
+    published_l.synchronize { published_c.wait published_l }
+    nil
   end
 end
 
 end # module RJR
+end