worker_roulette 0.0.10 → 0.0.11

data/lib/worker_roulette/a_foreman.rb

@@ -2,21 +2,39 @@ 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
+      Lua.call(self.class.lua_enqueue_work_orders, [COUNTER_KEY, job_board_key, sender_key, @channel],
+                   [@sender, Oj.dump(work_order),  WorkerRoulette::JOB_NOTIFICATIONS], &callback)
+    end
+
+  private
+    def self.lua_enqueue_work_orders
+      <<-HERE
+        local counter_key       = KEYS[1]
+        local job_board_key     = KEYS[2]
+        local sender_key        = KEYS[3]
+        local channel           = KEYS[4]
+
+        local sender            = ARGV[1]
+        local work_order        = ARGV[2]
+        local job_notification  = ARGV[3]
+
+        local function enqueue_work_orders(sender, work_order, job_notification)
+          local result    = sender .. ' updated'
+          local sender_on_job_board = redis.call('ZSCORE', job_board_key, sender_key)
+
+          if (sender_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 .. ' added'
+          end
+
+          local work_added          = redis.call('RPUSH',sender_key, work_order)
+          local job_board_update    = redis.call('PUBLISH', channel, job_notification)
+          return result
         end
-      end
+
+        return enqueue_work_orders(sender, work_order, job_notification)
+      HERE
     end
   end
 end

data/lib/worker_roulette/a_tradesman.rb

@@ -9,27 +9,12 @@ module WorkerRoulette
     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
+      Lua.call(self.class.lua_drain_work_orders, [job_board_key, nil], [@namespace]) do |results|
+        @sender = (results.first || '').split(':').first
+        callback.call (results[1] || []).map {|work_order| Oj.load(work_order)} if callback
       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
@@ -44,9 +29,30 @@ module WorkerRoulette
       end
     end
 
-    private
-    def get_sender_for_next_job(redis, &callback)
-      redis.zrange(job_board_key, 0, 0).callback &callback
+  private
+    def self.lua_drain_work_orders
+      <<-HERE
+        local job_board_key     = KEYS[1]
+        local empty             = KEYS[2]
+        local namespace         = ARGV[1]
+
+        local function drain_work_orders(job_board_key, namespace)
+          local sender_key = redis.call('ZRANGE', job_board_key, 0, 0)[1]
+
+          if sender_key == false then
+            return {}
+          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
+        end
+
+        return drain_work_orders(job_board_key, namespace)
+      HERE
     end
   end
 end

data/lib/worker_roulette/lua.rb

@@ -0,0 +1,31 @@
+module WorkerRoulette
+  module Lua
+    @cache = Hash.new
+
+    def self.call(lua_script, keys_accessed = [], args = [], &callback)
+      WorkerRoulette.tradesman_connection_pool.with do |redis|
+        results = redis.evalsha(sha(lua_script), keys_accessed.length, *keys_accessed, *args)
+        results.callback &callback
+        results.errback {self.eval(redis, lua_script, keys_accessed, args, &callback)}
+      end
+    end
+
+    def self.sha(lua_script)
+      @cache[lua_script] ||= Digest::SHA1.hexdigest(lua_script)
+    end
+
+    def self.cache
+      @cache.dup
+    end
+
+    def self.clear_cache!
+      @cache = {}
+    end
+
+    def self.eval(redis, lua_script, keys_accessed, args, &callback)
+      results = redis.eval(lua_script, keys_accessed.size, *keys_accessed, *args)
+      results.callback &callback
+      results.errback  {|err_msg| raise EM::Hiredis::RedisError.new(err_msg)}
+    end
+  end
+end

data/lib/worker_roulette/version.rb

@@ -1,3 +1,3 @@
 module WorkerRoulette
-  VERSION = "0.0.10"
+  VERSION = "0.0.11"
 end

data/lib/worker_roulette.rb

@@ -4,6 +4,7 @@ require 'redis'
 require 'hiredis'
 require 'em-hiredis'
 require 'connection_pool'
+require "digest/sha1"
 
 Dir[File.join(File.dirname(__FILE__),'worker_roulette','**','*.rb')].sort.each { |file| require file.gsub(".rb", "")}
 

data/spec/benchmark/perf_test.rb

@@ -3,48 +3,94 @@ require 'benchmark'
 require 'eventmachine'
 
 REDIS_CONNECTION_POOL_SIZE = 100
-ITERATIONS = 10_000
+ITERATIONS = 100_000
 
 work_order = {'ding dong' => "hello_foreman_" * 100}
 
-WorkerRoulette.start(size: REDIS_CONNECTION_POOL_SIZE)#{driver: :synchrony}
-WorkerRoulette.tradesman_connection_pool.with {|r| r.flushdb}
+# WorkerRoulette.start(size: REDIS_CONNECTION_POOL_SIZE, evented: true)#{driver: :synchrony}
+# WorkerRoulette.tradesman_connection_pool.with {|r| r.flushdb}
 
-puts "Redis Connection Pool Size: #{REDIS_CONNECTION_POOL_SIZE}"
+# 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
+
+EM::Hiredis.reconnect_timeout = 0.01
 
 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
+  x.report "Time to evently insert and read #{ITERATIONS} large work_orders" do # ~2500 work_orders / second round trip; 50-50 read-write time; CPU and IO bound
+    EM.run do
 
-    ITERATIONS.times do |iteration|
-      sender = 'sender_' + iteration.to_s
-      tradesman = WorkerRoulette.tradesman
-      tradesman.work_orders!
+      WorkerRoulette.start(evented: true)#{driver: :synchrony}
+      WorkerRoulette.tradesman_connection_pool.with {|r| r.flushdb}
+      @total = 0
+      @tradesman = WorkerRoulette.a_tradesman
+
+      ITERATIONS.times do |iteration|
+        sender = 'sender_' + iteration.to_s
+        foreman = WorkerRoulette.a_foreman(sender)
+        foreman.enqueue_work_order(work_order) do
+          @tradesman.work_orders! do
+            @total += 1
+            EM.stop if @total == (ITERATIONS - 1)
+          end
+        end
+      end
     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
+  x.report "Time to evently pubsub insert and read #{ITERATIONS} large work_orders" do # ~2500 work_orders / second round trip; 50-50 read-write time; CPU and IO bound
+    EM.run do
+      @processed = 0
+      @total     = 0
+      WorkerRoulette.start(evented: true)#{driver: :synchrony}
+      WorkerRoulette.tradesman_connection_pool.with {|r| r.flushdb}
+      @total = 0
+      @tradesman = WorkerRoulette.a_tradesman
+      on_subscribe = ->(*args) do
+        ITERATIONS.times do |iteration|
           sender = 'sender_' + iteration.to_s
-          foreman = WorkerRoulette.foreman(sender)
+          foreman = WorkerRoulette.a_foreman(sender)
           foreman.enqueue_work_order(work_order)
         end
-      tradesman = WorkerRoulette.tradesman
-      tradesman.wait_for_work_orders(p) {|m| m; tradesman.unsubscribe}
+      end
+      @tradesman.wait_for_work_orders(on_subscribe) {@processed += 1; EM.stop if @processed == (ITERATIONS - 1)}
     end
   end
 end
 
-WorkerRoulette.tradesman_connection_pool.with {|r| r.flushdb}
+# 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; tradesman.unsubscribe}
+#     end
+#   end
+# end
+
+# WorkerRoulette.tradesman_connection_pool.with {|r| r.flushdb}
 
 # EM.run do
 #   EM.add_timer(6) {puts "em off";EM.stop}
@@ -63,4 +109,4 @@ WorkerRoulette.tradesman_connection_pool.with {|r| r.flushdb}
 # end
 
 # puts  @end - @start
-# WorkerRoulette.tradesman_connection_pool.with {|r| r.flushdb}
+# WorkerRoulette.tradesman_connection_pool.with {|r| r.flushdb}

data/spec/integration/evented_worker_roulette_spec.rb

@@ -23,9 +23,9 @@ describe WorkerRoulette do
     it "should enqueue work" do
       called = false
       foreman      = WorkerRoulette.a_foreman('foreman')
-      foreman.enqueue_work_order('some old fashion work') do |redis_response|
+      foreman.enqueue_work_order('some old fashion work') do |redis_response, stuff|
         called = true
-        redis_response.should == [1, 1, 0]
+        redis_response.should == 'foreman added'
       end
       done(0.1) {called.should == true}
     end
@@ -63,28 +63,28 @@ describe WorkerRoulette do
     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
+      first_foreman      = WorkerRoulette.a_foreman('first_foreman')
+      first_foreman.enqueue_work_order('foo') 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 == [["first_foreman", 1.0], ["katie_80", 2.0]]
+            done
+          end
         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
+    it "should generate a monotically increasing score for senders not on the job board, but not for senders already there" do
+      first_foreman = WorkerRoulette.a_foreman('first_foreman')
       redis.get(subject.counter_key).should == nil
-      subject.enqueue_work_order(work_orders.first) do
+      first_foreman.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
+        first_foreman.enqueue_work_order(work_orders.last) do
+          redis.get(subject.counter_key).should == "1"
+          subject.enqueue_work_order(work_orders.first) do
+            redis.get(subject.counter_key).should == "2"
+            done
+          end
         end
       end
     end
@@ -100,13 +100,52 @@ 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 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.work_orders! do |r|
           subject.sender.should == sender
           done
         end
@@ -137,21 +176,16 @@ describe WorkerRoulette do
       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
+      publish = proc {foreman.enqueue_work_order(work_orders)}
 
-      subject.wait_for_work_orders do |redis_work_orders, message, channel|
+      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]
         done
       end
 
-      foreman.enqueue_work_order(work_orders)
     end
 
     it "should publish and subscribe on custom channels" do
@@ -164,8 +198,8 @@ describe WorkerRoulette do
       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}
+      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
@@ -175,32 +209,28 @@ describe WorkerRoulette do
       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|
+      publish = proc {foreman.enqueue_work_order(work_orders)}
+      subject.wait_for_work_orders(publish) 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
 
     it "should periodically (random time between 10  and 15 seconds?) poll the job board for new work, in case it missed a notification"
     it "should not delete the messages from the queue until they have been processed succcesfully"
     it "should not cache the sender our counter keys"
-    it "should pull off more than one patch"
+    it "should pull off work orders for more than one sender"
   end
 
   context "Read Lock" do

data/spec/spec_helper.rb

@@ -3,6 +3,8 @@ require 'evented-spec'
 require 'simplecov'
 require 'simplecov-rcov'
 require 'rspec'
+require 'pry'
+
 class SimpleCov::Formatter::MergedFormatter
   def format(result)
      SimpleCov::Formatter::HTMLFormatter.new.format(result)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: worker_roulette
 version: !ruby/object:Gem::Version
-  version: 0.0.10
+  version: 0.0.11
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-02-17 00:00:00.000000000 Z
+date: 2014-02-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: oj
@@ -253,6 +253,7 @@ files:
 - lib/worker_roulette/a_foreman.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/perf_test.rb