worker_roulette 0.1.7 → 0.1.9

data/spec/integration/worker_roulette_spec.rb

@@ -1,184 +1,162 @@
 require "spec_helper"
+module WorkerRoulette
+  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) {[WorkerRoulette.dump(work_orders_with_headers)]}
+    let(:worker_roulette) { WorkerRoulette.start }
 
-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) {[WorkerRoulette.dump(work_orders_with_headers)]}
+    let(:redis) {Redis.new(worker_roulette.redis_config)}
 
-  let(:redis) {Redis.new(WorkerRoulette.redis_config)}
-
-  before do
-    WorkerRoulette.start
-  end
-
-  it "should exist" do
-    expect(WorkerRoulette).not_to be_nil
-  end
-
-  context Foreman do
-    let(:subject) {WorkerRoulette.foreman(sender)}
-
-    it "should be working on behalf of a sender" do
-      expect(subject.sender).to eq(sender)
+    it "should exist" do
+      expect(worker_roulette).to be_instance_of(WorkerRoulette)
     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) {}
-      expect(redis.lrange(sender, 0, -1)).to eq(work_orders.map {|m| WorkerRoulette.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)
-      expect(redis.lrange(sender, 0, -1)).to eq([WorkerRoulette.dump(work_orders)])
-    end
+    context Foreman do
+      let(:subject) {worker_roulette.foreman(sender)}
 
-    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)
-      expect(redis.lrange(sender, 0, -1)).to eq(jsonized_work_orders_with_headers)
-    end
+      it "should be working on behalf of a sender" do
+        expect(subject.sender).to eq(sender)
+      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)
-      expect(redis.lrange(sender, 0, -1)).to eq([WorkerRoulette.dump(work_orders_with_headers)])
-    end
+      it "should enqueue_work_order two work_orders in the sender's work queue" do
+        subject.enqueue_work_order(work_orders.first) {}
+        subject.enqueue_work_order(work_orders.last) {}
+        expect(redis.lrange(sender, 0, -1)).to eq(work_orders.map {|m| WorkerRoulette.dump(default_headers.merge({'payload' => m})) })
+      end
 
-    it "should post the sender's id to the job board with an order number" do
-      subject.enqueue_work_order(work_orders.first)
-      WorkerRoulette.foreman('other_forman').enqueue_work_order(work_orders.last)
-      expect(redis.zrange(subject.job_board_key, 0, -1, with_scores: true)).to eq([[sender, 1.0], ["other_forman", 2.0]])
-    end
+      it "should enqueue_work_order an array of work_orders without headers in the sender's work queue" do
+        subject.enqueue_work_order_without_headers(work_orders)
+        expect(redis.lrange(sender, 0, -1)).to eq([WorkerRoulette.dump(work_orders)])
+      end
 
-    it "should generate a monotically increasing score for senders not on the job board, but not for senders already there" do
-      other_forman = WorkerRoulette.foreman('other_forman')
-      expect(redis.get(subject.counter_key)).to be_nil
-      subject.enqueue_work_order(work_orders.first)
-      expect(redis.get(subject.counter_key)).to eq("1")
-      subject.enqueue_work_order(work_orders.last)
-      expect(redis.get(subject.counter_key)).to eq("1")
-      other_forman.enqueue_work_order(work_orders.last)
-      expect(redis.get(other_forman.counter_key)).to eq("2")
-    end
+      it "should enqueue_work_order an array of work_orders with default headers in the sender's work queue" do
+        subject.enqueue_work_order(work_orders)
+        expect(redis.lrange(sender, 0, -1)).to eq(jsonized_work_orders_with_headers)
+      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
+      it "should enqueue_work_order an array of work_orders with additional headers in the sender's work queue" do
+        extra_headers = {'foo' => 'bars'}
+        subject.enqueue_work_order(work_orders, extra_headers)
+        work_orders_with_headers['headers'].merge!(extra_headers)
+        expect(redis.lrange(sender, 0, -1)).to eq([WorkerRoulette.dump(work_orders_with_headers)])
+      end
 
-        on.message do |channel, notification|
-          result = notification
-          redis_tradesman.unsubscribe(WorkerRoulette::JOB_NOTIFICATIONS)
-        end
+      it "should post the sender's id to the job board with an order number" do
+        subject.enqueue_work_order(work_orders.first)
+        worker_roulette.foreman('other_forman').enqueue_work_order(work_orders.last)
+        expect(redis.zrange(subject.job_board_key, 0, -1, with_scores: true)).to eq([[sender, 1.0], ["other_forman", 2.0]])
       end
 
-      expect(result).to eq(WorkerRoulette::JOB_NOTIFICATIONS)
+      it "should generate a monotically increasing score for senders not on the job board, but not for senders already there" do
+        other_forman = worker_roulette.foreman('other_forman')
+        expect(redis.get(subject.counter_key)).to be_nil
+        subject.enqueue_work_order(work_orders.first)
+        expect(redis.get(subject.counter_key)).to eq("1")
+        subject.enqueue_work_order(work_orders.last)
+        expect(redis.get(subject.counter_key)).to eq("1")
+        other_forman.enqueue_work_order(work_orders.last)
+        expect(redis.get(other_forman.counter_key)).to eq("2")
+      end
     end
-  end
 
-  context Tradesman do
-    let(:foreman) {WorkerRoulette.foreman(sender)}
-    let(:subject)  {WorkerRoulette.tradesman}
+    context Tradesman do
+      let(:foreman) {worker_roulette.foreman(sender)}
+      let(:subject)  {worker_roulette.tradesman}
 
-    before do
-      foreman.enqueue_work_order(work_orders)
-    end
+      before do
+        foreman.enqueue_work_order(work_orders)
+      end
 
-    it "should have a last sender if it found messages" do
-      expect(subject.work_orders!.length).to eq(1)
-      expect(subject.last_sender).to eq(sender)
-    end
+      it "should have a last sender if it found messages" do
+        expect(subject.work_orders!.length).to eq(1)
+        expect(subject.last_sender).to eq(sender)
+      end
 
-    it "should not have a last sender if it found no messages" do
-      expect(subject.work_orders!.length).to eq(1)
-      expect(subject.work_orders!.length).to eq(0)
-      expect(subject.last_sender).to be_nil
-    end
+      it "should not have a last sender if it found no messages" do
+        expect(subject.work_orders!.length).to eq(1)
+        expect(subject.work_orders!.length).to eq(0)
+        expect(subject.last_sender).to be_nil
+      end
 
-    it "should drain one set of work_orders from the sender's slot in the switchboard" do
-      expect(subject.work_orders!).to eq([work_orders_with_headers])
-      expect(subject.work_orders!).to be_empty
-      expect(subject.work_orders!).to be_empty #does not throw an error if queue is already empty
-    end
+      it "should drain one set of work_orders from the sender's work queue" do
+        expect(subject.work_orders!).to eq([work_orders_with_headers])
+        expect(subject.work_orders!).to be_empty
+        expect(subject.work_orders!).to be_empty #does not throw an error if queue is already empty
+      end
 
-    it "should drain all the work_orders from the sender's slot in the switchboard" do
-      foreman.enqueue_work_order(work_orders)
-      expect(subject.work_orders!).to eq([work_orders_with_headers, work_orders_with_headers])
-      expect(subject.work_orders!).to be_empty
-      expect(subject.work_orders!).to be_empty #does not throw an error if queue is already empty
-    end
+      it "should drain all the work_orders from the sender's work queue" do
+        foreman.enqueue_work_order(work_orders)
+        expect(subject.work_orders!).to eq([work_orders_with_headers, work_orders_with_headers])
+        expect(subject.work_orders!).to be_empty
+        expect(subject.work_orders!).to be_empty #does not throw an error if queue is already 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)
-      expect(redis.zrange(subject.job_board_key, 0, -1)).to eq([oldest_sender, most_recent_sender])
-      subject.work_orders!
-      expect(redis.zrange(subject.job_board_key, 0, -1)).to eq([most_recent_sender])
-    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 = worker_roulette.foreman(most_recent_sender)
+        most_recent_foreman.enqueue_work_order(work_orders)
+        expect(redis.zrange(subject.job_board_key, 0, -1)).to eq([oldest_sender, most_recent_sender])
+        subject.work_orders!
+        expect(redis.zrange(subject.job_board_key, 0, -1)).to eq([most_recent_sender])
+      end
 
-    it "should get the work_orders from the next queue when a new job is ready" do
-      subject.work_orders!
-      expect(subject).to receive(:work_orders!).twice.and_call_original
+      it "should get the work_orders from the next queue when a new job is ready, then poll for new work" do
+        subject.work_orders!
+        expect(subject).to receive(:work_orders!).and_call_original
+        expect(subject.timer).to receive(:after)
 
-      publisher = -> {foreman.enqueue_work_order(work_orders); subject.unsubscribe}
+        foreman.enqueue_work_order(work_orders)
 
-      subject.wait_for_work_orders(publisher) do |redis_work_orders|
-        expect(redis_work_orders).to eq([work_orders_with_headers])
-        expect(subject.last_sender).to be_nil
+        subject.wait_for_work_orders do |redis_work_orders|
+          expect(redis_work_orders).to eq([work_orders_with_headers])
+          expect(subject.last_sender).to eq('katie_80')
+        end
       end
-    end
-
-    it "should publish and subscribe on custom channels" do
-      tradesman         = WorkerRoulette.tradesman('good_channel')
-      expect(tradesman).to receive(:work_orders!).twice.and_call_original
 
-      good_foreman      = WorkerRoulette.foreman('foreman', 'good_channel')
-      bad_foreman       = WorkerRoulette.foreman('foreman', 'bad_channel')
+      it "should publish and subscribe on custom channels" do
+        tradesman         = worker_roulette.tradesman('good_channel')
+        expect(tradesman).to receive(:work_orders!).and_call_original
 
+        good_foreman      = worker_roulette.foreman('foreman', 'good_channel')
+        bad_foreman       = worker_roulette.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')
-        tradesman.unsubscribe
-      end
 
-      tradesman.wait_for_work_orders(publish) do |work|
-        expect(work.to_s).to match("some old fashion work")
-        expect(work.to_s).not_to match("evil")
-        expect(tradesman.last_sender).to be_nil
+        tradesman.wait_for_work_orders do |work|
+          expect(work.to_s).to match("some old fashion work")
+          expect(work.to_s).not_to match("evil")
+          expect(tradesman.last_sender).to eq('foreman')
+        end
       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; 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; 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|
-          expect(pooled_redis.info["connected_clients"].to_i).to be > (WorkerRoulette.pool_size)
+      context "Concurrent Access" do
+        it "should pool its connections" do
+          Array.new(100) do
+            Thread.new {worker_roulette.tradesman_connection_pool.with {|pooled_redis| pooled_redis.get("foo")}}
+          end.each(&:join)
+          worker_roulette.tradesman_connection_pool.with do |pooled_redis|
+            expect(pooled_redis.info["connected_clients"].to_i).to be > (worker_roulette.pool_size)
+          end
         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
-        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)
+        #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
+          instance = WorkerRoulette.start
+          instance.tradesman_connection_pool.with {|pooled_redis| pooled_redis.get("foo")}
+          fork do
+            expect {instance.tradesman_connection_pool.with {|pooled_redis| pooled_redis.get("foo")}}.to raise_error(Redis::InheritedError)
+          end
         end
       end
     end

data/spec/spec_helper.rb

@@ -1,17 +1,18 @@
-require 'worker_roulette'
-require 'evented-spec'
-require 'rspec'
-require 'pry'
+module WorkerRoulette
+  require 'worker_roulette'
+  require 'evented-spec'
+  require 'rspec'
+  require 'pry'
 
-require File.expand_path(File.join("..", "..", "lib", "worker_roulette.rb"), __FILE__)
-include WorkerRoulette
+  require File.expand_path(File.join("..", "..", "lib", "worker_roulette.rb"), __FILE__)
 
-Dir[File.join(File.dirname(__FILE__), 'helpers', '**/*.rb')].sort.each { |file| require file.gsub(".rb", "")}
+  Dir[File.join(File.dirname(__FILE__), 'helpers', '**/*.rb')].sort.each { |file| require file.gsub(".rb", "")}
 
-EM::Hiredis.reconnect_timeout = 0.01
+  EM::Hiredis.reconnect_timeout = 0.01
 
-RSpec.configure do |c|
-  c.after(:each) do
-    Redis.new(WorkerRoulette.redis_config).flushdb
+  RSpec.configure do |c|
+    c.after(:each) do
+      Redis.new(WorkerRoulette.start.redis_config).flushdb
+    end
   end
-end
+end

data/spec/unit/evented_readlock_spec.rb

@@ -1,23 +1,24 @@
 require 'spec_helper'
 module WorkerRoulette
- describe "Evented Read Lock" do
+  describe "Evented Read Lock" do
     include EventedSpec::EMSpec
 
-    let(:redis) {Redis.new(WorkerRoulette.redis_config)}
+    let(:redis) {Redis.new(WorkerRoulette.start.redis_config)}
     let(:sender) {'katie_80'}
     let(:work_orders) {"hellot"}
     let(:lock_key) {"L*:#{sender}"}
     let(:default_headers) {Hash['headers' => {'sender' => sender}]}
     let(:work_orders_with_headers) {default_headers.merge({'payload' => work_orders})}
     let(:jsonized_work_orders_with_headers) {[WorkerRoulette.dump(work_orders_with_headers)]}
-    let(:foreman) {WorkerRoulette.foreman(sender)}
-    let(:number_two) {WorkerRoulette.foreman('number_two')}
-    let(:subject) {WorkerRoulette.tradesman}
-    let(:subject_two) {WorkerRoulette.tradesman}
+    let(:worker_roulette) { WorkerRoulette.start(evented: true) }
+    let(:foreman) {worker_roulette.foreman(sender)}
+    let(:number_two) {worker_roulette.foreman('number_two')}
+    let(:subject) {worker_roulette.tradesman}
+    let(:subject_two) {worker_roulette.tradesman}
+    let(:lua) { Lua.new(worker_roulette.tradesman_connection_pool) }
 
     em_before do
-      WorkerRoulette.start(evented: true)
-      Lua.clear_cache!
+      lua.clear_cache!
       redis.script(:flush)
       redis.flushdb
     end
@@ -29,9 +30,9 @@ module WorkerRoulette
       end
     end
 
-    it "should set the lock to expire in 1 second" do
+    it "should set the lock to expire in 3 seconds" do
       evented_readlock_preconditions do
-        expect(redis.ttl(lock_key)).to eq(1)
+        expect(redis.ttl(lock_key)).to eq(3)
         done
       end
     end
@@ -45,13 +46,13 @@ module WorkerRoulette
     end
 
     it "should read from the first available queue that is not locked" do
-       evented_readlock_preconditions do
-         foreman.enqueue_work_order(work_orders) do    #locked
-           number_two.enqueue_work_order(work_orders) do  #unlocked
+      evented_readlock_preconditions do
+        foreman.enqueue_work_order(work_orders) do    #locked
+          number_two.enqueue_work_order(work_orders) do  #unlocked
             subject_two.work_orders!{|work| expect(work.first['headers']['sender']).to eq('number_two'); done}
           end
-         end
-       end
+        end
+      end
     end
 
     it "should release its last lock when it asks for its next work order from another sender" do
@@ -94,13 +95,13 @@ module WorkerRoulette
         end
       end
     end
-  end
 
-  def evented_readlock_preconditions(&spec_block)
-    foreman.enqueue_work_order(work_orders) do
-      subject.work_orders! do |work|
-        expect(work).to eq([work_orders_with_headers])
-        spec_block.call
+    def evented_readlock_preconditions(&spec_block)
+      foreman.enqueue_work_order(work_orders) do
+        subject.work_orders! do |work|
+          expect(work).to eq([work_orders_with_headers])
+          spec_block.call
+        end
       end
     end
   end

data/spec/unit/lua_spec.rb

@@ -2,23 +2,21 @@ require 'spec_helper'
 module WorkerRoulette
  describe Lua do
     include EventedSpec::EMSpec
-    let(:redis) {Redis.new(WorkerRoulette.redis_config)}
-
-    em_before do
-      WorkerRoulette.start(evented: true)
-    end
+    let(:worker_roulette) {WorkerRoulette.start(evented: true)}
+    let(:lua) { Lua.new(worker_roulette.tradesman_connection_pool) }
+    let(:redis) {Redis.new(worker_roulette.redis_config)}
 
     before do
-      Lua.clear_cache!
+      lua.clear_cache!
       redis.script(:flush)
       redis.flushdb
     end
 
     it "should load and call a lua script" do
       lua_script = 'return redis.call("SET", KEYS[1], ARGV[1])'
-      Lua.call(lua_script, ['foo'], ['daddy']) do |result|
-        expect(Lua.cache.keys.first).to eq(lua_script)
-        expect(Lua.cache.values.first).to eq(Digest::SHA1.hexdigest(lua_script))
+      lua.call(lua_script, ['foo'], ['daddy']) do |result|
+        expect(lua.cache.keys.first).to eq(lua_script)
+        expect(lua.cache.values.first).to eq(Digest::SHA1.hexdigest(lua_script))
         expect(result).to eq("OK")
         done
       end
@@ -26,12 +24,12 @@ module WorkerRoulette
 
     it "should send a sha instead of a script once the script has been cached" do
       lua_script = 'return KEYS'
-      expect(Lua).to receive(:eval).and_call_original
+      expect(lua).to receive(:eval).and_call_original
 
-      Lua.call(lua_script) do |result|
-        expect(Lua).not_to receive(:eval)
+      lua.call(lua_script) do |result|
+        expect(lua).not_to receive(:eval)
 
-        Lua.call(lua_script) do |inner_result|
+        lua.call(lua_script) do |inner_result|
           expect(inner_result).to be_empty
           done
         end
@@ -40,7 +38,7 @@ module WorkerRoulette
 
     it "should raise an error to the caller if the script fails in redis" do
       lua_script = 'this is junk'
-      # Lua.call(lua_script)
+      # lua.call(lua_script)
       # rspec cannot test this bc of the callbacks, but if you have doubts,
       # uncomment the line above and watch it fail
       done

data/spec/unit/readlock_spec.rb

@@ -1,21 +1,22 @@
 require 'spec_helper'
 module WorkerRoulette
  describe "Read Lock" do
-    let(:redis) {Redis.new(WorkerRoulette.redis_config)}
+    let(:worker_roulette) {WorkerRoulette.start(evented: false)}
+    let(:redis) {Redis.new(worker_roulette.redis_config)}
     let(:sender) {'katie_80'}
     let(:work_orders) {"hellot"}
     let(:lock_key) {"L*:#{sender}"}
     let(:default_headers) {Hash['headers' => {'sender' => sender}]}
     let(:work_orders_with_headers) {default_headers.merge({'payload' => work_orders})}
     let(:jsonized_work_orders_with_headers) {[WorkerRoulette.dump(work_orders_with_headers)]}
-    let(:foreman) {WorkerRoulette.foreman(sender)}
-    let(:number_two) {WorkerRoulette.foreman('number_two')}
-    let(:subject) {WorkerRoulette.tradesman}
-    let(:subject_two) {WorkerRoulette.tradesman}
+    let(:foreman) {worker_roulette.foreman(sender)}
+    let(:number_two) {worker_roulette.foreman('number_two')}
+    let(:subject) {worker_roulette.tradesman}
+    let(:subject_two) {worker_roulette.tradesman}
+    let(:lua) { Lua.new(worker_roulette.tradesman_connection_pool) }
 
     before do
-      WorkerRoulette.start(evented: false)
-      Lua.clear_cache!
+      lua.clear_cache!
       redis.script(:flush)
       redis.flushdb
       foreman.enqueue_work_order(work_orders)
@@ -26,8 +27,8 @@ module WorkerRoulette
       expect(redis.get(lock_key)).not_to be_nil
     end
 
-    it "should set the lock to expire in 1 second" do
-      expect(redis.ttl(lock_key)).to eq(1)
+    it "should set the lock to expire in 3 second" do
+      expect(redis.ttl(lock_key)).to eq(3)
     end
 
     it "should not read a locked queue" do
@@ -66,7 +67,5 @@ module WorkerRoulette
       expect(subject.work_orders!).to be_empty
       expect(redis.get(lock_key)).to be_nil
     end
-
-    pending "pubsub should clean up one contention or remove the lock on the same sender queue automaticly"
   end
 end

data/worker_roulette.gemspec

@@ -23,6 +23,7 @@ Gem::Specification.new do |spec|
   spec.add_dependency 'em-hiredis', '~> 0.2.1'
   spec.add_dependency 'connection_pool'
   spec.add_dependency 'eventmachine', '~> 1.0.3'
+  spec.add_dependency 'timers', '~> 3.0.1'
 
   spec.add_development_dependency 'bundler'
   spec.add_development_dependency 'rake'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: worker_roulette
 version: !ruby/object:Gem::Version
-  version: 0.1.7
+  version: 0.1.9
 platform: ruby
 authors:
 - Paul Saieg
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-07-09 00:00:00.000000000 Z
+date: 2014-07-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: oj
@@ -94,6 +94,20 @@ dependencies:
     - - ~>
       - !ruby/object:Gem::Version
         version: 1.0.3
+- !ruby/object:Gem::Dependency
+  name: timers
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 3.0.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 3.0.1
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -236,11 +250,11 @@ files:
 - README.md
 - Rakefile
 - lib/worker_roulette.rb
-- lib/worker_roulette/a_tradesman.rb
 - lib/worker_roulette/foreman.rb
 - lib/worker_roulette/lua.rb
 - lib/worker_roulette/tradesman.rb
 - lib/worker_roulette/version.rb
+- spec/benchmark/irb_demo_runner.rb
 - spec/benchmark/perf_test.rb
 - spec/helpers/.gitkeep
 - spec/integration/evented_worker_roulette_spec.rb
@@ -249,7 +263,6 @@ files:
 - spec/unit/evented_readlock_spec.rb
 - spec/unit/lua_spec.rb
 - spec/unit/readlock_spec.rb
-- spec/unit/worker_roulette_spec.rb
 - worker_roulette.gemspec
 homepage: https://github.com/nexiahome/worker_roulette
 licenses: []
@@ -275,6 +288,7 @@ signing_key:
 specification_version: 4
 summary: Pub Sub Queue for Redis that ensures ordered processing
 test_files:
+- spec/benchmark/irb_demo_runner.rb
 - spec/benchmark/perf_test.rb
 - spec/helpers/.gitkeep
 - spec/integration/evented_worker_roulette_spec.rb
@@ -283,4 +297,3 @@ test_files:
 - spec/unit/evented_readlock_spec.rb
 - spec/unit/lua_spec.rb
 - spec/unit/readlock_spec.rb
-- spec/unit/worker_roulette_spec.rb

data/lib/worker_roulette/a_tradesman.rb

@@ -1,46 +0,0 @@
-require_relative './tradesman'
-module WorkerRoulette
-  class ATradesman < Tradesman
-    attr_reader :timer
-
-    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| get_messages(message, channel, on_message_callback)}
-      set_timer(on_message_callback);
-      @redis_pubsub.subscribe(@channel)
-    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_messages(message, channel, on_message_callback)
-      return unless on_message_callback
-      work_orders! do |work_orders_1|
-        work_orders! do |work_orders|
-          on_message_callback.call(work_orders_1 + work_orders, message, channel)
-        end
-      end
-    end
-
-    def set_timer(on_message_callback)
-      return if (@timer || !on_message_callback)
-      @timer = EM::PeriodicTimer.new(rand(20..25)) do
-        work_orders! {|work_orders| on_message_callback.call(work_orders, nil, nil)}
-      end
-    end
-  end
-end