threadz 1.0.0 → 1.1.0.rc2

data/.travis.yml

@@ -0,0 +1,9 @@
+language: ruby
+rvm:
+  - "1.9.2"
+  - "1.9.3"
+  - jruby-19mode # JRuby in 1.9 mode
+  - rbx-19mode
+  - ruby-head
+# uncomment this line if your project needs to run something other than `rake`:
+# script: bundle exec rspec spec

data/CHANGELOG

@@ -1,3 +1,11 @@
+1.1.0
+=====
+Improved exception handling!
+
+1.0.0
+=====
+No changes from 1.0.0.beta
+
 1.0.0.beta
 ==========
 Removing rcov and jeweler dependencies, fixing rspec at 1.x, adding some

data/Gemfile

@@ -2,4 +2,5 @@ source "http://rubygems.org"
 
 # Specify your gem's dependencies in threadz.gemspec
 gemspec
-gem "rake"
+gem "rake", "~> 10.0"
+gem "rdoc", "~> 3.12"

data/Gemfile.lock

@@ -1,18 +1,32 @@
 PATH
   remote: .
   specs:
-    threadz (1.0.0.beta)
+    threadz (1.1.0.rc1)
 
 GEM
   remote: http://rubygems.org/
   specs:
-    rake (0.9.2.2)
-    rspec (1.3.2)
+    diff-lcs (1.1.3)
+    json (1.7.5)
+    json (1.7.5-java)
+    rake (10.0.3)
+    rdoc (3.12)
+      json (~> 1.4)
+    rspec (2.12.0)
+      rspec-core (~> 2.12.0)
+      rspec-expectations (~> 2.12.0)
+      rspec-mocks (~> 2.12.0)
+    rspec-core (2.12.2)
+    rspec-expectations (2.12.1)
+      diff-lcs (~> 1.1.3)
+    rspec-mocks (2.12.0)
 
 PLATFORMS
+  java
   ruby
 
 DEPENDENCIES
-  rake
-  rspec (~> 1.0)
+  rake (~> 10.0)
+  rdoc (~> 3.12)
+  rspec (~> 2.12)
   threadz!

data/README.rdoc

@@ -1,5 +1,9 @@
 = Threadz Thread Pool Library
 
+{<img src="https://travis-ci.org/nanodeath/threadz.png?branch=master" alt="Build Status" />}[https://travis-ci.org/nanodeath/threadz]
+{<img src="https://codeclimate.com/badge.png" />}[https://codeclimate.com/github/nanodeath/threadz]
+{<img src="https://gemnasium.com/nanodeath/threadz.png" alt="Dependency Status" />}[https://gemnasium.com/nanodeath/threadz]
+
 == Description
 
 This is a thread pool library that you can do two main things with, which I'll demonstrate in code:
@@ -38,6 +42,8 @@ This is a thread pool library that you can do two main things with, which I'll d
   b.wait_until_done(:timeout => 0.1)
   puts b.completed? ? "finished!" : "didn't finish"
 
+  # Exception handling: well-supported, see the specs though.  Much better examples.
+
 The thread pool is also smart -- depending on load, it can either spawn or cull additional threads (at a rate you can set).
 
 == Examples

data/Rakefile

@@ -1,47 +1,41 @@
-require 'rubygems'
-require 'rake/testtask'
-require 'rdoc/task'
-require 'rubygems/package_task'
-require 'rubygems/source_info_cache'
-require 'spec/rake/spectask'
+require "rubygems"
+require "rake/testtask"
+require "rdoc/task"
+require "rubygems/package_task"
+require "rspec/core/rake_task"
 require "bundler/gem_tasks"
 
-spec = Gem::Specification.load(File.join(File.dirname(__FILE__), 'threadz.gemspec'))
+spec = Gem::Specification.load(File.join(File.dirname(__FILE__), "threadz.gemspec"))
 
 desc "Default Task"
-task 'default' => ['spec', 'rdoc']
+task "default" => ["spec", "rdoc"]
 
 
-desc "Run all test cases"
-task 'spec' do |task|
-  exec 'spec -c -f n spec/*.rb spec/basic/*.rb'
+desc "Run all unit tests"
+RSpec::Core::RakeTask.new(:spec) do |t|
+  t.rspec_opts = ["-c", "-f n", "-r ./spec/spec_helper.rb"]
+  t.pattern = 'spec/*_spec.rb'
 end
 
-desc "Run all performance-oriented test cases"
-task 'spec:performance' do |task|
-  exec 'spec -c -f n -t 30.0 spec/spec_helper.rb spec/performance/*.rb'
-end
 
-desc "Run *all* specs"
-task 'spec:all' do |task|
-  exec 'spec -c -f n -t 30.0 spec/spec_helper.rb spec/**/*.rb'
-end
+namespace "spec" do
+  desc "Run all performance-oriented test cases"
+  RSpec::Core::RakeTask.new(:performance) do |t|
+    t.rspec_opts = ["-c", "-f n", "-r ./spec/spec_helper.rb"]
+    t.pattern = 'spec/performance/*_spec.rb'
+  end
 
-desc "Run all test cases 10 times (or n times)"
-task 'spec-stress', [:times] do |task, args|
-  args.with_defaults :times => 10
-  puts "Executing spec #{args.times} times"
-  puts Rake::Task[:spec].methods.sort.inspect
-  args.times.times do
-    Rake::Task[:spec].execute
-    puts "foo"
+  desc "Run *all* specs"
+  RSpec::Core::RakeTask.new(:all) do |t|
+    t.rspec_opts = ["-c", "-f n", "-r ./spec/spec_helper.rb"]
+    t.pattern = 'spec/**/*_spec.rb'
   end
-  puts "Done!"
 end
 
+
 Rake::RDocTask.new do |rdoc|
-  rdoc.main = 'README.rdoc'
-  rdoc.rdoc_files.include('README.rdoc', 'lib/**/*.rb')
+  rdoc.main = "README.rdoc"
+  rdoc.rdoc_files.include("README.rdoc", "lib/**/*.rb")
   rdoc.title = "Threadz Thread Pool"
-  rdoc.rdoc_dir = 'doc'
+  rdoc.rdoc_dir = "doc"
 end

data/lib/threadz.rb

@@ -31,5 +31,5 @@ end
 
 Threadz::dputs("Loading threadz")
 
-['atomic_integer', 'sleeper', 'directive', 'batch', 'thread_pool'].each { |lib| require File.join(File.dirname(__FILE__), 'threadz', lib) }
+['atomic_integer', 'sleeper', 'directive', 'batch', 'thread_pool', 'errors'].each { |lib| require File.join(File.dirname(__FILE__), 'threadz', lib) }
 

data/lib/threadz/batch.rb

@@ -1,113 +1,158 @@
-['atomic_integer', 'sleeper'].each { |lib| require File.join(File.dirname(__FILE__), lib) }
+['atomic_integer', 'sleeper', 'errors'].each { |lib| require File.join(File.dirname(__FILE__), lib) }
 
 module Threadz
-    # A batch is a collection of jobs you care about that gets pushed off to
-    # the attached thread pool.  The calling thread can be signaled when the
-    # batch has completed executing, or a block can be executed.
-    class Batch
-      # Creates a new batch attached to the given threadpool.  A number of options
-      # are available:
-      # +:latent+:: If latent, none of the jobs in the batch will actually start
-      #            executing until the +start+ method is called.
-      def initialize(threadpool, opts={})
-        @threadpool = threadpool
-        @waiting_threads = []
-        @job_lock = Mutex.new
-        @jobs_count = AtomicInteger.new(0)
-        @when_done_blocks = []
-        @sleeper = ::Threadz::Sleeper.new
+  # A batch is a collection of jobs you care about that gets pushed off to
+  # the attached thread pool.  The calling thread can be signaled when the
+  # batch has completed executing, or a block can be executed.
+  class Batch
+    # Creates a new batch attached to the given threadpool.  A number of options
+    # are available:
+    # +:latent+:: If latent, none of the jobs in the batch will actually start
+    #            executing until the +start+ method is called.
+    def initialize(threadpool, opts={})
+      @threadpool = threadpool
+      @job_lock = Mutex.new
+      @jobs_count = AtomicInteger.new(0)
+      @when_done_blocks = []
+      @sleeper = ::Threadz::Sleeper.new
+      @error_lock = Mutex.new
+      @job_errors = []
+      @error_handler_errors = []
+      @error_handler = opts[:error_handler]
+      if @error_handler && !@error_handler.respond_to?(:call)
+        raise ArgumentError.new("ErrorHandler must respond to #call")
+      end
+      @max_retries = opts[:max_retries] || 3
+      @verbose = opts[:verbose]
 
-        ## Options
+      ## Options
 
-        #latent
-        @latent = opts.key?(:latent) ? opts[:latent] : false
-        if(@latent)
-          @started = false
-        else
-          @started = true
-        end
-        @job_queue = Queue.new if @latent
+      #latent
+      @latent = opts.key?(:latent) ? opts[:latent] : false
+      if(@latent)
+        @started = false
+      else
+        @started = true
       end
+      @job_queue = Queue.new if @latent
+    end
 
-      # Add a new job to the batch.  If this is a latent batch, the job can't
-      # be scheduled until the batch is #start'ed; otherwise it may start
-      # immediately.  The job can be anything that responds to +call+ or an
-      # array of objects that respond to +call+.
-      def push(job)
-        if job.is_a? Array
-          job.each {|j| self << j}
-        elsif job.respond_to? :call
-          @jobs_count.increment
-          if @latent && !@started
-            @job_queue << job
-          else
-            send_to_threadpool job
-          end
+    # Add a new job to the batch.  If this is a latent batch, the job can't
+    # be scheduled until the batch is #start'ed; otherwise it may start
+    # immediately.  The job can be anything that responds to +call+ or an
+    # array of objects that respond to +call+.
+    def push(job)
+      if job.is_a? Array
+        job.each {|j| self << j}
+      elsif job.respond_to? :call
+        @jobs_count.increment
+        if @latent && !@started
+          @job_queue << job
         else
-          raise "Not a valid job: needs to support #call"
+          send_to_threadpool(job)
         end
+      else
+        raise "Not a valid job: needs to support #call"
       end
+    end
 
-      alias << push
+    alias << push
 
-      # Put the current thread to sleep until the batch is done processing.
-      # There are options available:
-      # +:timeout+:: If specified, will only wait for at least this many seconds
-      #              for the batch to finish.  Typically used with #completed?
-      def wait_until_done(opts={})
-        raise "Threadz: thread deadlocked because batch job was never started" if @latent && !@started
+    # Put the current thread to sleep until the batch is done processing.
+    # There are options available:
+    # +:timeout+:: If specified, will only wait for at least this many seconds
+    #              for the batch to finish.  Typically used with #completed?
+    def wait_until_done(opts={})
+      raise "Threadz: thread deadlocked because batch job was never started" if @latent && !@started
 
-        timeout = opts.key?(:timeout) ? opts[:timeout] : 0
-        @sleeper.wait(timeout) unless completed?
+      timeout = opts.key?(:timeout) ? opts[:timeout] : 0
+      @sleeper.wait(timeout) unless completed?
+      errors = self.job_errors
+      if !errors.empty? && !@error_handler
+        raise JobError.new(errors)
       end
+    end
 
-      # Returns true iff there are no jobs outstanding.
-      def completed?
-        return @jobs_count.value == 0
-      end
+    # Returns true iff there are no jobs outstanding.
+    def completed?
+      return @jobs_count.value == 0
+    end
 
-      # If this is a latent batch, start processing all of the jobs in the queue.
-      def start
-				@job_lock.synchronize {  # in case another thread tries to push new jobs onto the queue while we're starting
-          if @latent
-            @started = true
-            until @job_queue.empty?
-              send_to_threadpool @job_queue.pop
-            end
-            return true
-          else
-            return false
-          end
-				}
-      end
+    # Returns the list of errors that occurred in the jobs
+    def job_errors
+      arr = nil
+      @error_lock.synchronize { arr = @job_errors.dup }
+      arr
+    end
 
-      # Execute a given block when the batch has finished processing.  If the batch
-      # has already finished executing, execute immediately.
-      def when_done(&block)
-        @job_lock.synchronize { completed? ? block.call : @when_done_blocks << block }
-      end
+    # Returns the list of errors that occurred in the error handler
+    def error_handler_errors
+      arr = nil
+      @error_lock.synchronize { arr = @error_handler_errors.dup }
+      arr
+    end
 
-      private
-      def handle_done
-        @sleeper.broadcast
-        @when_done_blocks.each do |b|
-          b.call
+    # If this is a latent batch, start processing all of the jobs in the queue.
+    def start
+      @job_lock.synchronize {  # in case another thread tries to push new jobs onto the queue while we're starting
+        if @latent
+          @started = true
+          until @job_queue.empty?
+            send_to_threadpool(@job_queue.pop)
+          end
+          return true
+        else
+          return false
         end
-        @when_done_blocks = []
+      }
+    end
+
+    # Execute a given block when the batch has finished processing.  If the batch
+    # has already finished executing, execute immediately.
+    def when_done(&block)
+      @job_lock.synchronize { completed? ? block.call : @when_done_blocks << block }
+    end
+
+    private
+    def handle_done
+      @sleeper.broadcast
+      @when_done_blocks.each do |b|
+        b.call
       end
+      @when_done_blocks = []
+    end
 
-      def send_to_threadpool(job)
-        @threadpool.process do
+    def send_to_threadpool(job)
+      @threadpool.process do
+        control = Control.new(job)
+        retries = 0
+        begin
           job.call
-          # Lock in case we get two threads at the "fork in the road" at the same time
-					# Note: locking here actually creates undesirable behavior.  Still investigating why,
-					# seems like it should be useful.
-          #@job_lock.lock
-          @jobs_count.decrement
-          # fork in the road
-          handle_done if completed?
-          #@job_lock.unlock
+        rescue StandardError => e
+          @error_lock.synchronize { @job_errors << e }
+          control.job_errors << e
+          if @error_handler
+            begin
+              @error_handler.call(e, control)
+            rescue StandardError => e2
+              # Who handles the error handler?!
+              $stderr.puts %{Exception in error handler: #{e}} if @verbose
+              @error_lock.synchronize { @error_handler_errors << e2 }
+              control.error_handler_errors << e2
+            end
+            retries += 1
+            retry unless retries >= @max_retries
+          end
         end
+        # Lock in case we get two threads at the "fork in the road" at the same time
+        # Note: locking here actually creates undesirable behavior.  Still investigating why,
+        # seems like it should be useful.
+        #@job_lock.lock
+        @jobs_count.decrement
+        # fork in the road
+        handle_done if completed?
+        #@job_lock.unlock
       end
     end
+  end
 end

data/lib/threadz/control.rb

@@ -0,0 +1,14 @@
+module Threadz
+	# A control through which to manipulate an individual job
+	class Control
+		attr_reader :job
+		attr_reader :job_errors
+		attr_reader :error_handler_errors
+
+		def initialize(job)
+			@job = job
+			@job_errors = []
+			@error_handler_errors = []
+		end
+	end
+end

data/lib/threadz/errors.rb

@@ -0,0 +1,18 @@
+module Threadz
+  class ThreadzError < StandardError; end
+
+  class JobError < ThreadzError
+    attr_reader :errors
+    def initialize(errors)
+      super("One or more jobs failed due to errors (see #errors)")
+      @errors = errors
+    end
+  end
+  class ErrorHandlerError < ThreadzError
+    attr_reader :error
+    def initialize(error)
+      super("An error occurred in the error handler itself (see #error)")
+      @error = error
+    end
+  end
+end

data/lib/threadz/thread_pool.rb

@@ -1,4 +1,6 @@
 require 'thread'
+['control'].each { |lib| require File.join(File.dirname(__FILE__), lib) }
+
 
 module Threadz
 
@@ -53,7 +55,7 @@ module Threadz
     # finishes.  If you care about when it finishes, use batches.
     def process(callback = nil, &block)
       callback ||= block
-      @queue << callback
+      @queue << Control.new(callback)
       nil
     end
 
@@ -76,7 +78,7 @@ module Threadz
           end
           Thread.pass
           begin
-            x.call
+            x.job.call(x)
           rescue StandardError => e
             $stderr.puts "Threadz: Error in thread, but restarting with next job: #{e.inspect}\n#{e.backtrace.join("\n")}"
           end

data/lib/threadz/version.rb

@@ -1,4 +1,4 @@
 module Threadz
-  VERSION = "1.0.0"
+  VERSION = "1.1.0.rc2"
 end
   

data/spec/atomic_integer_spec.rb

@@ -2,28 +2,6 @@ $LOAD_PATH.unshift File.expand_path(File.dirname(__FILE__))
 require 'spec_helper'
 
 describe Threadz do
-	describe Fixnum do
-		it "should perform badly when under heavy thread usage" do
-			# This test should always fail, but there is a small chance it won't...
-			
-			i = 0
-			n = 100_000
-			threads = 100
-			t = []
-			threads.times do
-				t << Thread.new do
-					sleep 0.1
-					n.times { i += 1 }
-				end
-				t << Thread.new do 
-					sleep 0.1
-					n.times { i -= 1 }
-				end
-			end
-			t.each { |thread| thread.join }
-			i.should_not == 0
-		end
-	end
 	describe Threadz::AtomicInteger do
 		it "should perform better than an int for counting" do
 			i = Threadz::AtomicInteger.new(0)

data/spec/basic/thread_pool_spec.rb

@@ -7,7 +7,7 @@ describe Threadz::ThreadPool do
 
 	it "should perform well for IO jobs" do
 		urls = []
-		urls << "http://www.google.com/" << "http://www.yahoo.com/" << 'http://www.microsoft.com/'
+		urls << "http://www.google.com/" << "http://www.yahoo.com/" << "http://www.microsoft.com/"
 		urls << "http://www.cnn.com/" << "http://slashdot.org/" << "http://www.mozilla.org/"
 		urls << "http://www.ubuntu.com/" << "http://github.com/"
 		time_single_threaded = Time.now

data/spec/threadz_spec.rb

@@ -8,135 +8,133 @@ describe Threadz do
     end
 
     it "should support process and accept a block" do
-      i = 0
+      i = Threadz::AtomicInteger.new(0)
       3.times do
-        @T.process { i += 1}
+        @T.process { i.increment }
       end
       sleep 0.1
 
-      i.should == 3
+      i.value.should == 3
     end
 
     it "should support process and accept an arg that responds to :call" do
-      i = 0
+      i = Threadz::AtomicInteger.new(0)
       3.times do
-        @T.process(Proc.new { i += 1} )
+        @T.process(Proc.new { i.increment })
       end
       sleep 0.1
 
-      i.should == 3
+      i.value.should == 3
     end
 
     it "should support creating batches" do
-      i = 0
-
       lambda { @T.new_batch }.should_not raise_error
       lambda { @T.new_batch(:latent => true) }.should_not raise_error
     end
     
     it "should not crash when killing threads" do
-        i = 0
-        b = @T.new_batch(:latent => true)
-        5000.times do
-          b << lambda { i += 1 }
-          b << lambda { i -= 1 }
-          b << [lambda { i += 2}, lambda { i -= 1}]
-        end
+      i = Threadz::AtomicInteger.new(0)
+      b = @T.new_batch(:latent => true)
+      5000.times do
+        b << lambda { i.increment }
+        b << lambda { i.decrement }
+        b << [lambda { i.increment(2) }, lambda { i.decrement }]
+      end
 
-        b.start
-        b.wait_until_done
+      b.start
+      b.wait_until_done
 
-		50.times { sleep 0.1 }
+      50.times { sleep 0.1 }
     end
 
     describe Threadz::Batch do
       it "should support jobs" do
-        i = 0
+        i = Threadz::AtomicInteger.new(0)
         b = @T.new_batch
         10.times do
-          b << lambda { i += 1 }
-          b << Proc.new { i += 1 }
+          b << lambda { i.increment }
+          b << Proc.new { i.increment }
         end
         b.wait_until_done
 
-        i.should == 20
+        i.value.should == 20
       end
 
       it "should support arrays of jobs" do
-        i = 0
+        i = Threadz::AtomicInteger.new(0)
         b = @T.new_batch
-        b << [lambda { i += 2}, lambda { i -= 1}]
-        b << [lambda { i += 2}]
-        b << lambda { i += 1 }
+        b << [lambda { i.increment(2) }, lambda { i.decrement }]
+        b << [lambda { i.increment(2) }]
+        b << lambda { i.increment }
         b.wait_until_done
 
-        i.should == 4
+        i.value.should == 4
       end
 
       it "should support reuse" do
-        i = 0
+        i = Threadz::AtomicInteger.new(0)
         b = @T.new_batch
-        b << [lambda { i += 2}, lambda { i -= 1}, lambda { i -= 2 }]
+        b << [lambda { i.increment(2) }, lambda { i.decrement }, lambda { i.decrement(2) }]
         b.wait_until_done
 
-        i.should == -1
+        i.value.should == -1
 
-        b << [lambda { i += 9}, lambda { i -= 3}, lambda { i -= 4 }]
+        b << [lambda { i.increment(9) }, lambda { i.decrement(3) }, lambda { i.decrement(4) }]
         b.wait_until_done
 
-        i.should == 1
+        i.value.should == 1
       end
 
-      it "should play nicely with instance variables" do
-        @i = 0
+      it "should play nicely with instance variables (shouldn't steal binding)" do
+        @i = Threadz::AtomicInteger.new(0)
         b = @T.new_batch
-        b << [lambda { @i += 2}, lambda { @i -= 1}]
-        b << lambda { @i += 2}
+        b << [lambda { @i.increment(2) }, lambda { @i.decrement }]
+        b << lambda { @i.increment(2) }
         b.wait_until_done
 
-        @i.should == 3
+        @i.value.should == 3
       end
 
       it "should support latent option" do
-        i = 0
+        i = Threadz::AtomicInteger.new(0)
         b = @T.new_batch(:latent => true)
-        b << lambda { i += 1 }
-        b << lambda { i -= 1 }
-        b << [lambda { i += 2}, lambda { i -= 1}]
+        b << lambda { i.increment }
+        b << lambda { i.decrement }
+        b << [lambda { i.increment(2) }, lambda { i.decrement }]
 
-        i.should == 0
+        i.value.should == 0
 
         sleep 0.1
 
-        i.should == 0
+        i.value.should == 0
 
         b.start
         b.wait_until_done
 
-        i.should == 1
+        i.value.should == 1
       end
 
       it "should support waiting with timeouts" do
-        i = 0
+        i = Threadz::AtomicInteger.new(0)
         b = @T.new_batch
-        b << lambda { i += 1 }
-        b << lambda { i -= 1 }
-        b << [lambda { i += 2}, lambda { 500000000.times { i += 1}}]
+        b << lambda { i.increment }
+        b << lambda { i.increment }
+        b << [lambda { i.increment(2) }, lambda { 500000000.times { i.increment } }]
         t = Time.now
         timeout = 0.2
         b.wait_until_done(:timeout => timeout)
 
         b.completed?.should be_false
         (Time.now - t).should >= timeout
-        i.should > 2
+        i.value.should > 2
       end
 
       it "should support 'completed?' even without timeouts" do
-        i = 0
+        i = Threadz::AtomicInteger.new(0)
         b = @T.new_batch
-        b << lambda { i += 1 }
-        b << lambda { i -= 1 }
-        b << [lambda { i += 2}, lambda { sleep 0.01 while i < 10 }]
+        b << lambda { i.increment }
+        b << lambda { i.decrement }
+        b << [lambda { i.increment(2)}, lambda { sleep 0.1 while i.value < 10 }]
 
         b.completed?.should be_false
 
@@ -144,24 +142,27 @@ describe Threadz do
 
         b.completed?.should be_false
 
-        i = 10
-        sleep 0.1
+        i.set(10)
+
+        5.times do
+          sleep 1 if !b.completed?
+        end
 
         b.completed?.should be_true
       end
 
       it "should support 'push'" do
-        i = 0
+        i = Threadz::AtomicInteger.new(0)
         b = @T.new_batch
-        b.push(lambda { i += 1 })
-        b.push([lambda { i += 1 }, lambda { i += 1 }])
+        b.push(lambda { i.increment })
+        b.push([lambda { i.increment }, lambda { i.increment }])
         b.wait_until_done
 
-        i.should == 3
+        i.value.should == 3
       end
 
       it "should support 'when_done'" do
-        i = ::Threadz::AtomicInteger.new(0)
+        i = Threadz::AtomicInteger.new(0)
         when_done_executed = false
         b = @T.new_batch(:latent => true)
 
@@ -218,6 +219,62 @@ describe Threadz do
         b.completed?.should be_true
         when_done_executed.should == 10
       end
+
+      context "when exceptions occur" do
+        it "should throw on #wait_until_done if no exception handler" do
+          b = @T.new_batch
+          b << lambda { raise }
+          expect { b.wait_until_done }.to raise_error(Threadz::JobError)
+        end
+        it "should execute the exception handler when given (and not throw in #wait_until_done)" do
+          error = nil
+          b = @T.new_batch(:error_handler => lambda { |e, ctrl| error = e })
+          b << lambda { raise }
+          b.wait_until_done
+          error.should_not be_nil
+        end
+        it "should retry up to 3 times by default" do
+          count = 0
+          b = @T.new_batch(:error_handler => lambda { |e, ctrl| count += 1 })
+          b << lambda { raise }
+          b.wait_until_done
+          count.should == 3
+        end
+        it "should retry up to the designated number of times" do
+          count = 0
+          # Try again up to 4 times (excluding the first one; that wasn't a "retry")
+          b = @T.new_batch(:error_handler => lambda { |e, ctrl| count += 1 }, :max_retries => 4)
+          b << lambda { raise }
+          b.wait_until_done
+          count.should == 4
+        end
+        it "should stash exceptions in the #job_errors field" do
+          b = @T.new_batch
+          b.job_errors.should be_empty
+          b << lambda { raise }
+          expect { b.wait_until_done }.to raise_error(Threadz::JobError)
+          b.job_errors.should_not be_empty
+        end
+        it "shouldn't hang if there's an exception in the error handler" do
+          error = nil
+          b = @T.new_batch(:error_handler => lambda { |e, ctrl| raise })
+          b << lambda { raise }
+          b.wait_until_done
+          b.job_errors.length.should == 3
+          b.error_handler_errors.length.should == 3
+        end
+        it "should allow you to respond to errors on a per-job basis" do
+          job1 = lambda { 1 + 2 }
+          job2 = lambda { raise "Hi" }
+          errors = {job1 => [], job2 => []}
+          b = @T.new_batch(:error_handler => lambda { |e, ctrl| errors[ctrl.job] << e }, :max_retries => 1)
+          b << job1
+          b << job2
+          b.wait_until_done
+          errors[job1].length.should == 0
+          errors[job2].length.should == 1
+        end
+      end
     end
   end
 end

data/threadz.gemspec

@@ -18,5 +18,5 @@ Gem::Specification.new do |s|
   s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
   s.require_paths = ["lib"]
 
-  s.add_development_dependency "rspec", "~> 1.0"
+  s.add_development_dependency "rspec", "~> 2.12"
 end

metadata

@@ -1,15 +1,15 @@
 --- !ruby/object:Gem::Specification
 name: threadz
 version: !ruby/object:Gem::Version
-  version: 1.0.0
-  prerelease: 
+  version: 1.1.0.rc2
+  prerelease: 6
 platform: ruby
 authors:
 - Max Aller
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-07-16 00:00:00.000000000 Z
+date: 2012-12-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
@@ -18,7 +18,7 @@ dependencies:
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: '1.0'
+        version: '2.12'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -26,7 +26,7 @@ dependencies:
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: '1.0'
+        version: '2.12'
 description: A Ruby threadpool library to handle threadpools and make batch jobs easier.
 email:
 - nanodeath@gmail.com
@@ -35,6 +35,7 @@ extensions: []
 extra_rdoc_files: []
 files:
 - .gitignore
+- .travis.yml
 - CHANGELOG
 - Gemfile
 - Gemfile.lock
@@ -44,7 +45,9 @@ files:
 - lib/threadz.rb
 - lib/threadz/atomic_integer.rb
 - lib/threadz/batch.rb
+- lib/threadz/control.rb
 - lib/threadz/directive.rb
+- lib/threadz/errors.rb
 - lib/threadz/sleeper.rb
 - lib/threadz/thread_pool.rb
 - lib/threadz/version.rb
@@ -69,9 +72,9 @@ required_ruby_version: !ruby/object:Gem::Requirement
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
-  - - ! '>='
+  - - ! '>'
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.3.1
 requirements: []
 rubyforge_project: threadz
 rubygems_version: 1.8.24