dat-worker-pool 0.3.0 → 0.4.0

data/dat-worker-pool.gemspec

@@ -20,6 +20,6 @@ Gem::Specification.new do |gem|
 
   gem.add_dependency("SystemTimer", ["~> 1.2"])
 
-  gem.add_development_dependency("assert")
+  gem.add_development_dependency("assert", ["~> 2.12"])
 
 end

data/lib/dat-worker-pool.rb

@@ -11,6 +11,10 @@ class DatWorkerPool
   TimeoutError = Class.new(RuntimeError)
 
   attr_reader :logger, :spawned
+  attr_reader :queue
+  attr_reader :on_worker_start_callbacks, :on_worker_shutdown_callbacks
+  attr_reader :on_worker_sleep_callbacks, :on_worker_wakeup_callbacks
+  attr_reader :before_work_callbacks, :after_work_callbacks
 
   def initialize(min = 0, max = 1, debug = false, &do_work_proc)
     @min_workers  = min
@@ -26,7 +30,14 @@ class DatWorkerPool
     @workers = []
     @spawned = 0
 
-    @min_workers.times{ self.spawn_worker }
+    @on_worker_start_callbacks    = []
+    @on_worker_shutdown_callbacks = [proc{ |worker| despawn_worker(worker) }]
+    @on_worker_sleep_callbacks    = [proc{ @workers_waiting.increment }]
+    @on_worker_wakeup_callbacks   = [proc{ @workers_waiting.decrement }]
+    @before_work_callbacks = []
+    @after_work_callbacks  = []
+
+    @started = false
   end
 
   def work_items
@@ -62,7 +73,13 @@ class DatWorkerPool
     return if work_item.nil?
     new_worker_needed = all_spawned_workers_are_busy?
     @queue.push work_item
-    self.spawn_worker if new_worker_needed && !reached_max_workers?
+    self.spawn_worker if @started && new_worker_needed && !reached_max_workers?
+  end
+
+  def start
+    @started = true
+    @queue.start
+    @min_workers.times{ self.spawn_worker }
   end
 
   # Shutdown each worker and then the queue. Shutting down the queue will
@@ -72,8 +89,13 @@ class DatWorkerPool
   # **NOTE** Any work that is left on the queue isn't processed. The controlling
   # application for the worker pool should gracefully handle these items.
   def shutdown(timeout = nil)
+    @started = false
     begin
       proc = OptionalTimeoutProc.new(timeout, true) do
+        # Workers need to be shutdown before the queue. This marks a flag that
+        # tells the workers to exit out of their loop once they wakeup. The
+        # queue shutdown signals the workers to wakeup, so the flag needs to be
+        # set before they wakeup.
         @workers.each(&:shutdown)
         @queue.shutdown
 
@@ -91,15 +113,32 @@ class DatWorkerPool
     end
   end
 
+  def on_queue_pop_callbacks;  @queue.on_pop_callbacks;  end
+  def on_queue_push_callbacks; @queue.on_push_callbacks; end
+
+  def on_queue_pop(&block);  @queue.on_pop_callbacks << block;  end
+  def on_queue_push(&block); @queue.on_push_callbacks << block; end
+
+  def on_worker_start(&block);    @on_worker_start_callbacks << block;    end
+  def on_worker_shutdown(&block); @on_worker_shutdown_callbacks << block; end
+  def on_worker_sleep(&block);    @on_worker_sleep_callbacks << block;    end
+  def on_worker_wakeup(&block);   @on_worker_wakeup_callbacks << block;   end
+
+  def before_work(&block); @before_work_callbacks << block; end
+  def after_work(&block);  @after_work_callbacks << block;  end
+
   protected
 
   def spawn_worker
     @mutex.synchronize do
       Worker.new(@queue).tap do |w|
-        w.on_work       = proc{ |work_item| do_work(work_item) }
-        w.on_waiting    = proc{ @workers_waiting.increment }
-        w.on_continuing = proc{ @workers_waiting.decrement }
-        w.on_shutdown   = proc{ |worker| despawn_worker(worker) }
+        w.on_work = proc{ |worker, work_item| do_work(work_item) }
+        w.on_start_callbacks    = @on_worker_start_callbacks
+        w.on_shutdown_callbacks = @on_worker_shutdown_callbacks
+        w.on_sleep_callbacks    = @on_worker_sleep_callbacks
+        w.on_wakeup_callbacks   = @on_worker_wakeup_callbacks
+        w.before_work_callbacks = @before_work_callbacks
+        w.after_work_callbacks  = @after_work_callbacks
 
         @workers << w
         @spawned += 1
@@ -139,7 +178,6 @@ class DatWorkerPool
     def decrement
       @mutex.synchronize{ @count -= 1 }
     end
-
   end
 
   class OptionalTimeoutProc

data/lib/dat-worker-pool/queue.rb

@@ -4,11 +4,16 @@ class DatWorkerPool
 
   class Queue
 
+    attr_accessor :on_push_callbacks, :on_pop_callbacks
+
     def initialize
       @work_items = []
       @shutdown = false
       @mutex = Mutex.new
       @condition_variable = ConditionVariable.new
+
+      @on_pop_callbacks  = []
+      @on_push_callbacks = []
     end
 
     def work_items
@@ -23,26 +28,37 @@ class DatWorkerPool
         @work_items << work_item
         @condition_variable.signal
       end
+      @on_push_callbacks.each(&:call)
     end
 
     def pop
       return if @shutdown
-      @mutex.synchronize do
+      item = @mutex.synchronize do
         @condition_variable.wait(@mutex) while !@shutdown && @work_items.empty?
         @work_items.shift
       end
+      @on_pop_callbacks.each(&:call)
+      item
     end
 
     def empty?
       @mutex.synchronize{ @work_items.empty? }
     end
 
+    def start
+      @shutdown = false
+    end
+
     # wake up any workers who are idle (because of `wait_for_work_item`)
     def shutdown
       @shutdown = true
       @mutex.synchronize{ @condition_variable.broadcast }
     end
 
+    def shutdown?
+      @shutdown
+    end
+
   end
 
 end

data/lib/dat-worker-pool/version.rb

@@ -1,3 +1,3 @@
 class DatWorkerPool
-  VERSION = "0.3.0"
+  VERSION = "0.4.0"
 end

data/lib/dat-worker-pool/worker.rb

@@ -3,14 +3,21 @@ require 'thread'
 class DatWorkerPool
 
   class Worker
-    attr_writer :on_work, :on_waiting, :on_continuing, :on_shutdown
+
+    attr_accessor :on_work
+    attr_accessor :on_start_callbacks, :on_shutdown_callbacks
+    attr_accessor :on_sleep_callbacks, :on_wakeup_callbacks
+    attr_accessor :before_work_callbacks, :after_work_callbacks
 
     def initialize(queue)
       @queue = queue
-      @on_work       = proc{ |work_item| }
-      @on_waiting    = proc{ |worker| }
-      @on_continuing = proc{ |worker| }
-      @on_shutdown   = proc{ |worker| }
+      @on_work = proc{ |worker, work_item| }
+      @on_start_callbacks    = []
+      @on_shutdown_callbacks = []
+      @on_sleep_callbacks    = []
+      @on_wakeup_callbacks   = []
+      @before_work_callbacks = []
+      @after_work_callbacks  = []
 
       @shutdown = false
       @thread   = nil
@@ -35,18 +42,25 @@ class DatWorkerPool
     protected
 
     def work_loop
+      @on_start_callbacks.each{ |p| p.call(self) }
       loop do
-        @on_waiting.call(self)
+        @on_sleep_callbacks.each{ |p| p.call(self) }
         work_item = @queue.pop
-        @on_continuing.call(self)
+        @on_wakeup_callbacks.each{ |p| p.call(self) }
         break if @shutdown
-        @on_work.call(work_item) if work_item
+        do_work(work_item) if work_item
       end
     ensure
-      @on_shutdown.call(self)
+      @on_shutdown_callbacks.each{ |p| p.call(self) }
       @thread = nil
     end
 
+    def do_work(work_item)
+      @before_work_callbacks.each{ |p| p.call(self, work_item) }
+      @on_work.call(self, work_item)
+      @after_work_callbacks.each{ |p| p.call(self, work_item) }
+    end
+
   end
 
 end

data/lib/dat-worker-pool/worker_pool_spy.rb

@@ -1,15 +1,36 @@
 class DatWorkerPool
 
   class WorkerPoolSpy
-    attr_reader :work_items
+    attr_reader :min_workers, :max_workers, :debug
+    attr_reader :work_proc, :work_items
+    attr_reader :start_called
     attr_reader :shutdown_called, :shutdown_timeout
+    attr_reader :on_queue_pop_callbacks, :on_queue_push_callbacks
+    attr_reader :on_worker_start_callbacks, :on_worker_shutdown_callbacks
+    attr_reader :on_worker_sleep_callbacks, :on_worker_wakeup_callbacks
+    attr_reader :before_work_callbacks, :after_work_callbacks
     attr_accessor :worker_available
 
-    def initialize
+    def initialize(min = 0, max = 1, debug = false, &block)
+      @min_workers  = min
+      @max_workers  = max
+      @debug        = debug
+      @work_proc    = block
+
       @worker_available = false
       @work_items = []
+      @start_called = false
       @shutdown_called  = false
       @shutdown_timeout = nil
+
+      @on_queue_pop_callbacks       = []
+      @on_queue_push_callbacks      = []
+      @on_worker_start_callbacks    = []
+      @on_worker_shutdown_callbacks = []
+      @on_worker_sleep_callbacks    = []
+      @on_worker_wakeup_callbacks   = []
+      @before_work_callbacks        = []
+      @after_work_callbacks         = []
     end
 
     def worker_available?
@@ -21,13 +42,35 @@ class DatWorkerPool
     end
 
     def add_work(work)
-      @work_items << work if work
+      return unless work
+      @work_items << work
+      @on_queue_push_callbacks.each(&:call)
+    end
+
+    def pop_work
+      work = @work_items.shift
+      @on_queue_pop_callbacks.each(&:call)
+      work
     end
 
-    def shutdown(timeout)
+    def start
+      @start_called = true
+    end
+
+    def shutdown(timeout = nil)
       @shutdown_called = true
       @shutdown_timeout = timeout
     end
+
+    def on_queue_pop(&block);       @on_queue_pop_callbacks << block;       end
+    def on_queue_push(&block);      @on_queue_push_callbacks << block;      end
+    def on_worker_start(&block);    @on_worker_start_callbacks << block;    end
+    def on_worker_shutdown(&block); @on_worker_shutdown_callbacks << block; end
+    def on_worker_sleep(&block);    @on_worker_sleep_callbacks << block;    end
+    def on_worker_wakeup(&block);   @on_worker_wakeup_callbacks << block;   end
+    def before_work(&block);        @before_work_callbacks << block;        end
+    def after_work(&block);         @after_work_callbacks << block;         end
+
   end
 
 end

data/test/system/use_worker_pool_tests.rb

@@ -10,6 +10,7 @@ class UseWorkerPoolTests < Assert::Context
     @work_pool = DatWorkerPool.new(1, 2, !!ENV['DEBUG']) do |work|
       @mutex.synchronize{ @results << (work * 100) }
     end
+    @work_pool.start
   end
 
   should "be able to add work, have it processed and stop the pool" do

data/test/unit/dat-worker-pool_tests.rb

@@ -10,12 +10,47 @@ class DatWorkerPool
     end
     subject{ @work_pool }
 
-    should have_readers :logger, :spawned
-    should have_imeths :add_work, :shutdown, :despawn_worker
+    should have_readers :logger, :spawned, :queue
+    should have_readers :on_worker_start_callbacks, :on_worker_shutdown_callbacks
+    should have_readers :on_worker_sleep_callbacks, :on_worker_wakeup_callbacks
+    should have_readers :before_work_callbacks, :after_work_callbacks
+    should have_imeths :add_work, :start, :shutdown, :despawn_worker
     should have_imeths :work_items, :waiting
     should have_imeths :worker_available?, :all_spawned_workers_are_busy?
     should have_imeths :reached_max_workers?
     should have_imeths :queue_empty?
+    should have_imeths :on_queue_pop_callbacks, :on_queue_push_callbacks
+    should have_imeths :on_queue_pop, :on_queue_push
+    should have_imeths :on_worker_start, :on_worker_shutdown
+    should have_imeths :on_worker_sleep, :on_worker_wakeup
+    should have_imeths :before_work, :after_work
+
+    should "know its attributes" do
+      assert_instance_of ::Logger, subject.logger
+      assert_equal 0, subject.spawned
+      assert_instance_of Queue, subject.queue
+    end
+
+    should "default its worker callbacks" do
+      assert_equal [], subject.on_worker_start_callbacks
+      assert_equal 1, subject.on_worker_shutdown_callbacks.size
+      assert_instance_of Proc, subject.on_worker_shutdown_callbacks.first
+      assert_equal 1, subject.on_worker_sleep_callbacks.size
+      assert_instance_of Proc, subject.on_worker_sleep_callbacks.first
+      assert_equal 1, subject.on_worker_wakeup_callbacks.size
+      assert_instance_of Proc, subject.on_worker_wakeup_callbacks.first
+      assert_equal [], subject.before_work_callbacks
+      assert_equal [], subject.after_work_callbacks
+    end
+
+    should "demeter its queue's callbacks" do
+      callback = proc{ }
+      subject.on_queue_pop(&callback)
+      assert_equal [callback], subject.on_queue_pop_callbacks
+      callback = proc{ }
+      subject.on_queue_push(&callback)
+      assert_equal [callback], subject.on_queue_push_callbacks
+    end
 
   end
 
@@ -23,6 +58,7 @@ class DatWorkerPool
     desc "workers"
     setup do
       @work_pool = DatWorkerPool.new(1, 2, true){ |work| sleep(work) }
+      @work_pool.start
     end
 
     should "be created as needed and only go up to the maximum number allowed" do
@@ -74,6 +110,51 @@ class DatWorkerPool
 
   end
 
+  class WorkerCallbackTests < UnitTests
+    desc "worker callbacks"
+    setup do
+      @start_called = false
+      @shutdown_called = false
+      @sleep_called = false
+      @wakeup_called = false
+      @before_work_called = false
+      @after_work_called = false
+
+      @work_pool = DatWorkerPool.new(1){ |work| }.tap do |p|
+        p.on_worker_start{ @start_called = true }
+        p.on_worker_shutdown{ @shutdown_called = true }
+        p.on_worker_sleep{ @sleep_called = true }
+        p.on_worker_wakeup{ @wakeup_called = true }
+        p.before_work{ @before_work_called = true }
+        p.after_work{ @after_work_called = true }
+      end
+    end
+    subject{ @work_pool }
+
+    should "call the worker callbacks as workers wait or wakeup" do
+      assert_false @start_called
+      assert_false @sleep_called
+      subject.start
+      assert_true @start_called
+      assert_true @sleep_called
+      assert_false @wakeup_called
+      assert_false @before_work_called
+      assert_false @after_work_called
+      @sleep_called = false
+      subject.add_work 'work'
+      assert_true @wakeup_called
+      assert_true @before_work_called
+      assert_true @after_work_called
+      assert_true @sleep_called
+      @wakeup_called = false
+      assert_false @shutdown_called
+      subject.shutdown
+      assert_true @wakeup_called
+      assert_true @shutdown_called
+    end
+
+  end
+
   class AddWorkWithNoWorkersTests < UnitTests
     setup do
       @work_pool = DatWorkerPool.new(0, 0){ |work| }
@@ -92,6 +173,7 @@ class DatWorkerPool
     setup do
       @result = nil
       @work_pool = DatWorkerPool.new(1){|work| @result = (2 / work) }
+      @work_pool.start
     end
 
     should "have added the work and processed it by calling the passed block" do
@@ -112,6 +194,33 @@ class DatWorkerPool
 
   end
 
+  class StartTests < UnitTests
+    desc "start"
+    setup do
+      @work_pool = DatWorkerPool.new(1, 2){ |work| sleep(work) }
+    end
+    subject{ @work_pool }
+
+    should "start its queue" do
+      assert_false subject.queue.shutdown?
+      subject.start
+      assert_false subject.queue.shutdown?
+      subject.shutdown
+      assert_true subject.queue.shutdown?
+      subject.start
+      assert_false subject.queue.shutdown?
+    end
+
+    should "keep workers from being spawned until its called" do
+      assert_equal 0, subject.spawned
+      subject.add_work 1
+      assert_equal 0, subject.spawned
+      subject.start
+      assert_equal 1, subject.spawned
+    end
+
+  end
+
   class ShutdownTests < UnitTests
     desc "shutdown"
     setup do
@@ -121,6 +230,7 @@ class DatWorkerPool
         sleep 1
         @mutex.synchronize{ @finished << work }
       end
+      @work_pool.start
       @work_pool.add_work 'a'
       @work_pool.add_work 'b'
       @work_pool.add_work 'c'

data/test/unit/queue_tests.rb

@@ -10,14 +10,27 @@ class DatWorkerPool::Queue
     end
     subject{ @queue }
 
+    should have_accessors :on_push_callbacks, :on_pop_callbacks
     should have_imeths :work_items, :push, :pop, :empty?
-    should have_imeths :shutdown
+    should have_imeths :start, :shutdown, :shutdown?
+
+    should "default its callbacks" do
+      assert_equal [], subject.on_push_callbacks
+      assert_equal [], subject.on_pop_callbacks
+    end
 
     should "allow pushing work items onto the queue with #push" do
       subject.push 'work'
       assert_equal [ 'work' ], subject.work_items
     end
 
+    should "call its on push callback when work is pushed" do
+      on_push_called = false
+      subject.on_push_callbacks << proc{ on_push_called = true }
+      subject.push 'work'
+      assert_true on_push_called
+    end
+
     should "raise an exception if trying to push work when shutdown" do
       subject.shutdown
       assert_raises(RuntimeError){ subject.push('work') }
@@ -34,6 +47,14 @@ class DatWorkerPool::Queue
       assert_equal 0, subject.work_items.size
     end
 
+    should "call its on pop callback when work is popped" do
+      subject.push 'work'
+      on_pop_called = false
+      subject.on_pop_callbacks << proc{ on_pop_called = true }
+      subject.pop
+      assert_true on_pop_called
+    end
+
     should "return nothing with pop when the queue has been shutdown" do
       subject.push 'work1'
       subject.shutdown
@@ -48,6 +69,14 @@ class DatWorkerPool::Queue
       assert subject.empty?
     end
 
+    should "reset its shutdown flag when started" do
+      assert_false subject.shutdown?
+      subject.shutdown
+      assert_true subject.shutdown?
+      subject.start
+      assert_false subject.shutdown?
+    end
+
   end
 
   class SignallingTests < UnitTests

data/test/unit/worker_pool_spy_tests.rb

@@ -6,15 +6,28 @@ class DatWorkerPool::WorkerPoolSpy
   class UnitTests < Assert::Context
     desc "DatWorkerPool::WorkerPoolSpy"
     setup do
-      @worker_pool_spy = DatWorkerPool::WorkerPoolSpy.new
+      @work_proc = proc{ 'work' }
+      @worker_pool_spy = DatWorkerPool::WorkerPoolSpy.new(&@work_proc)
     end
     subject{ @worker_pool_spy }
 
-    should have_readers :work_items
-    should have_readers :shutdown_called, :shutdown_timeout
+    should have_readers :work_proc, :work_items
+    should have_readers :start_called, :shutdown_called, :shutdown_timeout
+    should have_readers :on_queue_pop_callbacks, :on_queue_push_callbacks
+    should have_readers :on_worker_start_callbacks, :on_worker_shutdown_callbacks
+    should have_readers :on_worker_sleep_callbacks, :on_worker_wakeup_callbacks
+    should have_readers :before_work_callbacks, :after_work_callbacks
     should have_accessors :worker_available
     should have_imeths :worker_available?, :queue_empty?
-    should have_imeths :add_work, :shutdown
+    should have_imeths :add_work, :start, :shutdown
+    should have_imeths :on_queue_pop, :on_queue_push
+    should have_imeths :on_worker_start, :on_worker_shutdown
+    should have_imeths :on_worker_sleep, :on_worker_wakeup
+    should have_imeths :before_work, :after_work
+
+    should "know its work proc" do
+      assert_equal @work_proc, subject.work_proc
+    end
 
     should "have nothing in it's work items by default" do
       assert subject.work_items.empty?
@@ -25,6 +38,10 @@ class DatWorkerPool::WorkerPoolSpy
       assert_not subject.worker_available?
     end
 
+    should "return false for start called by default" do
+      assert_equal false, subject.start_called
+    end
+
     should "return false for shutdown called by default" do
       assert_equal false, subject.shutdown_called
     end
@@ -56,12 +73,65 @@ class DatWorkerPool::WorkerPoolSpy
       assert_equal false, subject.queue_empty?
     end
 
+    should "know when it's been started" do
+      subject.start
+      assert_true subject.start_called
+    end
+
     should "know when it's been shutdown and with what timeout" do
       subject.shutdown(10)
-      assert subject.shutdown_called
+      assert_true subject.shutdown_called
       assert_equal 10, subject.shutdown_timeout
     end
 
+    should "allow calling shutdown with no timeout" do
+      subject.shutdown
+      assert_true subject.shutdown_called
+      assert_nil subject.shutdown_timeout
+    end
+
+    should "know its queue and worker callbacks" do
+      assert_equal [], subject.on_queue_pop_callbacks
+      callback = proc{ }
+      subject.on_queue_pop(&callback)
+      assert_equal [callback], subject.on_queue_pop_callbacks
+
+      assert_equal [], subject.on_queue_push_callbacks
+      callback = proc{ }
+      subject.on_queue_push(&callback)
+      assert_equal [callback], subject.on_queue_push_callbacks
+
+      assert_equal [], subject.on_worker_start_callbacks
+      callback = proc{ }
+      subject.on_worker_start(&callback)
+      assert_equal [callback], subject.on_worker_start_callbacks
+
+      assert_equal [], subject.on_worker_shutdown_callbacks
+      callback = proc{ }
+      subject.on_worker_shutdown(&callback)
+      assert_equal [callback], subject.on_worker_shutdown_callbacks
+
+      assert_equal [], subject.on_worker_sleep_callbacks
+      callback = proc{ }
+      subject.on_worker_sleep(&callback)
+      assert_equal [callback], subject.on_worker_sleep_callbacks
+
+      assert_equal [], subject.on_worker_wakeup_callbacks
+      callback = proc{ }
+      subject.on_worker_wakeup(&callback)
+      assert_equal [callback], subject.on_worker_wakeup_callbacks
+
+      assert_equal [], subject.before_work_callbacks
+      callback = proc{ }
+      subject.before_work(&callback)
+      assert_equal [callback], subject.before_work_callbacks
+
+      assert_equal [], subject.after_work_callbacks
+      callback = proc{ }
+      subject.after_work(&callback)
+      assert_equal [callback], subject.after_work_callbacks
+    end
+
   end
 
 end

data/test/unit/worker_tests.rb

@@ -12,7 +12,7 @@ class DatWorkerPool::Worker
       @queue = DatWorkerPool::Queue.new
       @work_done = []
       @worker = DatWorkerPool::Worker.new(@queue).tap do |w|
-        w.on_work = proc{ |work| @work_done << work }
+        w.on_work = proc{ |worker, work| @work_done << work }
       end
     end
     teardown do
@@ -22,9 +22,22 @@ class DatWorkerPool::Worker
     end
     subject{ @worker }
 
-    should have_writers :on_waiting, :on_continuing, :on_shutdown
+    should have_accessors :on_work
+    should have_accessors :on_start_callbacks, :on_shutdown_callbacks
+    should have_accessors :on_sleep_callbacks, :on_wakeup_callbacks
+    should have_accessors :before_work_callbacks, :after_work_callbacks
     should have_imeths :start, :shutdown, :join, :running?
 
+    should "default its callbacks" do
+      worker = DatWorkerPool::Worker.new(@queue)
+      assert_equal [], worker.on_start_callbacks
+      assert_equal [], worker.on_shutdown_callbacks
+      assert_equal [], worker.on_sleep_callbacks
+      assert_equal [], worker.on_wakeup_callbacks
+      assert_equal [], worker.before_work_callbacks
+      assert_equal [], worker.after_work_callbacks
+    end
+
     should "start a thread with it's work loop with #start" do
       thread = nil
       assert_nothing_raised{ thread = subject.start }
@@ -60,54 +73,82 @@ class DatWorkerPool::Worker
   class CallbacksTests < UnitTests
     desc "callbacks"
     setup do
+      @call_counter = 0
+      @on_start_called_with = nil
+      @on_start_call_count = nil
+      @on_shutdown_called_with = nil
+      @on_shutdown_call_count = nil
+      @on_sleep_called_with = nil
+      @on_sleep_call_count = nil
+      @on_wakeup_called_with = nil
+      @on_wakeup_call_count = nil
+      @before_work_called_with = nil
+      @before_work_called_at = nil
+      @after_work_called_with = nil
+      @after_work_called_at = nil
       @worker = DatWorkerPool::Worker.new(@queue).tap do |w|
-        w.on_work = proc{ |work| sleep 0.2 }
+        w.on_start_callbacks    << proc do |*args|
+          @on_start_called_with = args
+          @on_start_called_at = (@call_counter += 1)
+        end
+        w.on_shutdown_callbacks << proc do |*args|
+          @on_shutdown_called_with = args
+          @on_shutdown_called_at = (@call_counter += 1)
+        end
+        w.on_sleep_callbacks    << proc do |*args|
+          @on_sleep_called_with = args
+          @on_sleep_called_at = (@call_counter += 1)
+        end
+        w.on_wakeup_callbacks   << proc do |*args|
+          @on_wakeup_called_with = args
+          @on_wakeup_called_at = (@call_counter += 1)
+        end
+        w.before_work_callbacks << proc do |*args|
+          @before_work_called_with = args
+          @before_work_called_at = (@call_counter += 1)
+        end
+        w.after_work_callbacks << proc do |*args|
+          @after_work_called_with = args
+          @after_work_called_at = (@call_counter += 1)
+        end
       end
     end
 
-    should "call the on waiting callback, yielding itself, when " \
-           "it's waiting on work from the queue" do
-      waiting, yielded_worker = nil, nil
-      subject.on_waiting = proc do |worker|
-        waiting = true
-        yielded_worker = worker
-      end
+    should "pass its self to its start, shutdown, sleep and wakupe callbacks" do
       subject.start
-      subject.join 0.1 # trigger the worker's thread to run
+      @queue.push('work')
+      subject.shutdown
+      @queue.shutdown
 
-      assert_equal true, waiting
-      assert_equal subject, yielded_worker
+      assert_equal [subject], @on_start_called_with
+      assert_equal [subject], @on_shutdown_called_with
+      assert_equal [subject], @on_sleep_called_with
+      assert_equal [subject], @on_wakeup_called_with
     end
 
-    should "call the on continuing callback, yielding itself, when " \
-           "it's done waiting for work from the queue" do
-      waiting, yielded_worker = nil, nil
-      subject.on_continuing = proc do |worker|
-        waiting = false
-        yielded_worker = worker
-      end
+    should "pass its self and work to its beofre and after work callbacks" do
       subject.start
-      @queue.push 'some work'
-      subject.join 0.1 # trigger the worker's thread to run
+      @queue.push('work')
+      subject.shutdown
+      @queue.shutdown
 
-      assert_equal false, waiting
-      assert_equal subject, yielded_worker
+      assert_equal [subject, 'work'], @before_work_called_with
+      assert_equal [subject, 'work'], @after_work_called_with
     end
 
-    should "call the on shutdown callback, yielding itself, when " \
-           "it's shutdown" do
-      shutdown, yielded_worker = nil, nil
-      subject.on_shutdown = proc do |worker|
-        shutdown = true
-        yielded_worker = worker
-      end
+    should "call its callbacks throughout its lifecycle" do
       subject.start
+      assert_equal 1, @on_start_called_at
+      assert_equal 2, @on_sleep_called_at
+      @queue.push('work')
+      assert_equal 3, @on_wakeup_called_at
+      assert_equal 4, @before_work_called_at
+      assert_equal 5, @after_work_called_at
+      assert_equal 6, @on_sleep_called_at
       subject.shutdown
       @queue.shutdown
-      subject.join 0.1 # trigger the worker's thread to run
-
-      assert_equal true, shutdown
-      assert_equal subject, yielded_worker
+      assert_equal 7, @on_wakeup_called_at
+      assert_equal 8, @on_shutdown_called_at
     end
 
   end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: dat-worker-pool
 version: !ruby/object:Gem::Version 
-  hash: 19
+  hash: 15
   prerelease: 
   segments: 
   - 0
-  - 3
+  - 4
   - 0
-  version: 0.3.0
+  version: 0.4.0
 platform: ruby
 authors: 
 - Collin Redding
@@ -16,10 +16,10 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2013-10-10 00:00:00 Z
+date: 2015-01-02 00:00:00 Z
 dependencies: 
 - !ruby/object:Gem::Dependency 
-  version_requirements: &id001 !ruby/object:Gem::Requirement 
+  requirement: &id001 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
     - - ~>
@@ -29,24 +29,25 @@ dependencies:
         - 1
         - 2
         version: "1.2"
+  version_requirements: *id001
   type: :runtime
-  requirement: *id001
-  prerelease: false
   name: SystemTimer
+  prerelease: false
 - !ruby/object:Gem::Dependency 
-  version_requirements: &id002 !ruby/object:Gem::Requirement 
+  requirement: &id002 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
-    - - ">="
+    - - ~>
       - !ruby/object:Gem::Version 
-        hash: 3
+        hash: 27
         segments: 
-        - 0
-        version: "0"
+        - 2
+        - 12
+        version: "2.12"
+  version_requirements: *id002
   type: :development
-  requirement: *id002
-  prerelease: false
   name: assert
+  prerelease: false
 description: A simple thread pool for processing generic 'work'
 email: 
 - collin.redding@me.com
@@ -106,7 +107,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: 
-rubygems_version: 1.8.15
+rubygems_version: 1.8.29
 signing_key: 
 specification_version: 3
 summary: A simple thread pool for processing generic 'work'