chantier 0.0.5 → 1.0.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 748fbefb75937019db2ddbf9d8ff6ffcd88c1227
-  data.tar.gz: cacf4320b37f1891393ec55a8ed43d316825d21b
+  metadata.gz: 9f7e3721971fc3b264faba767be38065cd763f97
+  data.tar.gz: 615d99c6ffccc92804ca9ce6eae1e9e4b7dda18d
 SHA512:
-  metadata.gz: 0c14a5d0828f0ed0f4491abdb6e152f027e73d457869f90e4ec3bf9630deb819f0ffd3e710814bfa94b654dc4a25403efdf1fe27800aa4b164af123d0852ff42
-  data.tar.gz: b6382976248c36e1fa908dcd3f4b80162f4534c5392de7ceecf0687446d8a5aa2b727507f3bdf6ccff466f14ff9818aa36a25ba26bb6b455dfe72befd57d9369
+  metadata.gz: 962aa2648f78ce54fdf25af4c272b4a5babb99c2f7ad7fe2edbeadd772180bde851eecea335d75e5e6983b6111ea42854afd56a7a7580ecbdebca94501dfc4d4
+  data.tar.gz: f47eb5fcdd418b5fc78e3a77716eeb42c2cf781100fc22b9528c72b44699d90a564dfdd50c0593e030140189cb68dcb779398701ab79afb9bed5b98b8701a2d3

data/.travis.yml

@@ -0,0 +1,4 @@
+rvm:
+  - 2.0.0
+  - 2.1.2
+cache: bundler

data/README.md

@@ -0,0 +1,81 @@
+# chantier
+
+Dead-simple task manager for "fire and forget" jobs. Has two interchangeable pools -
+processes and threads. The API of those two is the same, so you can play at will and figure
+out which one works better.
+
+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`/`ThreadPool`, like so:
+ 
+    manager = Chantier::ThreadPool.new(slots = 4)
+    
+    manager.map_fork(job_tickets) do | job_ticket | # job_tickets has to be an Enumerable 
+      # this block will run in a thread
+      Churner.new(job_ticket).churn
+      ...
+    end
+
+Chantier does not provide any built-in IPC or inter-thread communication features - this
+should stimulate you to write your tasks without them having to do IPC in the first place.
+
+
+## Managing job failure
+
+Chantier implements what it calls `FailurePolicies`. A `Policy` is an object that works
+like a counter for failed and successfully completed jobs. After each job, the policy
+object will be asked whether `limit_reached?` is now true. If it is, calls to `fork_task()`
+on the `Pool` using the failure policy will fail with an exception. There is a number of
+standard `FailurePolcies` which can be applied to each specific `Pool`, by supplying it in
+the `failure_policy` keyword argument.
+
+For example, to stop the `Pool` from accepting jobs if more than half of the jobs fail
+(either by raising an exception within their threads or by exiting the forked process with
+a non-0 exit code):
+
+    fp = Chantier::FailurePolicies::Percentage.new(50)
+    pool = Chantier::ThreadPool.new(num_threads = 5, failure_policy: fp)
+    4.times { pool.fork { puts "All is well"} }
+    6.times { pool.fork { raise "Drat!"} } # Will only run 4 times and fail after
+
+To allow only a specific number of failures within a time period wrap the policy in
+a `WithInterval` object:
+    
+    # Only allow 5 failures per second
+    counter = Chantier::FailurePolicies::Count.new(5)
+    fp = Chantier::FailurePolicies::WithinInterval.new(counter, within_seconds=3)
+  
+You can use those to set fine-grained failure conditions based on the runtime behavior of
+the Pool you are using and job duration/failure rate. Chantier pools are made to run in
+very long loops, sometimes indefinitely - so a `FailurePolicy` can be your best friend. You
+can also bundle those policies together.
+
+
+## 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/chantier.gemspec

@@ -2,34 +2,41 @@
 # DO NOT EDIT THIS FILE DIRECTLY
 # Instead, edit Jeweler::Tasks in Rakefile, and run 'rake gemspec'
 # -*- encoding: utf-8 -*-
-# stub: chantier 0.0.5 ruby lib
+# stub: chantier 1.0.5 ruby lib
 
 Gem::Specification.new do |s|
   s.name = "chantier"
-  s.version = "0.0.5"
+  s.version = "1.0.5"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.require_paths = ["lib"]
   s.authors = ["Julik Tarkhanov"]
-  s.date = "2014-08-05"
+  s.date = "2014-08-07"
   s.description = " Process your jobs in parallel with a simple table of processes or threads "
   s.email = "me@julik.nl"
   s.extra_rdoc_files = [
     "LICENSE.txt",
-    "README.rdoc"
+    "README.md"
   ]
   s.files = [
     ".document",
     ".rspec",
+    ".travis.yml",
     "Gemfile",
     "LICENSE.txt",
-    "README.rdoc",
+    "README.md",
     "Rakefile",
     "chantier.gemspec",
     "lib/chantier.rb",
+    "lib/failure_policies.rb",
     "lib/process_pool.rb",
     "lib/process_pool_with_kill.rb",
     "lib/thread_pool.rb",
+    "spec/failure_policy_by_percentage_spec.rb",
+    "spec/failure_policy_counter_spec.rb",
+    "spec/failure_policy_mutex_wrapper_spec.rb",
+    "spec/failure_policy_spec.rb",
+    "spec/failure_policy_within_interval_spec.rb",
     "spec/process_pool_spec.rb",
     "spec/process_pool_with_kill_spec.rb",
     "spec/spec_helper.rb",

data/lib/chantier.rb

@@ -1,6 +1,7 @@
 module Chantier
-  VERSION = '0.0.5'
+  VERSION = '1.0.5'
   require_relative 'process_pool'
   require_relative 'process_pool_with_kill'
   require_relative 'thread_pool'
+  require_relative 'failure_policies'
 end

data/lib/failure_policies.rb

@@ -0,0 +1,168 @@
+module Chantier::FailurePolicies
+  # A very basic failure policy that will do nothing at all.
+  # It will always answer "nil" to limit_reached?, therefore allowing
+  # the works to proceed indefinitely. By overriding the four main methods
+  # on it you can control the policy further.
+  #
+  # Note that all calls to arm!, failure!, success! and limit_reached? are
+  # automatically protected by a Mutex - you don't need to set one up
+  # yourself.
+  class None
+    # Start counting the failures (will be triggered on the first job). You can manually
+    # call this to reset the object the object to the initial state (reset error counts)
+    def arm!
+    end
+  
+    # Increment the failure counter
+    def failure!
+    end
+  
+    # Increment the success counter
+    def success!
+    end
+  
+    # Tells whether the failure policy has been triggered.
+    # Return something falsey from here if everything is in order
+    def limit_reached?
+    end
+  end
+
+  # Simplest failure policy based on overall error count.
+  #
+  #   policy = FailAfterCount.new(4)
+  #   policy.limit_reached? # => false
+  #   1.times { policy.failure! }
+  #   policy.limit_reached? # => false
+  #   #... and then
+  #   4.times { policy.failure! }
+  #   policy.limit_reached? # => true
+  class Count < None
+    def initialize(max_failures)
+      @max = max_failures
+    end
+  
+    # Arm the counter, prepare all the parameters
+    def arm!
+      @count = 0
+    end
+  
+    # Register a failure (simply increments the counter)
+    def failure!
+      @count += 1
+    end
+  
+    # Tells whether we had too many failures
+    def limit_reached?
+      @count >= @max
+    end
+  end
+
+  # Limits the number of failures that may be registered 
+  # by percentage of errors vs successful triggers.
+  #
+  #   policy = FailByPercentage.new(40)
+  #   policy.limit_reached? # => false
+  #   600.times { policy.success! }
+  #   policy.limit_reached? # => false
+  #   1.times { policy.failure! }
+  #   policy.limit_reached? # => false
+  #   400.times { policy.failure! }
+  #   policy.limit_reached? # => true
+  class Percentage < None
+    def initialize(percents_failing)
+      @threshold = percents_failing
+    end
+    
+    def arm!
+      @failures, @successes = 0, 0
+    end
+    
+    def failure!
+      @failures += 1
+    end
+  
+    def success!
+      @successes += 1
+    end
+  
+    def limit_reached?
+      ratio = @failures.to_f / (@failures + @successes)
+      (ratio * 100) >= @threshold
+    end
+  end
+
+  # Limits the number of failures that may be registered
+  # within the given interval
+  #
+  #   policy = Count.new(10)
+  #   policy_within_interval = FailWithinTimePeriod.new(policy, 60 * 2) # 2 minutes
+  #   policy_within_interval.limit_reached? # => false
+  #   #... and then during 1 minute
+  #   5.times { policy_within_interval.failure! }
+  #   policy_within_interval.limit_reached? # => true
+  #
+  # Once the interval is passed,
+  # the error count will be reset back to 0.
+  class WithinInterval < None
+    def initialize(policy, interval_in_seconds)
+      @policy = policy
+      @interval = interval_in_seconds
+    end
+    
+    def success!
+      interval_cutoff!
+      @policy.success!
+    end
+    
+    def arm!
+      @policy.arm!
+      @interval_started = Time.now.utc.to_f
+      @count = 0
+    end
+  
+    def failure!
+      interval_cutoff!
+      @policy.failure!
+    end
+  
+    def limit_reached?
+      @policy.limit_reached?
+    end
+    
+    private
+    
+    def interval_cutoff!
+      t = Time.now.utc.to_f
+      if (t - @interval_started) > @interval
+        @interval_started = t
+        @policy.arm!
+      end
+    end
+    
+  end
+
+  # Wraps a FailurePolicy-compatible object in a Mutex 
+  # for all method calls.
+  class MutexWrapper
+    def initialize(failure_policy)
+      @policy = failure_policy
+      @mutex = Mutex.new
+    end
+  
+    def arm!
+      @mutex.synchronize { @policy.arm! }
+    end
+  
+    def success!
+      @mutex.synchronize { @policy.success! }
+    end
+  
+    def failure!
+      @mutex.synchronize { @policy.failure! }
+    end
+  
+    def limit_reached?
+      @mutex.synchronize { @policy.limit_reached? }
+    end
+  end
+end

data/lib/process_pool.rb

@@ -37,13 +37,13 @@ class Chantier::ProcessPool
   # Initializes a new ProcessPool with the given number of workers. If max_failures is
   # given the fork_task method will raise an exception if more than N processes spawned
   # have been terminated with a non-0 exit status.
-  def initialize(num_procs, max_failures: nil)
-    @max_failures = max_failures && max_failures.to_i
-    @non_zero_exits = 0
-    
+  def initialize(num_procs, failure_policy: Chantier::FailurePolicies::None.new)
     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
+    
+    @failure_policy = Chantier::FailurePolicies::MutexWrapper.new(failure_policy)
+    @failure_policy.arm!
   end
   
   # Distributes the elements in the given Enumerable to parallel workers,
@@ -68,8 +68,8 @@ class Chantier::ProcessPool
   # becomes free. Once that happens, the given block will be forked off
   # and the method will return.
   def fork_task(&blk)
-    if @max_failures && @non_zero_exits > @max_failures
-      raise "Reached error limit of processes quitting with non-0 status - limit set at #{@max_failures}"
+    if @failure_policy.limit_reached?
+      raise "Reached error limit of processes quitting with non-0 status"
     end
     
     destination_slot_idx = nil
@@ -102,27 +102,12 @@ class Chantier::ProcessPool
       @semaphore.synchronize do
         # Now we can remove that process from the process table
         @pids[destination_slot_idx] = nil
-        # and increment the error count if needed
-        @non_zero_exits += 1 unless terminated_normally
       end
+      terminated_normally ? @failure_policy.success! : @failure_policy.failure!
     end
     
-    return task_pid
-    
-    # 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
+    # Make sure to return the PID afterwards
+    task_pid
   end
   
   # Tells whether some processes are still churning

data/lib/thread_pool.rb

@@ -37,17 +37,15 @@ class Chantier::ThreadPool
   # Initializes a new ProcessPool with the given number of workers. If max_failures is
   # given the fork_task method will raise an exception if more than N threads spawned
   # have raised during execution.
-  def initialize(num_threads, max_failures: nil)
+  def initialize(num_threads, failure_policy: Chantier::FailurePolicies::None.new)
     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
     
-    # Failure counters
-    @failure_count = 0
-    @max_failures = max_failures && max_failures.to_i
+    @failure_policy = Chantier::FailurePolicies::MutexWrapper.new(failure_policy)
+    @failure_policy.arm!
     
     # Information on the last exception that happened
-    @aborted = false
     @last_representative_exception = nil
   end
   
@@ -72,8 +70,8 @@ class Chantier::ThreadPool
   # the thread it is called from until a slot in the thread table
   # becomes free.
   def fork_task(&blk)
-    if @last_representative_exception
-      raise "Reached error limit of #{@max_failures} (last error was #{@last_representative_exception.inspect})"
+    if @failure_policy.limit_reached?
+      raise "Reached error limit (last error was #{@last_representative_exception.inspect})"
     end
     
     destination_slot_idx = nil
@@ -118,15 +116,12 @@ class Chantier::ThreadPool
   
   def run_block_with_exception_protection(&blk)
     yield
+    @failure_policy.success!
   rescue Exception => e
     # Register the failure and decrement the counter. If we had more than N 
     # failures stop the machine completely by raising an exception in the caller.
-    @semaphore.synchronize do
-      @failure_count += 1
-      if @max_failures && (@failure_count > @max_failures)
-        @last_representative_exception = e
-      end
-    end
+    @failure_policy.failure!
+    @last_representative_exception = e if @failure_policy.limit_reached?
   end
   
 end

data/spec/failure_policy_by_percentage_spec.rb

@@ -0,0 +1,27 @@
+require_relative 'spec_helper'
+
+describe Chantier::FailurePolicies::Percentage do
+  it 'performs the percentage checks' do
+    policy = described_class.new(40.0)
+    policy.arm!
+    
+    599.times { policy.success! }
+    1.times { policy.failure! }
+    expect(policy).not_to be_limit_reached
+    
+    399.times { policy.failure! }
+    expect(policy).to be_limit_reached
+  end
+  
+  it 'resets the counts when calling arm!' do
+    policy = described_class.new(40)
+    policy.arm!
+    
+    50.times { policy.failure! }
+    50.times { policy.success! }
+    expect(policy).to be_limit_reached
+    
+    policy.arm!
+    expect(policy).not_to be_limit_reached
+  end
+end

data/spec/failure_policy_counter_spec.rb

@@ -0,0 +1,28 @@
+require_relative 'spec_helper'
+
+describe Chantier::FailurePolicies::Count do
+  it 'performs the counts with the right responses' do
+    policy = described_class.new(12)
+    
+    policy.arm!
+    
+    (644 - 12).times { policy.success! }
+    expect(policy).not_to be_limit_reached
+    
+    5.times { policy.failure! }
+    expect(policy).not_to be_limit_reached
+    
+    (12 - 5).times { policy.failure! }
+    expect(policy).to be_limit_reached
+  end
+  
+  it 'resets the counts when calling arm!' do
+    policy = described_class.new(4)
+    policy.arm!
+    4.times { policy.failure! }
+    expect(policy).to be_limit_reached
+    
+    policy.arm!
+    expect(policy).not_to be_limit_reached
+  end
+end

data/spec/failure_policy_mutex_wrapper_spec.rb

@@ -0,0 +1,106 @@
+require_relative 'spec_helper'
+
+def rsleep
+  sleep(rand(10)/1200.0)
+end
+
+describe Chantier::FailurePolicies::MutexWrapper do
+  class NonThreadsafe
+    attr_reader :arms, :successes, :failures, :limits_reached
+    
+    def initialize
+      @arms, @successes, @failures, @limits_reached = 0,0,0,0
+    end
+    
+    def arm!
+      @arms += 6
+      rsleep
+      @arms -= 6
+      rsleep
+      @arms += 1
+    end
+    
+    def success!
+      @successes += 12
+      rsleep
+      @successes -= 12
+      rsleep
+      @successes += 1
+    end
+    
+    def failure!
+      @failures += 4
+      rsleep
+      @failures -= 4
+      rsleep
+      @failures += 1
+    end
+    
+    def limit_reached?
+      @limits_reached += 13
+      rsleep
+      @limits_reached -= 13
+      rsleep
+      @limits_reached += 1
+    end
+  end
+  
+  it 'evaluates a non-threadsafe object in this spec' do
+    policy = NonThreadsafe.new
+    
+    n = 400
+    states = []
+    threads = (1..n).map do | n |
+      Thread.new do
+        rsleep
+        policy.arm!
+        rsleep
+        policy.failure!
+        rsleep
+        policy.success!
+        rsleep
+        policy.limit_reached?
+        call_counts = [
+          policy.arms,
+          policy.failures,
+          policy.successes,
+          policy.limits_reached,
+        ]
+        states << call_counts
+      end
+    end
+    
+    threads.map(&:join)
+    expect(states.uniq.length).not_to eq(n)
+  end
+  
+  it 'wraps all the necessary methods' do
+    wrapped = NonThreadsafe.new
+    policy = described_class.new(wrapped)
+    
+    n = 400
+    states = []
+    threads = (1..n).map do | n |
+      Thread.new do
+        rsleep
+        policy.arm!
+        rsleep
+        policy.failure!
+        rsleep
+        policy.success!
+        rsleep
+        policy.limit_reached?
+        call_counts = [
+          wrapped.arms,
+          wrapped.failures,
+          wrapped.successes,
+          wrapped.limits_reached,
+        ]
+        states << call_counts
+      end
+    end
+    
+    threads.map(&:join)
+    expect(states.uniq.length).to eq(n)
+  end
+end

data/spec/failure_policy_spec.rb

@@ -0,0 +1,10 @@
+require_relative 'spec_helper'
+
+describe Chantier::FailurePolicies::None do
+  it 'has all the necessary methods' do
+    expect(subject.arm!).to be_nil
+    expect(subject.failure!).to be_nil
+    expect(subject.success!).to be_nil
+    expect(subject.limit_reached?).to be_nil
+  end
+end

data/spec/failure_policy_within_interval_spec.rb

@@ -0,0 +1,30 @@
+require_relative 'spec_helper'
+
+describe Chantier::FailurePolicies::WithinInterval do
+  let(:counter) { Chantier::FailurePolicies::Count.new(10) }
+  
+  it 'does not cross the limit when errors are spread out' do
+    policy = described_class.new(counter, 0.5)
+    policy.arm!
+    
+    10.times do
+      policy.failure!
+      sleep 0.1
+    end
+    expect(policy).not_to be_limit_reached
+  end
+  
+  it 'does cross the limit when errors are spread out' do
+    policy = described_class.new(counter, 0.5)
+    policy.arm!
+    
+    10.times do
+      policy.failure!
+      sleep 0.01
+    end
+    expect(policy).to be_limit_reached
+    
+    policy.arm!
+    expect(policy).not_to be_limit_reached
+  end
+end

data/spec/process_pool_spec.rb

@@ -52,12 +52,13 @@ describe Chantier::ProcessPool do
   
   context 'with failures' do
     it 'raises after 4 failures' do
-      under_test = described_class.new(num_workers=3, max_failures: '4')
+      fp = Chantier::FailurePolicies::Count.new(4)
+      under_test = described_class.new(num_workers = 3, failure_policy: fp)
       expect {
         15.times do 
           under_test.fork_task { raise "I am such a failure" }
         end
-      }.to raise_error('Reached error limit of processes quitting with non-0 status - limit set at 4')
+      }.to raise_error('Reached error limit of processes quitting with non-0 status')
     end
     
     it 'runs through the jobs if max_failures is not given' do

data/spec/thread_pool_spec.rb

@@ -48,12 +48,13 @@ describe Chantier::ThreadPool do
   
   context 'with failures' do
     it 'raises after 4 failures' do
-      under_test = described_class.new(num_workers=3, max_failures: '4')
+      fp = Chantier::FailurePolicies::Count.new(4)
+      under_test = described_class.new(num_workers=3, failure_policy: fp)
       expect {
         15.times do 
           under_test.fork_task { raise "I am such a failure" }
         end
-      }.to raise_error('Reached error limit of 4 (last error was #<RuntimeError: I am such a failure>)')
+      }.to raise_error('Reached error limit (last error was #<RuntimeError: I am such a failure>)')
     end
     
     it 'runs through the jobs if max_failures is not given' do

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: chantier
 version: !ruby/object:Gem::Version
-  version: 0.0.5
+  version: 1.0.5
 platform: ruby
 authors:
 - Julik Tarkhanov
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-08-05 00:00:00.000000000 Z
+date: 2014-08-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
@@ -86,19 +86,26 @@ executables: []
 extensions: []
 extra_rdoc_files:
 - LICENSE.txt
-- README.rdoc
+- README.md
 files:
 - ".document"
 - ".rspec"
+- ".travis.yml"
 - Gemfile
 - LICENSE.txt
-- README.rdoc
+- README.md
 - Rakefile
 - chantier.gemspec
 - lib/chantier.rb
+- lib/failure_policies.rb
 - lib/process_pool.rb
 - lib/process_pool_with_kill.rb
 - lib/thread_pool.rb
+- spec/failure_policy_by_percentage_spec.rb
+- spec/failure_policy_counter_spec.rb
+- spec/failure_policy_mutex_wrapper_spec.rb
+- spec/failure_policy_spec.rb
+- spec/failure_policy_within_interval_spec.rb
 - spec/process_pool_spec.rb
 - spec/process_pool_with_kill_spec.rb
 - spec/spec_helper.rb

data/README.rdoc

@@ -1,47 +0,0 @@
-= chantier
-
-Dead-simple task manager for "fire and forget" jobs. Has two interchangeable pools - processes and threads. The API
-of those two is the same, so you can play at will and figure out which one works better.
-
-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/ThreadPool, like so:
- 
-   manager = Chantier::ThreadPool.new(slots = 4)
-   
-   manager.map_fork(job_tickets) do | job_ticket | # job_tickets has to be an Enumerable 
-     # this block will run in a thread
-     Churner.new(job_ticket).churn
-     ...
-   end
-
-Chantier does not provide any built-in IPC or inter-thread communication features - this should
-stimulate you to write your tasks without them having to do IPC in the first place.
-
-
-== 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.
-