actionpool 0.2.2 → 0.2.3

data/CHANGELOG

@@ -1,3 +1,9 @@
+0.2.3
+    - Better thread destroying when removed normally and forcibly
+    - Flushing threads to ensure proper joining
+    - Fixed splatting for ruby < 1.9
+    - Removed the useless logger wrapper
+    - Use a simple monitor
 0.2.2
     - Better thread management within the pool
     - Restart thread timeouts when modified

data/README.rdoc

@@ -4,7 +4,7 @@ ActionPool is just a simple thread pool. It allows for various constraints and r
 
 === install (easy):
 
-    gem install ActionPool
+    gem install actionpool
 
 === install (less easy):
 
@@ -17,6 +17,15 @@ ActionPool is just a simple thread pool. It allows for various constraints and r
 
 {rip}[http://hellorip.com/about.html] makes it easy to install directly from a github repository.
 
+=== Testing
+
+ActionPool is currently tested on:
+
+* Ruby 1.8.6-p383
+* Ruby 1.8.7-p248
+* Ruby 1.9.1-p376
+* JRuby 1.4.0
+
 == Documentation
 
 {rdocs}[http://allgems.ruby-forum.com/gems/ActionPool/]

data/actionpool.gemspec

@@ -2,7 +2,7 @@ spec = Gem::Specification.new do |s|
     s.name              = 'actionpool'
     s.author            = %q(spox)
     s.email             = %q(spox@modspox.com)
-    s.version           = '0.2.2'
+    s.version           = '0.2.3'
     s.summary           = %q(Thread Pool)
     s.platform          = Gem::Platform::RUBY
     s.files             = Dir['**/*']
@@ -10,6 +10,7 @@ spec = Gem::Specification.new do |s|
     s.extra_rdoc_files  = %w(README.rdoc CHANGELOG)
     s.require_paths     = %w(lib)
     s.required_ruby_version = '>= 1.8.6'
+    s.add_dependency    'splib', '~> 1.4'
     s.homepage          = %q(http://github.com/spox/actionpool)
     s.description         = "The ActionPool is an easy to use thread pool for ruby."
 end

data/lib/actionpool.rb

@@ -1,7 +1,10 @@
+require 'rubygems'
 begin
     require 'fastthread'
 rescue LoadError
     # we don't care if it's available
     # just load it if it's around
 end
+require 'splib'
+Splib.load :Array, :Monitor
 require 'actionpool/Pool'

data/lib/actionpool/Pool.rb

@@ -1,6 +1,6 @@
 require 'actionpool/Thread'
 require 'actionpool/Queue'
-require 'actionpool/LogHelper'
+require 'logger'
 require 'thread'
 
 module ActionPool
@@ -17,10 +17,10 @@ module ActionPool
         # Creates a new pool
         def initialize(args={})
             raise ArgumentError.new('Hash required for initialization') unless args.is_a?(Hash)
-            @logger = LogHelper.new(args[:logger])
+            @logger = args[:logger] && args[:logger].is_a?(Logger) ? args[:logger] : Logger.new(nil)
             @queue = ActionPool::Queue.new
             @threads = []
-            @lock = Mutex.new
+            @lock = Splib::Monitor.new
             @thread_timeout = args[:t_to] ? args[:t_to] : 0
             @action_timeout = args[:a_to] ? args[:a_to] : 0
             @max_threads = args[:max_threads] ? args[:max_threads] : 100
@@ -48,36 +48,44 @@ module ActionPool
             fill_pool if @open
         end
 
-        # args:: :force forces a new thread. :nowait will create a thread if threads are waiting
+        # args::    :force forces a new thread. 
+        #           :nowait will create a thread if threads are waiting
         # Create a new thread for pool.
-        # Returns newly created thread of nil if pool is at maximum size
+        # Returns newly created thread or nil if pool is at maximum size
         def create_thread(*args)
             return if pool_closed?
             thread = nil
             @lock.synchronize do
                 if(((size == working || args.include?(:nowait)) && @threads.size < @max_threads) || args.include?(:force))
-                    thread = ActionPool::Thread.new(:pool => self, :respond_thread => @respond_to, :a_timeout => @action_timeout, :t_timeout => @thread_timeout, :logger => @logger)
+                    thread = ActionPool::Thread.new(:pool => self, :respond_thread => @respond_to, :a_timeout => @action_timeout,
+                        :t_timeout => @thread_timeout, :logger => @logger, :autostart => false)
                     @threads << thread
                 end
             end
-            return thread
+            thread.start if thread
+            thread
         end
 
         # Fills the pool with the minimum number of threads
         # Returns array of created threads
         def fill_pool
             threads = []
-            @lock.synchronize do
-                required = min - size
-                if(required > 0)
-                    required.times do
-                        thread = ActionPool::Thread.new(:pool => self, :respond_thread => @respond_to, :a_timeout => @action_timeout, :t_timeout => @thread_timeout, :logger => @logger)
-                        @threads << thread
-                        threads << thread
+            if(@open)
+                @lock.synchronize do
+                    required = min - size
+                    if(required > 0)
+                        required.times do
+                            thread = ActionPool::Thread.new(:pool => self, :respond_thread => @respond_to,
+                                :a_timeout => @action_timeout, :t_timeout => @thread_timeout, :logger => @logger,
+                                :autostart => false)
+                            @threads << thread
+                            threads << thread
+                        end
                     end
                 end
             end
-            return threads
+            threads.each{|t|t.start}
+            threads
         end
 
         # force:: force immediate stop
@@ -92,6 +100,10 @@ module ActionPool
             while(t = @threads.pop) do
                 t.stop(*args)
             end
+            unless(force)
+                flush
+                @threads.each{|t|t.join}
+            end
             nil
         end
 
@@ -193,12 +205,10 @@ module ActionPool
         def remove(t)
             raise ArgumentError.new('Expecting an ActionPool::Thread object') unless t.is_a?(ActionPool::Thread)
             t.stop
-            if(@threads.include?(t))
-                @threads.delete(t)
-                return true
-            else
-                return false
-            end
+            del = @threads.include?(t)
+            @threads.delete(t) if del
+            fill_pool
+            del
         end
 
         # Maximum number of seconds a thread
@@ -251,17 +261,20 @@ module ActionPool
         # the pool if existing threads have a long thread life waiting
         # for input.
         def flush
-            lock = Mutex.new
-            guard = ConditionVariable.new
-            @threads.size.times{ queue{ lock.synchronize{ guard.wait(lock) } } }
-            Thread.pass
+            mon = Splib::Monitor.new
+            @threads.size.times{ queue{ mon.wait } }
+            @queue.wait_empty
             sleep(0.01)
-            lock.synchronize{ guard.broadcast }
+            mon.broadcast
         end
 
         # Returns current number of threads in the pool working
         def working
-            @threads.find_all{|t|!t.waiting?}.size
+            @threads.select{|t|t.running?}.size
+        end
+
+        def thread_stats
+            @threads.map{|t|[t.object_id,t.status]}
         end
 
         private

data/lib/actionpool/Queue.rb

@@ -7,47 +7,35 @@ module ActionPool
         def initialize
             super
             @wait = false
-            @pause_lock = Mutex.new
-            @empty_lock = Mutex.new
-            @pause_guard = ConditionVariable.new
-            @empty_guard = ConditionVariable.new
+            @pause_guard = Splib::Monitor.new
+            @empty_guard = Splib::Monitor.new
         end
         # Stop the queue from returning results to requesting
         # threads. Threads will wait for results until signalled
         def pause
-            @pause_lock.synchronize{@wait = true}
+            @wait = true
         end
         # Allow the queue to return results. Any threads waiting
         # will have results given to them.
         def unpause
-            @pause_lock.synchronize do
-                @wait = false
-                @pause_guard.broadcast
-            end
+            @wait = false
+            @pause_guard.broadcast
         end
         # Check if queue needs to wait before returning
         def pop
-            @pause_lock.synchronize do
-                @pause_guard.wait(@pause_lock) if @wait
-            end
+            @pause_guard.wait_while{ @wait }
             o = super
-            @empty_lock.synchronize do
-                @empty_guard.broadcast if empty?
-            end
+            @empty_guard.broadcast if empty?
             return o
         end
         # Clear queue
         def clear
             super
-            @empty_lock.synchronize do
-                @empty_guard.broadcast
-            end
+            @empty_guard.broadcast
         end
         # Park a thread here until queue is empty
         def wait_empty
-            @empty_lock.synchronize do
-                @empty_guard.wait(@empty_lock) if size > 0
-            end
+            @empty_guard.wait_while{ size > 0 }
         end
     end
 end

data/lib/actionpool/Thread.rb

@@ -13,6 +13,7 @@ module ActionPool
         # :a_timeout:: max time thread is allowed to work
         # :respond_thread:: thread to send execptions to
         # :logger:: LogHelper for logging messages
+        # :autostart:: Automatically start the thread
         # Create a new thread
         def initialize(args)
             raise ArgumentError.new('Hash required for initialization') unless args.is_a?(Hash)
@@ -22,24 +23,45 @@ module ActionPool
             @respond_to = args[:respond_thread]
             @thread_timeout = args[:t_timeout] ? args[:t_timeout].to_f : 0
             @action_timeout = args[:a_timeout] ? args[:a_timeout].to_f : 0
+            args[:autostart] = true unless args.has_key?(:autostart)
             @kill = false
-            @logger = args[:logger].is_a?(LogHelper) ? args[:logger] : LogHelper.new(args[:logger])
-            @lock = Mutex.new
-            @thread = ::Thread.new{ start_thread }
+            @logger = args[:logger].is_a?(Logger) ? args[:logger] : Logger.new(nil)
+            @lock = Splib::Monitor.new
+            @action = nil
+            @thread = args[:autostart] ? ::Thread.new{ start_thread } : nil
         end
 
+        def start
+            @thread = ::Thread.new{ start_thread } if @thread.nil?
+        end
+        
         # :force:: force the thread to stop
         # :wait:: wait for the thread to stop
         # Stop the thread
         def stop(*args)
             @kill = true
-            @thread.raise Wakeup.new if args.include?(:force) || waiting?
+            if(args.include?(:force) || waiting?)
+                begin
+                    @thread.raise Wakeup.new
+                rescue Wakeup
+                    #ignore since we are the caller
+                end
+                sleep(0.01)
+                @thread.kill if @thread.alive?
+            end
             nil
         end
 
         # Currently waiting
         def waiting?
-            @lock.synchronize{@status} == :wait
+            @action.nil?
+#             @status == :wait
+        end
+
+        # Currently running
+        def running?
+            !@action.nil?
+#             @status == :run
         end
 
         # Is the thread still alive
@@ -49,14 +71,21 @@ module ActionPool
 
         # Current thread status
         def status
-            @lock.synchronize{ return @status }
+            @action
         end
-        
-        # arg:: :wait or :run
-        # Set current status
-        def status(arg)
-            raise InvalidType.new('Status can only be set to :wait or :run') unless arg == :wait || arg == :run
-            @lock.synchronize{ @status = arg }
+
+        # Join internal thread
+        def join
+            @thread.join(@action_timeout)
+            if(@thread.alive?)
+                @thread.kill
+                @thread.join
+            end
+        end
+
+        # Kill internal thread
+        def kill
+            @thread.kill
         end
 
         # Seconds thread will wait for input
@@ -96,20 +125,17 @@ module ActionPool
             begin
                 @logger.info("New pool thread is starting (#{self})")
                 until(@kill) do
-                    status(:wait)
                     begin
-                        action = nil
+                        @action = nil
                         if(@pool.size > @pool.min && !@thread_timeout.zero?)
                             Timeout::timeout(@thread_timeout) do
-                                action = @pool.action
+                                @action = @pool.action
                             end
                         else
-                            action = @pool.action
+                            @action = @pool.action
                         end
-                        status(:run)
-                        run(action[0], action[1]) unless action.nil?
-                        status(:wait)
-                    rescue Timeout::Error => boom
+                        run(@action[0], @action[1]) unless @action.nil?
+                    rescue Timeout::Error
                         @kill = true
                     rescue Wakeup
                         @logger.info("Thread #{::Thread.current} was woken up.")
@@ -131,7 +157,6 @@ module ActionPool
             ensure
                 @logger.info("Pool thread is shutting down (#{self})")
                 @pool.remove(self)
-                @pool.create_thread
             end
         end
 
@@ -139,13 +164,14 @@ module ActionPool
         # args:: arguments to be passed to task
         # Run the task
         def run(action, args)
+            args = args.respond_to?(:fixed_flatten) ? args.fixed_flatten(1) : args.flatten(1)
             begin
                 unless(@action_timeout.zero?)
                     Timeout::timeout(@action_timeout) do
-                        action.call(*args[0])
+                        action.call(*args)
                     end
                 else
-                    action.call(*args[0])
+                    action.call(*args)
                 end
             rescue Timeout::Error => boom
                 @logger.warn("Pool thread reached max execution time for action: #{boom}")

data/tests/cases/general.rb

@@ -28,6 +28,7 @@ class GeneralPoolTest < Test::Unit::TestCase
         jobs = [].fill(run,0,100)
         @pool.add_jobs(jobs)
         @pool.shutdown
+        sleep(0.01)
         assert_equal(100, a)
         @pool.shutdown(true)
     end
@@ -36,17 +37,24 @@ class GeneralPoolTest < Test::Unit::TestCase
         output = nil
         @pool << [lambda{|x| output = x}, [2]]
         assert(2, output)
+        output = nil
         @pool.add_jobs([[lambda{|x| output = x}, [3]]])
         assert(3, output)
+        output = nil
         @pool << [lambda{|x,y| output = x+y}, [1,2]]
         assert(3, output)
-        output = []
-        @pool.add_jobs([[lambda{|x,y| output << x + y}, [1,1]], [lambda{|x| output << x}, [3]]])
-        assert(output.include?(2))
-        assert(output.include?(3))
-        @pool << [lambda{|x,y| output = [x,y]}, ['test', [1,2]]]
-        assert_equal(output[0], 'test')
-        assert(output[1].is_a?(Array))
+        output = nil
+        arr = []
+        @pool.add_jobs([[lambda{|x,y| arr << x + y}, [1,1]], [lambda{|x| arr << x}, [3]]])
+        ::Thread.pass
+        sleep(0.01)
+        assert(arr.include?(2))
+        assert(arr.include?(3))
+        arr.clear
+        @pool << [lambda{|x,y| arr = [x,y]}, ['test', [1,2]]]
+        sleep(0.01)
+        assert_equal('test', arr[0])
+        assert(arr[1].is_a?(Array))
         @pool.shutdown(true)
     end
 end

data/tests/cases/timeouts.rb

@@ -9,26 +9,39 @@ class TimeoutPoolTest < Test::Unit::TestCase
         @pool.shutdown(true)
     end
     def test_actiontimeout
-        @pool.action_timeout = 0.01
+        @pool.action_timeout = 0.25
         assert_equal(10, @pool.size)
         stop = false
-        @pool.add_jobs [].fill(lambda{loop{ 1+1 }}, 0, 20)
-        ::Thread.pass
-        assert(@pool.working > 10)
+        output = []
+        20.times do
+            @pool.process do
+                until(stop) do
+                    output << 1
+                    sleep(0.1)
+                end
+            end
+        end
+        assert(@pool.working >= 10)
+        assert_equal(20, output.size)
+        sleep(0.11)
         stop = true
-        sleep(0.5)
-        assert(@pool.working == 0)
+        sleep(0.1)
+        assert_equal(0, @pool.working)
+        assert_equal(40, output.size)
         @pool.shutdown(true)
     end
     def test_threadtimeout
-        @pool.thread_timeout = 0.01
+        @pool.thread_timeout = 0.05
         assert_equal(10, @pool.size)
-        lock = Mutex.new
-        guard = ConditionVariable.new
-        @pool.add_jobs [].fill(lambda{ lock.synchronize{ guard.wait(lock) } }, 0, 20)
+        t = [].fill(lambda{
+                        begin
+                            sleep(0.1)
+                        rescue
+                        end }, 0, 20)
+        @pool.add_jobs(t)
         ::Thread.pass
-        assert_equal(30, @pool.size)
-        lock.synchronize{ guard.broadcast }
+        sleep(0.01)
+        assert(@pool.size >= 20)
         ::Thread.pass
         sleep(0.1)
         assert(10, @pool.size)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: actionpool
 version: !ruby/object:Gem::Version 
-  version: 0.2.2
+  version: 0.2.3
 platform: ruby
 authors: 
 - spox
@@ -9,10 +9,19 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-01-05 00:00:00 -08:00
+date: 2010-01-13 00:00:00 -08:00
 default_executable: 
-dependencies: []
-
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: splib
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        version: "1.4"
+    version: 
 description: The ActionPool is an easy to use thread pool for ruby.
 email: spox@modspox.com
 executables: []
@@ -23,30 +32,24 @@ extra_rdoc_files:
 - README.rdoc
 - CHANGELOG
 files: 
-- lib/actionpool/Pool.rb~
-- lib/actionpool/LogHelper.rb
-- lib/actionpool/Pool.rb
-- lib/actionpool/Thread.rb
-- lib/actionpool/Queue.rb~
-- lib/actionpool/Queue.rb
-- lib/actionpool/Thread.rb~
-- lib/actionpool.rb
-- tests/cases/shutdown.rb
-- tests/cases/nogrow.rb
+- Rakefile
+- actionpool.gemspec
 - tests/cases/general.rb
-- tests/cases/thread.rb
-- tests/cases/grow.rb
-- tests/cases/general.rb~
-- tests/cases/timeouts.rb
 - tests/cases/resize.rb
+- tests/cases/nogrow.rb
+- tests/cases/timeouts.rb
+- tests/cases/thread.rb
+- tests/cases/shutdown.rb
 - tests/cases/queue.rb
+- tests/cases/grow.rb
 - tests/run_tests.rb
-- Rakefile
+- lib/actionpool/Pool.rb
+- lib/actionpool/Thread.rb
+- lib/actionpool/Queue.rb
+- lib/actionpool.rb
 - CHANGELOG
 - LICENSE
 - README.rdoc
-- actionpool.gemspec
-- test.rb
 has_rdoc: true
 homepage: http://github.com/spox/actionpool
 licenses: []

data/lib/actionpool/LogHelper.rb

@@ -1,25 +0,0 @@
-module ActionPool
-    class LogHelper
-    
-        def initialize(logger=nil)
-            require 'logger'
-            @logger = logger
-        end
-
-        def info(m)
-            @logger.info(m) unless @logger.nil?
-        end
-
-        def warn(m)
-            @logger.warn(m) unless @logger.nil?
-        end
-
-        def fatal(m)
-            @logger.fatal(m) unless @logger.nil?
-        end
-
-        def error(m)
-            @logger.error(m) unless @logger.nil?
-        end
-    end
-end

data/lib/actionpool/Pool.rb~

@@ -1,260 +0,0 @@
-require 'actionpool/Thread'
-require 'actionpool/Queue'
-require 'actionpool/LogHelper'
-require 'thread'
-
-module ActionPool
-    # Raised when pool is closed
-    class PoolClosed < StandardError
-    end
-    class Pool
-
-        # :min_threads:: minimum number of threads in pool
-        # :max_threads:: maximum number of threads in pool
-        # :t_to:: thread timeout waiting for action to process
-        # :a_to:: maximum time action may be worked on before aborting
-        # :logger:: logger to print logging messages to
-        # Creates a new pool
-        def initialize(args={})
-            raise ArgumentError.new('Hash required for initialization') unless args.is_a?(Hash)
-            @logger = LogHelper.new(args[:logger])
-            @queue = ActionPool::Queue.new
-            @threads = []
-            @lock = Mutex.new
-            @thread_timeout = args[:t_to] ? args[:t_to] : 0
-            @action_timeout = args[:a_to] ? args[:a_to] : 0
-            @max_threads = args[:max_threads] ? args[:max_threads] : 100
-            @min_threads = args[:min_threads] ? args[:min_threads] : 10
-            @min_threads = @max_threads if @max_threads < @min_threads
-            @respond_to = args[:respond_thread] || ::Thread.current
-            @open = true
-            create_thread
-        end
-
-        # Pool is closed
-        def pool_closed?
-            !@open
-        end
-
-        # Pool is open
-        def pool_open?
-            @open
-        end
-
-        # arg:: :open or :closed
-        # Set pool status
-        def status(arg)
-            @open = arg == :open
-        end
-
-        # force:: force creation of a new thread
-        # Create a new thread for pool. Returns newly created ActionPool::Thread or
-        # nil if pool has reached maximum threads
-        def create_thread(force=false)
-            return if pool_closed?
-            pt = nil
-            @lock.synchronize do
-                if(@threads.size < @max_threads || force)
-                    @logger.info('Pool is creating a new thread')
-                    (min - size > 0 ? min - size : 1).times do |i|
-                        pt = ActionPool::Thread.new(:pool => self, :respond_thread => @respond_to, :a_timeout => @action_timeout, :t_timeout => @thread_timeout, :logger => @logger)
-                        @threads << pt
-                    end
-                else
-                    @logger.info('Pool is at maximum size. Not creating new thread')
-                end
-            end
-            return pt
-        end
-
-        # force:: force immediate stop
-        # Stop the pool
-        def shutdown(force=false)
-            args = [:wait]
-            args += [:force] if force
-            @logger.info("Pool is now shutting down #{force ? 'using force' : ''}")
-            @queue.wait_empty
-            while(t = @threads.pop) do
-                t.stop(*args)
-            end
-            nil
-        end
-
-        # action:: proc to be executed or array of [proc, [*args]]
-        # Add a new proc/lambda to be executed (alias for queue)
-        def <<(action)
-            raise PoolClosed.new("Pool #{self} is currently closed") if pool_closed?
-            case action
-                when Proc
-                    queue(action)
-                when Array
-                    raise ArgumentError.new('Actions to be processed by the pool must be a proc/lambda or [proc/lambda, [*args]]') unless action.size == 2 and action[0].is_a?(Proc) and action[1].is_a?(Array)
-                    queue(action[0], action[1])
-                else
-                    raise ArgumentError.new('Actions to be processed by the pool must be a proc/lambda or [proc/lambda, [*args]]')
-            end
-            nil
-        end
-
-        # action:: proc to be executed
-        # Add a new proc/lambda to be executed
-        def queue(action, *args)
-            raise ArgumentError.new('Expecting block') unless action.is_a?(Proc)
-            @queue << [action, args]
-            ::Thread.pass
-            create_thread if @queue.num_waiting < 1 # only start a new thread if we need it
-        end
-
-        # jobs:: Array of proc/lambdas
-        # Will queue a list of jobs into the pool
-        def add_jobs(jobs)
-            raise ArgumentError.new("Expecting an array but received: #{jobs.class}") unless jobs.is_a?(Array)
-            @queue.pause
-            begin
-                jobs.each do |job|
-                    case job
-                    when Proc
-                        @queue << [job, []]
-                    when Array
-                        raise ArgumentError.new('Jobs to be processed by the pool must be a proc/lambda or [proc/lambda, [*args]]') unless job.size == 2 and job[0].is_a?(Proc) and job[1].is_a?(Array)
-                        @queue << [job.unshift, job]
-                    else
-                        raise ArgumentError.new('Jobs to be processed by the pool must be a proc/lambda or [proc/lambda, [*args]]')
-                    end
-                end
-            ensure
-                create_thread
-                @queue.unpause
-            end
-            true
-        end
-
-        # block:: block to process
-        # Adds a block to be processed
-        def process(*args, &block)
-            queue(block, *args)
-            nil
-        end
-
-        # Current size of pool
-        def size
-            @threads.size
-        end
-
-        # Maximum allowed number of threads
-        def max
-            @max_threads
-        end
-
-        # Minimum allowed number of threads
-        def min
-            @min_threads
-        end
-
-        # m:: new max
-        # Set maximum number of threads
-        def max=(m)
-            m = m.to_i
-            raise ArgumentError.new('Maximum value must be greater than 0') unless m > 0
-            @max_threads = m
-            @min_threads = m if m < @min_threads
-            resize if m < size
-            m
-        end
-
-        # m:: new min
-        # Set minimum number of threads
-        def min=(m)
-            m = m.to_i
-            raise ArgumentError.new("Minimum value must be greater than 0 and less than or equal to maximum (#{max})") unless m > 0 && m <= max
-            @min_threads = m
-            m
-        end
-
-        # t:: ActionPool::Thread to remove
-        # Removes a thread from the pool
-        def remove(t)
-            raise ArgumentError.new('Expecting an ActionPool::Thread object') unless t.is_a?(ActionPool::Thread)
-            t.stop
-            if(@threads.include?(t))
-                @threads.delete(t)
-                return true
-            else
-                return false
-            end
-        end
-
-        # Maximum number of seconds a thread
-        # is allowed to idle in the pool. 
-        # (nil means thread life is infinite)
-        def thread_timeout
-            @thread_timeout
-        end
-
-        # Maximum number of seconds a thread
-        # is allowed to work on a given action
-        # (nil means thread is given unlimited
-        # time to work on action)
-        def action_timeout
-            @action_timeout
-        end
-
-        # t:: timeout in seconds (nil for infinite)
-        # Set maximum allowed time thead may idle in pool
-        def thread_timeout=(t)
-            t = t.to_f
-            raise ArgumentError.new('Value must be great than zero or nil') unless t > 0
-            @thread_timeout = t
-            @threads.each{|thread|thread.thread_timeout = t}
-            t
-        end
-
-        # t:: timeout in seconds (nil for infinte)
-        # Set maximum allowed time thread may work
-        # on a given action
-        def action_timeout=(t)
-            t = t.to_f
-            raise ArgumentError.new('Value must be great than zero or nil') unless t > 0
-            @action_timeout = t
-            @threads.each{|thread|thread.action_timeout = t}
-            t
-        end
-
-        # Returns the next action to be processed
-        def action
-            @queue.pop
-        end
-
-        # Number of actions in the queue
-        def action_size
-            @queue.size
-        end
-
-        # Flush the thread pool. Mainly used for forcibly resizing
-        # the pool if existing threads have a long thread life waiting
-        # for input.
-        def flush
-            lock = Mutex.new
-            guard = ConditionVariable.new
-            @threads.size.times{ queue{ lock.synchronize{ guard.wait(lock) } } }
-            Thread.pass
-            sleep(0.01)
-            lock.synchronize{ guard.broadcast }
-        end
-
-        private
-
-        # Resize the pool
-        def resize
-            @logger.info("Pool is being resized to stated maximum: #{max}")
-            until(size <= max) do
-                t = nil
-                t = @threads.find{|t|t.waiting?}
-                t = @threads.shift unless t
-                t.stop
-            end
-            flush
-            nil
-        end
-    end
-end

data/lib/actionpool/Queue.rb~

@@ -1,46 +0,0 @@
-require 'thread'
-
-module ActionPool
-    # Adds a little bit extra functionality to the Queue class
-    class Queue < ::Queue
-        # Create a new Queue for the ActionPool::Pool
-        def initialize
-            super
-            @wait = false
-            @pause_lock = Mutex.new
-            @emtpy_lock = Mutex.new
-            @pause_guard = ConditionVariable.new
-            @empty_guard = ConditionVariable.new
-        end
-        # Stop the queue from returning results to requesting
-        # threads. Threads will wait for results until signalled
-        def pause
-            @pause_lock.synchronize{@wait = true}
-        end
-        # Allow the queue to return results. Any threads waiting
-        # will have results given to them.
-        def unpause
-            @pause_lock.synchronize do
-                @wait = false
-                @pause_guard.broadcast
-            end
-        end
-        # Check if queue needs to wait before returning
-        def pop
-            @pause_lock.synchronize do
-                @pause_guard.wait(@pause_lock) if @wait
-            end
-            o = super
-            @empty_lock.synchronize do
-                @empty_guard.broadcast if empty?
-            end
-            return o
-        end
-        # Park a thread here until queue is empty
-        def wait_empty
-            @empty_lock.synchronize do
-                @empty_guard.wait(@empty_lock) if size > 0
-            end
-        end
-    end
-end

data/lib/actionpool/Thread.rb~

@@ -1,146 +0,0 @@
-require 'timeout'
-
-module ActionPool
-    # Exception class used for waking up a thread
-    class Wakeup < StandardError
-    end
-
-    class Thread
-        # :pool:: pool thread is associated with
-        # :t_timeout:: max time a thread is allowed to wait for action
-        # :a_timeout:: max time thread is allowed to work
-        # :respond_thread:: thread to send execptions to
-        # :logger:: LogHelper for logging messages
-        # Create a new thread
-        def initialize(args)
-            raise ArgumentError.new('Hash required for initialization') unless args.is_a?(Hash)
-            raise ArgumentError.new('ActionPool::Thread requires a pool') unless args[:pool]
-            raise ArgumentError.new('ActionPool::Thread requries thread to respond') unless args[:respond_thread]
-            @pool = args[:pool]
-            @respond_to = args[:respond_thread]
-            @thread_timeout = args[:t_timeout] ? args[:t_timeout].to_f : 0
-            @action_timeout = args[:a_timeout] ? args[:a_timeout].to_f : 0
-            @kill = false
-            @logger = args[:logger].is_a?(LogHelper) ? args[:logger] : LogHelper.new(args[:logger])
-            @lock = Mutex.new
-            @thread = ::Thread.new{ start_thread }
-        end
-
-        # :force:: force the thread to stop
-        # :wait:: wait for the thread to stop
-        # Stop the thread
-        def stop(*args)
-            @kill = true
-            @thread.raise Wakeup.new if args.include?(:force) || waiting?
-            nil
-        end
-
-        # Currently waiting
-        def waiting?
-            @status == :wait
-        end
-
-        # Is the thread still alive
-        def alive?
-            @thread.alive?
-        end
-
-        # Current thread status
-        def status
-            @lock.synchronize{ return @status }
-        end
-        
-        # arg:: :wait or :run
-        # Set current status
-        def status(arg)
-            raise InvalidType.new('Status can only be set to :wait or :run') unless arg == :wait || arg == :run
-            @lock.synchronize{ @status = arg }
-        end
-
-        # Seconds thread will wait for input
-        def thread_timeout
-            @thread_timeout
-        end
-
-        # Seconds thread will spend working on a given task
-        def action_timeout
-            @action_timeout
-        end
-
-        # t:: seconds to wait for input (floats allow for values 0 < t < 1)
-        # Set the maximum amount of time to wait for a task
-        def thread_timeout=(t)
-            t = t.to_f
-            raise ArgumentError.new('Value must be great than zero or nil') unless t > 0
-            @thread_timeout = t
-            t
-        end
-
-        # t:: seconds to work on a task (floats allow for values 0 < t < 1)
-        # Set the maximum amount of time to work on a given task
-        def action_timeout=(t)
-            t = t.to_f
-            raise ArgumentError.new('Value must be great than zero or nil') unless t > 0
-            @action_timeout = t
-            t
-        end
-
-        private
-
-        # Start our thread
-        def start_thread
-            begin
-                @logger.info("New pool thread is starting (#{self})")
-                until(@kill) do
-                    status(:wait)
-                    begin
-                        action = nil
-                        if(@pool.size > @pool.min)
-                            Timeout::timeout(@thread_timeout) do
-                                action = @pool.action
-                            end
-                        else
-                            action = @pool.action
-                        end
-                        status(:run)
-                        run(action[0], action[1]) unless action.nil?
-                        status(:wait)
-                    rescue Timeout::Error => boom
-                        @kill = true
-                    rescue Wakeup
-                        @logger.info("Thread #{::Thread.current} was woken up.")
-                    rescue Exception => boom
-                        @logger.error("Pool thread caught an exception: #{boom}\n#{boom.backtrace.join("\n")}")
-                        @respond_to.raise boom
-                    end
-                end
-            rescue Wakeup
-                @logger.info("Thread #{::Thread.current} was woken up.")
-            rescue Exception => boom
-                @logger.error("Pool thread caught an exception: #{boom}\n#{boom.backtrace.join("\n")}")
-                @respond_to.raise boom
-            ensure
-                @logger.info("Pool thread is shutting down (#{self})")
-                @pool.remove(self)
-                @pool.create_threads
-            end
-        end
-
-        # action:: task to be run
-        # args:: arguments to be passed to task
-        # Run the task
-        def run(action, args)
-            begin
-                if(@action_timeout > 0)
-                    Timeout::timeout(@action_timeout) do
-                        action.call(*args.flatten)
-                    end
-                else
-                    action.call(*args[0])
-                end
-            rescue Timeout::Error => boom
-                @logger.warn("Pool thread reached max execution time for action: #{boom}")
-            end
-        end
-    end
-end

data/test.rb

@@ -1,7 +0,0 @@
-require 'actionpool'
-
-pool = ActionPool::Pool.new
-
-pool << [lambda{|x,y| puts "#{x}, #{y}"}, [1,[:a, :b]]]
-
-sleep(1)

data/tests/cases/general.rb~

@@ -1,45 +0,0 @@
-require 'actionpool'
-require 'test/unit'
-
-class GeneralPoolTest < Test::Unit::TestCase
-    def setup
-        @pool = ActionPool::Pool.new
-    end
-    def test_numbers
-        assert_equal(10, @pool.size)
-        assert_equal(10, @pool.min)
-        assert_equal(100, @pool.max)
-        assert_equal(0, @pool.action_timeout)
-        assert_equal(0, @pool.thread_timeout)
-        assert_equal(0, @pool.action_size)
-    end
-    def test_output
-        a = 0
-        lock = Mutex.new
-        run = lambda{ lock.synchronize{ a += 1 } }
-        100.times{ @pool << run }
-        @pool.shutdown
-        assert_equal(100, a)
-        a = 0
-        jobs = [].fill(run,0,100)
-        @pool.add_jobs(jobs)
-        @pool.shutdown
-        assert_equal(100, a)
-        @pool.shutdown(true)
-    end
-    def test_args
-        output = nil
-        @pool << [lambda{|x| output = x}, [2]]
-        assert(2, output)
-        @pool.add_jobs([[lambda{|x| output = x}, [3]]])
-        assert(3, output)
-        @pool << [lambda{|x,y| output = x+y}, [1,2]]
-#         assert(3, output)
-        sleep(0.01)
-        output = []
-        @pool.add_jobs([[lambda{|x,y| output << x + y}, [1,1]], [lambda{|x| output << x}, [3]]])
-#         assert(output.include?(2))
-#         assert(output.include?(3))
-        @pool.shutdown(true)
-    end
-end