worker_roulette 0.1.3 → 0.1.4

data/lib/worker_roulette/foreman.rb

@@ -45,23 +45,24 @@ module WorkerRoulette
 
         local work_order        = ARGV[1]
         local job_notification  = ARGV[2]
+        local redis_call        = redis.call
+        local zscore            = 'ZSCORE'
+        local incr              = 'INCR'
+        local zadd              = 'ZADD'
+        local rpush             = 'RPUSH'
+        local publish           = 'PUBLISH'
 
         local function enqueue_work_orders(work_order, job_notification)
-          local result    = sender_key .. ' updated'
-          local sender_is_on_job_board = redis.call('ZSCORE', job_board_key, sender_key)
-
-          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'
+          if (redis_call(zscore, job_board_key, sender_key) == false) then
+            local count     = redis_call(incr, counter_key)
+            redis_call(zadd, job_board_key, count, sender_key)
           end
 
-          local work_added          = redis.call('RPUSH',sender_key, work_order)
-          local job_board_update    = redis.call('PUBLISH', channel, job_notification)
-          return result
+          redis_call(rpush,sender_key, work_order)
+          redis_call(publish, channel, job_notification)
         end
 
-        return enqueue_work_orders(work_order, job_notification)
+        enqueue_work_orders(work_order, job_notification)
       HERE
     end
   end

data/lib/worker_roulette/tradesman.rb

@@ -38,47 +38,56 @@ module WorkerRoulette
   private
     def self.lua_drain_work_orders
       <<-HERE
+        local empty_string      = ""
         local job_board_key     = KEYS[1]
-        local last_sender_key   = KEYS[2]
-        local sender_key        = ARGV[1]
+        local last_sender_key   = KEYS[2] or empty_string
+        local sender_key        = ARGV[1] or empty_string
+        local redis_call        = redis.call
+        local lock_key_prefix   = "L*:"
+        local lock_value        = "L"
+        local ex                = "EX"
+        local nx                = "NX"
+        local get               = "GET"
+        local set               = "SET"
+        local del               = "DEL"
+        local zrank             = "ZRANK"
+        local zrange            = "ZRANGE"
 
         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)
+          if last_sender_key ~= empty_string then
+            local last_sender_lock_key = lock_key_prefix .. last_sender_key
+            redis_call(del, last_sender_lock_key)
           end
 
-          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
+          if sender_key == empty_string then
+            sender_key = redis_call(zrange, job_board_key, 0, 0)[1] or empty_string
+            if sender_key == empty_string then
               return {}
             end
           end
 
-          local lock_key = 'L*:' .. sender_key
-          local locked   = (redis.call('GET', lock_key) == 'L')
+          local lock_key = lock_key_prefix .. sender_key
+          local locked   = (redis_call(get, lock_key) == lock_value)
 
           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')
+            local results = {sender_key, 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, lock_value, ex, 1, nx)
             return results
           else
-            local sender_index    = redis.call('ZRANK', job_board_key, sender_key)
+            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]
+            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)
+              return drain_work_orders(job_board_key, empty_string, next_sender_key)
             else
               return {}
             end
           end
         end
 
-        return drain_work_orders(job_board_key, last_sender_key, "")
+        return drain_work_orders(job_board_key, last_sender_key, empty_string)
       HERE
     end
   end

data/lib/worker_roulette/version.rb

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

data/spec/integration/evented_worker_roulette_spec.rb

@@ -25,7 +25,6 @@ describe WorkerRoulette do
       foreman      = WorkerRoulette.a_foreman('foreman')
       foreman.enqueue_work_order('some old fashion work') do |redis_response, stuff|
         called = true
-        redis_response.should == 'foreman added'
       end
       done(0.1) {called.should == true}
     end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: worker_roulette
 version: !ruby/object:Gem::Version
-  version: 0.1.3
+  version: 0.1.4
   prerelease: 
 platform: ruby
 authors: