ActionPool 0.0.1

data/README

@@ -0,0 +1,40 @@
+        == ActionPool ==
+~Who doesn't love a pool with action?~
+
+ActionPool is just a simple thread pool. It allows
+for various contraints and resizing in a pretty
+easy and unobtrusive manner. You can set limits
+on how long tasks are worked on, as well as on the
+life of a thread. For things that like to use lots
+threads, it can be helpful to reuse threads instead of
+constantly recreating them.
+
+install (easy):
+
+gem install ActionPool
+
+install (less easy):
+
+git clone http://github.com/spox/actionpool.git
+cd actionpool
+gem build actionpool.gemspec
+gem install ActionPool-x.x.x.gem
+
+It has RDocs. They are where ever your rubygems installed them.
+They will probably be helpful to look over.
+
+Simple example of using the pool:
+
+pool = ActionPool::Pool.new
+pool.process do
+    puts "Hello world"
+    sleep(1)
+    puts "Goodbye world"
+end
+puts "Hello to you too"
+
+Result:
+Hello world
+Hello to you too
+Goodbye world
+

data/actionpool.gemspec

@@ -0,0 +1,12 @@
+spec = Gem::Specification.new do |s|
+    s.name              = 'ActionPool'
+    s.author            = %q(spox)
+    s.email             = %q(spox@modspox.com)
+    s.version           = '0.0.1'
+    s.summary           = %q(Thread Pool)
+    s.platform          = Gem::Platform::RUBY
+    s.has_rdoc          = true
+    s.files             = Dir['**/*']
+    s.require_paths     = %w(lib)
+    s.required_ruby_version = '>= 1.8.6'
+end

data/lib/actionpool/Exceptions.rb

@@ -0,0 +1,19 @@
+module ActionPool
+
+    class InvalidType < Exception
+        attr_reader :given
+        attr_reader :expected
+        def initialize(g,e)
+            @given = given
+            @expected = e
+        end
+
+        def to_s
+            "Given type: #{g} Expected type: #{e}"
+        end
+    end
+
+    class InvalidValue < Exception
+    end
+    
+end

data/lib/actionpool/LogHelper.rb

@@ -0,0 +1,26 @@
+require 'logger'
+
+module ActionPool
+    class LogHelper
+    
+        def initialize(logger=nil)
+            @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

@@ -0,0 +1,158 @@
+require 'actionpool/Exceptions'
+require 'actionpool/Thread'
+require 'actionpool/LogHelper'
+require 'thread'
+
+module ActionPool
+    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(min_threads=10, max_threads=100, t_to=60, a_to=nil, logger=nil)
+            @logger = LogHelper.new(logger)
+            @queue = Queue.new
+            @threads = []
+            @lock = Mutex.new
+            @thread_timeout = t_to
+            @action_timeout = a_to
+            @min_threads = min_threads
+            @max_threads = max_threads
+            @min_threads.times{create_thread}
+        end
+
+        # force:: force creation of a new thread
+        # Create a new thread for pool
+        def create_thread(force=false)
+            return nil unless @threads.size < @max_threads || force
+            @logger.info('Pool is creating a new thread')
+            pt = ActionPool::Thread.new(self, @thread_timeout, @action_timeout, @logger)
+            @threads << pt
+            return pt
+        end
+
+        # force:: force immediate stop
+        # Stop the pool
+        def shutdown(force=false)
+            @logger.info("Pool is now shutting down #{force ? 'using force' : ''}")
+            @threads.each{|t|t.stop}
+            until(size < 1) do
+                @queue << lambda{}
+                sleep(0.1)
+            end
+        end
+
+        # action:: proc to be executed
+        # Add a new proc/lambda to be executed (alias for queue)
+        def <<(action)
+            queue(action)
+        end
+
+        # action:: proc to be executed
+        # Add a new proc/lambda to be executed
+        def queue(action)
+            raise InvalidType.new(action.class, Proc) unless action.is_a?(Proc)
+            @queue << action
+            start_thread if size > min
+        end
+
+        # block:: block to process
+        # Adds a block to be processed
+        def process(&block)
+            queue(block)
+        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 InvalidValue.new unless m > 0
+            @max_threads = m
+        end
+
+        # m:: new min
+        # Set minimum number of threads
+        def min=(m)
+            m = m.to_i
+            raise InvalidValue.new unless m > 0 && m <= @max_threads
+            @min_threads = m
+            resize if m < size
+        end
+
+        # t:: ActionPool::Thread to remove
+        # Removes a thread from the pool
+        def remove(t)
+            @threads.delete(t)
+        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 = to_i unless t.nil?
+            raise InvalidValue.new unless t > 0 || t.nil?
+            @thread_timeout = 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 = to_i unless t.nil?
+            raise InvalidValue.new unless t > 0 || t.nil?
+            @action_timeout = 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
+
+        private
+        
+        def resize
+            @logger.info("Pool is being resized to stated minimum: #{min}")
+            size - min.times do
+                t = @threads.shift
+                t.stop
+            end
+        end
+    end
+end

data/lib/actionpool/Thread.rb

@@ -0,0 +1,71 @@
+require 'timeout'
+
+module ActionPool
+    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
+        # logger:: LogHelper for logging messages
+        # Create a new thread
+        def initialize(pool, t_timeout, a_timeout, logger=nil)
+            @pool = pool
+            @pool_timeout = t_timeout.nil? ? 0 : t_timeout
+            @action_timeout = a_timeout.nil? ? 0 : a_timeout
+            @kill = false
+            @logger = logger
+            @thread = ::Thread.new{ start_thread }
+        end
+
+        # stop the thread
+        def stop(force=false)
+            @kill = true
+            @thread.kill if force
+        end
+
+        private
+
+        def start_thread
+            begin
+                @logger.info("New pool thread is starting (#{self})")
+                until(@kill) do
+                    begin
+                        action = nil
+                        if(@pool.size > @pool.min)
+                            Timeout::timeout(@thread_timeout) do
+                                action = @pool.action
+                            end
+                        else
+                            action = @pool.action
+                        end
+                        run(action) unless action.nil?
+                    rescue Timeout::Error => boom
+                        @kill = true
+                    rescue Object => boom
+                        @logger.error("Pool thread caught an exception: #{boom}\n#{boom.backtrace.join("\n")}")
+                    end
+                end
+            rescue Object => boom
+                @logger.error("Pool thread caught an exception: #{boom}\n#{boom.backtrace.join("\n")}")
+            ensure
+                @logger.info("Pool thread is shutting down (#{self})")
+                @pool.remove(self)
+            end
+        end
+
+        def run(action)
+            begin
+                if(@action_timeout > 0)
+                    Timeout::timeout(@action_timeout) do
+                        action.call
+                    end
+                else
+                    action.call
+                end
+            rescue Timeout::Error => boom
+                @logger.warn("Pool thread reached max execution time for action: #{boom}")
+            rescue Object => boom
+                @logger.error("Pool thread caught an exception running action: #{boom}\n#{boom.backtrace.join("\n")}")
+            end
+        end
+    end
+end

data/lib/actionpool.rb

@@ -0,0 +1 @@
+require 'actionpool/Pool'

metadata

@@ -0,0 +1,62 @@
+--- !ruby/object:Gem::Specification 
+name: ActionPool
+version: !ruby/object:Gem::Version 
+  version: 0.0.1
+platform: ruby
+authors: 
+- spox
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-04-13 00:00:00 -07:00
+default_executable: 
+dependencies: []
+
+description: 
+email: spox@modspox.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- lib
+- lib/actionpool
+- lib/actionpool/Exceptions.rb
+- lib/actionpool/LogHelper.rb
+- lib/actionpool/Pool.rb
+- lib/actionpool/Thread.rb
+- lib/actionpool.rb
+- README
+- ActionPool-0.0.1.gem
+- actionpool.gemspec
+has_rdoc: true
+homepage: 
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: 1.8.6
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.0
+signing_key: 
+specification_version: 2
+summary: Thread Pool
+test_files: []
+