worker_roulette 0.0.2

data/.gitignore

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

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--format doc

data/Gemfile

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

data/Guardfile

@@ -0,0 +1,3 @@
+guard 'rspec' do  
+  watch(%r{.*})
+end

data/README.md

@@ -0,0 +1,70 @@
+# WorkerRoulette
+
+WorkerRoulette is designed to allow large numbers of unique devices, processes, users, or whatever communicate over individual channels without messing up the order of their messages. WorkerRoulette was created to solve two otherwise hard problems. First, other messaging solutions (I'm looking at you RabbitMQ) are not designed to  handle very large numbers of queues (30,000+); because WorkerRoulette is built on top of Redis, we have successfully tested it running with millions of queues. Second, other messaging systems assume one (or more) of three things: 1. Your message consumers know the routing key of messages they are interested in processing; 2. Your messages can wait so that only one consumer is processed at a time; 3. You love to complicated write code to put your messages back in order. Sometimes, none of these things is true and that is where WorkerRoulette comes in.
+
+WorkerRoulette lets you have thousands of competing consumers (distrubted over as many machines as you'd like) processing ordered messages from millions of totally unknown message providers. It does all this and ensures that the messages sent from each message provider are processed in exactly the order it sent them.
+
+## Usage
+    size_of_connection_pool = 100
+    redis_config = {host: 'localhost', timeout: 5, db: 1}
+
+    WorkerRoulette.start(size_of_connection_pool, redis_config)
+
+    sender_id = :shady
+    foreman = WorkerRoulette.foreman(sender_id)
+    foreman.enqueue_work_order(['hello', 'foreman'])
+
+    tradesman = WorkerRoulette.tradesman
+    messages = tradesman.work_orders! #drain the queue of the next available sender
+    messages.first # => ['hello', 'foreman']
+
+    other_sender_id = :the_real_slim_shady
+    other_foreman = WorkerRoulette.foreman(other_sender_id)
+    other_foreman.enqueue_work_order({'can you get me' => 'the number nine?'})
+
+    messages = tradesman.work_orders! #drain the queue of the next available sender
+    messages.first # => {'can you get me' => 'the number nine?'}
+
+    on_subscribe_callback = -> do
+      puts "Huzzah! We're listening!"
+      foreman.enqueue_work_order('will I see you later?')
+      foreman.enqueue_work_order('can you give me back my dime?')
+    end
+
+    tradesman.wait_for_work_orders(on_subscribe_callback) do |messages| #drain the queue of the next available sender
+      messages # => ['will I see you later', 'can you give me back my dime?']
+    end
+
+##Caveat Emptor
+    While WorkerRoulette does promise to keep the messages of each consumer processed in order by competing consumers, it does NOT guarantee the order in which the queues themselves will be processed. In general, work is processed in a FIFO order, but for performance reasons this has been left a loose FIFO. For example, if Abdul enqueue_work_orders some ordered messages ('1', '2', and '3') and then so do Mark and Wanda, Mark's messages may be processed first, then it would likely be Abdul's, and then Wanda's. However, even though Mark jumped the line, Abdul's messages will still be processed the order he enqueue_work_orderd them ('1', '2', then '3').
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'worker_roulette'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install worker_roulette
+
+## Run the specs
+
+    $ bundle exec rake spec:ci
+
+## Run the performance tests
+
+    $ bundle exec rake spec:perf
+
+
+## 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,25 @@
+#!/usr/bin/env rake
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new
+
+task :default => :spec
+task :test => :spec
+
+# def rspec_out_file
+#   require 'rspec_junit_formatter'
+#   "-f RspecJunitFormatter -o results.xml"
+# end
+
+desc "Run all unit and integration tests"
+task :'spec:ci' do
+  rspec_out_file = nil
+  sh "bundle exec rspec #{rspec_out_file} spec"
+end
+
+desc "Run perf tests"
+task :'spec:perf' do
+  rspec_out_file = nil
+  sh "bundle exec ruby ./spec/benchmark/perf_test.rb"
+end

data/lib/worker_roulette/foreman.rb

@@ -0,0 +1,44 @@
+module WorkerRoulette
+  class Foreman
+    attr_reader :sender
+    COUNTER_KEY = 'counter_key'
+
+    def initialize(sender, redis_pool)
+      @sender = sender
+      @redis_pool = redis_pool
+    end
+
+    def job_board_key
+      WorkerRoulette::JOB_BOARD
+    end
+
+    def counter_key
+      COUNTER_KEY
+    end
+
+    def enqueue_work_order_without_headers(work_order)
+      #Caveat Emptor: There is a race condition here, but it not serious;
+      #the count may be incremented again by another process before the sender
+      #is added to the job_queue. This is not a big deal bc it just means that
+      #the sender's queue will be processed one slot behind it's rightful place.
+      #This does not effect work_order ordering.
+      @redis_pool.with do |redis|
+        @count = redis.incr(COUNTER_KEY)
+        redis.multi do
+          redis.zadd(WorkerRoulette::JOB_BOARD, @count, sender)
+          redis.rpush(sender, Oj.dump(work_order))
+          redis.publish(WorkerRoulette::JOB_NOTIFICATIONS, WorkerRoulette::JOB_NOTIFICATIONS)
+        end
+      end
+    end
+
+    def enqueue_work_order(work_order, headers = {})
+      work_order = {headers: default_headers.merge(headers), payload: work_order}
+      enqueue_work_order_without_headers(work_order)
+    end
+
+    def default_headers
+      Hash[sender: sender]
+    end
+  end
+end

data/lib/worker_roulette/tradesman.rb

@@ -0,0 +1,39 @@
+module WorkerRoulette
+  class Tradesman
+    attr_reader :sender
+    def initialize(client_pool, pubsub_pool)
+      @client_pool = client_pool
+      @pubsub_pool = pubsub_pool
+    end
+
+    def job_board_key
+      WorkerRoulette::JOB_BOARD
+    end
+
+    def wait_for_work_orders(on_subscribe_callback = nil, &block)
+      @pubsub_pool.with do |redis|
+        redis.subscribe(WorkerRoulette::JOB_NOTIFICATIONS) do |on|
+          on.subscribe {on_subscribe_callback.call if on_subscribe_callback}
+          on.message   {redis.unsubscribe; block.call(work_orders!) if block}
+        end
+      end
+    end
+
+    def work_orders!
+      @client_pool.with do |redis|
+        get_sender_for_next_job(redis)
+        results = redis.multi do
+          redis.lrange(sender, 0, -1)
+          redis.del(sender)
+          redis.zrem(WorkerRoulette::JOB_BOARD, sender)
+        end
+        ((results || []).first || []).map {|work_order| Oj.load(work_order)}
+      end
+    end
+
+  private
+    def get_sender_for_next_job(redis)
+      @sender = (redis.zrange(WorkerRoulette::JOB_BOARD, 0, 0) || []).first.to_s
+    end
+  end
+end

data/lib/worker_roulette/version.rb

@@ -0,0 +1,3 @@
+module WorkerRoulette
+  VERSION = "0.0.2"
+end

data/lib/worker_roulette.rb

@@ -0,0 +1,38 @@
+require "worker_roulette/version"
+require 'redis'
+require 'hiredis'
+require 'redis/connection/hiredis'
+require 'connection_pool'
+require 'oj'
+
+Dir[File.join(File.dirname(__FILE__),'worker_roulette','**','*.rb')].sort.each { |file| require file.gsub(".rb", "")}
+
+module WorkerRoulette
+  JOB_BOARD = "job_board"
+  JOB_NOTIFICATIONS = "new_job_ready"
+
+  def self.start(pool_size = 10, config = {})
+    config = {host: 'localhost', db: 15, timeout: 5}.merge(config)
+    @foreman_connection_pool    = ConnectionPool.new(config.merge Hash[size: pool_size, timeout: config[:timeout]]) {Redis.new}
+    @tradesman_connection_pool  = ConnectionPool.new(config.merge Hash[size: pool_size, timeout: config[:timeout]]) {Redis.new}
+    @pubsub_connection_pool     = ConnectionPool.new(config.merge Hash[size: pool_size, timeout: config[:timeout]]) {Redis.new}
+  end
+
+  def self.foreman(sender)
+    raise "WorkerRoulette not Started" unless @foreman_connection_pool
+    Foreman.new(sender, @foreman_connection_pool)
+  end
+
+  def self.tradesman
+    raise "WorkerRoulette not Started" unless @tradesman_connection_pool
+    Tradesman.new(@tradesman_connection_pool, @pubsub_connection_pool)
+  end
+
+  def self.tradesman_connection_pool
+    @tradesman_connection_pool
+  end
+
+  def self.pubsub_connection_pool
+    @pubsub_connection_pool
+  end
+end

data/spec/benchmark/perf_test.rb

@@ -0,0 +1,66 @@
+require_relative '../spec_helper'
+require 'benchmark'
+require 'eventmachine'
+
+REDIS_CONNECTION_POOL_SIZE = 100
+ITERATIONS = 10_000
+
+work_order = {'ding dong' => "hello_foreman_" * 100}
+
+WorkerRoulette.start(REDIS_CONNECTION_POOL_SIZE)#{driver: :synchrony}
+WorkerRoulette.tradesman_connection_pool.with {|r| r.flushdb}
+
+puts "Redis Connection Pool Size: #{REDIS_CONNECTION_POOL_SIZE}"
+
+Benchmark.bmbm do |x|
+  x.report "Time to insert and read #{ITERATIONS} large work_orders" do # ~2500 work_orders / second round trip; 50-50 read-write time; CPU and IO bound
+    ITERATIONS.times do |iteration|
+      sender = 'sender_' + iteration.to_s
+      foreman = WorkerRoulette.foreman(sender)
+      foreman.enqueue_work_order(work_order)
+    end
+
+    ITERATIONS.times do |iteration|
+      sender = 'sender_' + iteration.to_s
+      tradesman = WorkerRoulette.tradesman
+      tradesman.work_orders!
+    end
+  end
+end
+
+WorkerRoulette.tradesman_connection_pool.with {|r| r.flushdb}
+
+Benchmark.bmbm do |x|
+  x.report "Time for tradesmans to enqueue_work_order and read #{ITERATIONS} large work_orders via pubsub" do # ~1800 work_orders / second round trip
+      ITERATIONS.times do |iteration|
+        p = -> do
+          sender = 'sender_' + iteration.to_s
+          foreman = WorkerRoulette.foreman(sender)
+          foreman.enqueue_work_order(work_order)
+        end
+      tradesman = WorkerRoulette.tradesman
+      tradesman.wait_for_work_orders(p) {|m| m}
+    end
+  end
+end
+
+WorkerRoulette.tradesman_connection_pool.with {|r| r.flushdb}
+
+# EM.run do
+#   EM.add_timer(6) {puts "em off";EM.stop}
+#   tradesmans = []
+#   foremans = []
+#   @start = Time.now
+#   @end = nil
+#   ITERATIONS.times do |iteration|
+#     s = WorkerRoulette.tradesman
+#     tradesmans << s
+#     sender = 'sender_' + iteration.to_s
+#     foreman = WorkerRoulette.foreman(sender)
+#     a = -> {foreman.enqueue_work_order(work_order)}
+#     s.wait_for_work_orders(a) {|m| @end = Time.now if iteration == (ITERATIONS - 1) }
+#   end
+# end
+
+# puts  @end - @start
+# WorkerRoulette.tradesman_connection_pool.with {|r| r.flushdb}

data/spec/helpers/.gitkeep

@@ -0,0 +1 @@
+.gitkeep

data/spec/integration/worker_roulette_spec.rb

@@ -0,0 +1,182 @@
+require "spec_helper"
+
+describe WorkerRoulette do
+  let(:sender) {'katie_80'}
+  let(:work_orders) {["hello", "foreman"]}
+  let(:default_headers) {Hash[headers: {sender: sender}]}
+  let(:hello_work_order) {Hash[payload: "hello"]}
+  let(:foreman_work_order) {Hash[payload: "foreman"]}
+  let(:work_orders_with_headers) {default_headers.merge({payload: work_orders})}
+  let(:jsonized_work_orders_with_headers) {[Oj.dump(work_orders_with_headers)]}
+
+  let(:redis) {Redis.new}
+  let(:pool_size) {10}
+
+  before do
+    WorkerRoulette.start(pool_size)
+    Redis.new.flushdb
+  end
+
+  it "should exist" do
+    WorkerRoulette.should_not be_nil
+  end
+
+  context Foreman do
+    let(:subject) {WorkerRoulette.foreman(sender)}
+
+    it "should be working on behalf of a sender" do
+      subject.sender.should == sender
+    end
+
+    it "should be injected with a raw_redis_client so it can do is work" do
+      Redis.any_instance.should_receive(:rpush)
+      subject.enqueue_work_order(:whatever)
+    end
+
+    it "should enqueue_work_order two work_orders in the sender's slot in the switchboard" do
+      subject.enqueue_work_order(work_orders.first)
+      subject.enqueue_work_order(work_orders.last)
+      redis.lrange(sender, 0, -1).should == work_orders.map {|m| Oj.dump(default_headers.merge({payload: m})) }
+    end
+
+    it "should enqueue_work_order an array of work_orders without headers in the sender's slot in the switchboard" do
+      subject.enqueue_work_order_without_headers(work_orders)
+      redis.lrange(sender, 0, -1).should == [Oj.dump(work_orders)]
+    end
+
+    it "should enqueue_work_order an array of work_orders with default headers in the sender's slot in the switchboard" do
+      subject.enqueue_work_order(work_orders)
+      redis.lrange(sender, 0, -1).should == jsonized_work_orders_with_headers
+    end
+
+    it "should enqueue_work_order an array of work_orders with additional headers in the sender's slot in the switchboard" do
+      extra_headers = {foo: :bars}
+      subject.enqueue_work_order(work_orders, extra_headers)
+      work_orders_with_headers[:headers].merge!(extra_headers)
+      redis.lrange(sender, 0, -1).should == [Oj.dump(work_orders_with_headers)]
+    end
+
+    it "should post the sender's id to the job board with an order number" do
+      subject.enqueue_work_order(work_orders.first)
+      subject.enqueue_work_order(work_orders.last)
+      redis.zrange(subject.job_board_key, 0, -1, with_scores: true).should == [[sender.to_s, work_orders.length.to_f]]
+    end
+
+    it "should post the sender_id and work_orders transactionally" do
+      Redis.any_instance.should_receive(:multi)
+      subject.enqueue_work_order(work_orders.first)
+    end
+
+    it "should generate sequential order numbers" do
+      redis.get(subject.counter_key).should == nil
+      subject.enqueue_work_order(work_orders.first)
+      redis.get(subject.counter_key).should == "1"
+      subject.enqueue_work_order(work_orders.last)
+      redis.get(subject.counter_key).should == "2"
+    end
+
+    it "should publish a notification that a new job is ready" do
+      result = nil
+      redis_tradesman = Redis.new
+      redis_tradesman.subscribe(WorkerRoulette::JOB_NOTIFICATIONS) do |on|
+        on.subscribe do |channel, subscription|
+          subject.enqueue_work_order(work_orders)
+        end
+
+        on.message do |channel, notification|
+          result = notification
+          redis_tradesman.unsubscribe(WorkerRoulette::JOB_NOTIFICATIONS)
+        end
+     end
+
+      result.should == WorkerRoulette::JOB_NOTIFICATIONS
+    end
+  end
+
+  context Tradesman do
+    let(:foreman) {WorkerRoulette.foreman(sender)}
+    let(:subject)  {WorkerRoulette.tradesman}
+
+    before do
+      foreman.enqueue_work_order(work_orders)
+    end
+
+    it "should be working on behalf of a sender" do
+      subject.work_orders!
+      subject.sender.should == sender
+    end
+
+    it "should be injected with a redis client so it can do its work" do
+      Redis.any_instance.should_receive(:lrange).and_call_original
+      subject.work_orders!
+    end
+
+    it "should drain one set of work_orders from the sender's slot in the switchboard" do
+      subject.work_orders!.should == [work_orders_with_headers]
+      subject.work_orders!.should == []
+      subject.work_orders!.should == [] #does not throw an error if queue is alreay empty
+    end
+
+    it "should drain all the work_orders from the sender's slot in the switchboard" do
+      foreman.enqueue_work_order(work_orders)
+      subject.work_orders!.should == [work_orders_with_headers, work_orders_with_headers]
+      subject.work_orders!.should == []
+      subject.work_orders!.should == [] #does not throw an error if queue is alreay empty
+    end
+
+    it "should take the oldest sender off the job board (FIFO)" do
+      oldest_sender = sender.to_s
+      most_recent_sender = 'most_recent_sender'
+      most_recent_foreman = WorkerRoulette.foreman(most_recent_sender)
+      most_recent_foreman.enqueue_work_order(work_orders)
+      redis.zrange(subject.job_board_key, 0, -1).should == [oldest_sender, most_recent_sender]
+      subject.work_orders!
+      redis.zrange(subject.job_board_key, 0, -1).should == [most_recent_sender]
+    end
+
+    it "should get the sender and work_order list transactionally" do
+      Redis.any_instance.should_receive(:multi).and_call_original
+      subject.work_orders!
+    end
+
+    it "should get the work_orders from the next sender's slot when a new job is ready" do
+      subject.work_orders!
+      subject.should_receive(:work_orders!).and_call_original
+      publisher = -> {foreman.enqueue_work_order(work_orders)}
+      subject.wait_for_work_orders(publisher) do |redis_work_orders|
+        redis_work_orders.should == [work_orders_with_headers]
+      end
+    end
+
+    it "should checkout a readlock for a queue and put it back when its done processing; lock should expire after 5 minutes?"
+    it "should eves drop on the job board"
+
+    context "Failure" do
+      it "should not put the sender_id and work_orders back if processing fails bc new work_orders may have been processed while that process failed" do; end
+    end
+
+    context "Concurrent Access" do
+      it "should pool its connections" do
+        Array.new(100) do
+          Thread.new {WorkerRoulette.tradesman_connection_pool.with {|pooled_redis| pooled_redis.get("foo")}}
+        end.each(&:join)
+        WorkerRoulette.tradesman_connection_pool.with do |pooled_redis|
+          pooled_redis.info["connected_clients"].to_i.should > (pool_size)
+        end
+      end
+
+      #This may be fixed soon (10 Feb 2014 - https://github.com/redis/redis-rb/pull/389 and https://github.com/redis/redis-rb/issues/364)
+      it "should not be fork() proof -- forking reconnects need to be handled in the calling code (until redis gem is udpated, then we should be fork-proof)" do
+        WorkerRoulette.start(1)
+        WorkerRoulette.tradesman_connection_pool.with {|pooled_redis| pooled_redis.get("foo")}
+        fork do
+          expect {WorkerRoulette.tradesman_connection_pool.with {|pooled_redis| pooled_redis.get("foo")}}.to raise_error(Redis::InheritedError)
+        end
+      end
+
+      it "should use optionally non-blocking I/O" do
+        expect {WorkerRoulette.start(1, :driver => :synchrony)}.not_to raise_error
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,22 @@
+require 'worker_roulette'
+# require 'simplecov'
+# require 'simplecov-rcov'
+# class SimpleCov::Formatter::MergedFormatter
+#   def format(result)
+#      SimpleCov::Formatter::HTMLFormatter.new.format(result)
+#      SimpleCov::Formatter::RcovFormatter.new.format(result)
+#   end
+# end
+# SimpleCov.formatter = SimpleCov::Formatter::MergedFormatter
+# SimpleCov.start
+
+require File.expand_path(File.join("..", "..", "lib", "worker_roulette.rb"), __FILE__)
+include WorkerRoulette
+
+Dir[File.join(File.dirname(__FILE__), 'helpers', '**/*.rb')].sort.each { |file| require file.gsub(".rb", "")}
+
+# RSpec.configure do |c|
+#   after(:each) do
+#     Redis.new.flushall
+#   end
+# end

data/worker_roulette.gemspec

@@ -0,0 +1,36 @@
+# encoding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'worker_roulette/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "worker_roulette"
+  spec.version       = WorkerRoulette::VERSION
+  spec.authors       = ["Paul Saieg"]
+  spec.email         = ["classicist@gmail.com"]
+  spec.description   = %q{Write a gem description}
+  spec.summary       = %q{Write a gem summary}
+  spec.homepage      = ""
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(spec)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency 'redis'
+  spec.add_dependency 'oj'
+  spec.add_dependency 'hiredis', '~> 0.4.5'
+  spec.add_dependency 'em-synchrony'
+  spec.add_dependency 'connection_pool'
+
+  spec.add_development_dependency "bundler"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency 'rspec'
+  spec.add_development_dependency 'pry-debugger'
+  # spec.add_development_dependency 'guard'
+  # spec.add_development_dependency 'guard-rspec'
+  # spec.add_development_dependency 'simplecov'
+  # spec.add_development_dependency 'simplecov-rcov'
+  # spec.add_development_dependency 'rspec_junit_formatter'
+  # spec.add_development_dependency 'sidekiq'
+end

metadata

@@ -0,0 +1,210 @@
+--- !ruby/object:Gem::Specification
+name: worker_roulette
+version: !ruby/object:Gem::Version
+  version: 0.0.2
+  prerelease: 
+platform: ruby
+authors:
+- Paul Saieg
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-02-12 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: redis
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: oj
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: hiredis
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.4.5
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.4.5
+- !ruby/object:Gem::Dependency
+  name: em-synchrony
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: connection_pool
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: pry-debugger
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Write a gem description
+email:
+- classicist@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .rspec
+- Gemfile
+- Guardfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/worker_roulette.rb
+- lib/worker_roulette/foreman.rb
+- lib/worker_roulette/tradesman.rb
+- lib/worker_roulette/version.rb
+- spec/benchmark/perf_test.rb
+- spec/helpers/.gitkeep
+- spec/integration/worker_roulette_spec.rb
+- spec/spec_helper.rb
+- worker_roulette.gemspec
+homepage: ''
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.25
+signing_key: 
+specification_version: 3
+summary: Write a gem summary
+test_files:
+- spec/benchmark/perf_test.rb
+- spec/helpers/.gitkeep
+- spec/integration/worker_roulette_spec.rb
+- spec/spec_helper.rb
+has_rdoc: