actionpool 0.2.2

data/lib/actionpool/Thread.rb

@@ -0,0 +1,155 @@
+require 'timeout'
+
+module ActionPool
+    # Exception class used for waking up a thread
+    class Wakeup < StandardError
+    end
+    # Raised within a thread when the timeout is changed
+    class Retimeout < 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?
+            @lock.synchronize{@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
+            @thread.raise Retimeout.new if waiting?
+            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
+        # Note: Modification of this will not affect actions already in process
+        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 && !@thread_timeout.zero?)
+                            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 Retimeout
+                        @logger.warn('Thread was woken up to reset thread timeout')
+                    rescue Exception => boom
+                        @logger.error("Pool thread caught an exception: #{boom}\n#{boom.backtrace.join("\n")}")
+                        @respond_to.raise boom
+                    end
+                end
+            rescue Retimeout
+                @logger.warn('Thread was woken up to reset thread timeout')
+                retry
+            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_thread
+            end
+        end
+
+        # action:: task to be run
+        # args:: arguments to be passed to task
+        # Run the task
+        def run(action, args)
+            begin
+                unless(@action_timeout.zero?)
+                    Timeout::timeout(@action_timeout) do
+                        action.call(*args[0])
+                    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/lib/actionpool/Thread.rb~

@@ -0,0 +1,146 @@
+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/lib/actionpool.rb

@@ -0,0 +1,7 @@
+begin
+    require 'fastthread'
+rescue LoadError
+    # we don't care if it's available
+    # just load it if it's around
+end
+require 'actionpool/Pool'

data/test.rb

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

data/tests/cases/general.rb

@@ -0,0 +1,52 @@
+require 'actionpool'
+require 'test/unit'
+
+class GeneralPoolTest < Test::Unit::TestCase
+    def setup
+        @pool = ActionPool::Pool.new
+    end
+    def teardown
+        @pool.shutdown(true)
+    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)
+        @pool.status :open
+        a = 0
+        jobs = [].fill(run,0,100)
+        @pool.add_jobs(jobs)
+        @pool.shutdown
+        assert_equal(100, a)
+        @pool.shutdown(true)
+    end
+    def test_args
+        @pool.status :open
+        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)
+        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))
+        @pool.shutdown(true)
+    end
+end

data/tests/cases/general.rb~

@@ -0,0 +1,45 @@
+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

data/tests/cases/grow.rb

@@ -0,0 +1,24 @@
+require 'actionpool'
+require 'test/unit'
+
+class GrowPoolTest < Test::Unit::TestCase
+    def setup
+        @pool = ActionPool::Pool.new
+    end
+    def teardown
+        @pool.shutdown(true)
+    end
+    def test_grow
+        jobs = [].fill(lambda{sleep}, 0..20)
+        @pool.add_jobs(jobs)
+        Thread.pass
+        assert(@pool.size > 10)
+        @pool.shutdown(true)
+    end
+    def test_max
+        @pool.create_thread(:force) until @pool.size > @pool.max
+        assert(@pool.create_thread.nil?)
+        assert(!@pool.create_thread(:force).nil?)
+        @pool.shutdown(true)
+    end
+end

data/tests/cases/nogrow.rb

@@ -0,0 +1,15 @@
+require 'actionpool'
+require 'test/unit'
+
+class NoGrowPoolTest < Test::Unit::TestCase
+    def setup
+        @pool = ActionPool::Pool.new
+    end
+    def teardown
+        @pool.shutdown(true)
+    end
+    def test_nogrow
+        5.times{ @pool << lambda{} }
+        assert_equal(10, @pool.size)
+    end
+end

data/tests/cases/queue.rb

@@ -0,0 +1,34 @@
+require 'actionpool'
+require 'test/unit'
+
+class QueueTest < Test::Unit::TestCase
+    def setup
+        @queue = ActionPool::Queue.new
+    end
+    def test_pop
+        3.times{|i|@queue << i}
+        3.times{|i|assert(i, @queue.pop)}
+        assert(@queue.empty?)
+    end
+    def test_pause
+        3.times{|i|@queue << i}
+        @queue.pause
+        output = []
+        3.times{Thread.new{output << @queue.pop}}
+        assert(output.empty?)
+        assert_equal(3, @queue.size)
+        @queue.unpause
+        sleep(1)
+        assert(@queue.empty?)
+        assert_equal(3, output.size)
+        3.times{|i|assert(output.include?(i))}
+        @queue << 1
+        output = nil
+        Thread.new{@queue.wait_empty; output = true}
+        assert_nil(output)
+        @queue.pop
+        Thread.pass
+        sleep(0.01)
+        assert(output)
+    end
+end

data/tests/cases/resize.rb

@@ -0,0 +1,35 @@
+require 'actionpool'
+require 'test/unit'
+
+class ResizePoolTest < Test::Unit::TestCase
+    def setup
+        @pool = ActionPool::Pool.new
+    end
+    def teardown
+        @pool.shutdown(true)
+    end
+    def test_resize
+        stop = false
+        20.times{ @pool << lambda{ sleep } }
+        Thread.pass
+        sleep(0.1)
+        assert(@pool.size > 10)
+        stop = true
+        @pool.shutdown(true)
+        @pool.status :open
+        @pool.max = 10
+        assert_equal(10, @pool.max)
+        stop = false
+        20.times{ @pool << lambda{ a = 0; a += 1 until stop || a > 9999999999 } }
+        assert_equal(10, @pool.size)
+        stop = true
+        @pool.shutdown(true)
+        @pool.status :open
+        @pool.max = 20
+        stop = false
+        30.times{ @pool << lambda{ a = 0; a += 1 until stop || a > 9999999999 } }
+        stop = true
+        assert(@pool.size > 10)
+        @pool.shutdown(true)
+    end
+end

data/tests/cases/shutdown.rb

@@ -0,0 +1,36 @@
+require 'actionpool'
+require 'test/unit'
+
+class ShutdownPoolTest < Test::Unit::TestCase
+    def setup
+        @pool = ActionPool::Pool.new
+    end
+    def teardown
+        @pool.shutdown(true)
+    end
+    def test_close
+        result = 0
+        @pool << lambda{ result = 5 }
+        sleep(0.01)
+        assert(5, result)
+        @pool.status :closed
+        assert_raise(ActionPool::PoolClosed) do
+            @pool << lambda{}
+        end
+        assert_raise(ActionPool::PoolClosed) do
+            @pool.add_jobs [lambda{}, lambda{}]
+        end
+        @pool.shutdown(true)
+    end
+    def test_shutdown
+        assert_equal(10, @pool.size)
+        @pool.shutdown
+        sleep(0.5)
+        assert_equal(0, @pool.size)
+        @pool.status :open
+        @pool << lambda{ sleep }
+        sleep(0.01)
+        assert_equal(10, @pool.size)
+        @pool.shutdown(true)
+    end
+end

data/tests/cases/thread.rb

@@ -0,0 +1,27 @@
+require 'actionpool'
+require 'test/unit'
+
+class ThreadTest < Test::Unit::TestCase
+    def setup
+        @pool = ActionPool::Pool.new(:min_threads => 1, :max_threads => 1)
+        @thread = ActionPool::Thread.new(:pool => @pool, :respond_thread => self, :t_timeout => 60, :a_timeout => 0)
+    end
+    def teardown
+        @pool.shutdown(true)
+    end
+    def test_thread
+        sleep(0.01)
+        assert(@thread.waiting?)
+        assert_equal(60, @thread.thread_timeout)
+        assert_equal(0, @thread.action_timeout)
+        assert(@thread.alive?)
+        stop = false
+        10.times{ @pool << lambda{ a = 0; a += 1 until stop || a > 9999999999 } }
+        assert(!@thread.waiting?)
+        @thread.stop(:force)
+        sleep(0.01)
+        assert(!@thread.alive?)
+        stop = true
+        @pool.shutdown(true)
+    end
+end

data/tests/cases/timeouts.rb

@@ -0,0 +1,37 @@
+require 'actionpool'
+require 'test/unit'
+
+class TimeoutPoolTest < Test::Unit::TestCase
+    def setup
+        @pool = ActionPool::Pool.new
+    end
+    def teardown
+        @pool.shutdown(true)
+    end
+    def test_actiontimeout
+        @pool.action_timeout = 0.01
+        assert_equal(10, @pool.size)
+        stop = false
+        @pool.add_jobs [].fill(lambda{loop{ 1+1 }}, 0, 20)
+        ::Thread.pass
+        assert(@pool.working > 10)
+        stop = true
+        sleep(0.5)
+        assert(@pool.working == 0)
+        @pool.shutdown(true)
+    end
+    def test_threadtimeout
+        @pool.thread_timeout = 0.01
+        assert_equal(10, @pool.size)
+        lock = Mutex.new
+        guard = ConditionVariable.new
+        @pool.add_jobs [].fill(lambda{ lock.synchronize{ guard.wait(lock) } }, 0, 20)
+        ::Thread.pass
+        assert_equal(30, @pool.size)
+        lock.synchronize{ guard.broadcast }
+        ::Thread.pass
+        sleep(0.1)
+        assert(10, @pool.size)
+        @pool.shutdown(true)
+    end
+end

data/tests/run_tests.rb

@@ -0,0 +1,8 @@
+$LOAD_PATH.unshift(File.expand_path("#{__FILE__}/../../lib"))
+
+require 'test/unit'
+require 'actionpool'
+
+Dir.new("#{File.dirname(__FILE__)}/cases").each{|f|
+    require "#{File.dirname(__FILE__)}/cases/#{f}" if f[-2..f.size] == 'rb'
+}