rjr 0.12.2 → 0.15.1

data/lib/rjr/thread_pool.rb

@@ -1,184 +1,239 @@
-# Thread Pool
+# Thread Pool (second implementation)
 #
-# Copyright (C) 2010-2012 Mohammed Morsi <mo@morsi.org>
+# Copyright (C) 2010-2013 Mohammed Morsi <mo@morsi.org>
 # Licensed under the Apache License, Version 2.0
 
-# Work item to be executed in a thread launched by pool
+require 'singleton'
+
+module RJR
+
+# Work item to be executed in a thread launched by {ThreadPool}.
+#
+# The end user should initialize this class with a handle
+# to the job to be executed and the params to pass to it, then
+# hand the instance off to the thread pool to take care of the rest.
 class ThreadPoolJob
+  # Proc to be invoked to perform work
   attr_accessor :handler
+
+  # Parameters to pass to handler proc
   attr_accessor :params
 
+  # Time job started, if nil job hasn't started yet
+  attr_accessor :time_started
+
+  # Time job completed, if nil job hasn't completed yet
+  attr_accessor :time_completed
+
+  # Thread running the job
+  attr_accessor :thread
+
   # 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 bool indicating if job has started
+  def started?
+    !@time_started.nil?
+  end
+
+  # Return bool indicating if job has completed
+  def completed?
+    !@time_started.nil? && !@time_completed.nil?
+  end
+
+  # Return bool indicating if the job has started but not completed
+  # and the specified timeout has expired
+  def expired?(timeout)
+    !@time_started.nil? && @time_completed.nil? && ((Time.now - @time_started) > timeout)
   end
-end
 
+  # Set job metadata and execute job with specified params.
+  #
+  # Used internally by thread pool
+  def exec(lock)
+    lock.synchronize {
+      @thread = Thread.current
+      @time_started = Time.now
+    }
+
+    @handler.call *@params
+
+    # ensure we do not switch to another job
+    # before atomic check expiration / terminate
+    # expired threads happens below
+    lock.synchronize {
+      @time_completed = Time.now
+      @thread = nil
+    }
+  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
+# Supports optional timeout which allows the user to kill and restart
 # threads if a job is taking too long to run.
 class ThreadPool
+  include Singleton
 
-  # @private
-  # Helper class to encapsulate each thread pool thread
-  class ThreadPoolJobRunner
-    attr_accessor :time_started
+  class << self
+    # @!group Config options (must be set before first node is instantiated)
 
-    def initialize(thread_pool)
-      @thread_pool = thread_pool
-      @timeout_lock = Mutex.new
-      @thread_lock  = Mutex.new
-    end
+    # Number of threads to instantiate in local worker pool
+    attr_accessor :num_threads
 
-    # Start thread and pull a work items off the thread pool work queue and execute them.
-    #
-    # This method will return immediately after the worker thread is started but the
-    # thread launched will persist until {#stop} is invoked
-    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
+    # Timeout after which worker threads are killed
+    attr_accessor :timeout
 
-    # Return boolean indicating if worker thread is running or not
-    def running?
-      res = nil
-      @thread_lock.synchronize{
-        res = (!@thread.nil? && (@thread.status != false))
-      }
-      res
-    end
+    # @!endgroup
+  end
 
-    # Return boolean indicating if worker thread run time has exceeded timeout
-    # 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
+  private
+
+  # Internal helper, launch worker thread
+  def launch_worker
+    @worker_threads << Thread.new {
+      while work = @work_queue.pop
+        begin
+          #RJR::Logger.debug "launch thread pool job #{work}"
+          @running_queue << work
+          work.exec(@thread_lock)
+          # 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
+    }
+  end
+
+  # Internal helper, performs checks on workers
+  def check_workers
+    if @terminate
+      @worker_threads.each { |t| 
+        t.kill
       }
+      @worker_threads = []
+
+    elsif @timeout
+      readd = []
+      while @running_queue.size > 0 && work = @running_queue.pop
+        # check expiration / killing expired threads must be atomic
+        # and mutually exclusive with the process of marking a job completed above
+        @thread_lock.synchronize{
+          if work.expired?(@timeout)
+            work.thread.kill
+            @worker_threads.delete(work.thread)
+            launch_worker
+
+          elsif !work.completed?
+            readd << work
+          end
+        }
+      end
+      readd.each { |work| @running_queue << work }
     end
+  end
 
-    # Stop the worker thread being executed
-    def stop
-      @thread_lock.synchronize {
-        if @thread.alive?
-          @thread.kill
-          @thread.join
+  # Internal helper, launch management thread
+  def launch_manager
+    @manager_thread = Thread.new {
+      until @terminate
+        if @timeout
+          sleep @timeout
+          check_workers
+        else
+          Thread.yield
         end
-        @thread = nil
-      }
-    end
+      end
 
-    # Block until the worker thread is finished
-    def join
-      @thread_lock.synchronize {
-        @thread.join unless @thread.nil?
-      }
-    end
+      check_workers
+    }
   end
 
-  # 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 = {})
-    @num_threads = num_threads
-    @timeout     = args[:timeout]
-    @job_runners = []
-    @job_runners_lock = Mutex.new
-    @terminate = false
-    @terminate_lock = Mutex.new
+  # Create a new thread pool
+  def initialize
+    RJR::ThreadPool.num_threads ||=  20
+    RJR::ThreadPool.timeout     ||=  10
+    @num_threads    = RJR::ThreadPool.num_threads
+    @timeout        = RJR::ThreadPool.timeout
+    @worker_threads = []
 
-    @work_queue  = Queue.new
+    @work_queue     = Queue.new
+    @running_queue  = Queue.new
 
-    0.upto(@num_threads) { |i| 
-      runner = ThreadPoolJobRunner.new(self)
-      @job_runners << runner
-      runner.run
-    }
+    @thread_lock = Mutex.new
+    @terminate = true
 
-    # 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
+    ObjectSpace.define_finalizer(self, self.class.finalize(self))
   end
 
-  # Return boolean indicated if thread pool is running.
-  #
-  # If at least one worker thread isn't terminated, the pool is still considered running
-  def running?
-    !terminate && (@timeout.nil? || (!@timeout_thread.nil? && @timeout_thread.status)) &&
-    @job_runners.all? { |r| r.running? }
+  # Ruby ObjectSpace finalizer to ensure that thread pool terminates all
+  # threads when object is destroyed.
+  def self.finalize(thread_pool)
+    # TODO this isn't doing much as by the time this is invoked threads will
+    # already be shutdown
+    proc { thread_pool.stop ; thread_pool.join }
   end
 
-  # Return boolean indicating if the thread pool should be terminated
-  def terminate
-    @terminate_lock.synchronize { @terminate }
+  public
+
+  # Start the thread pool
+  def start
+    return self unless @terminate
+    @terminate = false
+    0.upto(@num_threads-1) { |i| launch_worker }
+    launch_manager
+    self
   end
 
-  # Instruct thread pool to terminate
-  # @param [Boolean] val true/false indicating if thread pool should terminate
-  def terminate=(val)
-    @terminate_lock.synchronize { @terminate = val }
+  # Return boolean indicating if thread pool is running
+  def running?
+    !@manager_thread.nil? &&
+    ['sleep', 'run'].include?(@manager_thread.status)
   end
 
   # Add work to the pool
   # @param [ThreadPoolJob] work job to execute in first available thread
+  # @return self
   def <<(work)
+    # TODO option to increase worker threads if work queue gets saturated
     @work_queue.push work
-  end
-
-  # Return the next job queued up and remove it from the queue
-  def next_job
-    @work_queue.pop
+    self
   end
 
   # Terminate the thread pool, stopping all worker threads
+  #
+  # @return self
   def stop
-    terminate = true
-    unless @timout_thread.nil?
-      @timeout_thread.join
-      @timeout_thread.terminate
+    @terminate = true
+
+    # this will wake up on it's own, but we can
+    # speed things up if we manually wake it up,
+    # surround w/ block incase thread cleans up on its own
+    begin
+      @manager_thread.wakeup if @manager_thread
+    rescue
     end
-    @timeout_thread = nil
-    @work_queue.clear
-    @job_runners_lock.synchronize { @job_runners.each { |jr| jr.stop } }
+    self
   end
 
   # Block until all worker threads have finished executing
+  #
+  # @return self
   def join
-    @job_runners_lock.synchronize { @job_runners.each { |jr| jr.join } }
+    @manager_thread.join if @manager_thread
+    self
   end
 end
 
+end # module RJR

data/site/index.html

@@ -0,0 +1,45 @@
+<!-- An example rjr js client.
+     To run:
+       - start bin/rjr-server
+       - setup a frontend webserver,
+         for example, add the following apache conf:
+           Alias /rjr-test /path/to/rjr/site
+           ProxyPass /rjr http://localhost:8888
+           ProxyPassReverse /rjr http://localhost:8888
+       - startup your webserver:
+           sudo service httpd start
+           (make sure to configure selinux / resolve permissions / etc)
+       - navigate to http://localhost/rjr-test
+
+  Copyright (C) 2013 Mohammed Morsi <mo@morsi.org>
+  Licensed under the Apache License, Version 2.0
+-->
+<html>
+  <head>
+    <script type="text/javascript" src="http://ajax.googleapis.com/ajax/libs/jquery/1.7.1/jquery.min.js"></script>
+    <script type="text/javascript" src="json.js"></script>
+    <script type="text/javascript" src="jrw.js"></script>
+    <script type="text/javascript">
+      var ws_node = new WSNode('127.0.0.1', '8080');
+      ws_node.onopen = function(){
+        ws_node.invoke('stress', 'ws1', function(res){
+          alert(res.result);
+        });
+
+        ws_node.invoke('failed', 'ws2', function(res){
+          alert(res.error.message);
+        });
+        ws_node.invoke('stress_callback', 3);
+      };
+      ws_node.open();
+
+      var www_node = new WebNode('http://localhost/rjr');
+      www_node.invoke('stress', 'http1', function(res){
+         alert(res.result);
+      })
+      www_node.invoke('failed', 'http2', function(res){
+         alert(res.error.message);
+      })
+    </script>
+  </head>
+</html>