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)

data/tests/run_tests.rb

@@ -1,3 +1,5 @@
+$LOAD_PATH.unshift(File.expand_path("#{__FILE__}/../../lib"))
+
 require 'test/unit'
 require 'actionpool'
 

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: 2009-12-11 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: []
@@ -36,12 +45,12 @@ files:
 - tests/run_tests.rb
 - lib/actionpool/Pool.rb
 - lib/actionpool/Thread.rb
-- lib/actionpool/LogHelper.rb
 - lib/actionpool/Queue.rb
 - lib/actionpool.rb
 - CHANGELOG
 - LICENSE
 - README.rdoc
+- ActionPool-0.2.3.gem
 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