chantier 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 02886ce2234ab79bd1088a0ef7964d3a52046a94
+  data.tar.gz: e9facf80639b5f4cee600a21356a51f85181c699
+SHA512:
+  metadata.gz: ee8e5e32959c699e69bb4d33a5d5101843a24427ed0d61db8d73fe4ce34bf769949d0554e61457faa3597aef4408dbccca8ed92c71d2ffaa83bdf5da175eb378
+  data.tar.gz: efe1866c848fa2ebc49a8324b10741725eaea701ad4cdd69aed35bf41852f530473c6e29ce29320466e67cec888e973e698649be983e3bb6bd58b362abb5f5fa

data/.document

@@ -0,0 +1,5 @@
+lib/**/*.rb
+bin/*
+- 
+features/**/*.feature
+LICENSE.txt

data/.rspec

@@ -0,0 +1 @@
+--color

data/Gemfile

@@ -0,0 +1,9 @@
+source "http://rubygems.org"
+
+group :development do
+  gem "rspec", "~> 2.9"
+  gem "rdoc", "~> 3.12"
+  gem "bundler", "~> 1.0"
+  gem "jeweler", "~> 2.0.1"
+  gem "simplecov", ">= 0"
+end

data/LICENSE.txt

@@ -0,0 +1,20 @@
+Copyright (c) 2014 Julik Tarkhanov
+
+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.rdoc

@@ -0,0 +1,43 @@
+= chantier
+
+Dead-simple task manager for "fire and forget" jobs. Has two interchangeable pools - processes and threads, which
+are interchangeable.
+
+The only thing Chantier checks for is that the spun off tasks have completed. It also limits the number of tasks
+active at the same time. Your code will block until a slot becomes available for a task.
+
+    manager = Chantier::ProcessPool.new(slots = 4) # You can also use ThreadPool
+    jobs_hose.each_job do | job |
+      manager.fork_task do # this call will block until a slot becomes available
+        Churner.new(job).churn # this block runs in a subprocess
+      end
+      manager.still_running? # => most likely "true"
+    end
+    
+    manager.block_until_complete! #=> Will block until all the subprocesses have terminated
+ 
+If you have a finite Enumerable at hand you can also launch it into the ProcessPool, like so:
+ 
+   manager = Chantier::ThreadPool.new(slots = 4)
+   
+   manager.map_fork(job_tickets) do | job_ticket |
+     # this block will run in a forked subprocess
+     Churner.new(job).churn
+     ...
+   end
+
+== Contributing to chantier
+ 
+* Check out the latest master to make sure the feature hasn't been implemented or the bug hasn't been fixed yet.
+* Check out the issue tracker to make sure someone already hasn't requested it and/or contributed it.
+* Fork the project.
+* Start a feature/bugfix branch.
+* Commit and push until you are happy with your contribution.
+* Make sure to add tests for it. This is important so I don't break it in a future version unintentionally.
+* Please try not to mess with the Rakefile, version, or history. If you want to have your own version, or is otherwise necessary, that is fine, but please isolate to its own commit so I can cherry-pick around it.
+
+== Copyright
+
+Copyright (c) 2014 Julik Tarkhanov. See LICENSE.txt for
+further details.
+

data/Rakefile

@@ -0,0 +1,53 @@
+# encoding: utf-8
+
+require 'rubygems'
+require 'bundler'
+require_relative 'lib/chantier'
+
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+require 'rake'
+
+require 'jeweler'
+Jeweler::Tasks.new do |gem|
+  # gem is a Gem::Specification... see http://guides.rubygems.org/specification-reference/ for more options
+  gem.version = Chantier::VERSION
+  gem.name = "chantier"
+  gem.homepage = "http://github.com/julik/chantier"
+  gem.license = "MIT"
+  gem.summary = %Q{ Dead-simple worker table based multiprocessing/multithreading }
+  gem.description = %Q{ Process your jobs in parallel with a simple table of processes or threads }
+  gem.email = "me@julik.nl"
+  gem.authors = ["Julik Tarkhanov"]
+  # dependencies defined in Gemfile
+end
+Jeweler::RubygemsDotOrgTasks.new
+
+require 'rspec/core'
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new(:spec) do |spec|
+  spec.pattern = FileList['spec/**/*_spec.rb']
+end
+
+desc "Code coverage detail"
+task :simplecov do
+  ENV['COVERAGE'] = "true"
+  Rake::Task['spec'].execute
+end
+
+task :default => :spec
+
+require 'rdoc/task'
+Rake::RDocTask.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "chantier #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/lib/chantier.rb

@@ -0,0 +1,5 @@
+module Chantier
+  VERSION = '0.0.1'
+  require_relative 'process_pool'
+  require_relative 'thread_pool'
+end

data/lib/process_pool.rb

@@ -0,0 +1,128 @@
+# Allows you to spin off a pool of subprocesses that is not larger than X, and
+# maintains a pool of those proceses. You can then enqueue tasks to be executed
+# within that pool. When all slots are full the caller will be blocked until a slot becomes
+# available.
+#
+#   manager = ProcessPool.new(slots = 4)
+#   jobs_hose.each_job do | job |
+#     # this call will block until a slot becomes available
+#     manager.fork_task do # this block runs in a subprocess
+#       Churner.new(job).churn
+#     end
+#     manager.still_running? # => most likely "true"
+#   end
+#   
+#   manager.block_until_complete! #=> Will block until all the subprocesses have terminated
+#
+# If you have a finite Enumerable at hand you can also launch it into the ProcessPool, like so:
+#
+#  manager = ProcessPool.new(slots = 4)
+#  
+#  manager.map_fork(job_tickets) do | job_ticket |
+#    # this block will run in a forked subprocess
+#    Churner.new(job).churn
+#    ...
+#  end
+#
+# Can be rewritten using Threads if operation on JVM/Rubinius will be feasible.
+class Chantier::ProcessPool
+  # Kill the spawned processes after at most X seconds
+  KILL_AFTER_SECONDS = 60 * 2
+  
+  # http://linuxman.wikispaces.com/killing+me+softly
+  TERMINATION_SIGNALS = %w( TERM HUP INT QUIT PIPE KILL )
+  
+  # The manager uses loops in a few places. By doing a little sleep()
+  # in those loops we can yield process control back to the OS which brings
+  # the CPU usage of the managing process to small numbers. If you just do
+  # a loop {} MRI will saturate a whole core and not let go off of it until
+  # the loop returns.
+  SCHEDULER_SLEEP_SECONDS = 0.05
+  
+  def initialize(num_procs)
+    raise "Need at least 1 slot, given #{num_procs.to_i}" unless num_procs.to_i > 0
+    @pids = [nil] * num_procs.to_i
+    @semaphore = Mutex.new
+  end
+  
+  # Distributes the elements in the given Enumerable to parallel workers,
+  # N workers at a time. The method will return once all the workers for all
+  # the elements of the Enumerable have terminated.
+  #
+  #   pool = ProcessPool.new(5)
+  #   pool.map_fork(array_of_urls) do | single_url |
+  #     Faraday.get(single_url).response ...
+  #     ...
+  #     ...
+  #   end
+  def map_fork(arguments_per_job, &blk)
+    arguments_per_job.each do | single_block_argument |
+      fork_task { yield(single_block_argument) }
+    end
+    block_until_complete!
+  end
+  
+  # Run the given block in a forked subprocess. This method will block
+  # the thread it is called from until a slot in the process table
+  # becomes free. Once that happens, the given block will be forked off
+  # and the method will return.
+  def fork_task(&blk)
+    destination_slot_idx = nil
+    
+    # Try to find a slot in the process table where this job can go
+    catch :_found do
+      loop do
+        @semaphore.synchronize do
+          if destination_slot_idx = @pids.index(nil)
+            @pids[destination_slot_idx] = true # occupy it
+            throw :_found
+          end
+        end
+        sleep SCHEDULER_SLEEP_SECONDS # Breathing room
+      end
+    end
+    
+    task_pid = fork(&blk)
+    
+    # No need to lock this because we already reserved that slot
+    @pids[destination_slot_idx] = task_pid
+    
+    puts("Spun off a task process #{task_pid} into slot #{destination_slot_idx}") if $VERBOSE
+    
+    # Dispatch the watcher thread that will record that the process has quit into the
+    # process table
+    Thread.new do
+      Process.wait(task_pid) # This call will block until that process quites
+      # Now we can remove that process from the process table
+      @semaphore.synchronize { @pids[destination_slot_idx] = nil }
+    end
+    
+    # Dispatch the killer thread which kicks in after KILL_AFTER_SECONDS.
+    # Note that we do not manage the @pids table here because once the process
+    # gets terminated it will bounce back to the standard wait() above.
+    Thread.new do
+      sleep KILL_AFTER_SECONDS
+      begin
+        TERMINATION_SIGNALS.each do | sig |
+          Process.kill(sig, task_pid)
+          sleep 5 # Give it some time to react
+        end
+      rescue Errno::ESRCH
+        # It has already quit, nothing to do
+      end
+    end
+  end
+  
+  # Tells whether some processes are still churning
+  def still_running?
+    @pids.any?{|e| e }
+  end
+  
+  # Analogous to Process.wait or wait_all - will block until all of the process slots have been freed.
+  def block_until_complete!
+    loop do
+      return unless still_running?
+      sleep SCHEDULER_SLEEP_SECONDS # Breathing room
+    end
+  end
+end

data/lib/thread_pool.rb

@@ -0,0 +1,101 @@
+# Allows you to spin off a pool of Threads that is not larger than X. 
+# You can then enqueue tasks to be executed within that pool. 
+# When all slots are full the caller will be blocked until a slot becomes
+# available.
+#
+#   manager = ThreadPool.new(slots = 4)
+#   jobs_hose.each_job do | job |
+#     # this call will block until a slot becomes available
+#     manager.fork_task do # this block runs in a subprocess
+#       Churner.new(job).churn
+#     end
+#     manager.still_running? # => most likely "true"
+#   end
+#   
+#   manager.block_until_complete! #=> Will block until all the subprocesses have terminated
+#
+# If you have a finite Enumerable at hand you can also launch it into the ThreadPool, like so:
+#
+#  manager = ThreadPool.new(slots = 4)
+#  
+#  manager.map_fork(job_tickets) do | job_ticket |
+#    # this block will run in a forked subprocess
+#    Churner.new(job).churn
+#    ...
+#  end
+#
+# Can be rewritten using Threads if operation on JVM/Rubinius will be feasible.
+class Chantier::ThreadPool
+  
+  # The manager uses loops in a few places. By doing a little sleep()
+  # in those loops we can yield process control back to the OS which brings
+  # the CPU usage of the managing process to small numbers. If you just do
+  # a loop {} MRI will saturate a whole core and not let go off of it until
+  # the loop returns.
+  SCHEDULER_SLEEP_SECONDS = 0.05
+  
+  def initialize(num_threads)
+    raise "Need at least 1 slot, given #{num_threads.to_i}" unless num_threads.to_i > 0
+    @threads = [nil] * num_threads.to_i
+    @semaphore = Mutex.new
+  end
+  
+  # Distributes the elements in the given Enumerable to parallel workers,
+  # N workers at a time. The method will return once all the workers for all
+  # the elements of the Enumerable have terminated.
+  #
+  #   pool = ThreadPool.new(5)
+  #   pool.map_fork(array_of_urls) do | single_url |
+  #     Faraday.get(single_url).response ...
+  #     ...
+  #     ...
+  #   end
+  def map_fork(arguments_per_job, &blk)
+    arguments_per_job.each do | single_block_argument |
+      fork_task { yield(single_block_argument) }
+    end
+    block_until_complete!
+  end
+  
+  # Run the given block in a thread. This method will block
+  # the thread it is called from until a slot in the thread table
+  # becomes free.
+  def fork_task(&blk)
+    destination_slot_idx = nil
+    
+    # Try to find a slot in the process table where this job can go
+    catch :_found do
+      loop do
+        @semaphore.synchronize do
+          if destination_slot_idx = @threads.index(nil)
+            @threads[destination_slot_idx] = true # occupy it
+            throw :_found
+          end
+        end
+        sleep SCHEDULER_SLEEP_SECONDS # Breathing room
+      end
+    end
+    
+    # No need to lock this because we already reserved that slot
+    @threads[destination_slot_idx] = Thread.new do
+      yield
+      # Now we can remove that process from the process table
+      @semaphore.synchronize { @threads[destination_slot_idx] = nil }
+    end
+    
+  end
+  
+  # Tells whether some processes are still churning
+  def still_running?
+    @threads.any?{|e| e && e.respond_to?(:alive?) && e.alive? }
+  end
+  
+  # Analogous to Process.wait or wait_all - will block until all of the process slots have been freed.
+  def block_until_complete!
+    @threads.map do |e| 
+      if e.respond_to?(:join) && e.alive?
+        e.join
+      end
+    end
+  end
+end

data/spec/process_pool_spec.rb

@@ -0,0 +1,111 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe Chantier::ProcessPool do
+  
+  before(:each) do
+    @files = (0...20).map do
+      SecureRandom.hex(12).tap { |filename| FileUtils.touch(filename) }
+    end
+  end
+  
+  after(:each) do
+    @files.map(&File.method(:unlink))
+  end
+  
+  context '#map_fork' do
+    let(:manager) { described_class.new(5) }
+    
+    it 'processes multiple files' do
+      
+      data_chunks = (0..10).map{|e| Digest::SHA1.hexdigest(e.to_s) }
+      
+      expect(manager).not_to be_still_running
+      
+      manager.map_fork(@files) do | filename |
+        sleep(0.05 + (rand / 10))
+        File.open(filename, "wb"){|f| f.write("Worker completed for #{filename}") }
+      end
+      
+      expect(manager).not_to be_still_running
+      
+      @files.each do | filename |
+        expect(File.read(filename)).to eq("Worker completed for #{filename}")
+      end
+    end
+  end
+  
+  context 'with 0 concurrent slots' do
+    it 'raises an exception' do
+      expect {
+        Chantier::ProcessPool.new(0)
+      }.to raise_error(RuntimeError, 'Need at least 1 slot, given 0')
+      
+      expect {
+        Chantier::ProcessPool.new(-1)
+      }.to raise_error(RuntimeError, 'Need at least 1 slot, given -1')
+    end
+  end
+  
+  it 'gets instantiated with the given number of slots' do
+    Chantier::ProcessPool.new(10)
+  end
+  
+  context 'with 1 slot' do
+    let(:manager) { described_class.new(1) }
+    
+    it 'processes 1 file' do
+      filename = @files[0]
+      manager.fork_task do
+        sleep(0.05 + (rand / 10))
+        File.open(filename, "wb"){|f| f.write("Worker completed") }
+      end
+      manager.block_until_complete!
+      
+      expect(File.read(filename)).to eq('Worker completed')
+    end
+    
+    it 'processes multiple files' do
+      expect(manager).not_to be_still_running
+      
+      @files.each do | filename |
+        manager.fork_task do
+          sleep(0.05 + (rand / 10))
+          File.open(filename, "wb"){|f| f.write("Worker completed for #{filename}") }
+        end
+      end
+      
+      expect(manager).to be_still_running
+      
+      manager.block_until_complete!
+      
+      @files.each do | filename |
+        expect(File.read(filename)).to eq("Worker completed for #{filename}")
+      end
+    end
+  end
+  
+  context 'with 5 slots' do
+    let(:manager) { described_class.new(5) }
+    
+    it 'processes multiple files' do
+      
+      expect(manager).not_to be_still_running
+      
+      @files.each do | filename |
+        manager.fork_task do
+          sleep(0.05 + (rand / 10))
+          File.open(filename, "wb"){|f| f.write("Worker completed for #{filename}") }
+        end
+      end
+      
+      expect(manager).to be_still_running
+      
+      manager.block_until_complete!
+      
+      @files.each do | filename |
+        expect(File.read(filename)).to eq("Worker completed for #{filename}")
+      end
+    end
+  end
+end
+

data/spec/spec_helper.rb

@@ -0,0 +1,29 @@
+require 'simplecov'
+
+module SimpleCov::Configuration
+  def clean_filters
+    @filters = []
+  end
+end
+
+SimpleCov.configure do
+  clean_filters
+#  load_adapter 'test_frameworks'
+end
+
+ENV["COVERAGE"] && SimpleCov.start do
+  add_filter "/.rvm/"
+end
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+
+require 'rspec'
+require 'chantier'
+
+# Requires supporting files with custom matchers and macros, etc,
+# in ./support/ and its subdirectories.
+Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each {|f| require f}
+
+RSpec.configure do |config|
+
+end

data/spec/thread_pool_spec.rb

@@ -0,0 +1,111 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe Chantier::ThreadPool do
+  
+  before(:each) do
+    @files = (0...20).map do
+      SecureRandom.hex(12).tap { |filename| FileUtils.touch(filename) }
+    end
+  end
+  
+  after(:each) do
+    @files.map(&File.method(:unlink))
+  end
+  
+  context '#map_fork' do
+    let(:manager) { described_class.new(5) }
+    
+    it 'processes multiple files' do
+      
+      data_chunks = (0..10).map{|e| Digest::SHA1.hexdigest(e.to_s) }
+      
+      expect(manager).not_to be_still_running
+      
+      manager.map_fork(@files) do | filename |
+        sleep(0.05 + (rand / 10))
+        File.open(filename, "wb"){|f| f.write("Worker completed for #{filename}") }
+      end
+      
+      expect(manager).not_to be_still_running
+      
+      @files.each do | filename |
+        expect(File.read(filename)).to eq("Worker completed for #{filename}")
+      end
+    end
+  end
+  
+  context 'with 0 concurrent slots' do
+    it 'raises an exception' do
+      expect {
+        described_class.new(0)
+      }.to raise_error(RuntimeError, 'Need at least 1 slot, given 0')
+      
+      expect {
+        described_class.new(-1)
+      }.to raise_error(RuntimeError, 'Need at least 1 slot, given -1')
+    end
+  end
+  
+  it 'gets instantiated with the given number of slots' do
+    described_class.new(10)
+  end
+  
+  context 'with 1 slot' do
+    let(:manager) { described_class.new(1) }
+    
+    it 'processes 1 file' do
+      filename = @files[0]
+      manager.fork_task do
+        sleep(0.05 + (rand / 10))
+        File.open(filename, "wb"){|f| f.write("Worker completed") }
+      end
+      manager.block_until_complete!
+      
+      expect(File.read(filename)).to eq('Worker completed')
+    end
+    
+    it 'processes multiple files' do
+      expect(manager).not_to be_still_running
+      
+      @files.each do | filename |
+        manager.fork_task do
+          sleep(0.05 + (rand / 10))
+          File.open(filename, "wb"){|f| f.write("Worker completed for #{filename}") }
+        end
+      end
+      
+      expect(manager).to be_still_running
+      
+      manager.block_until_complete!
+      
+      @files.each do | filename |
+        expect(File.read(filename)).to eq("Worker completed for #{filename}")
+      end
+    end
+  end
+  
+  context 'with 5 slots' do
+    let(:manager) { described_class.new(5) }
+    
+    it 'processes multiple files' do
+      
+      expect(manager).not_to be_still_running
+      
+      @files.each do | filename |
+        manager.fork_task do
+          sleep(0.05 + (rand / 10))
+          File.open(filename, "wb"){|f| f.write("Worker completed for #{filename}") }
+        end
+      end
+      
+      expect(manager).to be_still_running
+      
+      manager.block_until_complete!
+      
+      @files.each do | filename |
+        expect(File.read(filename)).to eq("Worker completed for #{filename}")
+      end
+    end
+  end
+end
+

metadata

@@ -0,0 +1,127 @@
+--- !ruby/object:Gem::Specification
+name: chantier
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Julik Tarkhanov
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-07-13 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.9'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.9'
+- !ruby/object:Gem::Dependency
+  name: rdoc
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.12'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.12'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: jeweler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.0.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.0.1
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  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: ' Process your jobs in parallel with a simple table of processes or threads '
+email: me@julik.nl
+executables: []
+extensions: []
+extra_rdoc_files:
+- LICENSE.txt
+- README.rdoc
+files:
+- .document
+- .rspec
+- Gemfile
+- LICENSE.txt
+- README.rdoc
+- Rakefile
+- lib/chantier.rb
+- lib/process_pool.rb
+- lib/thread_pool.rb
+- spec/process_pool_spec.rb
+- spec/spec_helper.rb
+- spec/thread_pool_spec.rb
+homepage: http://github.com/julik/chantier
+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.0.3
+signing_key: 
+specification_version: 4
+summary: Dead-simple worker table based multiprocessing/multithreading
+test_files: []