worker_roulette 0.0.7 → 0.0.8

data/README.md

@@ -57,18 +57,19 @@ bad_foreman       = WorkerRoulette.foreman('foreman', 'bad_channel')
 
 publish  = -> do
   good_foreman.enqueue_work_order('some old fashion work')
-  bad_foreman.enqueue_work_order('evil biddings you should not carry out') #channels let us ignore his evil orders
+  bad_foreman.enqueue_work_order('evil biddings you should not carry out')
 end
 
 tradesman.wait_for_work_orders(publish) do |work|
   work.to_s.should match("some old fashion work") #only got the work from the good foreman
+  work.to_s.should_not match("evil")              #channels let us ignore the other's evil orders
   tradesman.unsubscribe
 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').
+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 enqueues 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 enqueued them ('1', '2', then '3').
 
 ## Installation
 

data/lib/worker_roulette/a_foreman.rb

@@ -0,0 +1,22 @@
+require_relative './foreman'
+module WorkerRoulette
+  class AForeman < Foreman
+    def enqueue_work_order_without_headers(work_order, &callback)
+      #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|
+        redis.incr(COUNTER_KEY) do |count|
+          @count = count ||= 1
+          redis.multi
+          redis.zadd(job_board_key, @count, @sender)
+          redis.rpush(sender_key, Oj.dump(work_order))
+          redis.publish(@channel, WorkerRoulette::JOB_NOTIFICATIONS)
+          redis.exec.callback &callback
+        end
+      end
+    end
+  end
+end

data/lib/worker_roulette/a_tradesman.rb

@@ -0,0 +1,52 @@
+require_relative './tradesman'
+module WorkerRoulette
+  class ATradesman < Tradesman
+    def wait_for_work_orders(on_subscribe_callback = nil, &on_message_callback)
+      @redis_pubsub ||= WorkerRoulette.new_redis_pubsub #cannot use connection pool bc redis expects each obj to own its own pubsub connection for the life of the subscription
+      @redis_pubsub.on(:subscribe) {|channel, subscription_count| on_subscribe_callback.call(channel, subscription_count) if on_subscribe_callback}
+      @redis_pubsub.on(:message)   {|channel, message| work_orders! {|work_orders| on_message_callback.call(work_orders, message, channel)} if on_message_callback}
+      @redis_pubsub.subscribe(@channel)
+    end
+
+    def work_orders!(&callback)
+      @client_pool.with do |redis|
+        get_sender_for_next_job(redis) do |sender_results|
+          @sender = (sender_results || []).first.to_s
+          redis.multi
+          redis.lrange(sender_key, 0, -1)
+          redis.del(sender_key)
+          redis.zrem(job_board_key, sender_key)
+          redis.exec do |work_orders|
+            callback.call ((work_orders || []).first || []).map {|work_order| Oj.load(work_order)} if callback
+          end
+        end
+      end
+    end
+
+    def get_lock(redis, sender, timeout, on_failure = nil, &on_success)
+      @lock = EM::Hiredis::Lock.new(redis, sender, timeout)
+      @lock.callback &on_success
+      @lock.errback &(on_failure || proc {})
+      @lock
+    end
+
+    def unsubscribe(&callback)
+      deferable = @redis_pubsub.unsubscribe(@channel)
+      deferable.callback do
+        @redis_pubsub.close_connection
+        @redis_pubsub = nil
+        callback.call
+      end
+      deferable.errback do
+        @redis_pubsub.close_connection
+        @redis_pubsub = nil
+        callback.call
+      end
+    end
+
+    private
+    def get_sender_for_next_job(redis, &callback)
+      redis.zrange(job_board_key, 0, 0).callback &callback
+    end
+  end
+end

data/lib/worker_roulette/foreman.rb

@@ -22,7 +22,7 @@ module WorkerRoulette
       @counter_key ||= "#{@namespace + ':' if @namespace}#{COUNTER_KEY}"
     end
 
-    def enqueue_work_order_without_headers(work_order)
+    def enqueue_work_order_without_headers(work_order, &callback)
       #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
@@ -38,9 +38,9 @@ module WorkerRoulette
       end
     end
 
-    def enqueue_work_order(work_order, headers = {})
+    def enqueue_work_order(work_order, headers = {}, &callback)
       work_order = {'headers' => default_headers.merge(headers), 'payload' => work_order}
-      enqueue_work_order_without_headers(work_order)
+      enqueue_work_order_without_headers(work_order, &callback)
     end
 
     def default_headers

data/lib/worker_roulette/tradesman.rb

@@ -17,16 +17,16 @@ module WorkerRoulette
     end
 
     def wait_for_work_orders(on_subscribe_callback = nil, &block)
-      @pubsub_pool.with({}) do |redis|
+      @pubsub_pool.with do |redis|
         redis.subscribe(@channel) do |on|
           on.subscribe {on_subscribe_callback.call if on_subscribe_callback}
-          on.message   {block.call(work_orders!) if block}
+          on.message   {self.unsubscribe; block.call(work_orders!) if block}
         end
       end
     end
 
     def work_orders!
-      @client_pool.with({}) do |redis|
+      @client_pool.with do |redis|
         get_sender_for_next_job(redis)
         results = redis.multi do
           redis.lrange(sender_key, 0, -1)
@@ -38,7 +38,7 @@ module WorkerRoulette
     end
 
     def unsubscribe
-      @pubsub_pool.with({}) {|redis| redis.unsubscribe(@channel)}
+      @pubsub_pool.with {|redis| redis.unsubscribe(@channel)}
     end
 
   private

data/lib/worker_roulette/version.rb

@@ -1,3 +1,3 @@
 module WorkerRoulette
-  VERSION = "0.0.7"
+  VERSION = "0.0.8"
 end

data/lib/worker_roulette.rb

@@ -2,24 +2,23 @@ require "worker_roulette/version"
 require 'oj'
 require 'redis'
 require 'hiredis'
-require 'em-synchrony'
+require 'em-hiredis'
+require 'connection_pool'
 
 Dir[File.join(File.dirname(__FILE__),'worker_roulette','**','*.rb')].sort.each { |file| require file.gsub(".rb", "")}
 
-class EventMachine::Synchrony::ConnectionPool
-  alias_method :with, :execute
-end
-
 module WorkerRoulette
   JOB_BOARD = "job_board"
   JOB_NOTIFICATIONS = "new_job_ready"
 
   def self.start(config = {})
-    @redis_config               = {host: 'localhost', db: 14, driver: :hiredis, timeout: 5, pool_size: 10}.merge(config)
+    @redis_config               = {host: 'localhost', port: 6379, db: 14, driver: :hiredis, timeout: 5, evented: false, pool_size: 10}.merge(config)
     @pool_config                = Hash[size: @redis_config.delete(:pool_size), timeout: @redis_config.delete(:timeout)]
-    @foreman_connection_pool    = connection_pool.new(@pool_config) {Redis.new(@redis_config)}
-    @tradesman_connection_pool  = connection_pool.new(@pool_config) {Redis.new(@redis_config)}
-    @pubsub_connection_pool     = connection_pool.new(@pool_config) {Redis.new(@redis_config)}
+    @evented                    = @redis_config.delete(:evented)
+
+    @foreman_connection_pool    = ConnectionPool.new(@pool_config) {new_redis}
+    @tradesman_connection_pool  = ConnectionPool.new(@pool_config) {new_redis}
+    @pubsub_connection_pool     = ConnectionPool.new(@pool_config) {new_redis_pubsub}
   end
 
   def self.foreman(sender, channel = nil)
@@ -32,6 +31,16 @@ module WorkerRoulette
     Tradesman.new(@tradesman_connection_pool, @pubsub_connection_pool, channel)
   end
 
+  def self.a_foreman(sender, channel = nil)
+    raise "WorkerRoulette not Started" unless @foreman_connection_pool
+    AForeman.new(sender, @foreman_connection_pool, channel)
+  end
+
+  def self.a_tradesman(channel = nil)
+    raise "WorkerRoulette not Started" unless @tradesman_connection_pool
+    ATradesman.new(@tradesman_connection_pool, @pubsub_connection_pool, channel)
+  end
+
   def self.tradesman_connection_pool
     @tradesman_connection_pool
   end
@@ -49,15 +58,21 @@ module WorkerRoulette
   end
 
 private
-  def self.connection_pool
-    if @redis_config[:driver] == :synchrony
-      require 'redis/connection/synchrony'
-      require 'em-synchrony/connection_pool'
-      EM::Synchrony::ConnectionPool
+  def self.new_redis
+    if @evented
+      require 'eventmachine'
+      redis = EM::Hiredis::Client.new(@redis_config[:host], @redis_config[:port], @redis_config[:password], @redis_config[:db])
+      redis.connect
+    else
+      Redis.new(@redis_config)
+    end
+  end
+
+  def self.new_redis_pubsub
+    if @evented
+     new_redis.pubsub
     else
-      require 'redis/connection/hiredis'
-      require 'connection_pool'
-      ConnectionPool
+      new_redis
     end
   end
 end

data/spec/benchmark/perf_test.rb

@@ -7,7 +7,7 @@ ITERATIONS = 10_000
 
 work_order = {'ding dong' => "hello_foreman_" * 100}
 
-WorkerRoulette.start(REDIS_CONNECTION_POOL_SIZE)#{driver: :synchrony}
+WorkerRoulette.start(size: REDIS_CONNECTION_POOL_SIZE)#{driver: :synchrony}
 WorkerRoulette.tradesman_connection_pool.with {|r| r.flushdb}
 
 puts "Redis Connection Pool Size: #{REDIS_CONNECTION_POOL_SIZE}"
@@ -39,7 +39,7 @@ Benchmark.bmbm do |x|
           foreman.enqueue_work_order(work_order)
         end
       tradesman = WorkerRoulette.tradesman
-      tradesman.wait_for_work_orders(p) {|m| m}
+      tradesman.wait_for_work_orders(p) {|m| m; tradesman.unsubscribe}
     end
   end
 end

data/spec/integration/evented_worker_roulette_spec.rb

@@ -0,0 +1,222 @@
+require "spec_helper"
+
+describe WorkerRoulette do
+  include EventedSpec::EMSpec
+
+  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(WorkerRoulette.redis_config)}
+
+  em_before do
+    WorkerRoulette.start(evented: true)
+  end
+
+  context Foreman do
+    let(:subject) {WorkerRoulette.a_foreman(sender)}
+
+    it "should enqueue work" do
+      called = false
+      foreman      = WorkerRoulette.a_foreman('foreman')
+      foreman.enqueue_work_order('some old fashion work') do |redis_response|
+        called = true
+        redis_response.should == [1, 1, 0]
+      end
+      done(0.1) {called.should == true}
+    end
+
+    it "should enqueue_work_order two work_orders in the sender's slot in the job board" do
+      subject.enqueue_work_order(work_orders.first) do
+        subject.enqueue_work_order(work_orders.last) do
+          redis.lrange(sender, 0, -1).should == work_orders.map {|m| Oj.dump(default_headers.merge({'payload' => m})) }
+          done
+        end
+      end
+    end
+
+    it "should enqueue_work_order an array of work_orders without headers in the sender's slot in the job board" do
+      subject.enqueue_work_order_without_headers(work_orders) do
+        redis.lrange(sender, 0, -1).should == [Oj.dump(work_orders)]
+        done
+      end
+    end
+
+    it "should enqueue_work_order an array of work_orders with default headers in the sender's slot in the job board" do
+      subject.enqueue_work_order(work_orders) do
+        redis.lrange(sender, 0, -1).should == jsonized_work_orders_with_headers
+        done
+      end
+    end
+
+    it "should enqueue_work_order an array of work_orders with additional headers in the sender's slot in the job board" do
+      extra_headers = {'foo' => 'bars'}
+      subject.enqueue_work_order(work_orders, extra_headers) do
+        work_orders_with_headers['headers'].merge!(extra_headers)
+        redis.lrange(sender, 0, -1).should == [Oj.dump(work_orders_with_headers)]
+        done
+      end
+    end
+
+    it "should post the sender's id to the job board with an order number" do
+      subject.enqueue_work_order(work_orders.first) do
+        subject.enqueue_work_order(work_orders.last) do
+          redis.zrange(subject.job_board_key, 0, -1, with_scores: true).should == [[sender.to_s, work_orders.length.to_f]]
+          done
+        end
+      end
+    end
+
+    it "should post the sender_id and work_orders transactionally" do
+      EM::Hiredis::Client.any_instance.should_receive(:multi).and_call_original
+      subject.enqueue_work_order(work_orders.first)  do
+        done
+      end
+    end
+
+    it "should generate sequential order numbers" do
+      redis.get(subject.counter_key).should == nil
+      subject.enqueue_work_order(work_orders.first) do
+        redis.get(subject.counter_key).should == "1"
+        subject.enqueue_work_order(work_orders.last) do
+          redis.get(subject.counter_key).should == "2"
+          done
+        end
+      end
+    end
+
+    it "should publish a notification that a new job is ready" do
+      result = nil
+      subscriber = WorkerRoulette.new_redis_pubsub
+      subscriber.subscribe(WorkerRoulette::JOB_NOTIFICATIONS) do |message|
+        subscriber.unsubscribe(WorkerRoulette::JOB_NOTIFICATIONS)
+        message.should == WorkerRoulette::JOB_NOTIFICATIONS
+        done
+      end.callback { subject.enqueue_work_order(work_orders) }
+    end
+  end
+
+  context Tradesman do
+    let(:foreman) {WorkerRoulette.a_foreman(sender)}
+    let(:subject)  {WorkerRoulette.a_tradesman}
+
+    it "should be working on behalf of a sender" do
+      foreman.enqueue_work_order(work_orders) do
+        subject.work_orders! do
+          subject.sender.should == sender
+          done
+        end
+      end
+    end
+
+
+    it "should drain one set of work_orders from the sender's slot in the job board" do
+      foreman.enqueue_work_order(work_orders) do
+        subject.work_orders! do |r|
+          r.should == [work_orders_with_headers]
+          subject.work_orders! do |r| r.should == []
+            subject.work_orders! {|r| r.should == []; done} #does not throw an error if queue is alreay empty
+          end
+        end
+      end
+    end
+
+    it "should take the oldest sender off the job board (FIFO)" do
+      foreman.enqueue_work_order(work_orders) do
+        oldest_sender = sender.to_s
+        most_recent_sender = 'most_recent_sender'
+        most_recent_foreman = WorkerRoulette.a_foreman(most_recent_sender)
+        most_recent_foreman.enqueue_work_order(work_orders) do
+          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]; done }
+        end
+      end
+    end
+
+    it "should get the sender and work_order list transactionally" do
+      EM::Hiredis::Client.any_instance.should_receive(:multi).and_call_original
+      subject.work_orders! {done}
+    end
+
+    it "should get the work_orders from the next queue when a new job is ready" do
+      subject.should_receive(:work_orders!).and_call_original
+
+      subject.wait_for_work_orders do |redis_work_orders, message, channel|
+        subject.sender.should == "katie_80"
+        redis_work_orders.should == [work_orders_with_headers]
+        done
+      end
+
+      foreman.enqueue_work_order(work_orders)
+    end
+
+    it "should publish and subscribe on custom channels" do
+      good_subscribed   = false
+      bad_subscribed    = false
+
+      tradesman         = WorkerRoulette.a_tradesman('good_channel')
+      evil_tradesman    = WorkerRoulette.a_tradesman('bad_channel')
+
+      good_foreman      = WorkerRoulette.a_foreman('foreman', 'good_channel')
+      bad_foreman       = WorkerRoulette.a_foreman('foreman', 'bad_channel')
+
+      good_publish = ->(a,b) {good_subscribed =  true}
+      bad_publish  = ->(a,b) {bad_subscribed =  true}
+
+      tradesman.should_receive(:work_orders!).and_call_original
+      evil_tradesman.should_receive(:work_orders!).and_call_original
+
+      #They are double subscribing; is it possible that it is the connection pool?
+
+      tradesman.wait_for_work_orders(good_publish) do |good_work|
+        good_work.to_s.should match("old fashion")
+        good_work.to_s.should_not match("evil")
+        good_subscribed.should == true
+      end
+
+      evil_tradesman.wait_for_work_orders(bad_publish) do |bad_work|
+        bad_work.to_s.should_not match("old fashion")
+        bad_work.to_s.should match("evil")
+        bad_subscribed.should == true
+      end
+
+      good_foreman.enqueue_work_order('some old fashion work')
+      bad_foreman.enqueue_work_order('evil biddings you should not carry out')
+      done(0.2)
+    end
+
+    it "should unsubscribe from the job board" do
+      subject.wait_for_work_orders do |redis_work_orders, message, channel|
+        subject.unsubscribe {done}
+      end
+      EM::Hiredis::PubsubClient.any_instance.should_receive(:close_connection).and_call_original
+      foreman.enqueue_work_order(work_orders)
+    end
+  end
+
+  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; done; end
+  end
+
+  context "Concurrent Access" do
+    it "should not leak connections"
+    it "should checkout a readlock for a queue and put it back when its done processing; lock should expire after 5 minutes?"
+    it "should retry doing work on a queue 3 times if it is locked (ex backoff)"
+    it "should not delete the messages from the queue until they have been processed succcesfully"
+    it "should periodically (10 seconds?) poll the job board for new work"
+
+    it "should be fork() proof" do
+      @subject = WorkerRoulette.a_tradesman
+      @subject.work_orders! do
+        fork do
+          @subject.work_orders!
+        end
+      end
+      done(1)
+    end
+  end
+end

data/spec/integration/worker_roulette_spec.rb

@@ -85,7 +85,7 @@ describe WorkerRoulette do
           result = notification
           redis_tradesman.unsubscribe(WorkerRoulette::JOB_NOTIFICATIONS)
         end
-     end
+      end
 
       result.should == WorkerRoulette::JOB_NOTIFICATIONS
     end
@@ -141,7 +141,7 @@ describe WorkerRoulette do
       subject.work_orders!
       subject.should_receive(:work_orders!).and_call_original
 
-      publisher = -> {puts :HOO.to_s; foreman.enqueue_work_order(work_orders); subject.unsubscribe}
+      publisher = -> {foreman.enqueue_work_order(work_orders); subject.unsubscribe}
 
       subject.wait_for_work_orders(publisher) do |redis_work_orders|
         redis_work_orders.should == [work_orders_with_headers]
@@ -164,6 +164,7 @@ describe WorkerRoulette do
 
       tradesman.wait_for_work_orders(publish) do |work|
         work.to_s.should match("some old fashion work")
+        work.to_s.should_not match("evil")
       end
     end
 
@@ -192,15 +193,6 @@ describe WorkerRoulette 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
-         EM.synchrony do
-          WorkerRoulette.start(:driver => :synchrony)
-          WorkerRoulette.foreman("muddle_man").enqueue_work_order("foo")
-          WorkerRoulette.tradesman.work_orders!.should == [work_orders_with_headers]
-          EM.stop
-        end
-      end
     end
   end
-end
+end

data/spec/spec_helper.rb

@@ -1,7 +1,8 @@
 require 'worker_roulette'
-require 'em-synchrony'
+require 'evented-spec'
 require 'simplecov'
 require 'simplecov-rcov'
+require 'rspec'
 class SimpleCov::Formatter::MergedFormatter
   def format(result)
      SimpleCov::Formatter::HTMLFormatter.new.format(result)
@@ -16,30 +17,7 @@ include WorkerRoulette
 
 Dir[File.join(File.dirname(__FILE__), 'helpers', '**/*.rb')].sort.each { |file| require file.gsub(".rb", "")}
 
-module RSpec
-  module Core
-    class ExampleGroup
-
-      class << self
-        alias_method :run_alias, :run
-
-        def run(reporter)
-          if EM.reactor_running?
-            run_alias reporter
-          else
-            out = nil
-            EM.synchrony do
-              out = run_alias reporter
-              EM.stop
-            end
-            out
-          end
-        end
-      end
-
-    end
-  end
-end
+EM::Hiredis.reconnect_timeout = 0.01
 
 RSpec.configure do |c|
   c.after(:each) do

data/worker_roulette.gemspec

@@ -20,8 +20,9 @@ Gem::Specification.new do |spec|
   spec.add_dependency 'oj'
   spec.add_dependency 'redis', '~> 3.0.7'
   spec.add_dependency 'hiredis', '~> 0.4.5'
-  spec.add_dependency 'em-synchrony'
+  spec.add_dependency 'em-hiredis', '~> 0.2.1'
   spec.add_dependency 'connection_pool'
+  spec.add_dependency 'eventmachine', '~> 1.0.3'
 
   spec.add_development_dependency "bundler"
   spec.add_development_dependency "rake"
@@ -30,4 +31,5 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency 'simplecov'
   spec.add_development_dependency 'simplecov-rcov'
   spec.add_development_dependency 'rspec_junit_formatter'
+  spec.add_development_dependency 'evented-spec'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: worker_roulette
 version: !ruby/object:Gem::Version
-  version: 0.0.7
+  version: 0.0.8
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-02-15 00:00:00.000000000 Z
+date: 2014-02-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: oj
@@ -60,21 +60,21 @@ dependencies:
       - !ruby/object:Gem::Version
         version: 0.4.5
 - !ruby/object:Gem::Dependency
-  name: em-synchrony
+  name: em-hiredis
   requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
-    - - ! '>='
+    - - ~>
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 0.2.1
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     none: false
     requirements:
-    - - ! '>='
+    - - ~>
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 0.2.1
 - !ruby/object:Gem::Dependency
   name: connection_pool
   requirement: !ruby/object:Gem::Requirement
@@ -91,6 +91,22 @@ dependencies:
     - - ! '>='
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: eventmachine
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.0.3
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.0.3
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -203,6 +219,22 @@ dependencies:
     - - ! '>='
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: evented-spec
+  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
@@ -218,11 +250,14 @@ files:
 - README.md
 - Rakefile
 - lib/worker_roulette.rb
+- lib/worker_roulette/a_foreman.rb
+- lib/worker_roulette/a_tradesman.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/evented_worker_roulette_spec.rb
 - spec/integration/worker_roulette_spec.rb
 - spec/spec_helper.rb
 - worker_roulette.gemspec
@@ -253,6 +288,7 @@ summary: Write a gem summary
 test_files:
 - spec/benchmark/perf_test.rb
 - spec/helpers/.gitkeep
+- spec/integration/evented_worker_roulette_spec.rb
 - spec/integration/worker_roulette_spec.rb
 - spec/spec_helper.rb
 has_rdoc: