sisyphus 0.2.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: f454308987e390a7ae0e4795760f41daf32a6643
+  data.tar.gz: c37488406b5d180482b9d815d6b912f1eb99f217
+SHA512:
+  metadata.gz: 1dbd8435f29ff6bda19c1d379f9009e3bb7276f092577600a9a21a7932bf571d81ffbfd04211fa8f84857911bdcd569b05eb70182c944ad31c748f7c0e08ce7b
+  data.tar.gz: e5b74daf39354ba9585e224645a18c7d1789fd897a16fdb1dd5a74c039ecf3371f2afae4a87d32d7e48c50138d65d796877f4788b48483bb2c77eb25ae4dabcb

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in coolie.gemspec
+gemspec

data/Gemfile.lock

@@ -0,0 +1,27 @@
+PATH
+  remote: .
+  specs:
+    sisyphus (0.1.1)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    diff-lcs (1.2.4)
+    rake (10.1.0)
+    rspec (2.14.1)
+      rspec-core (~> 2.14.0)
+      rspec-expectations (~> 2.14.0)
+      rspec-mocks (~> 2.14.0)
+    rspec-core (2.14.5)
+    rspec-expectations (2.14.2)
+      diff-lcs (>= 1.1.3, < 2.0)
+    rspec-mocks (2.14.3)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler (~> 1.3)
+  sisyphus!
+  rake (~> 10.0)
+  rspec (~> 2.14)

data/LICENSE.txt

@@ -0,0 +1,191 @@
+Apache License
+Version 2.0, January 2004
+http://www.apache.org/licenses/
+
+TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+1. Definitions.
+
+"License" shall mean the terms and conditions for use, reproduction, and
+distribution as defined by Sections 1 through 9 of this document.
+
+"Licensor" shall mean the copyright owner or entity authorized by the copyright
+owner that is granting the License.
+
+"Legal Entity" shall mean the union of the acting entity and all other entities
+that control, are controlled by, or are under common control with that entity.
+For the purposes of this definition, "control" means (i) the power, direct or
+indirect, to cause the direction or management of such entity, whether by
+contract or otherwise, or (ii) ownership of fifty percent (50%) or more of the
+outstanding shares, or (iii) beneficial ownership of such entity.
+
+"You" (or "Your") shall mean an individual or Legal Entity exercising
+permissions granted by this License.
+
+"Source" form shall mean the preferred form for making modifications, including
+but not limited to software source code, documentation source, and configuration
+files.
+
+"Object" form shall mean any form resulting from mechanical transformation or
+translation of a Source form, including but not limited to compiled object code,
+generated documentation, and conversions to other media types.
+
+"Work" shall mean the work of authorship, whether in Source or Object form, made
+available under the License, as indicated by a copyright notice that is included
+in or attached to the work (an example is provided in the Appendix below).
+
+"Derivative Works" shall mean any work, whether in Source or Object form, that
+is based on (or derived from) the Work and for which the editorial revisions,
+annotations, elaborations, or other modifications represent, as a whole, an
+original work of authorship. For the purposes of this License, Derivative Works
+shall not include works that remain separable from, or merely link (or bind by
+name) to the interfaces of, the Work and Derivative Works thereof.
+
+"Contribution" shall mean any work of authorship, including the original version
+of the Work and any modifications or additions to that Work or Derivative Works
+thereof, that is intentionally submitted to Licensor for inclusion in the Work
+by the copyright owner or by an individual or Legal Entity authorized to submit
+on behalf of the copyright owner. For the purposes of this definition,
+"submitted" means any form of electronic, verbal, or written communication sent
+to the Licensor or its representatives, including but not limited to
+communication on electronic mailing lists, source code control systems, and
+issue tracking systems that are managed by, or on behalf of, the Licensor for
+the purpose of discussing and improving the Work, but excluding communication
+that is conspicuously marked or otherwise designated in writing by the copyright
+owner as "Not a Contribution."
+
+"Contributor" shall mean Licensor and any individual or Legal Entity on behalf
+of whom a Contribution has been received by Licensor and subsequently
+incorporated within the Work.
+
+2. Grant of Copyright License.
+
+Subject to the terms and conditions of this License, each Contributor hereby
+grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free,
+irrevocable copyright license to reproduce, prepare Derivative Works of,
+publicly display, publicly perform, sublicense, and distribute the Work and such
+Derivative Works in Source or Object form.
+
+3. Grant of Patent License.
+
+Subject to the terms and conditions of this License, each Contributor hereby
+grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free,
+irrevocable (except as stated in this section) patent license to make, have
+made, use, offer to sell, sell, import, and otherwise transfer the Work, where
+such license applies only to those patent claims licensable by such Contributor
+that are necessarily infringed by their Contribution(s) alone or by combination
+of their Contribution(s) with the Work to which such Contribution(s) was
+submitted. If You institute patent litigation against any entity (including a
+cross-claim or counterclaim in a lawsuit) alleging that the Work or a
+Contribution incorporated within the Work constitutes direct or contributory
+patent infringement, then any patent licenses granted to You under this License
+for that Work shall terminate as of the date such litigation is filed.
+
+4. Redistribution.
+
+You may reproduce and distribute copies of the Work or Derivative Works thereof
+in any medium, with or without modifications, and in Source or Object form,
+provided that You meet the following conditions:
+
+You must give any other recipients of the Work or Derivative Works a copy of
+this License; and
+You must cause any modified files to carry prominent notices stating that You
+changed the files; and
+You must retain, in the Source form of any Derivative Works that You distribute,
+all copyright, patent, trademark, and attribution notices from the Source form
+of the Work, excluding those notices that do not pertain to any part of the
+Derivative Works; and
+If the Work includes a "NOTICE" text file as part of its distribution, then any
+Derivative Works that You distribute must include a readable copy of the
+attribution notices contained within such NOTICE file, excluding those notices
+that do not pertain to any part of the Derivative Works, in at least one of the
+following places: within a NOTICE text file distributed as part of the
+Derivative Works; within the Source form or documentation, if provided along
+with the Derivative Works; or, within a display generated by the Derivative
+Works, if and wherever such third-party notices normally appear. The contents of
+the NOTICE file are for informational purposes only and do not modify the
+License. You may add Your own attribution notices within Derivative Works that
+You distribute, alongside or as an addendum to the NOTICE text from the Work,
+provided that such additional attribution notices cannot be construed as
+modifying the License.
+You may add Your own copyright statement to Your modifications and may provide
+additional or different license terms and conditions for use, reproduction, or
+distribution of Your modifications, or for any such Derivative Works as a whole,
+provided Your use, reproduction, and distribution of the Work otherwise complies
+with the conditions stated in this License.
+
+5. Submission of Contributions.
+
+Unless You explicitly state otherwise, any Contribution intentionally submitted
+for inclusion in the Work by You to the Licensor shall be under the terms and
+conditions of this License, without any additional terms or conditions.
+Notwithstanding the above, nothing herein shall supersede or modify the terms of
+any separate license agreement you may have executed with Licensor regarding
+such Contributions.
+
+6. Trademarks.
+
+This License does not grant permission to use the trade names, trademarks,
+service marks, or product names of the Licensor, except as required for
+reasonable and customary use in describing the origin of the Work and
+reproducing the content of the NOTICE file.
+
+7. Disclaimer of Warranty.
+
+Unless required by applicable law or agreed to in writing, Licensor provides the
+Work (and each Contributor provides its Contributions) on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied,
+including, without limitation, any warranties or conditions of TITLE,
+NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A PARTICULAR PURPOSE. You are
+solely responsible for determining the appropriateness of using or
+redistributing the Work and assume any risks associated with Your exercise of
+permissions under this License.
+
+8. Limitation of Liability.
+
+In no event and under no legal theory, whether in tort (including negligence),
+contract, or otherwise, unless required by applicable law (such as deliberate
+and grossly negligent acts) or agreed to in writing, shall any Contributor be
+liable to You for damages, including any direct, indirect, special, incidental,
+or consequential damages of any character arising as a result of this License or
+out of the use or inability to use the Work (including but not limited to
+damages for loss of goodwill, work stoppage, computer failure or malfunction, or
+any and all other commercial damages or losses), even if such Contributor has
+been advised of the possibility of such damages.
+
+9. Accepting Warranty or Additional Liability.
+
+While redistributing the Work or Derivative Works thereof, You may choose to
+offer, and charge a fee for, acceptance of support, warranty, indemnity, or
+other liability obligations and/or rights consistent with this License. However,
+in accepting such obligations, You may act only on Your own behalf and on Your
+sole responsibility, not on behalf of any other Contributor, and only if You
+agree to indemnify, defend, and hold each Contributor harmless for any liability
+incurred by, or claims asserted against, such Contributor by reason of your
+accepting any such warranty or additional liability.
+
+END OF TERMS AND CONDITIONS
+
+APPENDIX: How to apply the Apache License to your work
+
+To apply the Apache License to your work, attach the following boilerplate
+notice, with the fields enclosed by brackets "[]" replaced with your own
+identifying information. (Don't include the brackets!) The text should be
+enclosed in the appropriate comment syntax for the file format. We also
+recommend that a file or class name and description of purpose be included on
+the same "printed page" as the copyright notice for easier identification within
+third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+     http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

data/README.md

@@ -0,0 +1,96 @@
+Sisyphus
+======
+
+Sisyphus provides a really simple way of starting and stopping multiple parallel
+worker processes that are meant to run repeatedly in an efficient way.
+
+It requires no frameworks, databases or anything. It just does what you
+want it to - until you tell it to stop doing it.
+
+How it works
+------------
+
+The Master takes a job as argument in the initializer, that responds to `setup` and `perform`.
+
+When sending the `start_worker` message to the master, it forks a child process where it hands
+the job to a new worker, which then sends the `setup` message to the job during initialization.
+The purpose of the `setup` method is to load and initialize anything necessary to perform the job.
+
+The master then starts the worker, which enters a run loop, that forks yet another child process where
+the job receives the `perform` message.
+
+Getting started
+---------------
+
+1. Add `gem 'coolie'` to your Gemfile and run `bundle`
+2. Subclass `Sisyphus::Job` and implement the `perform` method
+3. Instantiate the `Sisyphus::Master`, giving it an instance of your job
+   and optionally an options hash with the key `:workers` specifying the
+   number of workers you need
+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
+     restarts them if they encounters uncaught exceptions
+   * Otherwise send the `start_worker` message to the master as many
+     times as the number of workers needed. This doesn't start any run
+     loop, and there is no monitoring of workers.
+
+If you need to stop workers, you can do it one at the time by sending
+the `stop_worker` message to the master or stop them all by sending the
+`stop_all` message.
+
+When stopping workers, they are allowed to finish what they are doing,
+before they stop. Which means you're screwed right now, if the `perform`
+method in your job never returns.
+
+The master registers signal handlers when you send it the `start`
+message and enters a run loop.
+
+The signals the master responds to are:
+
+- `SIGINT` tells the master to gracefully stop all workers and shut down
+- `SIGTTIN` tells the master to spawn a new worker
+- `SIGTTOU` tells the master to stop a worker
+
+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
+- Daemonization of the master
+- The master should have a shutdown immediately signal
+- Communication with the master through signals (something like [Unicorn] [unicorn])
+- Basic logging
+- Some sort of error handling
+- Some sort of reaping of worker processes
+- Documentation
+
+[unicorn]: http://unicorn.bogomips.org/
+
+Contributing
+------------
+
+Feel free to report issues or fork, fix and submit pull requests.
+
+License
+-------
+
+Copyright 2013 Rasmus Bang Grouleff
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+  http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.

data/Rakefile

@@ -0,0 +1,12 @@
+require "bundler/gem_tasks"
+
+desc 'Example task that fires up a sleep job with 2 workers'
+task :sleeper do
+  gem 'sisyphus'
+  require 'sisyphus'
+  require 'sisyphus/sleep'
+
+  job = Sisyphus::Sleep.new
+  master = Sisyphus::Master.new job, workers: 2
+  master.start
+end

data/lib/sisyphus/job.rb

@@ -0,0 +1,9 @@
+module Sisyphus
+  class Job
+    def setup
+    end
+
+    def perform
+    end
+  end
+end

data/lib/sisyphus/master.rb

@@ -0,0 +1,188 @@
+require 'timeout'
+require_relative './worker'
+
+module Sisyphus
+  class Master
+    IO_TIMEOUT = 10
+
+    HANDLED_SIGNALS = [:INT, :TTIN, :TTOU]
+
+    def initialize(job, options = {})
+      @number_of_workers = options.fetch :workers, 0
+      @workers = []
+      @job = job
+
+      self_reader, self_writer = IO.pipe
+      @selfpipe = { reader: self_reader, writer: self_writer }
+
+      Thread.main[:signal_queue] = []
+    end
+
+    def start
+      trap_signals
+      @number_of_workers.times do
+        start_worker
+        sleep rand(1000).fdiv(1000)
+      end
+      puts "Sisyphus::Master started with PID: #{Process.pid}"
+      watch_for_output
+    end
+
+    def start_worker
+      reader, writer = IO.pipe
+      if wpid = fork
+        writer.close
+        @workers << { pid: wpid, reader: reader }
+      else
+        reader.close
+        worker = Worker.new(@job, writer)
+        self.process_name = "Worker #{Process.pid}"
+        worker.start
+      end
+    end
+
+    def stop_worker(wpid)
+      if @workers.find { |w| w.fetch(:pid) == wpid }
+        Process.kill 'INT', wpid
+      else
+        raise "Unknown worker PID: #{wpid}"
+      end
+    end
+
+    def stop_all
+      @workers.each do |worker|
+        stop_worker worker.fetch(:pid)
+      end
+      Timeout.timeout(30) do
+        watch_for_shutdown while worker_count > 0
+      end
+    end
+
+    def worker_count
+      @workers.length
+    end
+
+    private
+
+    def watch_for_shutdown
+      wpid, _ = Process.wait2
+      worker = @workers.find { |w| w.fetch(:pid) == wpid }
+      worker.fetch(:reader).close
+      @workers.delete worker
+      wpid
+    rescue Errno::ECHILD
+    end
+
+    def watch_for_output
+      loop do
+        ready = IO.select(worker_pipes + [@selfpipe[:reader]], nil, nil, IO_TIMEOUT)
+        if ready
+          process_pipes(ready[0])
+          process_signal_queue
+        end
+      end
+    end
+
+    def process_signal_queue
+      handle_signal(Thread.main[:signal_queue].shift) until Thread.main[:signal_queue].empty?
+    end
+
+    def process_pipes(pipes)
+      begin
+        @selfpipe[:reader].read_nonblock(10) if pipes.include?(@selfpipe[:reader])
+      rescue Errno::EAGAIN, Errno::EINTR
+        # Ignore
+      end
+      process_output(pipes & worker_pipes) unless stopping?
+    end
+
+    def process_output(pipes)
+      pipes.each do |pipe|
+        restart_worker worker_pid(pipe) unless stopping?
+      end
+    end
+
+    def restart_worker(wpid)
+      start_worker
+      stop_worker wpid
+      watch_for_shutdown
+    end
+
+    def worker_pipes
+      if worker_count > 0
+        @workers.map { |w| w.fetch(:reader) }
+      else
+        []
+      end
+    end
+
+    def worker_pid(reader)
+      if worker = @workers.find { |w| w.fetch(:reader).fileno == reader.fileno }
+        worker.fetch(:pid)
+      else
+        raise 'Unknown worker pipe'
+      end
+    end
+
+    def trap_signals
+      HANDLED_SIGNALS.each do |signal|
+        Signal.trap signal do
+          queue_signal signal
+        end
+      end
+    end
+
+    def queue_signal(signal)
+      Thread.main[:signal_queue] << signal
+      @selfpipe[:writer].write_nonblock('.')
+    rescue Errno::EAGAIN
+      # Ignore
+    rescue Errno::EINTR
+      retry
+    end
+
+    def handle_signal(signal)
+      case signal
+      when :INT
+        handle_int
+      when :TTIN
+        handle_ttin
+      when :TTOU
+        handle_ttou
+      else
+        raise "Unknown signal"
+      end
+    end
+
+    def handle_int
+      puts "Waiting for workers to stop..."
+      stop
+      stop_all
+      exit 0
+    end
+
+    def handle_ttin
+      @number_of_workers += 1
+      start_worker
+    end
+
+    def handle_ttou
+      if @number_of_workers > 0
+        @number_of_workers -= 1
+        stop_worker(@workers.first.fetch(:pid))
+      end
+    end
+
+    def stop
+      @stopping = true
+    end
+
+    def stopping?
+      @stopping
+    end
+
+    def process_name=(name)
+      $0 = name
+    end
+  end
+end

data/lib/sisyphus/sleep.rb

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

data/lib/sisyphus/worker.rb

@@ -0,0 +1,65 @@
+module Sisyphus
+  class Worker
+    UNCAUGHT_ERROR = '.'
+
+    def initialize(job, output)
+      @job = job
+      @output = output
+      setup
+    end
+
+    def start
+      trap_signals
+
+      loop do
+        break if stopped?
+        perform_job
+      end
+
+      exit 0
+    end
+
+    private
+
+    def perform_job
+      if child = fork
+        _, status = Process.waitpid2 child
+        begin
+          @output.write UNCAUGHT_ERROR unless status.success? || stopped?
+        rescue Errno::EAGAIN, Errno::EINTR
+          # Ignore
+        end
+      else
+        self.process_name = "Child of worker #{Process.ppid}"
+        begin
+          @job.perform
+          exit 0
+        rescue Exception
+          exit 1
+        end
+      end
+    end
+
+    def trap_signals
+      Signal.trap('INT') do
+        stop
+      end
+    end
+
+    def stop
+      @stopped = true
+    end
+
+    def stopped?
+      @stopped
+    end
+
+    def setup
+      @job.setup if @job.respond_to? :setup
+    end
+
+    def process_name=(name)
+      $0 = name
+    end
+  end
+end

data/lib/sisyphus.rb

@@ -0,0 +1,8 @@
+require "version"
+require 'sisyphus/job'
+require 'sisyphus/worker'
+require 'sisyphus/master'
+
+module Sisyphus
+  # Your code goes here...
+end

data/lib/version.rb

@@ -0,0 +1,3 @@
+module Sisyphus
+  VERSION = "0.2.1"
+end

data/sisyphus.gemspec

@@ -0,0 +1,24 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "sisyphus"
+  spec.version       = Sisyphus::VERSION
+  spec.authors       = ["Rasmus Bang Grouleff"]
+  spec.email         = ["rasmusbg@virtualmanager.com"]
+  spec.description   = %q{A tiny library for spawning worker processes}
+  spec.summary       = %q{A tiny library for spawning worker processes}
+  spec.homepage      = "https://github.com/rbgrouleff/sisyphus"
+  spec.license       = "Apache License 2.0"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec", "~> 2.14"
+end

data/spec/sisyphus/master_spec.rb

@@ -0,0 +1,167 @@
+require_relative '../../lib/sisyphus/master'
+
+module Sisyphus
+  describe Master do
+    subject(:master) { Master.new job }
+
+    before(:each) { master.stub :puts }
+
+    let(:job) { double(:job) }
+    let(:pipes) { [double(:reader_pipe), double(:writer_pipe)] }
+
+    describe 'when receiving the start_worker message' do
+      it 'forks' do
+        master.should_receive(:fork) { 666 }
+        master.start_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(:start)
+        end
+
+        it 'should rename the process' do
+          master.should_receive(:process_name=).with("Worker #{666}")
+          master.start_worker
+        end
+
+        it 'starts a worker after forking' do
+          worker.should_receive :start
+          master.start_worker
+        end
+
+        it 'gives the writer pipe to the worker' do
+          Worker.should_receive(:new).with(job, pipes.last) { worker }
+          master.start_worker
+        end
+
+        it 'closes the reader pipe' do
+          pipes.first.should_receive :close
+          master.start_worker
+        end
+      end
+
+      describe 'in the master process' do
+        before :each do
+          master.stub(:fork) { 666 }
+          IO.stub(:pipe) { pipes }
+          pipes.last.stub(:close)
+        end
+
+        it 'increases worker_count' do
+          master.start_worker
+          master.worker_count.should eq(1)
+        end
+
+        it 'should open a pipe' do
+          IO.should_receive(:pipe) { pipes }
+          master.start_worker
+        end
+
+        it 'should close the writer pipe' do
+          pipes.last.should_receive :close
+          master.start_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)
+      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)
+          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 }
+
+        master.should_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) }.to raise_error("Unknown worker PID: #{666}")
+        end
+      end
+
+      describe 'and it receives stop_all' do
+        it 'does nothing' do
+          master.should_not_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.stub :puts
+      master.stub :watch_for_output
+      master.should_receive(:start_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 }
+
+      it 'should not start workers' do
+        master.stub :watch_for_output
+        master.should_not_receive :start_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
+      master.start
+    end
+
+    it 'should watch for output' do
+      master.stub :start_worker
+      master.should_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
+
+      master.send(:worker_pid, pipes.first).should eq(666)
+    end
+
+    it 'raises if it can\'t resolve a wpid from a reader pipe' do
+      expect { master.send(:worker_pid, pipes.first) }.to raise_error("Unknown worker pipe")
+    end
+  end
+end

data/spec/sisyphus/worker_spec.rb

@@ -0,0 +1,117 @@
+require_relative '../../lib/sisyphus/worker'
+
+module Sisyphus
+  describe Worker do
+    let(:job) { double :job }
+    let(:output) { double :pipe }
+    let(:worker) { Worker.new job, output }
+
+    it 'traps signals when started' do
+      worker.stub :exit
+      worker.instance_variable_set(:@stopped, true)
+      worker.should_receive :trap_signals
+      worker.start
+    end
+
+    it 'exits when it has been stopped' do
+      worker.instance_variable_set(:@stopped, true)
+      worker.should_receive :exit
+      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
+      end
+    end
+
+    context 'when job responds to :setup' do
+      it 'sets up the job upon initialization' do
+        job.stub(:respond_to?).with(:setup) { true }
+        job.should_receive :setup
+        Worker.new job, output
+      end
+    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
+
+      it 'should exit after having performed the job' do
+        job.stub :perform
+        worker.should_receive(:exit).with 0
+        worker.send :perform_job
+      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
+      end
+
+      context 'when job.perform raises an error' do
+        it 'should exit with a non-zero status' do
+          job.stub(:perform).and_raise Exception.new "should be rescued!"
+          worker.should_receive(:exit).with(1)
+          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
+      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
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,103 @@
+--- !ruby/object:Gem::Specification
+name: sisyphus
+version: !ruby/object:Gem::Version
+  version: 0.2.1
+platform: ruby
+authors:
+- Rasmus Bang Grouleff
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-09-24 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
+email:
+- rasmusbg@virtualmanager.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- Gemfile.lock
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/sisyphus.rb
+- lib/sisyphus/job.rb
+- lib/sisyphus/master.rb
+- lib/sisyphus/sleep.rb
+- lib/sisyphus/worker.rb
+- lib/version.rb
+- sisyphus.gemspec
+- spec/sisyphus/master_spec.rb
+- spec/sisyphus/worker_spec.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'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.2
+signing_key: 
+specification_version: 4
+summary: A tiny library for spawning worker processes
+test_files:
+- spec/sisyphus/master_spec.rb
+- spec/sisyphus/worker_spec.rb