sbm 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 5e18a93f50941dd24fa6348a0ca45ed4c7648dad
+  data.tar.gz: 2653657223ff6fc5ae1862839e8906e233f8fc14
+SHA512:
+  metadata.gz: 21485914dab3bed5742d63d813c8dbf2b8de47dce842bb3c562426f8bf0e5a6956c586884aba8dcc33f93c06552d4302d11d24a8ddb51a8efbc9994d5c2840d2
+  data.tar.gz: c24c64c4c4a463572d23154f1c1b6ffb9613cf2100af5576312ee843a1384e5932397ffe46d95ae5b0c1e2001e63e374041f4a8427f1f047407fac8f0bf14455

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/.rspec

@@ -0,0 +1 @@
+--colour

data/Gemfile

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

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Darcy Laycock
+
+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,55 @@
+# SBM - Simple Batch Manager
+
+Manages running / coordinating batch processes running across multiple hosts.
+
+Uses redis as a simple coordinator to ensure split work runs across hosts evenly.
+
+**Note:** SBM is still a hack. It's untested. Don't use this for production stuff. Please!
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'sbm'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install sbm
+
+## Usage
+
+SBM is composed of a set of simple scripts useful for running in shells. The only required
+variable is `SBM_WORKER` as an environment variable - the name of the node the current job is
+running on.`
+
+```bash
+#!/usr/bin/env bash -e
+
+export SBM_WORKER="$(hostname)-$$"
+
+# Used if you have a bunch of different batches with the same name:
+# export SBM_COORDINATOR='your-groups'
+
+sbm start-work my-test-batch
+rake do:your:work
+sbm complete-work my-test-batch && sbm wait-for my-test-batch 20 # There are 20 nodes running this process
+
+sbm status
+
+```
+
+Wait for simply checks the number of items in the completed set have the correct length.
+
+Please note that by default it uses redis for this, so to change your default redis use `REDIS_URI`.
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,9 @@
+require 'rake'
+require 'rspec/core'
+require 'rspec/core/rake_task'
+require 'bundler/gem_tasks'
+
+task default: :spec
+
+desc "Run all specs in spec directory (excluding plugin specs)"
+RSpec::Core::RakeTask.new :spec

data/bin/sbm

@@ -0,0 +1,3 @@
+#!/usr/bin/env ruby
+require 'sbm'
+SBM::Runner.new(ARGV).run

data/lib/sbm.rb

@@ -0,0 +1,6 @@
+require "sbm/version"
+
+module SBM
+  require "sbm/coordinator"
+  require "sbm/runner"
+end

data/lib/sbm/coordinator.rb

@@ -0,0 +1,87 @@
+# Handles the base of coordinating works in sets between
+# X nodes, with each item having a node identifier.
+
+require 'redis'
+
+module SBM
+  class Coordinator
+
+    def self.defaults
+      worker_name      = (ENV['SBM_WORKER'] or raise "Please ensure SBM_WORKER is set")
+      coordinator_name = (ENV['SBM_COORDINATOR'] || "worker-coordinator")
+      return new(coordinator_name), Worker.new(worker_name)
+    end
+
+    attr_reader :name, :redis
+
+    def initialize(name)
+      @name = name.to_s
+      @redis = Redis.current
+    end
+
+    class Batch < Struct.new(:name)
+
+      def to_s; name; end
+
+    end
+
+    class Worker < Struct.new(:name)
+      def to_s; name; end
+    end
+
+    def batches
+      redis.smembers(key(:batches)).map { |w| Batch.new(w) }
+    end
+
+    def workers
+      redis.smembers(key(:workers)).map { |w| Worker.new(w) }
+    end
+
+    def started_workers_for_batch(batch)
+      redis.smembers(key(:batches, batch, :started)).map { |w| Worker.new(w) }
+    end
+
+    def completed_workers_for_batch(batch)
+      redis.smembers(key(:batches, batch, :completed)).map { |w| Worker.new(w) }
+    end
+
+    def start(batch, worker)
+      prepare worker, batch
+      redis.sadd key(:batches, batch, :started),   worker.to_s
+      redis.srem key(:batches, batch, :completed), worker.to_s
+    end
+
+    def complete(batch, worker)
+      prepare worker, batch
+      redis.sadd key(:batches, batch, :completed), worker.to_s
+    end
+
+    # Waits on batch to reach a count, waiting for 15 seconds at a time.
+    def wait_for(batch, worker_count, wait_time = 15)
+      while redis.scard(key(:batches, batch, :completed)) < worker_count
+        sleep wait_time
+        yield if block_given?
+      end
+    end
+
+    private
+
+    def prepare(worker, batch)
+      register_worker worker
+      register_batch  batch
+    end
+
+    def register_worker(worker)
+      redis.sadd key(:workers), worker.to_s
+    end
+
+    def register_batch(batch)
+      redis.sadd key(:batches), batch.to_s
+    end
+
+    def key(*args)
+      [name, *args].join(":")
+    end
+
+  end
+end

data/lib/sbm/runner.rb

@@ -0,0 +1,92 @@
+module SBM
+  class Runner
+
+    USAGES = {
+      'status'         => '',
+      'wait-for'       => 'batch-name worker-count',
+      'start-batch'    => 'batch-name',
+      'complete-batch' => 'batch-name'
+    }
+
+    attr_reader :command, :args, :coordinator, :worker, :output, :error
+
+    def initialize(args, output = STDOUT, error = STDERR)
+      @command = args.first
+      @args    = args.drop(1)
+      @output = output
+      @error = error
+      @coordinator, @worker = SBM::Coordinator.defaults
+    end
+
+    def validate_command!
+      if command.nil? or !USAGES.has_key?(command)
+        usage true
+      end
+    end
+
+    def run
+      validate_command!
+      send command.tr('-', '_').to_sym
+    end
+
+    def status
+      output.puts "Known Workers: #{coordinator.workers.map(&:name).sort.join(", ")}"
+      output.puts "Known Batches: #{coordinator.batches.map(&:name).sort.join(", ")}"
+      output.puts ""
+      output.puts ""
+      coordinator.batches.each do |batch|
+        started   = coordinator.started_workers_for_batch batch
+        completed = coordinator.started_workers_for_batch completed
+        output.puts "Batch: #{batch}"
+        output.puts "Number Started:   #{started.size}"
+        output.puts "Number Completed: #{completed.size}"
+        output.puts "Number Pending:   #{started.size - completed.size}"
+        output.puts "---"
+        output.puts "Started:   #{started.map(&:name).sort.join(", ")}"
+        output.puts "Completed: #{completed.map(&:name).sort.join(", ")}"
+        output.puts ""
+      end
+    end
+
+    def wait_for
+      batch = extract_batch!
+      worker_count = args.shift.to_i
+      if worker_count.zero?
+        error.puts "You must provide a non-zero worker count"
+        usage
+      end
+      coordinator.wait_for batch, worker_count
+    end
+
+    def start_batch
+      batch = extract_batch!
+      coordinator.start batch, worker
+    end
+
+    def complete_batch
+      batch = extract_batch!
+      coordinator.complete batch, worker
+    end
+
+    def usage(invalid_command = false)
+      if invalid_command
+        error.puts "Invalid / unknown command - must be one of #{USAGES.keys.join(", ")}"
+        error.puts "Usage: #$0 #{USAGES.keys.join("|")} [arguments]"
+        exit 1
+      else
+        error.puts "Usage: #$0 #{command} #{USAGES[command]}".strip
+        exit 1
+      end
+    end
+
+    def extract_batch!
+      batch_name = args.shift
+      if batch_name.to_s.strip.empty?
+        error.puts "You must provide a batch name."
+        usage
+      end
+      Coordinator::Batch.new(batch_name)
+    end
+
+  end
+end

data/lib/sbm/version.rb

@@ -0,0 +1,3 @@
+module SBM
+  VERSION = "0.0.1"
+end

data/sbm.gemspec

@@ -0,0 +1,27 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'sbm/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "sbm"
+  spec.version       = SBM::VERSION
+  spec.authors       = ["Darcy Laycock"]
+  spec.email         = ["sutto@sutto.net"]
+  spec.description   = %q{Tools for managed simple batches across N nodes.}
+  spec.summary       = %q{Built on redis, provides a basic set of tools that let you process tasks in parallel across N nodes.}
+  spec.homepage      = "https://github.com/Sutto"
+  spec.license       = "MIT"
+
+  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_dependency "redis"
+
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rspec"
+  spec.add_development_dependency "rr"
+end

data/spec/coordinator_spec.rb

@@ -0,0 +1,120 @@
+require 'spec_helper'
+
+describe SBM::Coordinator do
+
+  let(:worker_a) { described_class::Worker.new 'elephant' }
+  let(:worker_b) { described_class::Worker.new 'pony'     }
+  let(:worker_c) { described_class::Worker.new 'fish'     }
+
+  let(:batch_a) { described_class::Batch.new 'fishing' }
+  let(:batch_b) { described_class::Batch.new 'running' }
+  let(:batch_c) { described_class::Batch.new 'rocking' }
+
+  subject { described_class.new 'my-awesome-item' }
+
+  it 'should register the batch and worker on starting' do
+    subject.batches.should be_empty
+    subject.workers.should be_empty
+    subject.start batch_a, worker_a
+    subject.batches.should == [batch_a]
+    subject.workers.should == [worker_a]
+    subject.start batch_a, worker_b
+    subject.batches.should == [batch_a]
+    subject.workers.should =~ [worker_a, worker_b]
+    subject.start batch_b, worker_c
+    subject.batches.should =~ [batch_a, batch_b]
+    subject.workers.should =~ [worker_a, worker_b, worker_c]
+  end
+
+  it 'should register the batch and worker on completing' do
+    subject.batches.should be_empty
+    subject.workers.should be_empty
+    subject.complete batch_a, worker_a
+    subject.batches.should == [batch_a]
+    subject.workers.should == [worker_a]
+    subject.complete batch_a, worker_b
+    subject.batches.should == [batch_a]
+    subject.workers.should =~ [worker_a, worker_b]
+    subject.complete batch_b, worker_c
+    subject.batches.should =~ [batch_a, batch_b]
+    subject.workers.should =~ [worker_a, worker_b, worker_c]
+  end
+
+  it 'should return a list of started workers' do
+    subject.started_workers_for_batch(batch_a).should == []
+    subject.started_workers_for_batch(batch_b).should == []
+    subject.started_workers_for_batch(batch_c).should == []
+    subject.start batch_a, worker_a
+    subject.started_workers_for_batch(batch_a).should == [worker_a]
+    subject.started_workers_for_batch(batch_b).should == []
+    subject.started_workers_for_batch(batch_c).should == []
+    subject.start batch_a, worker_b
+    subject.started_workers_for_batch(batch_a).should =~ [worker_a, worker_b]
+    subject.started_workers_for_batch(batch_b).should == []
+    subject.started_workers_for_batch(batch_c).should == []
+    subject.start batch_c, worker_c
+    subject.started_workers_for_batch(batch_a).should =~ [worker_a, worker_b]
+    subject.started_workers_for_batch(batch_b).should == []
+    subject.started_workers_for_batch(batch_c).should == [worker_c]
+  end
+
+  it 'should return a list of completed workers' do
+    subject.completed_workers_for_batch(batch_a).should == []
+    subject.completed_workers_for_batch(batch_b).should == []
+    subject.completed_workers_for_batch(batch_c).should == []
+    subject.complete batch_a, worker_a
+    subject.completed_workers_for_batch(batch_a).should == [worker_a]
+    subject.completed_workers_for_batch(batch_b).should == []
+    subject.completed_workers_for_batch(batch_c).should == []
+    subject.complete batch_a, worker_b
+    subject.completed_workers_for_batch(batch_a).should =~ [worker_a, worker_b]
+    subject.completed_workers_for_batch(batch_b).should == []
+    subject.completed_workers_for_batch(batch_c).should == []
+    subject.complete batch_c, worker_c
+    subject.completed_workers_for_batch(batch_a).should =~ [worker_a, worker_b]
+    subject.completed_workers_for_batch(batch_b).should == []
+    subject.completed_workers_for_batch(batch_c).should == [worker_c]
+  end
+
+  it 'should remove from completed on starting' do
+    subject.started_workers_for_batch(batch_a).should == []
+    subject.completed_workers_for_batch(batch_a).should == []
+    subject.complete batch_a, worker_a
+    subject.started_workers_for_batch(batch_a).should == []
+    subject.completed_workers_for_batch(batch_a).should == [worker_a]
+    subject.start batch_a, worker_a
+    subject.started_workers_for_batch(batch_a).should == [worker_a]
+    subject.completed_workers_for_batch(batch_a).should == []
+  end
+
+  it 'should work for the full flow' do
+    subject.started_workers_for_batch(batch_a).should == []
+    subject.completed_workers_for_batch(batch_a).should == []
+    subject.start batch_a, worker_a
+    subject.started_workers_for_batch(batch_a).should == [worker_a]
+    subject.completed_workers_for_batch(batch_a).should == []
+    subject.complete batch_a, worker_a
+    subject.started_workers_for_batch(batch_a).should == [worker_a]
+    subject.completed_workers_for_batch(batch_a).should == [worker_a]
+  end
+
+  it 'should let you wait for a given batch to finish' do
+    encountered = 0
+    mock(subject).sleep(anything).times(3) do
+      encountered += 1
+      if encountered == 2
+        subject.completed_workers_for_batch(batch_a).should == [worker_c]
+        subject.complete batch_a, worker_a
+        subject.completed_workers_for_batch(batch_a).should =~ [worker_c, worker_a]
+      elsif encountered == 3
+        subject.completed_workers_for_batch(batch_a).should =~ [worker_c, worker_a]
+        subject.complete batch_a, worker_b
+        subject.completed_workers_for_batch(batch_a).should =~ [worker_c, worker_a, worker_b]
+      end
+    end
+    subject.complete batch_a, worker_c
+    subject.completed_workers_for_batch(batch_a).should == [worker_c]
+    subject.wait_for batch_a, 3
+  end
+
+end

data/spec/runner_spec.rb

@@ -0,0 +1,163 @@
+require 'spec_helper'
+
+describe SBM::Runner do
+
+  before do
+    ENV['SBM_WORKER'] = 'xyz'
+  end
+
+  context 'initialization' do
+
+    it 'should setup the default worker' do
+      instance = described_class.new([])
+      worker = instance.worker
+      worker.should be_a SBM::Coordinator::Worker
+      worker.name.should == SBM::Coordinator.defaults[1].name
+    end
+
+    it 'should setup the default coordinator' do
+      instance = described_class.new([])
+      coordinator = instance.coordinator
+      coordinator.should be_a SBM::Coordinator
+      coordinator.name.should == SBM::Coordinator.defaults[0].name
+    end
+
+    it 'should setup output / error' do
+      instance = described_class.new([])
+      instance.output.should == STDOUT
+      instance.error.should == STDERR
+    end
+
+    it 'should allow overriding the output and error' do
+      out = StringIO.new
+      err = StringIO.new
+      instance = described_class.new([], out, err)
+      instance.output.should == out
+      instance.error.should == err
+    end
+
+    it 'should extract the command and args' do
+      instance = described_class.new ['x', 'y', 'z']
+      instance.command.should == 'x'
+      instance.args.should == ['y', 'z']
+    end
+
+  end
+
+  context 'setting up runner stuff' do
+
+    let(:output) { StringIO.new }
+    let(:error)  { StringIO.new }
+
+    let(:args) { [] }
+
+    subject do
+      instance = described_class.new args, output, error
+      stub(instance).exit.with_any_args
+      instance
+    end
+
+    context 'with a runner' do
+
+      it 'should let you validate the command' do
+        ['status', 'start-batch', 'complete-batch', 'wait-for'].each do |command|
+          instance = described_class.new [command], output, error
+          dont_allow(instance).exit.with_any_args
+          instance.validate_command!
+        end
+      end
+
+      it 'should exit with a bad command' do
+        ['dfsdf', 'startbatch', 'complete', nil].each do |command|
+          instance = described_class.new [command], output, error
+          mock(instance).exit 1
+          instance.validate_command!
+        end
+      end
+
+      it 'should run the command' do
+        args.replace %w(status)
+        mock(subject).status
+        subject.run
+      end
+
+      it 'should work with non-standard commands' do
+        args.replace %w(start-batch)
+        mock(subject).start_batch
+        subject.run
+      end
+
+      it 'should validate on run' do
+        args.replace %w(status)
+        mock(subject).validate_command!
+        subject.run
+      end
+
+    end
+
+    context 'starting batches' do
+
+      it 'should be an error without a batch name' do
+        subject.args.should == []
+        mock(subject).exit 1
+        subject.start_batch
+      end
+
+      it 'should work with the coordinator' do
+        subject.args.replace %w(xyz)
+        mock(subject.coordinator).start subject.worker, SBM::Coordinator::Batch.new('xyz')
+        dont_allow(subject).exit
+        subject.start_batch
+      end
+
+    end
+
+    context 'completing batches' do
+
+      it 'should be an error without a batch name' do
+        subject.args.should == []
+        mock(subject).exit 1
+        subject.complete_batch
+      end
+
+      it 'should work with the coordinator' do
+        subject.args.replace %w(xyz)
+        mock(subject.coordinator).complete subject.worker, SBM::Coordinator::Batch.new('xyz')
+        dont_allow(subject).exit
+        subject.complete_batch
+      end
+
+    end
+
+    context 'waiting for batches' do
+
+      it 'should be an error without a batch name' do
+        subject.args.replace []
+        mock(subject).exit 1
+        subject.wait_for
+      end
+
+      it 'should be an error without an instance count' do
+        subject.args.replace ['test-batch']
+        mock(subject).exit 1
+        subject.wait_for
+      end
+
+      it 'should be an error with a bad instance count' do
+        subject.args.replace ['test-batch', '0']
+        mock(subject).exit 1
+        subject.wait_for
+      end
+
+      it 'should work with the coordinator' do
+        subject.args.replace %w(xyz 3)
+        mock(subject.coordinator).wait_for SBM::Coordinator::Batch.new('xyz'), 3
+        dont_allow(subject).exit
+        subject.wait_for
+      end
+
+    end
+
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,9 @@
+ENV['REDIS_URL'] ||= "redis://127.0.0.1:6379/#{ENV['REDIS_TEST_DATABASE'] || 9}"
+
+require 'sbm'
+require 'rr'
+
+RSpec.configure do |config|
+  config.mock_with :rr
+  config.before(:each) { Redis.current.flushdb }
+end

metadata

@@ -0,0 +1,134 @@
+--- !ruby/object:Gem::Specification
+name: sbm
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Darcy Laycock
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-06-24 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: redis
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !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: '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'
+- !ruby/object:Gem::Dependency
+  name: rr
+  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: Tools for managed simple batches across N nodes.
+email:
+- sutto@sutto.net
+executables:
+- sbm
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .rspec
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/sbm
+- lib/sbm.rb
+- lib/sbm/coordinator.rb
+- lib/sbm/runner.rb
+- lib/sbm/version.rb
+- sbm.gemspec
+- spec/coordinator_spec.rb
+- spec/runner_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/Sutto
+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.2
+signing_key: 
+specification_version: 4
+summary: Built on redis, provides a basic set of tools that let you process tasks
+  in parallel across N nodes.
+test_files:
+- spec/coordinator_spec.rb
+- spec/runner_spec.rb
+- spec/spec_helper.rb