worker_roulette 0.1.1 → 0.1.3

data/README.md

@@ -10,7 +10,7 @@ size_of_connection_pool = 100
 
 #Start it up
 #the config takes size for the connection pool size, evented to specify which api to use, then the normal redis config
-WorkerRoulette.start(size: size_of_connection_pool, evented: false, host: 'localhost', timeout: 5, db: 1)
+WorkerRoulette.start(size: size_of_connection_pool, evented: true, host: 'localhost', timeout: 5, db: 1)
 
 #Enqueue some work
 sender_id = :shady

data/lib/worker_roulette/a_tradesman.rb

@@ -4,7 +4,7 @@ module WorkerRoulette
     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| set_timer(on_message_callback); work_orders! {|work_orders| on_message_callback.call(work_orders, message, channel)} if on_message_callback}
+      @redis_pubsub.on(:message)   {|channel, message| set_timer(on_message_callback); get_messages(message, channel, on_message_callback)}
       @redis_pubsub.subscribe(@channel)
     end
 
@@ -24,6 +24,15 @@ module WorkerRoulette
 
   private
     attr_reader :timer
+    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 unless on_message_callback
       @timer && @timer.cancel

data/lib/worker_roulette/foreman.rb

@@ -48,12 +48,12 @@ module WorkerRoulette
 
         local function enqueue_work_orders(work_order, job_notification)
           local result    = sender_key .. ' updated'
-          local sender_on_job_board = redis.call('ZSCORE', job_board_key, sender_key)
+          local sender_is_on_job_board = redis.call('ZSCORE', job_board_key, sender_key)
 
-          if (sender_on_job_board == false) then
+          if (sender_is_on_job_board == false) then
             local count     = redis.call('INCR', counter_key)
             local job_added = redis.call('ZADD',job_board_key, count, sender_key)
-            result    = sender_key .. ' added'
+            result          = sender_key .. ' added'
           end
 
           local work_added          = redis.call('RPUSH',sender_key, work_order)

data/lib/worker_roulette/tradesman.rb

@@ -1,6 +1,6 @@
 module WorkerRoulette
   class Tradesman
-    attr_reader :sender
+    attr_reader :last_sender
     def initialize(client_pool, pubsub_pool, namespace = nil)
       @client_pool = client_pool
       @pubsub_pool = pubsub_pool
@@ -12,14 +12,15 @@ module WorkerRoulette
       @pubsub_pool.with do |redis|
         redis.subscribe(@channel) do |on|
           on.subscribe {on_subscribe_callback.call if on_subscribe_callback}
-          on.message   {self.unsubscribe; block.call(work_orders!) if block}
+          on.message   {block.call(work_orders! + work_orders!) if block}
         end
       end
     end
 
     def work_orders!(&callback)
-      Lua.call(self.class.lua_drain_work_orders, [job_board_key, nil], [@namespace]) do |results|
-        @sender = (results.first || '').split(':').first
+      Lua.call(self.class.lua_drain_work_orders, [job_board_key, @last_sender], [nil]) do |results|
+        results ||= []
+        @last_sender = (results.first || '').split(':').first
         work = (results[1] || []).map {|work_order| WorkerRoulette.load(work_order)}
         callback.call work if callback
         work
@@ -35,37 +36,50 @@ module WorkerRoulette
     end
 
   private
-    def sender_key
-      @sender_key = WorkerRoulette.sender_key(@sender, @namespace)
-    end
-
     def self.lua_drain_work_orders
       <<-HERE
         local job_board_key     = KEYS[1]
-        local empty             = KEYS[2]
-        local namespace         = ARGV[1]
+        local last_sender_key   = KEYS[2]
+        local sender_key        = ARGV[1]
 
-        local function drain_work_orders(job_board_key, namespace)
-          local sender_key = redis.call('ZRANGE', job_board_key, 0, 0)[1]
+        local function drain_work_orders(job_board_key, last_sender_key, sender_key)
+          if last_sender_key ~= "" and last_sender_key ~= nil then
+            local last_sender_lock_key = 'L*:' .. last_sender_key
+            redis.call('DEL', last_sender_lock_key)
+          end
 
-          if sender_key == false then
-            return {}
+          if (not sender_key) or (sender_key == "") then
+            sender_key = redis.call('ZRANGE', job_board_key, 0, 0)[1]
+            if (not sender_key) or (sender_key == "") then
+              return {}
+            end
           end
 
-          local results = {}
-          results[1] = sender_key
-          results[2] = redis.call('LRANGE', sender_key, 0, -1)
-          results[3] = redis.call('DEL', sender_key)
-          results[4] = redis.call('ZREM', job_board_key, sender_key)
-          return results
+          local lock_key = 'L*:' .. sender_key
+          local locked   = (redis.call('GET', lock_key) == 'L')
+
+          if not locked then
+            local results = {}
+            results[1] = sender_key
+            results[2] = redis.call('LRANGE', sender_key, 0, -1)
+            redis.call('DEL', sender_key)
+            redis.call('ZREM', job_board_key, sender_key)
+            redis.call('SET', lock_key, 'L', 'EX', 1, 'NX')
+            return results
+          else
+            local sender_index    = redis.call('ZRANK', job_board_key, sender_key)
+            local next_index      = sender_index + 1
+            local next_sender_key = redis.call('ZRANGE', job_board_key, next_index, next_index)[1]
+            if next_sender_key then
+              return drain_work_orders(job_board_key, "", next_sender_key)
+            else
+              return {}
+            end
+          end
         end
 
-        return drain_work_orders(job_board_key, namespace)
+        return drain_work_orders(job_board_key, last_sender_key, "")
       HERE
     end
-
-    def get_sender_for_next_job(redis)
-      @sender = (redis.zrange(job_board_key, 0, 0) || []).first.to_s
-    end
   end
 end

data/lib/worker_roulette/version.rb

@@ -1,3 +1,3 @@
 module WorkerRoulette
-  VERSION = "0.1.1"
+  VERSION = "0.1.3"
 end

data/spec/benchmark/perf_test.rb

@@ -1,4 +1,4 @@
-require_relative '../spec_helper'
+require 'worker_roulette'
 require 'benchmark'
 require 'eventmachine'
 
@@ -6,51 +6,13 @@ REDIS_CONNECTION_POOL_SIZE = 100
 ITERATIONS = 10_000
 
 work_order = {'ding dong' => "hello_foreman_" * 100}
-WorkerRoulette.start(size: REDIS_CONNECTION_POOL_SIZE, evented: false)
-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
-    WorkerRoulette.start(size: REDIS_CONNECTION_POOL_SIZE, evented: false)
-    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
 
 EM::Hiredis.reconnect_timeout = 0.01
 
-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 # ~2700 work_orders / second round trip
-    WorkerRoulette.start(size: REDIS_CONNECTION_POOL_SIZE, evented: false)
-    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; tradesman.unsubscribe}
-    end
-  end
-end
-
-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 evently insert and read #{ITERATIONS} large work_orders" do # ~4200 work_orders / second round trip; 50-50 read-write time; CPU and IO bound
+times = Benchmark.bm do |x|
+  x.report "#{ITERATIONS} ASync Api Read/Writes" do
     EM.run do
       WorkerRoulette.start(evented: true)
       WorkerRoulette.tradesman_connection_pool.with {|r| r.flushdb}
@@ -70,9 +32,14 @@ Benchmark.bmbm do |x|
     end
   end
 end
+puts "#{ITERATIONS / times.first.real} ASync Api Read/Writes per second"
+puts "#################"
+puts
+
+WorkerRoulette.tradesman_connection_pool.with {|r| r.flushdb}
 
-Benchmark.bmbm do |x|
-  x.report "Time to evently pubsub insert and read #{ITERATIONS} large work_orders" do # ~5200 work_orders / second round trip; 50-50 read-write time; CPU and IO bound
+times = Benchmark.bm do |x|
+  x.report "#{ITERATIONS * 2} ASync Api Pubsub Read/Writes" do
     EM.run do
       WorkerRoulette.start(evented: true)
       @processed = 0
@@ -92,5 +59,83 @@ Benchmark.bmbm do |x|
     end
   end
 end
+puts "#{ITERATIONS * 2 / times.first.real} ASync Api Pubsub Read/Writes per second"
+puts "#################"
+puts
+WorkerRoulette.tradesman_connection_pool.with {|r| r.flushdb}
+
+WorkerRoulette.start(size: REDIS_CONNECTION_POOL_SIZE, evented: false)
+times = Benchmark.bm do |x|
+  puts x.class.name
+  x.report "#{ITERATIONS} Sync Api Writes" do
+    ITERATIONS.times do |iteration|
+      sender = 'sender_' + iteration.to_s
+      foreman = WorkerRoulette.foreman(sender)
+      foreman.enqueue_work_order(work_order)
+    end
+  end
+  WorkerRoulette.tradesman_connection_pool.with {|r| r.flushdb}
+end
+WorkerRoulette.tradesman_connection_pool.with {|r| r.flushdb}
 
+puts "#{ITERATIONS / times.first.real} Sync Api Writes per second"
+puts "#################"
+puts
+ITERATIONS.times do |iteration|
+  sender = 'sender_' + iteration.to_s
+  foreman = WorkerRoulette.foreman(sender)
+  foreman.enqueue_work_order(work_order)
+end
+
+times = Benchmark.bm do |x|
+  x.report "#{ITERATIONS} Sync Api Reads" do
+    ITERATIONS.times do |iteration|
+      sender = 'sender_' + iteration.to_s
+      tradesman = WorkerRoulette.tradesman
+      tradesman.work_orders!
+    end
+  end
+end
+puts "#{ITERATIONS / times.first.real} Sync Api Reads per second"
+puts "#################"
+puts
 WorkerRoulette.tradesman_connection_pool.with {|r| r.flushdb}
+
+times = Benchmark.bm do |x|
+  x.report "#{ITERATIONS} Sync Api Read/Writes" do
+    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
+puts "#{ITERATIONS / times.first.real} Sync Api Read/Writes per second"
+puts "#################"
+puts
+WorkerRoulette.tradesman_connection_pool.with {|r| r.flushdb}
+
+times = Benchmark.bm do |x|
+  x.report "#{ITERATIONS * 2} Sync Api Pubsub Read/Writes" do
+    WorkerRoulette.start(size: REDIS_CONNECTION_POOL_SIZE, evented: false)
+    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; tradesman.unsubscribe}
+    end
+  end
+end
+puts "#{ITERATIONS * 2 / times.first.real} Sync Api Pubsub Read/Writes per second"
+puts "#################"
+puts
+WorkerRoulette.tradesman_connection_pool.with {|r| r.flushdb}

data/spec/integration/evented_worker_roulette_spec.rb

@@ -100,45 +100,6 @@ describe WorkerRoulette do
     end
   end
 
-  context Lua do
-    before do
-      Lua.clear_cache!
-      redis.script(:flush)
-    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|
-        Lua.cache.keys.first.should == lua_script
-        Lua.cache.values.first.should == Digest::SHA1.hexdigest(lua_script)
-        result.should == "OK"
-        done
-      end
-    end
-
-    it "should send a sha instead of a script once the script has been cached" do
-      lua_script = 'return KEYS'
-      Lua.should_receive(:eval).and_call_original
-
-      Lua.call(lua_script) do |result|
-
-        Lua.should_not_receive(:eval)
-        Lua.call(lua_script) do |result|
-          result.should == []
-          done
-        end
-      end
-    end
-
-    it "should raise an error to the caller if the script fails in redis" do
-      lua_script = 'this is junk'
-      # 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
-    end
-  end
-
   context "Evented Tradesman" do
     let(:foreman) {WorkerRoulette.a_foreman(sender)}
     let(:subject)  {WorkerRoulette.a_tradesman}
@@ -146,7 +107,7 @@ describe WorkerRoulette do
     it "should be working on behalf of a sender" do
       foreman.enqueue_work_order(work_orders) do
         subject.work_orders! do |r|
-          subject.sender.should == sender
+          subject.last_sender.should == sender
           done
         end
       end
@@ -177,15 +138,14 @@ describe WorkerRoulette do
     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.should_receive(:work_orders!).twice.and_call_original
       publish = proc {foreman.enqueue_work_order(work_orders)}
 
       subject.wait_for_work_orders(publish) do |redis_work_orders, message, channel|
-        subject.sender.should == "katie_80"
-        redis_work_orders.should == [work_orders_with_headers]
+        redis_work_orders.should   == [work_orders_with_headers]
+        subject.last_sender.should == nil
         done
       end
-
     end
 
     it "should publish and subscribe on custom channels" do
@@ -201,8 +161,8 @@ describe WorkerRoulette do
       good_publish = proc {good_foreman.enqueue_work_order('some old fashion work')}
       bad_publish  = proc {bad_foreman.enqueue_work_order('evil biddings you should not carry out')}
 
-      tradesman.should_receive(:work_orders!).and_call_original
-      evil_tradesman.should_receive(:work_orders!).and_call_original
+      tradesman.should_receive(:work_orders!).twice.and_call_original
+      evil_tradesman.should_receive(:work_orders!).twice.and_call_original
 
       #They are double subscribing; is it possible that it is the connection pool?
 

data/spec/integration/worker_roulette_spec.rb

@@ -92,9 +92,15 @@ describe WorkerRoulette 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
+    it "should have a last sender if it found messages" do
+      subject.work_orders!.length.should == 1
+      subject.last_sender.should == sender
+    end
+
+    it "should not have a last sender if it found no messages" do
+      subject.work_orders!.length.should == 1
+      subject.work_orders!.length.should == 0
+      subject.last_sender.should == nil
     end
 
     it "should drain one set of work_orders from the sender's slot in the switchboard" do
@@ -122,18 +128,19 @@ describe WorkerRoulette do
 
     it "should get the work_orders from the next queue when a new job is ready" do
       subject.work_orders!
-      subject.should_receive(:work_orders!).and_call_original
+      subject.should_receive(:work_orders!).twice.and_call_original
 
       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]
+        subject.last_sender.should == nil
       end
     end
 
     it "should publish and subscribe on custom channels" do
       tradesman         = WorkerRoulette.tradesman('good_channel')
-      tradesman.should_receive(:work_orders!).and_call_original
+      tradesman.should_receive(:work_orders!).twice.and_call_original
 
       good_foreman      = WorkerRoulette.foreman('foreman', 'good_channel')
       bad_foreman       = WorkerRoulette.foreman('foreman', 'bad_channel')
@@ -148,6 +155,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")
+        tradesman.last_sender.should == nil
       end
     end
 

data/spec/unit/evented_readlock_spec.rb

@@ -0,0 +1,107 @@
+require 'spec_helper'
+module WorkerRoulette
+ describe "Evented Read Lock" do
+    include EventedSpec::EMSpec
+
+    let(:redis) {Redis.new(WorkerRoulette.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}
+
+    em_before do
+      WorkerRoulette.start(evented: true)
+      Lua.clear_cache!
+      redis.script(:flush)
+      redis.flushdb
+    end
+
+    it "should lock a queue when it reads from it" do
+      evented_readlock_preconditions do
+        redis.get(lock_key).should_not be_nil
+        done
+      end
+    end
+
+    it "should set the lock to expire in 1 second" do
+      evented_readlock_preconditions do
+        redis.ttl(lock_key).should == 1
+        done
+      end
+    end
+
+    it "should not read a locked queue" do
+      evented_readlock_preconditions do
+        foreman.enqueue_work_order(work_orders) do #locked
+          subject_two.work_orders! {|work |work.should == []; done}
+        end
+      end
+    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
+            subject_two.work_orders!{|work| work.first['headers']['sender'].should == 'number_two'; done}
+          end
+         end
+       end
+    end
+
+    it "should release its last lock when it asks for its next work order from another sender" do
+      evented_readlock_preconditions do
+        number_two.enqueue_work_order(work_orders) do #unlocked
+          subject.last_sender.should == sender
+          subject.work_orders! do |work|
+            work.first['headers']['sender'].should == 'number_two'
+            redis.get(lock_key).should == nil
+            done
+          end
+        end
+      end
+    end
+
+    it "should not release its lock when it asks for its next work order from the same sender" do
+      evented_readlock_preconditions do
+        foreman.enqueue_work_order(work_orders) do #locked
+          subject.work_orders! do |work|
+            work.should == [work_orders_with_headers]
+            subject.last_sender.should == sender
+            redis.get(lock_key).should_not == nil
+            done
+          end
+        end
+      end
+    end
+
+    it "should not take out another lock if there is no work to do" do
+      evented_readlock_preconditions do
+        foreman.enqueue_work_order(work_orders) do #locked
+          subject.work_orders! do |work|
+            work.should == [work_orders_with_headers]
+            subject.work_orders! do |work|
+              work.should == []
+              redis.get(lock_key).should == nil
+              done
+            end
+          end
+        end
+      end
+    end
+  end
+
+  def evented_readlock_preconditions(&spec_block)
+    foreman.enqueue_work_order(work_orders) do
+      subject.work_orders! do |work|
+        work.should == [work_orders_with_headers]
+        spec_block.call
+      end
+    end
+  end
+end

data/spec/unit/lua_spec.rb

@@ -0,0 +1,49 @@
+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
+
+    before do
+      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|
+        Lua.cache.keys.first.should == lua_script
+        Lua.cache.values.first.should == Digest::SHA1.hexdigest(lua_script)
+        result.should == "OK"
+        done
+      end
+    end
+
+    it "should send a sha instead of a script once the script has been cached" do
+      lua_script = 'return KEYS'
+      Lua.should_receive(:eval).and_call_original
+
+      Lua.call(lua_script) do |result|
+
+        Lua.should_not_receive(:eval)
+        Lua.call(lua_script) do |result|
+          result.should == []
+          done
+        end
+      end
+    end
+
+    it "should raise an error to the caller if the script fails in redis" do
+      lua_script = 'this is junk'
+      # 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
+    end
+  end
+end

data/spec/unit/readlock_spec.rb

@@ -0,0 +1,74 @@
+require 'spec_helper'
+module WorkerRoulette
+ describe "Read Lock" do
+    let(:redis) {Redis.new(WorkerRoulette.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}
+
+    before do
+      WorkerRoulette.start(evented: false)
+      Lua.clear_cache!
+      redis.script(:flush)
+      redis.flushdb
+      foreman.enqueue_work_order(work_orders)
+      subject.work_orders!.should == [work_orders_with_headers]
+    end
+
+    it "should lock a queue when it reads from it" do
+      redis.get(lock_key).should_not be_nil
+    end
+
+    it "should set the lock to expire in 1 second" do
+      redis.ttl(lock_key).should == 1
+    end
+
+    it "should not read a locked queue" do
+      foreman.enqueue_work_order(work_orders)    #locked
+      subject_two.work_orders!.should == []
+    end
+
+    it "should read from the first available queue that is not locked" do
+       foreman.enqueue_work_order(work_orders)     #locked
+       number_two.enqueue_work_order(work_orders)  #unlocked
+       subject_two.work_orders!.first['headers']['sender'].should == 'number_two'
+    end
+
+    it "should release its previous lock when it asks for work from another sender" do
+      number_two.enqueue_work_order(work_orders)    #unlocked
+      subject.last_sender.should == sender
+      subject.work_orders!.first['headers']['sender'].should == 'number_two'
+      redis.get(lock_key).should == nil
+    end
+
+    it "should not release its lock when it asks for work from the same sender" do
+      foreman.enqueue_work_order(work_orders)    #locked
+      subject.work_orders!.should == [work_orders_with_headers]
+      subject.last_sender.should == sender
+
+      foreman.enqueue_work_order(work_orders)    #locked
+      subject.work_orders!.should == [work_orders_with_headers]
+      subject.last_sender.should == sender
+
+      redis.get(lock_key).should_not == nil
+    end
+
+    it "should release its previous lock if there is no work to do from the same sender" do
+      foreman.enqueue_work_order(work_orders)    #locked
+      subject.work_orders!.should == [work_orders_with_headers]
+      subject.work_orders!.should == []
+      redis.get(lock_key).should == nil
+    end
+
+    xit "pubsub should clean up one contention orremove the lock on the same sender queue automaticly" do
+
+    end
+  end
+end

data/worker_roulette.gemspec

@@ -32,4 +32,6 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency 'simplecov-rcov'
   spec.add_development_dependency 'rspec_junit_formatter'
   spec.add_development_dependency 'evented-spec'
+  spec.add_development_dependency 'guard'
+  spec.add_development_dependency 'guard-rspec'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: worker_roulette
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.1.3
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-02-19 00:00:00.000000000 Z
+date: 2014-02-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: oj
@@ -235,6 +235,38 @@ dependencies:
     - - ! '>='
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: guard
+  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: guard-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'
 description: Write a gem description
 email:
 - classicist@gmail.com
@@ -260,6 +292,9 @@ files:
 - spec/integration/evented_worker_roulette_spec.rb
 - spec/integration/worker_roulette_spec.rb
 - spec/spec_helper.rb
+- spec/unit/evented_readlock_spec.rb
+- spec/unit/lua_spec.rb
+- spec/unit/readlock_spec.rb
 - worker_roulette.gemspec
 homepage: https://github.com/nexiahome/worker_roulette
 licenses: []
@@ -291,4 +326,7 @@ test_files:
 - spec/integration/evented_worker_roulette_spec.rb
 - spec/integration/worker_roulette_spec.rb
 - spec/spec_helper.rb
+- spec/unit/evented_readlock_spec.rb
+- spec/unit/lua_spec.rb
+- spec/unit/readlock_spec.rb
 has_rdoc: