sisyphus 0.2.4 → 0.2.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: cba21106d39eba3304360aef31ce2a159d7a0213
-  data.tar.gz: e04b2f8ed6b63981e40c8f5bd99286ee1251f24e
+SHA256:
+  metadata.gz: 5b0d7aeac8761a528b7d084dcf254c284d541f1aabf3c728e35e5f25233fa8fe
+  data.tar.gz: 2358bceac26513eeab3f712138bbcd98cfda0fa9e3f3d38a1cdbbabacb762487
 SHA512:
-  metadata.gz: 68ec3f435ab8161d7510d849f4131b014b12c84660db5347c5fdc7c0717b1f3259efb979616d2f259f043d02861eab4103a5d971c533867e237055e2e3452c8e
-  data.tar.gz: a0e650e2792a69f15ca6b0b6e3c5ad1b3403533d5c5992ce01d70524fe43b545a294dbfb5e35a62fd132da09b51e74d6460f762c048f3f3783801b0f2495278a
+  metadata.gz: 66317b7e08c7c1de9125e1300811e808641fc76dc29230bcdff93ec66e1a1a1f8841b4565cdbd54709517501f283b81dbcb5e1ba4ceaeefe5f5ccfa7566437bd
+  data.tar.gz: cc2fb6929498e3c6ab44eddbd6aa7439cfef3357fdff42e11998f25941c2c44a522b6a7375800fa35068ddd2964bf2869e0f81b01cdafc08ed2546088299f327

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--format progress

data/lib/sisyphus/forking_execution_strategy.rb

@@ -1,56 +1,23 @@
 module Sisyphus
   class ForkingExecutionStrategy
 
-    attr_reader :logger
-
-    def initialize(logger)
-      @logger = logger
-    end
-
-    def execute(job, error_handler = ->{})
+    def execute(job, error_handler = ->(process_name, error) {})
       if @child_pid = fork
-        error_handler.call unless success?
+        ChildProcess.new(@child_pid).success?
       else
-        perform job
-      end
-    end
-
-    class ChildProcess
-      attr_reader :pid
-
-      def initialize(pid)
-        @pid = pid
-      end
-
-      def success?
-        status.success?
-      end
-
-      private
-
-      def status
-        _, status = ::Process.waitpid2 pid
-        status
+        perform job, error_handler
       end
     end
 
     private
 
-    def success?
-      child_process.success?
-    end
-
-    def child_process
-      ChildProcess.new(@child_pid)
-    end
-
-    def perform(job)
+    def perform(job, error_handler)
       self.process_name = "Child of worker #{::Process.ppid}"
       begin
         job.perform
         exit! 0
       rescue ::Exception => e
-        logger.warn(process_name) { e }
+        error_handler.call process_name, e
         exit! 1
       end
     end
@@ -63,5 +30,23 @@ module Sisyphus
       $0 = name
     end
 
+    class ChildProcess
+      attr_reader :pid
+
+      def initialize(pid)
+        @pid = pid
+      end
+
+      def success?
+        status.success?
+      end
+
+      def status
+        _, status = ::Process.waitpid2 pid
+        status
+      end
+
+    end
+
   end
 end

data/lib/sisyphus/master.rb

@@ -1,7 +1,8 @@
 require 'timeout'
-require_relative './forking_execution_strategy'
 require_relative './worker'
+require_relative './forking_execution_strategy'
 require_relative './null_logger'
+require_relative './worker_pool'
 
 module Sisyphus
   class Master
@@ -9,13 +10,15 @@ module Sisyphus
 
     HANDLED_SIGNALS = [:INT, :TTIN, :TTOU]
 
-    attr_reader :logger, :job, :number_of_workers
+    attr_reader :logger, :job, :number_of_workers, :execution_strategy
 
     def initialize(job, options = {})
       self.number_of_workers = options.fetch :workers, 0
       @logger = options.fetch(:logger) { NullLogger.new }
-      @execution_strategy = options.fetch(:execution_strategy) { ForkingExecutionStrategy }
-      @workers = []
+      @execution_strategy = options.fetch(:execution_strategy) { ForkingExecutionStrategy.new }
+
+      @worker_pool = options.fetch(:worker_pool) { WorkerPool.new self }
+
       @job = job
 
       self_reader, self_writer = IO.pipe
@@ -27,33 +30,15 @@ module Sisyphus
     def start
       trap_signals
       number_of_workers.times do
-        spawn_worker
+        @worker_pool.spawn_worker
         sleep rand(1000).fdiv(1000)
       end
       puts "Sisyphus::Master started with PID: #{Process.pid}"
       watch_for_output
     end
 
-    def spawn_worker
-      reader, writer = IO.pipe
-      if wpid = fork
-        writer.close
-        workers << { pid: wpid, reader: reader }
-      else
-        reader.close
-        self.process_name = "Worker #{Process.pid}"
-        worker = create_worker(writer)
-        start_worker worker
-      end
-    end
-
-    def start_worker(worker)
-      worker.setup
-      worker.start
-    rescue Exception => e
-      worker.error_handler.call
-      logger.warn(process_name) { e }
-      exit! 0
+    def create_worker
+      Worker.new(job, execution_strategy, logger)
     end
 
     def stop_worker(wpid)
@@ -70,7 +55,7 @@ module Sisyphus
         Timeout.timeout(30) do
           watch_for_shutdown while worker_count > 0
         end
-      rescue e
+      rescue Timeout::Error => e
         p "Timeout reached:", e
       end
     end
@@ -81,20 +66,15 @@ module Sisyphus
 
     private
 
-    attr_reader :workers
     attr_writer :number_of_workers
 
-    def create_worker(writer)
-      Worker.new(job, writer, execution_strategy)
-    end
-
-    def execution_strategy
-      @execution_strategy.new logger
+    def workers
+      @worker_pool.workers
     end
 
     def watch_for_shutdown
       wpid, _ = Process.wait2
-      worker = @workers.find { |w| w.fetch(:pid) == wpid }
+      worker = workers.find { |w| w.fetch(:pid) == wpid }
       worker.fetch(:reader).close
       workers.delete worker
       wpid
@@ -112,7 +92,7 @@ module Sisyphus
     end
 
     def process_signal_queue
-      handle_signal(Thread.main[:signal_queue].shift) until Thread.main[:signal_queue].empty?
+      handle_signal(signal_queue.shift) until signal_queue.empty?
     end
 
     def process_pipes(pipes)
@@ -131,7 +111,7 @@ module Sisyphus
     end
 
     def respawn_worker(wpid)
-      spawn_worker
+      @worker_pool.spawn_worker
       stop_worker wpid
       watch_for_shutdown
     end
@@ -161,7 +141,7 @@ module Sisyphus
     end
 
     def queue_signal(signal)
-      Thread.main[:signal_queue] << signal
+      signal_queue << signal
       @selfpipe[:writer].write_nonblock('.')
     rescue Errno::EAGAIN
       # Ignore
@@ -191,7 +171,7 @@ module Sisyphus
 
     def handle_ttin
       self.number_of_workers += 1
-      spawn_worker
+      @worker_pool.spawn_worker
     end
 
     def handle_ttou
@@ -209,12 +189,8 @@ module Sisyphus
       @stopping
     end
 
-    def process_name=(name)
-      $0 = name
-    end
-
-    def process_name
-      $0
+    def signal_queue
+      Thread.main[:signal_queue]
     end
   end
 end

data/lib/sisyphus/simple_execution_strategy.rb

@@ -1,17 +1,10 @@
 module Sisyphus
   class SimpleExecutionStrategy
 
-    attr_reader :logger
-
-    def initialize(logger)
-      @logger = logger
-    end
-
-    def execute(job, error_handler = ->{})
+    def execute(job, error_handler = ->(name, error) {})
       job.perform
     rescue Exception => e
-      logger.warn(process_name) { e }
-      error_handler.call
+      error_handler.call process_name, e
     end
 
     private

data/lib/sisyphus/worker.rb

@@ -2,25 +2,34 @@ module Sisyphus
   class Worker
     UNCAUGHT_ERROR = '.'
 
-    attr_reader :execution_strategy, :job, :output
+    attr_reader :logger, :execution_strategy, :job, :output, :to_master
 
-    def initialize(job, output, execution_strategy)
+    def initialize(job, execution_strategy, logger)
       @job = job
-      @output = output
+      @to_master, @output = IO.pipe
       @execution_strategy = execution_strategy
+      @logger = logger
+      @set_up = false
     end
 
-    def setup
-      job.setup if job.respond_to? :setup
+    def start
+      setup
+      run
     end
 
-    def start
+    def setup
       trap_signals
+      job.setup if job.respond_to? :setup
+      setup_done
+    rescue Exception => e
+      error_handler.call "Setup", e
+    end
 
+    def run
       loop do
         break if stopped?
         perform_job
-      end
+      end if set_up?
 
       exit! 0
     end
@@ -30,27 +39,45 @@ module Sisyphus
     end
 
     def error_handler
-      -> {
+      -> (name, error) {
+        return if stopped?
         begin
-          output.write UNCAUGHT_ERROR unless stopped?
+          logger.warn(name) { error }
+          output.write UNCAUGHT_ERROR
         rescue Errno::EAGAIN, Errno::EINTR
           # Ignore
         end
       }
     end
 
+    def stop
+      @stopped = true
+    end
+
+    def atfork_parent
+      output.close
+    end
+
+    def atfork_child
+      to_master.close
+    end
+
     private
 
+    def set_up?
+      @set_up
+    end
+
+    def setup_done
+      @set_up = true
+    end
+
     def trap_signals
       Signal.trap('INT') do
         stop
       end
     end
 
-    def stop
-      @stopped = true
-    end
-
     def stopped?
       @stopped
     end

data/lib/sisyphus/worker_pool.rb

@@ -0,0 +1,36 @@
+require_relative './worker'
+
+module Sisyphus
+  class WorkerPool
+
+    attr_reader :workers, :worker_factory
+
+    def initialize(worker_factory)
+      @worker_factory = worker_factory
+      @workers = []
+    end
+
+    def spawn_worker
+      worker = create_worker
+      if wpid = fork
+        worker.atfork_parent
+        workers << { pid: wpid, reader: worker.to_master }
+      else
+        worker.atfork_child
+        self.process_name = "Worker #{Process.pid}"
+        worker.start
+      end
+    end
+
+    private
+
+    def create_worker
+      worker_factory.create_worker
+    end
+
+    def process_name=(name)
+      $0 = name
+    end
+
+  end
+end

data/lib/sisyphus.rb

@@ -1,8 +1,6 @@
 require "version"
-require 'sisyphus/forking_execution_strategy'
 require 'sisyphus/simple_execution_strategy'
 require 'sisyphus/job'
-require 'sisyphus/worker'
 require 'sisyphus/master'
 
 module Sisyphus

data/lib/version.rb

@@ -1,3 +1,3 @@
 module Sisyphus
-  VERSION = "0.2.4"
+  VERSION = "0.2.5"
 end

data/sisyphus.gemspec

@@ -18,6 +18,8 @@ Gem::Specification.new do |spec|
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
   spec.require_paths = ["lib"]
 
+  spec.required_ruby_version = '>= 1.9.3'
+
   spec.add_development_dependency "bundler", "~> 1.3"
   spec.add_development_dependency "rake", "~> 10.0"
   spec.add_development_dependency "rspec", "~> 2.14"

data/spec/sisyphus/forking_execution_strategy_spec.rb

@@ -1,50 +1,37 @@
+require 'spec_helper'
 require_relative '../../lib/sisyphus/forking_execution_strategy'
 
 module Sisyphus
   describe ForkingExecutionStrategy do
 
-    let(:logger) { double :logger }
     let(:job) { double :job }
-    let(:error_handler) { double :error_handler }
-    let(:strategy) { ForkingExecutionStrategy.new logger }
+    let(:error_handler) { ->(name, raised_error) {} }
+    let(:strategy) { ForkingExecutionStrategy.new }
     let(:child_pid) { 1 }
+    let(:status) { double :process_status }
 
     it 'forks on execution' do
-      allow(strategy).to receive(:success?) { true }
+      allow(Process).to receive(:waitpid2).with(child_pid) { [child_pid, status] }
+      allow(status).to receive(:success?) { true }
       expect(strategy).to receive(:fork) { child_pid }
       strategy.execute job
     end
 
     context 'in the parent process' do
 
-      let(:child_process) { double :child_process }
-
       before :each do
         allow(strategy).to receive(:fork) { child_pid }
+        allow(status).to receive(:success?) { true }
       end
 
-      it 'calls error_handler if execution is unsuccessful' do
-        allow(strategy).to receive(:success?) { false }
-        expect(error_handler).to receive(:call)
-        strategy.execute job, error_handler
-      end
-
-      it 'does not call error_handler if execution is successful' do
-        allow(strategy).to receive(:success?) { true }
-        expect(error_handler).not_to receive(:call)
-        strategy.execute job, error_handler
-      end
-
-      it 'instantiates a child_process' do
-        allow(child_process).to receive(:success?) { true }
-        expect(ForkingExecutionStrategy::ChildProcess).to receive(:new).with(child_pid) { child_process }
-        strategy.execute job, error_handler
+      it 'waits for the execution to finish' do
+        expect(Process).to receive(:waitpid2).with(child_pid) { [child_pid, status] }
+        strategy.execute(job, error_handler)
       end
 
-      it 'checks if the child process is successful' do
-        expect(child_process).to receive(:success?) { true }
-        allow(strategy).to receive(:child_process) { child_process }
-        strategy.execute job, error_handler
+      it 'gets the status of the child process' do
+        allow(Process).to receive(:waitpid2) { [child_pid, status] }
+        expect(strategy.execute job, error_handler).to eq(true)
       end
 
     end
@@ -75,47 +62,36 @@ module Sisyphus
         strategy.execute job
       end
 
-      it 'logs the exception if job is performed and it fails' do
-        process_name = "foobarbaz"
-        exception_message = "foo"
-        allow(strategy).to receive(:process_name) { process_name }
-        allow(job).to receive(:perform) { raise Exception, exception_message }
-        expect(logger).to receive(:warn).with(process_name)
-        strategy.execute job
-      end
-
-      it 'exits with a 1 status if job is performed and it fails' do
-        process_name = "foobarbaz"
-        allow(strategy).to receive(:process_name) { process_name }
-        allow(job).to receive(:perform) { raise "foo" }
-        allow(logger).to receive(:warn)
-        expect(strategy).to receive(:exit!).with(1)
-        strategy.execute job
+      it 'does not call error_handler if execution is successful' do
+        allow(strategy).to receive(:exit!).with(0)
+        strategy.execute job, ->(n, e) { fail "Should not be called" }
       end
 
-    end
+      context 'when the job#perform fails' do
 
-    describe ForkingExecutionStrategy::ChildProcess do
+        let(:process_name) { "foobarbaz" }
+        let(:exception) { Exception.new("foo") }
 
-      let(:pid) { 1 }
-      let(:status) { double :status }
-      let(:child_process) { ForkingExecutionStrategy::ChildProcess.new pid }
+        before :each do
+          allow(strategy).to receive(:process_name) { process_name }
+          allow(job).to receive(:perform).and_raise(exception)
+        end
 
-      it 'waits for the process to finish' do
-        expect(Process).to receive(:waitpid2).with pid do
-          allow(status).to receive(:success?) { true }
-          [pid, status]
+        it 'exits with a 1 status if job is performed and it fails' do
+          expect(strategy).to receive(:exit!).with(1)
+          strategy.execute job, error_handler
         end
-        child_process.success?
-      end
 
-      it 'asks status about its success' do
-        allow(Process).to receive(:waitpid2).with pid do
-          expect(status).to receive(:success?) { true }
-          [pid, status]
+        it 'calls error_handler if execution is unsuccessful' do
+          allow(strategy).to receive(:exit!)
+          strategy.execute job, ->(name, raised_error) {
+            expect(name).to eq(process_name)
+            expect(raised_error).to eq(exception)
+          }
         end
-        child_process.success?
+
       end
+
     end
 
   end

data/spec/sisyphus/master_spec.rb

@@ -1,8 +1,11 @@
+require 'spec_helper'
 require_relative '../../lib/sisyphus/master'
 
 module Sisyphus
   describe Master do
-    subject(:master) { Master.new job }
+    subject(:master) { Master.new job, worker_pool: worker_pool }
+
+    let(:worker_pool) { double :worker_pool }
 
     before(:each) {
       allow(master).to receive(:puts)
@@ -12,186 +15,98 @@ module Sisyphus
     let(:job) { double(:job) }
     let(:pipes) { [double(:reader_pipe), double(:writer_pipe)] }
 
-    describe 'when receiving the spawn_worker message' do
-      it 'forks' do
-        expect(master).to receive(:fork) { 666 }
-        master.spawn_worker
-      end
-
-      describe 'in the worker process' do
-        let(:worker) { double :worker }
-
-        before :each do
-          allow(master).to receive(:fork) { nil }
-          allow(IO).to receive(:pipe) { pipes }
-          allow(pipes.first).to receive(:close)
-          allow(Process).to receive(:pid) { 666 }
-          allow(master).to receive(:exit!)
-          allow(Worker).to receive(:new) { worker }
-          allow(worker).to receive(:setup)
-          allow(worker).to receive(:start)
-        end
-
-        it 'should setup the worker' do
-          expect(worker).to receive(:setup)
-          master.spawn_worker
-        end
+    it 'creates a worker' do
+      execution_strategy = double :execution_strategy
+      master = Master.new job
+      allow(master).to receive(:execution_strategy) { execution_strategy }
+      worker = master.create_worker
+      expect(worker.job).to eq(job)
+      expect(worker.execution_strategy).to eq(execution_strategy)
+    end
 
-        it 'should rename the process' do
-          expect(master).to receive(:process_name=).with("Worker #{666}")
-          master.spawn_worker
-        end
+    describe 'when it has running workers' do
 
-        it 'starts a worker after forking' do
-          expect(worker).to receive(:start)
-          master.spawn_worker
-        end
+      let(:workers) { double :workers }
 
-        it 'gives the writer pipe to the worker' do
-          execution_strategy = double :execution_strategy
-          allow(master).to receive(:execution_strategy) { execution_strategy }
-          expect(Worker).to receive(:new).with(job, pipes.last, execution_strategy) { worker }
-          master.spawn_worker
-        end
+      it 'stops all workers when receiving stop_all' do
+        allow(worker_pool).to receive(:workers) { workers }
+        allow(workers).to receive(:each).and_yield({ pid: 666 }).and_yield({ pid: 667 })
+        allow(workers).to receive(:length).and_return(2, 1, 0)
 
-        it 'closes the reader pipe' do
-          expect(pipes.first).to receive(:close)
-          master.spawn_worker
-        end
+        expect(master).to receive(:stop_worker).with(666).ordered
+        expect(master).to receive(:stop_worker).with(667).ordered
 
-        describe 'when an exception is raised' do
-          let(:logger) { double(:logger) }
-
-          it 'should log the exception' do
-            allow(worker).to receive(:error_handler) { ->{} }
-            allow(master).to receive(:logger) { logger }
-            allow(worker).to receive(:setup) { raise :raised_by_spec }
-            expect(logger).to receive(:warn)
-            master.spawn_worker
-          end
-
-          it 'should write to the writer pipe' do
-            allow(master).to receive(:logger) { logger }
-            allow(worker).to receive(:setup) { raise :raised_by_spec }
-            allow(logger).to receive(:warn)
-            expect(worker).to receive(:error_handler) { ->{} }
-            master.spawn_worker
-          end
-        end
+        master.stop_all
       end
 
-      describe 'in the master process' do
+      describe 'and it receives stop_worker message' do
         before :each do
-          allow(master).to receive(:fork) { 666 }
-          allow(IO).to receive(:pipe) { pipes }
-          allow(pipes.last).to receive(:close)
-        end
-
-        it 'increases worker_count' do
-          master.spawn_worker
-          expect(master.worker_count).to eq(1)
-        end
-
-        it 'should open a pipe' do
-          expect(IO).to receive(:pipe) { pipes }
-          master.spawn_worker
-        end
-
-        it 'should close the writer pipe' do
-          expect(pipes.last).to receive(:close)
-          master.spawn_worker
+          allow(worker_pool).to receive(:workers) { workers }
+          allow(workers).to receive(:find) { |&block| block.call({ pid: 666 }) }
         end
-      end
-    end
-
-    describe 'when it has running workers' do
-      before :each do
-        pipes.each { |p| allow(p).to receive(:close) }
-        allow(IO).to receive(:pipe) { pipes }
-        allow(master).to receive(:fork) { 666 }
-        master.spawn_worker
-        allow(Process).to receive(:kill).with('INT', 666)
-        allow(Process).to receive(:waitpid2).with(666)
-      end
 
-      describe 'and it receives stop_worker message' do
         it 'kills a child with the INT signal' do
           expect(Process).to receive(:kill).with('INT', 666)
           master.stop_worker(666)
         end
-      end
-
-      it 'stops all workers when receiving stop_all' do
-        allow(Process).to receive(:kill).with('INT', 666)
-        allow(Process).to receive(:wait2) { 666 }
-
-        expect(master).to receive(:stop_worker).with(666).exactly(master.worker_count).times.and_call_original
 
-        master.stop_all
-      end
-    end
-
-    describe 'when there are no running workers' do
-      describe 'and it receives stop_worker' do
-        it 'raises an error' do
-          expect { master.stop_worker(666) }.not_to raise_error
+        it 'kills nothing if no worker corresponds to the pid' do
+          expect(Process).not_to receive(:kill).with('INT', 667)
+          master.stop_worker(667)
         end
       end
 
-      describe 'and it receives stop_all' do
-        it 'does nothing' do
-          expect(master).not_to receive(:stop_worker)
-          master.stop_all
-        end
-      end
     end
 
     it 'starts the specified number of workers when started' do
-      master = Master.new nil, workers: 3
+      master = Master.new nil, workers: 3, worker_pool: worker_pool
       allow(master).to receive(:puts)
       allow(master).to receive(:watch_for_output)
-      expect(master).to receive(:spawn_worker).exactly(3).times
+      allow(master).to receive(:sleep)
+      expect(worker_pool).to receive(:spawn_worker).exactly(3).times
       master.start
     end
 
     describe 'when number of workers is zero' do
-      let(:master) { Master.new nil, workers: 0 }
+      let(:master) { Master.new nil, workers: 0, worker_pool: worker_pool }
 
       before(:each) { allow(master).to receive(:puts) }
 
       it 'should not start workers' do
+        allow(master).to receive(:trap_signals)
         allow(master).to receive(:watch_for_output)
-        expect(master).not_to receive(:spawn_worker)
+        expect(worker_pool).not_to receive(:spawn_worker)
         master.start
       end
     end
 
     it 'attaches a signal handler when started' do
+      allow(worker_pool).to receive(:spawn_worker)
+      allow(master).to receive(:watch_for_output)
+
       expect(Signal).to receive(:trap).with(:TTIN)
       expect(Signal).to receive(:trap).with(:INT)
       expect(Signal).to receive(:trap).with(:TTOU)
-      allow(master).to receive(:spawn_worker)
-      allow(master).to receive(:watch_for_output)
+
       master.start
     end
 
     it 'should watch for output' do
-      allow(master).to receive(:spawn_worker)
+      allow(worker_pool).to receive(:spawn_worker)
+      allow(master).to receive(:trap_signals)
       expect(master).to receive(:watch_for_output)
       master.start
     end
 
     it 'can resolve a wpid from a reader pipe' do
-      allow(IO).to receive(:pipe) { pipes }
-      pipes.each { |p| allow(p).to receive(:close) }
-      allow(pipes.first).to receive(:fileno) { 213 }
-      allow(master).to receive(:fork) { 666 }
-      master.spawn_worker
-
-      expect(master.send(:worker_pid, pipes.first)).to eq(666)
+      pipe = double :pipe
+      allow(pipe).to receive(:fileno) { 123 }
+      allow(worker_pool).to receive(:workers) { [{ pid: 666, reader: pipe }] }
+      expect(master.send(:worker_pid, pipe)).to eq(666)
     end
 
     it 'raises if it can\'t resolve a wpid from a reader pipe' do
+      allow(worker_pool).to receive(:workers) { [] }
       expect { master.send(:worker_pid, pipes.first) }.to raise_error("Unknown worker pipe")
     end
   end

data/spec/sisyphus/simple_execution_strategy_spec.rb

@@ -1,32 +1,28 @@
+require 'spec_helper'
 require_relative '../../lib/sisyphus/simple_execution_strategy'
 
 module Sisyphus
   describe SimpleExecutionStrategy do
 
-    let(:logger) { double :logger }
     let(:job) { double :job }
-    let(:strategy) { SimpleExecutionStrategy.new(logger) }
+    let(:strategy) { SimpleExecutionStrategy.new }
 
     it 'should perform the job when executed' do
       expect(job).to receive(:perform)
       strategy.execute job
     end
 
-    it 'should log exceptions if the job fails' do
+    it 'should call the error_handler if the job fails' do
       error_message = "This is a horrible failure.. The Universe is probably ending!"
+      error = Exception.new(error_message)
       process_name = "uber awesome process name"
-      allow(job).to receive(:perform) { fail Exception, error_message }
+      allow(job).to receive(:perform) { fail error }
       allow(strategy).to receive(:process_name) { process_name }
-      expect(logger).to receive(:warn).with(process_name)
-      strategy.execute job
+      strategy.execute job, ->(name, raised_error) {
+        expect(name).to eq(process_name)
+        expect(raised_error).to eq(error)
+      }
     end
 
-    it 'should call the error_handler if the job fails' do
-      allow(job).to receive(:perform) { fail "foo" }
-      allow(logger).to receive(:warn)
-      error_handler = double :error_handler
-      expect(error_handler).to receive(:call)
-      strategy.execute job, error_handler
-    end
   end
 end

data/spec/sisyphus/worker_pool_spec.rb

@@ -0,0 +1,82 @@
+require 'spec_helper'
+require_relative '../../lib/sisyphus/master'
+require_relative '../../lib/sisyphus/worker_pool'
+
+module Sisyphus
+  describe WorkerPool do
+
+    subject(:worker_pool) { WorkerPool.new worker_factory }
+
+    describe 'when receiving the spawn_worker message' do
+
+      let(:job) { double :job }
+      let(:worker_factory) { Master.new(job) }
+      let(:pipes) { [double(:output), double(:input)] }
+
+      it 'retrieves a worker from the worker_factory' do
+        allow(worker_pool).to receive(:fork) { 3267 }
+        expect(worker_factory).to receive(:create_worker).and_call_original
+        worker_pool.spawn_worker
+      end
+
+      it 'forks' do
+        expect(worker_pool).to receive(:fork) { 666 }
+        worker_pool.spawn_worker
+      end
+
+      describe 'in the worker process' do
+
+        let(:worker) { double :worker }
+
+        before :each do
+          allow(worker_pool).to receive(:fork) { nil }
+          allow(worker_pool).to receive(:process_name=)
+          allow(worker).to receive(:start)
+          allow(worker).to receive(:atfork_child)
+        end
+
+        it 'runs Worker#atfork_child' do
+          allow(worker_factory).to receive(:create_worker) { worker }
+          expect(worker).to receive(:atfork_child).with(no_args)
+          worker_pool.spawn_worker
+        end
+
+        it 'renames the process' do
+          allow(worker_factory).to receive(:create_worker) { worker }
+          expect(worker_pool).to receive(:process_name=).with("Worker #{Process.pid}")
+          worker_pool.spawn_worker
+        end
+
+        it 'starts the worker' do
+          allow(worker_factory).to receive(:create_worker) { worker }
+          allow(worker).to receive(:atfork_child)
+          expect(worker).to receive(:start)
+          worker_pool.spawn_worker
+        end
+
+      end
+
+      describe 'in the master process' do
+
+        before :each do
+          allow(worker_pool).to receive(:fork) { Process.pid }
+          allow(pipes.last).to receive(:close)
+          allow(IO).to receive(:pipe) { pipes }
+        end
+
+        it 'closes the input pipe' do
+          worker = double :worker
+          allow(worker).to receive(:to_master)
+          allow(worker_factory).to receive(:create_worker) { worker }
+          expect(worker).to receive(:atfork_parent).with(no_args)
+          worker_pool.spawn_worker
+        end
+
+        it 'adds the worker pid and output pipe to the list of workers' do
+          expect(worker_pool.workers).to receive(:<<).with({ pid: Process.pid, reader: pipes.first })
+          worker_pool.spawn_worker
+        end
+      end
+    end
+  end
+end

data/spec/sisyphus/worker_spec.rb

@@ -1,23 +1,38 @@
+require 'spec_helper'
 require_relative '../../lib/sisyphus/worker'
 
 module Sisyphus
   describe Worker do
     let(:job) { double :job }
-    let(:output) { double :pipe }
     let(:execution_strategy) { double :execution_strategy }
-    let(:worker) { Worker.new job, output, execution_strategy }
+    let(:logger) { double :logger }
 
-    it 'traps signals when started' do
-      worker.stub :exit!
-      worker.instance_variable_set(:@stopped, true)
-      worker.should_receive :trap_signals
+    subject(:worker) { Worker.new job, execution_strategy, logger }
+
+    it 'sets up itself and executes run when started' do
+      expect(worker).to receive(:setup).ordered
+      expect(worker).to receive(:run).ordered
       worker.start
     end
 
-    it 'exits when it has been stopped' do
-      worker.instance_variable_set(:@stopped, true)
-      worker.should_receive :exit!
-      worker.start
+    it 'traps INT signals before setting up the job' do
+      allow(job).to receive(:respond_to?).with(:setup) { true }
+      expect(Signal).to receive(:trap).with('INT').ordered
+      expect(job).to receive(:setup).ordered
+      worker.setup
+    end
+
+    it 'does not perform the job when it has been stopped' do
+      worker.stop
+      allow(worker).to receive(:exit!)
+      expect(worker).not_to receive(:perform_job)
+      worker.run
+    end
+
+    it 'will not run if it has not been set up' do
+      expect(worker).not_to receive(:perform_job)
+      allow(worker).to receive(:exit!)
+      worker.run
     end
 
     it 'uses execution_strategy to perform the job' do
@@ -31,37 +46,82 @@ module Sisyphus
       worker.perform_job
     end
 
+    it 'only closes the output in atfork_parent' do
+      expect(worker.output).to receive(:close)
+      expect(worker.to_master).not_to receive(:close)
+      worker.atfork_parent
+    end
+
+    it 'only closes the to_master in atfork_child' do
+      expect(worker.to_master).to receive(:close)
+      expect(worker.output).not_to receive(:close)
+      worker.atfork_child
+    end
+
     context 'the error_handler' do
 
       it 'writes the UNCAUGHT_ERROR to output' do
-        expect(output).to receive(:write).with Worker::UNCAUGHT_ERROR
-        worker.error_handler.call
+        allow(logger).to receive(:warn)
+        expect(worker.output).to receive(:write).with Worker::UNCAUGHT_ERROR
+        worker.error_handler.call(:name, :error)
+      end
+
+      it 'logs the error being thrown' do
+        the_name = :the_name
+        the_exception = :the_exception
+        expect(worker.logger).to receive(:warn) do |name, &block|
+          expect(name).to eq(the_name)
+          expect(block.call).to eq(the_exception)
+        end
+        worker.error_handler.call(the_name, the_exception)
       end
 
       it 'does not write UNCAUGHT_ERROR to output if the worker is stopped' do
         allow(worker).to receive(:stopped?) { true }
-        expect(output).to_not receive(:write)
-        worker.error_handler.call
-        expect(output).to_not receive(:write)
-        worker.error_handler.call
+        expect(worker.output).to_not receive(:write)
+        worker.error_handler.call(:name, :error)
+        expect(worker.output).to_not receive(:write)
+        worker.error_handler.call(:name, :error)
       end
 
     end
 
     context 'when job does not respond to :setup' do
       it 'does not call job.setup' do
-        job.stub(:respond_to?).with(:setup) { false }
-        job.should_not_receive :setup
+        allow(job).to receive(:respond_to?).with(:setup) { false }
+        expect(job).not_to receive(:setup)
         worker.setup
       end
     end
 
     context 'when job responds to :setup' do
+
+      before :each do
+        allow(job).to receive(:respond_to?).with(:setup) { true }
+      end
+
       it 'sets up the job' do
-        job.stub(:respond_to?).with(:setup) { true }
-        job.should_receive :setup
+        expect(job).to receive(:setup)
         worker.setup
       end
+
+      context 'and job#setup raises an exception' do
+
+        before :each do
+          allow(job).to receive(:setup).and_raise(Exception)
+          allow(logger).to receive(:warn)
+        end
+
+        it 'handles the exception' do
+          expect { worker.setup }.not_to raise_error(Exception)
+        end
+
+        it 'calls the error_handler in the rescue block' do
+          expect(worker.output).to receive(:write).with(Worker::UNCAUGHT_ERROR)
+          worker.setup
+        end
+
+      end
     end
 
   end

data/spec/spec_helper.rb

@@ -0,0 +1,17 @@
+# This file was generated by the `rspec --init` command. Conventionally, all
+# specs live under a `spec` directory, which RSpec adds to the `$LOAD_PATH`.
+# Require this file using `require "spec_helper"` to ensure that it is only
+# loaded once.
+#
+# See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
+RSpec.configure do |config|
+  config.treat_symbols_as_metadata_keys_with_true_values = true
+  config.run_all_when_everything_filtered = true
+  config.filter_run :focus
+
+  # Run specs in random order to surface order dependencies. If you find an
+  # order dependency and want to debug it, you can fix the order by providing
+  # the seed, which is printed after each run.
+  #     --seed 1234
+  config.order = 'random'
+end

metadata

@@ -1,55 +1,54 @@
 --- !ruby/object:Gem::Specification
 name: sisyphus
 version: !ruby/object:Gem::Version
-  version: 0.2.4
+  version: 0.2.5
 platform: ruby
 authors:
 - Rasmus Bang Grouleff
-autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-03-31 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '1.3'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '1.3'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '10.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '10.0'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '2.14'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '2.14'
 description: A tiny library for spawning worker processes
@@ -59,7 +58,8 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- .gitignore
+- ".gitignore"
+- ".rspec"
 - Gemfile
 - Gemfile.lock
 - LICENSE.txt
@@ -73,38 +73,40 @@ files:
 - lib/sisyphus/simple_execution_strategy.rb
 - lib/sisyphus/sleep.rb
 - lib/sisyphus/worker.rb
+- lib/sisyphus/worker_pool.rb
 - lib/version.rb
 - sisyphus.gemspec
 - spec/sisyphus/forking_execution_strategy_spec.rb
 - spec/sisyphus/master_spec.rb
 - spec/sisyphus/simple_execution_strategy_spec.rb
+- spec/sisyphus/worker_pool_spec.rb
 - spec/sisyphus/worker_spec.rb
+- spec/spec_helper.rb
 homepage: https://github.com/rbgrouleff/sisyphus
 licenses:
 - Apache License 2.0
 metadata: {}
-post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>='
+  - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.9.3
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.1.5
-signing_key: 
+rubygems_version: 3.7.2
 specification_version: 4
 summary: A tiny library for spawning worker processes
 test_files:
 - spec/sisyphus/forking_execution_strategy_spec.rb
 - spec/sisyphus/master_spec.rb
 - spec/sisyphus/simple_execution_strategy_spec.rb
+- spec/sisyphus/worker_pool_spec.rb
 - spec/sisyphus/worker_spec.rb
+- spec/spec_helper.rb