job_pool 0.5

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 9a9c845f04a84fb0ae22818bec9b471bac197308
+  data.tar.gz: bdadd6aea6d4c068821a24d0afeb316d3f481f8b
+SHA512:
+  metadata.gz: 9fbbb0d9a5ab5bc2c811154b2313a5ec834aef8efca4af9bb17b4cd8d75f17b6964a6170d34418e433efa3851f1aed12c4e5ada2404355c3aab3b3c0301f4a07
+  data.tar.gz: 40f58a16103ca5f5722995ee640ce7b9740b7ceba2d22f027cc3f9fb5eb7832d39255b972196497558a460954794d3e48e300c46a0e81e538beb518181df9cd2

data/.gitignore

@@ -0,0 +1 @@
+Gemfile.lock

data/.travis.yml

@@ -0,0 +1,10 @@
+language: ruby
+
+rvm:
+  - 1.9.3
+  - 2.0.0
+  - 2.1.1
+  - 2.2.2
+  - ruby-head
+
+sudo: false

data/Gemfile

@@ -0,0 +1,2 @@
+source 'https://rubygems.org'
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2015 Scott Bronson
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,114 @@
+# JobPool
+
+Launch commands to run in the background.  Feed them data, read their results, kill them, set timeouts.
+
+[![Build Status](https://travis-ci.org/bronson/job_pool.svg?branch=master)](https://travis-ci.org/bronson/job_pool)
+[![Gem Version](https://badge.fury.io/rb/job_pool.svg)](http://badge.fury.io/rb/job_pool)
+
+
+## Installation
+
+Add this line to your Gemfile:
+
+```ruby
+gem 'job_pool'
+```
+
+## Usage
+
+Start like this if you want to try these examples in irb.
+
+```bash
+$ git clone https://github.com/bronson/job_pool
+$ cd job_pool
+$ irb -Ilib
+```
+
+First, create a job pool:
+
+```ruby
+require 'job_pool'
+
+pool = JobPool.new
+```
+
+Then fire off a job.  This one waits a bit and then ROT-13s its input.
+
+```ruby
+job = pool.launch("sleep 5; tr A-Za-z N-ZA-Mn-za-m", "the secrets")
+pool.count       => 1
+job.output       => ""
+           (after five seconds)
+pool.count       => 0
+job.output       => "gur frpergf"
+```
+
+#### IO Objects
+
+You can specify IO objects to read from and write to:
+
+TODO: this works, but it closes your stdout!  That's problematic.
+Maybe add a mode that doesn't close the output stream when done?
+Or just use a different example?
+
+```ruby
+pool.launch 'gunzip --to-stdout', File.open('contents.txt.gz'), STDOUT
+```
+
+#### Killing a Job
+
+If you want to terminate a job, just kill it:
+
+```ruby
+job = pool.launch("sleep 600")
+job.killed?     => false
+job.kill
+job.killed?     => true
+```
+
+JobPool first sends the process a nice TERM
+signal and waits a bit.  If the process is still running, it sends a KILL signal.
+Pass the number of seconds to wait, default is 2 seconds.
+
+
+#### Timeouts
+
+TODO
+
+#### Limiting Running Processes
+
+Pass the maximum number of running jobs when creating the
+job pool:
+
+```ruby
+pool = JobPool.new(max_jobs: 2)
+pool.launch("sleep 5")
+pool.launch("sleep 5")
+pool.launch("sleep 5")      => raises JobPool::TooManyJobsError
+```
+
+### Error Handling
+
+TODO: describe process result
+
+job.success?
+
+TODO: describe stderr
+
+TODO: friggin documentation!
+
+
+### Job Queues
+
+TODO: include an example of a job queue
+
+
+## License
+
+MIT, enjoy!
+
+
+## Contributing
+
+Submit patches and issues on
+[GitHub](https://github.com/bronson/job_pool/).

data/Rakefile

@@ -0,0 +1,6 @@
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec)
+task :default => ['spec']
+task :test => ['spec']

data/job_pool.gemspec

@@ -0,0 +1,23 @@
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'job_pool/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "job_pool"
+  spec.version       = JobPool::VERSION
+  spec.authors       = ["Scott Bronson"]
+  spec.email         = ["brons_jobpo@rinspin.com"]
+  spec.summary       = "Runs jobs in child processes."
+  spec.description   = "Makes it easy to launch, kill, communicate with, and watch child processes."
+  spec.homepage      = "http://github.com/bronson/job_pool"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  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"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rspec"
+end

data/lib/job_pool/job.rb

@@ -0,0 +1,159 @@
+# Fires off a child process, feeds it, and keeps track of the results.
+
+require 'open3'
+require 'tempfile'
+require 'stringio'
+
+
+class JobPool; end
+
+
+# A job keeps track of the child process that gets forked.
+# job is the Ruby data structure, process is the Unix process.
+class JobPool::Job
+  attr_reader :start_time, :stop_time  # start and finish times of this job
+  attr_reader :inio, :outio, :errio    # fds for child's stdin/stdout/stderr
+
+  # runs cmd, passes instr on its stdin, and fills outio and
+  # errio with the command's output.
+  # TODO: should specify args using keywords rather than position.
+  def initialize pool, cmd, inio=nil, outio=nil, errio=nil, timeout=nil
+    @start_time = Time.now
+    @pool  = pool
+    @inio  = inio || StringIO.new
+    @inio  = StringIO.new(@inio.to_s) unless @inio.respond_to?(:readpartial)
+    @outio = outio || StringIO.new
+    @errio = errio || StringIO.new
+    @chin, @chout, @cherr, @child = Open3.popen3(*cmd)
+
+    @pool._add(self)
+    @chout.binmode
+
+    @killed = false
+    @timed_out = false
+
+    @thrin  = Thread.new { drain(@inio, @chin) }
+    @throut = Thread.new { drain(@chout, @outio) }
+    @threrr = Thread.new { drain(@cherr, @errio) }
+
+    # ensure cleanup is called when the child exits. (crazy that this requires a whole new thread!)
+    @cleanup_thread = Thread.new do
+      if timeout
+        # TODO: inline outatime
+        outatime unless @child.join(timeout)
+      else
+        @child.join
+      end
+      stop
+    end
+  end
+
+  def write *args
+    @inio.write *args
+  end
+
+  def read *args
+    @outio.read *args
+  end
+
+  def output
+    @outio.string
+  end
+
+  def error
+    @errio.string
+  end
+
+  def finished?
+    @stop_time != nil
+  end
+
+  # returns false if the process hasn't finished yet
+  def success?
+    finished? && @child.value.success? ? true : false
+  end
+
+  def killed?
+    @killed
+  end
+
+  def timed_out?
+    @timed_out
+  end
+
+  # kill-o-zaps the phantom process now (using -9 if needed), then waits until it's truly gone
+  def kill seconds_until_panic=2
+    @killed = true
+    if @child.alive?
+      # rescue because process might have died between previous line and this one
+      Process.kill("TERM", @child.pid) rescue Errno::ESRCH
+    end
+    if !@child.join(seconds_until_panic)
+      Process.kill("KILL", @child.pid) if @child.alive?
+    end
+    # ensure kill doesn't return until process is truly gone
+    # (there may be a chance of this deadlocking with a blocking callback... not sure)
+    @cleanup_thread.join unless Thread.current == @cleanup_thread
+  end
+
+  # waits patiently until the process terminates, then cleans up
+  def stop
+    wait_for_the_end   # do all our waiting outside the sync loop
+    @pool._remove(self) do
+      _cleanup
+    end
+  end
+
+
+  # only meant to be used by the ProcessMonitor
+  def _child_thread
+    @child
+  end
+
+  # may only be called once, synchronized by stop()
+  def _cleanup
+    raise "Someone else already cleaned up this job?!" if @stop_time
+    @stop_time = Time.now
+  end
+
+  # returns true if process was previously active.  must be externally synchronized.
+  # TODO: this is a terrible api.  gotta be a way to clean it up.
+  def _deactivate
+    retval = @inactive
+    @inactive = true
+    return !retval
+  end
+
+
+private
+  def wait_for_the_end
+    [@thrin, @throut, @threrr, @child].each(&:join)
+    @cleanup_thread.join unless Thread.current == @cleanup_thread
+  end
+
+  def outatime
+    @timed_out = true
+    kill
+  end
+
+  # reads every last drop, then closes both files.  must be threadsafe.
+  def drain reader, writer
+    begin
+      # randomly chosen buffer size
+      loop { writer.write(reader.readpartial(256*1024)) }
+    rescue EOFError
+      # not an error
+      # puts "EOF STDOUT" if reader == @chout
+      # puts "EOF STDERR" if reader == @cherr
+      # puts "EOF STDIN #{reader}" if writer == @chin
+    rescue Errno::EPIPE
+      # child was killed, no problem
+    rescue StandardError => e
+      @pool.log "#{e.class}: #{e.message}\n"
+    ensure
+      reader.close
+      # writer may already be closed
+      writer.close rescue Errno::EPIPE
+    end
+  end
+end

data/lib/job_pool/version.rb

@@ -0,0 +1,3 @@
+class JobPool
+  VERSION = "0.5"
+end

data/lib/job_pool.rb

@@ -0,0 +1,96 @@
+require 'thwait'
+
+require 'job_pool/job'
+
+# TODO: take mutex once in kill_all
+# TODO: rewrite wait_next
+
+class JobPool
+  class TooManyJobsError < StandardError; end
+
+  attr_accessor :max_jobs
+
+  def initialize(options={})
+    @mutex ||= Mutex.new
+
+    @processes ||= []   # TODO: convert this to a hash by child thread?
+    @max_jobs = options[:max_jobs]
+  end
+
+  def launch *args
+    JobPool::Job.new self, *args
+  end
+
+  def first
+    @mutex.synchronize { @processes.first }
+  end
+
+  def count
+    @mutex.synchronize { @processes.count }
+  end
+
+  def find &block
+    @mutex.synchronize { @processes.find(&block) }
+  end
+
+  def kill_all
+    # TODO: this is racy...  if someone else is starting processes,
+    # we'll just endless loop.  can we take the mutex once outside the loop?
+    while f = first
+      f.kill
+    end
+  end
+
+  # blocks until any child process returns (unless nonblock is true, where it returns nil TODO)
+  # raises an exception if no processes are running, or if called nonblocking
+  # and no processes have finished (see ThreadsWait#next_wait for details).
+  def wait_next nonblock=nil
+    # we wait on child threads since calling waitpid would produce a race condition.
+
+    threads = {}
+    @processes.each { |p|
+      threads[p._child_thread] = p
+    }
+
+    # TODO: test nonblock
+
+    thread = ThreadsWait.new(threads.keys).next_wait(nonblock)
+    process = threads[thread]
+    process.stop # otherwise process will be in an indeterminite state
+    process
+  end
+
+  # called there's an error in a job's subthreads. never happens during normal # usage.
+  def log msg
+    STDERR.puts msg
+  end
+
+  def _add process
+    @mutex.synchronize do
+      if @max_jobs && @processes.count >= @max_jobs
+        raise JobPool::TooManyJobsError.new("launched process #{@processes.count+1} of #{@max_processes} maximum")
+      end
+      @processes.push process
+    end
+  end
+
+  # removes process from process table.  pass a block that cleans up after the process.
+  # _remove may be called lots of times but block will only be called once
+  def _remove process
+    cleanup = false
+
+    @mutex.synchronize do
+      cleanup = process._deactivate
+      raise "process not in process table??" if cleanup && !@processes.include?(process)
+    end
+
+    # don't want to hold mutex when calling callback because it might block
+    if cleanup
+      yield
+      @mutex.synchronize do
+        value = @processes.delete(process)
+        raise "someone else deleted process??" unless value
+      end
+    end
+  end
+end

data/spec/job_pool/job_spec.rb

@@ -0,0 +1,121 @@
+require 'spec_helper'
+require 'job_pool/job'
+
+# run this to ensure there are no deadlock / process synchronization problems:
+#    while rspec spec/job_pool/job_spec.rb ; do : ; done
+
+describe JobPool::Job do
+  class FakeJobPool
+    def initialize
+      @jobs = []
+    end
+
+    def _add(job)
+      @jobs << job
+    end
+
+    def _remove(job)
+      yield if @jobs.delete(job)
+    end
+
+    def count
+      @jobs.count
+    end
+  end
+
+  let(:pool)  { FakeJobPool.new }
+  let(:chin)  { StringIO.new('small instring') }
+  let(:chout) { StringIO.new }
+  let(:cherr) { StringIO.new }
+
+  def time_this_block &block
+    start = Time.now
+    block.call
+    finish = Time.now
+    finish - start
+  end
+
+
+  it "has a working drain method" do
+    bigin = StringIO.new('x' * 1024 * 1024) # at least 1 MB of data to test drain loop
+    job = JobPool::Job.new(pool, 'cat', bigin, chout, cherr)
+    job.stop
+    expect(chout.string).to eq bigin.string
+    expect(job.finished?).to eq true
+  end
+
+  it "waits until a sleeping command is finished" do
+    # pile a bunch of checks into this test so we only have to sleep once
+    expect(pool.count).to eq 0
+    claimed = nil
+
+    elapsed = time_this_block do
+      # echo -n doesn't work here because of platform variations
+      # and for some reason jruby requires the explicit subshell; mri launches it automatically
+      process = JobPool::Job.new(pool, '/bin/sh -c "sleep 0.1 && printf done."', chin, chout, cherr)
+      expect(pool.count).to eq 1
+      process.stop
+      expect(process.start_time).not_to eq nil
+      expect(process.stop_time).not_to eq nil
+      claimed = process.stop_time - process.start_time
+      expect(chout.string).to eq 'done.'
+      expect(process.finished?).to eq true
+      expect(process.success?).to eq true
+    end
+
+    # ensure process elapsed time is in the ballpark
+    expect(elapsed).to be >= 0.1
+    expect(claimed).to be >= 0.1
+    expect(claimed).to be <= elapsed
+
+    expect(pool.count).to eq 0
+    expect(chout.closed_read?).to eq true
+    expect(cherr.closed_read?).to eq true
+  end
+
+  it "has a working kill method" do
+    elapsed = time_this_block do
+      process = JobPool::Job.new(pool, ['sleep', '0.5'], chin, chout, cherr)
+
+      expect(process.finished?).to eq false
+      expect(process.killed?).to eq false
+      expect(process.success?).to eq false
+      expect(process.timed_out?).to eq false
+
+      process.kill
+
+      expect(process.finished?).to eq true
+      expect(process.killed?).to eq true
+      expect(process.success?).to eq false
+      expect(process.timed_out?).to eq false
+    end
+
+    expect(elapsed).to be < 0.5
+    expect(chout.closed_read?).to eq true
+    expect(cherr.closed_read?).to eq true
+  end
+
+  it "handles invalid commands" do
+    expect {
+      expect(pool.count).to eq 0
+      process = JobPool::Job.new(pool, ['ThisCmdDoes.Not.Exist.'], chin, chout, cherr)
+      raise "we shouldn't get here"
+    }.to raise_error(/[Nn]o such file/)
+    expect(pool.count).to eq 0
+  end
+
+  it "has a working timeout" do
+    elapsed = time_this_block do
+      process = JobPool::Job.new(pool, ['sleep', '10'], chin, chout, cherr, 0.1)
+    end
+    expect(elapsed).to be < 0.2
+  end
+
+  # TODO: should probably define exactly what happens in this case
+  it "accepts a 0-length timeout" do
+    elapsed = time_this_block do
+      process = JobPool::Job.new(pool, ['sleep', '10'], chin, chout, cherr, 0)
+    end
+    expect(elapsed).to be < 0.2
+  end
+end

data/spec/job_pool_spec.rb

@@ -0,0 +1,79 @@
+require 'spec_helper'
+require 'job_pool'
+
+describe JobPool do
+  describe "job counter" do
+    it "will add a job" do
+      jobs = JobPool.new(max_jobs: 1)
+      # this should not raise an exception
+      # not using expect(...).not_to raise_exception since that eats all raised expections.
+      jobs._add(Object.new)
+    end
+
+    it "won't launch too many jobs" do
+      jobs = JobPool.new(max_jobs: 0)
+      expect { jobs._add(Object.new) }.to raise_exception(JobPool::TooManyJobsError)
+    end
+
+    it "can disable the jobs counter" do
+      jobs = JobPool.new
+      jobs._add(Object.new)
+    end
+  end
+
+
+  describe "with a pool" do
+    let(:pool) { JobPool.new }
+
+    before { expect(pool.count).to eq 0 }
+    after { expect(pool.count).to eq 0 }
+
+    it "counts and kills multiple processes" do
+      pool.launch(['sleep', '20'], StringIO.new, StringIO.new, StringIO.new)
+      pool.launch(['sleep', '20'], StringIO.new, StringIO.new, StringIO.new)
+      pool.launch(['sleep', '20'], StringIO.new, StringIO.new, StringIO.new)
+      pool.launch(['sleep', '20'], StringIO.new, StringIO.new, StringIO.new)
+      expect(pool.count).to eq 4
+      pool.first.kill
+      expect(pool.count).to eq 3
+      # can't use Array#each since calling delete in the block causes it to screw up
+      pool.kill_all
+    end
+
+    it "waits for multiple processes" do
+      # these sleep durations might be too small, depends on machine load and scheduling.
+      # if you're seeing threads finishing in the wrong order, try increasing them 10X.
+      process1 = pool.launch(['sleep', '.3'], StringIO.new, StringIO.new, StringIO.new)
+      process2 = pool.launch(['sleep', '.1'], StringIO.new, StringIO.new, StringIO.new)
+      process3 = pool.launch(['sleep', '.2'], StringIO.new, StringIO.new, StringIO.new)
+      expect(pool.count).to eq 3
+
+      child = pool.wait_next
+      expect(child).to eq process2
+      expect(child.finished?).to eq true
+      expect(child.success?).to eq true
+      expect(pool.count).to eq 2
+
+      child = pool.wait_next
+      expect(child).to eq process3
+      expect(pool.count).to eq 1
+
+      child = pool.wait_next
+      expect(child).to eq process1
+    end
+
+    it "handles waiting for zero processes" do
+      expect {
+        child = pool.wait_next
+      }.to raise_exception(ThreadsWait::ErrNoWaitingThread)
+    end
+  end
+
+  it "can find a process" do
+    object = Object.new
+    pool = JobPool.new
+    pool._add(object)
+    result = pool.find { |o| o == object }
+    expect(result).to eq object
+  end
+end

data/spec/readme_spec.rb

@@ -0,0 +1,39 @@
+require 'spec_helper'
+require 'job_pool'
+
+describe 'README' do
+  it "can do the first example" do
+    pool = JobPool.new
+    job = pool.launch("sleep 0.1; tr A-Za-z N-ZA-Mn-za-m", "the secrets")
+    expect(job.output).to eq ''
+    expect(pool.count).to eq 1
+    sleep(0.2)
+    expect(job.output).to eq "gur frpergf"
+    expect(pool.count).to eq 0
+  end
+
+  it "can do the iostreams example" do
+    pool = JobPool.new
+    # can't use `expect { ... }.to output('contents').to_stdout`
+    # because the test's stdout gets closed
+    outstr = StringIO.new
+    pool.launch 'gunzip --to-stdout', File.open('spec/contents.txt.gz'), outstr
+    pool.wait_next
+    expect(outstr.string).to eq "contents\n"
+  end
+
+  it "can do the killer example" do
+    pool = JobPool.new
+    job = pool.launch("sleep 600")
+    expect(job.killed?).to eq false
+    job.kill
+    expect(job.killed?).to eq true
+  end
+
+  it "can do the max_jobs example" do
+    pool = JobPool.new(max_jobs: 2)
+    pool.launch("sleep 5")
+    pool.launch("sleep 5")
+    expect { pool.launch("sleep 5") }.to raise_error(JobPool::TooManyJobsError)
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,3 @@
+RSpec.configure do |config|
+  # defaults are all ok
+end

metadata

@@ -0,0 +1,106 @@
+--- !ruby/object:Gem::Specification
+name: job_pool
+version: !ruby/object:Gem::Version
+  version: '0.5'
+platform: ruby
+authors:
+- Scott Bronson
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-10-10 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Makes it easy to launch, kill, communicate with, and watch child processes.
+email:
+- brons_jobpo@rinspin.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".travis.yml"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- job_pool.gemspec
+- lib/job_pool.rb
+- lib/job_pool/job.rb
+- lib/job_pool/version.rb
+- spec/contents.txt.gz
+- spec/job_pool/job_spec.rb
+- spec/job_pool_spec.rb
+- spec/readme_spec.rb
+- spec/spec_helper.rb
+homepage: http://github.com/bronson/job_pool
+licenses:
+- MIT
+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.4.5
+signing_key: 
+specification_version: 4
+summary: Runs jobs in child processes.
+test_files:
+- spec/contents.txt.gz
+- spec/job_pool/job_spec.rb
+- spec/job_pool_spec.rb
+- spec/readme_spec.rb
+- spec/spec_helper.rb