sisyphus 0.2.3 → 0.2.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 1a96cdf599669e601888f70c06de7ae280b86fc6
-  data.tar.gz: 601d5544f93601e4b9aac5df9dad122040742300
+  metadata.gz: cba21106d39eba3304360aef31ce2a159d7a0213
+  data.tar.gz: e04b2f8ed6b63981e40c8f5bd99286ee1251f24e
 SHA512:
-  metadata.gz: 731a337d88e4ca319a824c2fdb44f2343808adfd1a15762bfb6a2417666c7aca8182b2859bf495c33f4c48c170091061b36f18fb0088281258288fe677a5d55a
-  data.tar.gz: e4c2bcbfb26349558d25d705fb69f370cc05e4040f8f46bc4430794b448b1e621bcece6988b68318a2ee6dba128594001cd42f2212bf52ac9ec79125e9704afc
+  metadata.gz: 68ec3f435ab8161d7510d849f4131b014b12c84660db5347c5fdc7c0717b1f3259efb979616d2f259f043d02861eab4103a5d971c533867e237055e2e3452c8e
+  data.tar.gz: a0e650e2792a69f15ca6b0b6e3c5ad1b3403533d5c5992ce01d70524fe43b545a294dbfb5e35a62fd132da09b51e74d6460f762c048f3f3783801b0f2495278a

data/README.md

@@ -32,6 +32,10 @@ Getting started
      master or workers encounter. The logger should quack like a
      `Logger` instance from the Ruby stdlib. Exceptions are logged with the
      `Logger::WARN` level.
+   * `:execution_strategy` which can either be `Sisyphus::SimpleExecutionStrategy` or
+     `Sisyphus::ForkingExecutionStrategy`. This is the strategy used by
+     workers when performing the job. The default is
+     `Sisyphus::ForkingExecutionStrategy`.
 4. You can start workers by doing one of the following things:
    * Send the `start` message to the master, if the `options` hash was
      provided. This starts a run loop which monitors workers and
@@ -63,8 +67,6 @@ Things missing
 Sisyphus is still very much in its infancy, though the ambition isn't to build a [Resque] [resque] clone, but
 instead build as small a tool with as few features as possible.
 
-[resque]: https://github.com/resque/resque
-
 There are, however, still features that are missing:
 
 - Force killing workers
@@ -76,6 +78,7 @@ There are, however, still features that are missing:
 - Some sort of reaping of worker processes
 - Documentation
 
+[resque]: https://github.com/resque/resque
 [unicorn]: http://unicorn.bogomips.org/
 
 Contributing

data/Rakefile

@@ -5,8 +5,10 @@ task :sleeper do
   gem 'sisyphus'
   require 'sisyphus'
   require 'sisyphus/sleep'
+  require 'logger'
 
+  logger = Logger.new(STDOUT)
   job = Sisyphus::Sleep.new
-  master = Sisyphus::Master.new job, workers: 2
+  master = Sisyphus::Master.new job, workers: 2, logger: logger
   master.start
 end

data/lib/sisyphus.rb

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

data/lib/sisyphus/forking_execution_strategy.rb

@@ -0,0 +1,67 @@
+module Sisyphus
+  class ForkingExecutionStrategy
+
+    attr_reader :logger
+
+    def initialize(logger)
+      @logger = logger
+    end
+
+    def execute(job, error_handler = ->{})
+      if @child_pid = fork
+        error_handler.call unless 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
+      end
+    end
+
+    private
+
+    def success?
+      child_process.success?
+    end
+
+    def child_process
+      ChildProcess.new(@child_pid)
+    end
+
+    def perform(job)
+      self.process_name = "Child of worker #{::Process.ppid}"
+      begin
+        job.perform
+        exit! 0
+      rescue ::Exception => e
+        logger.warn(process_name) { e }
+        exit! 1
+      end
+    end
+
+    def process_name
+      $0
+    end
+
+    def process_name=(name)
+      $0 = name
+    end
+
+  end
+end

data/lib/sisyphus/master.rb

@@ -1,4 +1,5 @@
 require 'timeout'
+require_relative './forking_execution_strategy'
 require_relative './worker'
 require_relative './null_logger'
 
@@ -8,11 +9,12 @@ module Sisyphus
 
     HANDLED_SIGNALS = [:INT, :TTIN, :TTOU]
 
-    attr_reader :logger
+    attr_reader :logger, :job, :number_of_workers
 
     def initialize(job, options = {})
-      @number_of_workers = options.fetch :workers, 0
-      @logger = options.fetch :logger, NullLogger.new
+      self.number_of_workers = options.fetch :workers, 0
+      @logger = options.fetch(:logger) { NullLogger.new }
+      @execution_strategy = options.fetch(:execution_strategy) { ForkingExecutionStrategy }
       @workers = []
       @job = job
 
@@ -24,60 +26,77 @@ module Sisyphus
 
     def start
       trap_signals
-      @number_of_workers.times do
-        start_worker
+      number_of_workers.times do
+        spawn_worker
         sleep rand(1000).fdiv(1000)
       end
       puts "Sisyphus::Master started with PID: #{Process.pid}"
       watch_for_output
     end
 
-    def start_worker
+    def spawn_worker
       reader, writer = IO.pipe
       if wpid = fork
         writer.close
-        @workers << { pid: wpid, reader: reader }
+        workers << { pid: wpid, reader: reader }
       else
         reader.close
         self.process_name = "Worker #{Process.pid}"
-        begin
-          worker = Worker.new(@job, writer, logger)
-          worker.setup
-          worker.start
-        rescue Exception => e
-          writer.write Worker::UNCAUGHT_ERROR
-          logger.warn(process_name) { e }
-          exit! 0
-        end
+        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
+    end
+
     def stop_worker(wpid)
-      if @workers.find { |w| w.fetch(:pid) == wpid }
+      if workers.find { |w| w.fetch(:pid) == wpid }
         Process.kill 'INT', wpid rescue Errno::ESRCH # Ignore if the process is already gone
       end
     end
 
     def stop_all
-      @workers.each do |worker|
+      workers.each do |worker|
         stop_worker worker.fetch(:pid)
       end
-      Timeout.timeout(30) do
-        watch_for_shutdown while worker_count > 0
+      begin
+        Timeout.timeout(30) do
+          watch_for_shutdown while worker_count > 0
+        end
+      rescue e
+        p "Timeout reached:", e
       end
     end
 
     def worker_count
-      @workers.length
+      workers.length
     end
 
     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
+    end
+
     def watch_for_shutdown
       wpid, _ = Process.wait2
       worker = @workers.find { |w| w.fetch(:pid) == wpid }
       worker.fetch(:reader).close
-      @workers.delete worker
+      workers.delete worker
       wpid
     rescue Errno::ECHILD
     end
@@ -107,26 +126,26 @@ module Sisyphus
 
     def process_output(pipes)
       pipes.each do |pipe|
-        restart_worker worker_pid(pipe) unless stopping?
+        respawn_worker worker_pid(pipe) unless stopping?
       end
     end
 
-    def restart_worker(wpid)
-      start_worker
+    def respawn_worker(wpid)
+      spawn_worker
       stop_worker wpid
       watch_for_shutdown
     end
 
     def worker_pipes
       if worker_count > 0
-        @workers.map { |w| w.fetch(:reader) }
+        workers.map { |w| w.fetch(:reader) }
       else
         []
       end
     end
 
     def worker_pid(reader)
-      if worker = @workers.find { |w| w.fetch(:reader).fileno == reader.fileno }
+      if worker = workers.find { |w| w.fetch(:reader).fileno == reader.fileno }
         worker.fetch(:pid)
       else
         raise 'Unknown worker pipe'
@@ -171,14 +190,14 @@ module Sisyphus
     end
 
     def handle_ttin
-      @number_of_workers += 1
-      start_worker
+      self.number_of_workers += 1
+      spawn_worker
     end
 
     def handle_ttou
-      if @number_of_workers > 0
-        @number_of_workers -= 1
-        stop_worker(@workers.first.fetch(:pid))
+      if number_of_workers > 0
+        self.number_of_workers -= 1
+        stop_worker(workers.first.fetch(:pid))
       end
     end
 

data/lib/sisyphus/simple_execution_strategy.rb

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

data/lib/sisyphus/sleep.rb

@@ -3,7 +3,7 @@ require_relative './job'
 module Sisyphus
   class Sleep < Job
     def perform
-      sleep 2
+      sleep 40
       puts "Goodmorning from #{Process.pid}"
       raise "Hest" if rand(10) % 2 == 0
     end

data/lib/sisyphus/worker.rb

@@ -2,16 +2,16 @@ module Sisyphus
   class Worker
     UNCAUGHT_ERROR = '.'
 
-    attr_reader :logger
+    attr_reader :execution_strategy, :job, :output
 
-    def initialize(job, output, logger)
+    def initialize(job, output, execution_strategy)
       @job = job
       @output = output
-      @logger = logger
+      @execution_strategy = execution_strategy
     end
 
     def setup
-      @job.setup if @job.respond_to? :setup
+      job.setup if job.respond_to? :setup
     end
 
     def start
@@ -25,28 +25,22 @@ module Sisyphus
       exit! 0
     end
 
-    private
-
     def perform_job
-      if child = fork
-        _, status = Process.waitpid2 child
+      execution_strategy.execute job, error_handler
+    end
+
+    def error_handler
+      -> {
         begin
-          @output.write UNCAUGHT_ERROR unless status.success? || stopped?
+          output.write UNCAUGHT_ERROR unless stopped?
         rescue Errno::EAGAIN, Errno::EINTR
           # Ignore
         end
-      else
-        self.process_name = "Child of worker #{Process.ppid}"
-        begin
-          @job.perform
-          exit! 0
-        rescue Exception => e
-          logger.warn(process_name) { e }
-          exit! 1
-        end
-      end
+      }
     end
 
+    private
+
     def trap_signals
       Signal.trap('INT') do
         stop
@@ -61,12 +55,5 @@ module Sisyphus
       @stopped
     end
 
-    def process_name=(name)
-      $0 = name
-    end
-
-    def process_name
-      $0
-    end
   end
 end

data/lib/version.rb

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

data/spec/sisyphus/forking_execution_strategy_spec.rb

@@ -0,0 +1,122 @@
+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(:child_pid) { 1 }
+
+    it 'forks on execution' do
+      allow(strategy).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 }
+      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
+      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
+      end
+
+    end
+
+    context 'in the execution process' do
+
+      let(:ppid) { 2 }
+
+      before :each do
+        allow(strategy).to receive(:fork) { nil }
+        allow(job).to receive(:perform)
+        allow(strategy).to receive(:exit!)
+      end
+
+      it 'updates the process name' do
+        allow(Process).to receive(:ppid) { ppid }
+        expect(strategy).to receive(:process_name=).with("Child of worker #{ppid}")
+        strategy.execute job
+      end
+
+      it 'performs the job' do
+        expect(job).to receive(:perform)
+        strategy.execute job
+      end
+
+      it 'exits with a 0 status if job is performed without failing' do
+        expect(strategy).to receive(:exit!).with(0)
+        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
+      end
+
+    end
+
+    describe ForkingExecutionStrategy::ChildProcess do
+
+      let(:pid) { 1 }
+      let(:status) { double :status }
+      let(:child_process) { ForkingExecutionStrategy::ChildProcess.new pid }
+
+      it 'waits for the process to finish' do
+        expect(Process).to receive(:waitpid2).with pid do
+          allow(status).to receive(:success?) { true }
+          [pid, status]
+        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]
+        end
+        child_process.success?
+      end
+    end
+
+  end
+end

data/spec/sisyphus/master_spec.rb

@@ -4,123 +4,128 @@ module Sisyphus
   describe Master do
     subject(:master) { Master.new job }
 
-    before(:each) { master.stub :puts }
+    before(:each) {
+      allow(master).to receive(:puts)
+      allow(master).to receive(:sleep)
+    }
 
     let(:job) { double(:job) }
     let(:pipes) { [double(:reader_pipe), double(:writer_pipe)] }
 
-    describe 'when receiving the start_worker message' do
+    describe 'when receiving the spawn_worker message' do
       it 'forks' do
-        master.should_receive(:fork) { 666 }
-        master.start_worker
+        expect(master).to receive(:fork) { 666 }
+        master.spawn_worker
       end
 
       describe 'in the worker process' do
         let(:worker) { double :worker }
 
         before :each do
-          master.stub(:fork) { nil }
-          IO.stub(:pipe) { pipes }
-          pipes.first.stub(:close)
-          Process.stub(:pid) { 666 }
-          master.stub :exit!
-          Worker.stub(:new) { worker }
-          worker.stub(:setup)
-          worker.stub(:start)
+          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
-          worker.should_receive :setup
-          master.start_worker
+          expect(worker).to receive(:setup)
+          master.spawn_worker
         end
 
         it 'should rename the process' do
-          master.should_receive(:process_name=).with("Worker #{666}")
-          master.start_worker
+          expect(master).to receive(:process_name=).with("Worker #{666}")
+          master.spawn_worker
         end
 
         it 'starts a worker after forking' do
-          worker.should_receive :start
-          master.start_worker
+          expect(worker).to receive(:start)
+          master.spawn_worker
         end
 
         it 'gives the writer pipe to the worker' do
-          Worker.should_receive(:new).with(job, pipes.last, master.logger) { worker }
-          master.start_worker
+          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 'closes the reader pipe' do
-          pipes.first.should_receive :close
-          master.start_worker
+          expect(pipes.first).to receive(:close)
+          master.spawn_worker
         end
 
         describe 'when an exception is raised' do
           let(:logger) { double(:logger) }
 
           it 'should log the exception' do
-            master.stub(:logger).and_return logger
-            pipes.last.stub(:write)
-            worker.stub(:setup).and_raise :raised_by_spec
-            logger.should_receive :warn
-            master.start_worker
+            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
-            master.stub(:logger).and_return logger
-            worker.stub(:setup).and_raise :raised_by_spec
-            logger.stub :warn
-            pipes.last.should_receive(:write).with Worker::UNCAUGHT_ERROR
-            master.start_worker
+            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
       end
 
       describe 'in the master process' do
         before :each do
-          master.stub(:fork) { 666 }
-          IO.stub(:pipe) { pipes }
-          pipes.last.stub(:close)
+          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.start_worker
-          master.worker_count.should eq(1)
+          master.spawn_worker
+          expect(master.worker_count).to eq(1)
         end
 
         it 'should open a pipe' do
-          IO.should_receive(:pipe) { pipes }
-          master.start_worker
+          expect(IO).to receive(:pipe) { pipes }
+          master.spawn_worker
         end
 
         it 'should close the writer pipe' do
-          pipes.last.should_receive :close
-          master.start_worker
+          expect(pipes.last).to receive(:close)
+          master.spawn_worker
         end
       end
     end
 
     describe 'when it has running workers' do
       before :each do
-        pipes.each { |p| p.stub :close }
-        IO.stub(:pipe) { pipes }
-        master.stub(:fork) { 666 }
-        master.start_worker
-        Process.stub(:kill).with('INT', 666)
-        Process.stub(:waitpid2).with(666)
+        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
-          Process.should_receive(:kill).with('INT', 666)
+          expect(Process).to receive(:kill).with('INT', 666)
           master.stop_worker(666)
         end
       end
 
       it 'stops all workers when receiving stop_all' do
-        Process.stub(:kill).with('INT', 666)
-        Process.stub(:wait2) { 666 }
+        allow(Process).to receive(:kill).with('INT', 666)
+        allow(Process).to receive(:wait2) { 666 }
 
-        master.should_receive(:stop_worker).with(666).exactly(master.worker_count).times.and_call_original
+        expect(master).to receive(:stop_worker).with(666).exactly(master.worker_count).times.and_call_original
 
         master.stop_all
       end
@@ -135,7 +140,7 @@ module Sisyphus
 
       describe 'and it receives stop_all' do
         it 'does nothing' do
-          master.should_not_receive(:stop_worker)
+          expect(master).not_to receive(:stop_worker)
           master.stop_all
         end
       end
@@ -143,47 +148,47 @@ module Sisyphus
 
     it 'starts the specified number of workers when started' do
       master = Master.new nil, workers: 3
-      master.stub :puts
-      master.stub :watch_for_output
-      master.should_receive(:start_worker).exactly(3).times
+      allow(master).to receive(:puts)
+      allow(master).to receive(:watch_for_output)
+      expect(master).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 }
 
-      before(:each) { master.stub :puts }
+      before(:each) { allow(master).to receive(:puts) }
 
       it 'should not start workers' do
-        master.stub :watch_for_output
-        master.should_not_receive :start_worker
+        allow(master).to receive(:watch_for_output)
+        expect(master).not_to receive(:spawn_worker)
         master.start
       end
     end
 
     it 'attaches a signal handler when started' do
-      Signal.should_receive(:trap).with(:INT)
-      Signal.should_receive(:trap).with(:TTIN)
-      Signal.should_receive(:trap).with(:TTOU)
-      master.stub :start_worker
-      master.stub :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
-      master.stub :start_worker
-      master.should_receive :watch_for_output
+      allow(master).to receive(:spawn_worker)
+      expect(master).to receive(:watch_for_output)
       master.start
     end
 
     it 'can resolve a wpid from a reader pipe' do
-      IO.stub(:pipe) { pipes }
-      pipes.each { |p| p.stub(:close) }
-      pipes.first.stub(:fileno) { 213 }
-      master.stub(:fork) { 666 }
-      master.start_worker
+      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
 
-      master.send(:worker_pid, pipes.first).should eq(666)
+      expect(master.send(:worker_pid, pipes.first)).to eq(666)
     end
 
     it 'raises if it can\'t resolve a wpid from a reader pipe' do

data/spec/sisyphus/simple_execution_strategy_spec.rb

@@ -0,0 +1,32 @@
+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) }
+
+    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
+      error_message = "This is a horrible failure.. The Universe is probably ending!"
+      process_name = "uber awesome process name"
+      allow(job).to receive(:perform) { fail Exception, error_message }
+      allow(strategy).to receive(:process_name) { process_name }
+      expect(logger).to receive(:warn).with(process_name)
+      strategy.execute job
+    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_spec.rb

@@ -4,8 +4,8 @@ module Sisyphus
   describe Worker do
     let(:job) { double :job }
     let(:output) { double :pipe }
-    let(:logger) { double :logger }
-    let(:worker) { Worker.new job, output, logger }
+    let(:execution_strategy) { double :execution_strategy }
+    let(:worker) { Worker.new job, output, execution_strategy }
 
     it 'traps signals when started' do
       worker.stub :exit!
@@ -20,107 +20,49 @@ module Sisyphus
       worker.start
     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
-        Worker.new job, output, logger
-      end
+    it 'uses execution_strategy to perform the job' do
+      expect(execution_strategy).to receive(:execute).with job, an_instance_of(Proc)
+      worker.perform_job
     end
 
-    context 'when job responds to :setup' do
-      it 'sets up the job' do
-        job.stub(:respond_to?).with(:setup) { true }
-        job.should_receive :setup
-        worker.setup
-      end
+    it 'passes the error_handler to the execution strategy' do
+      allow(execution_strategy).to receive(:execute).with job, an_instance_of(Proc)
+      expect(worker).to receive(:error_handler) { ->{} }
+      worker.perform_job
     end
 
-    context 'in the child process' do
-      before :each do
-        worker.stub(:fork) { nil }
-      end
-
-      it 'should perform the job' do
-        job.should_receive :perform
-        worker.stub :exit!
-        worker.send :perform_job
-      end
+    context 'the error_handler' do
 
-      it 'should exit after having performed the job' do
-        job.stub :perform
-        worker.should_receive(:exit!).with 0
-        worker.send :perform_job
+      it 'writes the UNCAUGHT_ERROR to output' do
+        expect(output).to receive(:write).with Worker::UNCAUGHT_ERROR
+        worker.error_handler.call
       end
 
-      it 'should change process name' do
-        job.stub :perform
-        worker.stub :exit!
-        Process.stub(:ppid) { 666 }
-        worker.should_receive(:process_name=).with "Child of worker 666"
-        worker.send :perform_job
+      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
       end
 
-      context 'when job.perform raises an error' do
-        it 'should exit with a non-zero status' do
-          logger.stub :warn
-          job.stub(:perform).and_raise Exception.new "should be rescued!"
-          worker.should_receive(:exit!).with(1)
-          worker.send :perform_job
-        end
-
-        it 'should log the raised error' do
-          worker.stub(:exit!).with(1)
-          job.stub(:perform).and_raise Exception.new "should be rescued!"
-          logger.should_receive :warn
-          worker.send :perform_job
-        end
-      end
     end
 
-    context 'in the worker process' do
-      let(:status) { double(:status) }
-
-      before :each do
-        worker.stub(:fork) { 666 }
-      end
-
-      it 'spawns a process and waits for it to finish' do
-        worker.should_receive(:fork) { 666 }
-        status.stub(:success?) { true }
-        Process.should_receive(:waitpid2).with(666) { [666, status] }
-        worker.send :perform_job
-      end
-
-      context 'when exit status from the child is non-zero' do
-        before :each do
-          status.stub(:success?) { false }
-          Process.stub(:waitpid2) { [666, status] }
-        end
-
-        it 'writes an error message to the output' do
-          output.should_receive(:write).with Worker::UNCAUGHT_ERROR
-          worker.send :perform_job
-        end
-
-        it "doesn't write error byte to output when it has been stopped" do
-          worker.stub(:stopped?) { true }
-          output.should_not_receive :write
-          worker.send :perform_job
-        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
+        worker.setup
       end
+    end
 
-      context 'when exit status from child is zero' do
-        before :each do
-          status.stub(:success?) { true }
-          Process.stub(:waitpid2) { [666, status] }
-        end
-
-        it "doesn't write error byte to output" do
-          output.should_not_receive :write
-          worker.send :perform_job
-        end
+    context 'when job responds to :setup' do
+      it 'sets up the job' do
+        job.stub(:respond_to?).with(:setup) { true }
+        job.should_receive :setup
+        worker.setup
       end
     end
+
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: sisyphus
 version: !ruby/object:Gem::Version
-  version: 0.2.3
+  version: 0.2.4
 platform: ruby
 authors:
 - Rasmus Bang Grouleff
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-12-04 00:00:00.000000000 Z
+date: 2014-03-31 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -66,14 +66,18 @@ files:
 - README.md
 - Rakefile
 - lib/sisyphus.rb
+- lib/sisyphus/forking_execution_strategy.rb
 - lib/sisyphus/job.rb
 - lib/sisyphus/master.rb
 - lib/sisyphus/null_logger.rb
+- lib/sisyphus/simple_execution_strategy.rb
 - lib/sisyphus/sleep.rb
 - lib/sisyphus/worker.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_spec.rb
 homepage: https://github.com/rbgrouleff/sisyphus
 licenses:
@@ -100,5 +104,7 @@ signing_key:
 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_spec.rb