ci-queue 0.5.1 → 0.5.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: '09984471792afae53d76117aea251073d3a204cf'
-  data.tar.gz: 28948b3a043c71e218d772b30343d53c0097f7e4
+  metadata.gz: 442794179d88fc5fc9a2c3a781b5056ff27ee013
+  data.tar.gz: 03fa2c61961e02864f122854c9c21e09c0e2b387
 SHA512:
-  metadata.gz: 399dea10f283781cff77c3e360cdd58f29dbe611c121ccacf92749eed98c4d71804cc2f948980b41ee38819f300e68ad4176673cd5f1e2300fb72ae5c3840f25
-  data.tar.gz: 1b38218e090b7ae97783b3d072b50d64ff3fb2187e141903bf81b5df13dd6f82a416eb48e9fc1ab552559e00601b48d766f1b55c687822090788355cad9b1db0
+  metadata.gz: ca06529e6a43ec5100ce6d4da2c6ab1bd1f439f36706349e41da7b4653cd3879dc58243626687505a9fb63dd8fb714fc83c886c032c2db6c923fb24aa35c0a16
+  data.tar.gz: 7971b3b1d661227e89f1b2b807c8a060ae951748afa1ddd0eb5357285f2da39c16dbb1dd294661da605362d0dcff804f9267505cf9503e57ea35a8882eca8ff8

data/lib/ci/queue/redis/worker.rb

@@ -19,7 +19,7 @@ module CI
           @global_max_requeues = (tests.size * requeue_tolerance).ceil
           @shutdown_required = false
           super(redis: redis, build_id: build_id)
-          @worker_id = worker_id
+          @worker_id = worker_id.to_s
           @timeout = timeout
           push(tests)
         end
@@ -69,47 +69,38 @@ module CI
           ]
         end
 
-        def acknowledge(test, success)
-          if @reserved_test == test
-            @reserved_test = nil
-          else
-            raise ReservationError, "Acknowledged #{test.inspect} but #{@reserved_test.inspect} was reserved"
-          end
-
-          if !success && should_requeue?(test)
-            requeue(test)
-            false
-          else
-            ack(test)
-            true
-          end
+        def acknowledge(test)
+          raise_on_mismatching_test(test)
+          ack(test)
         end
 
-        private
+        REQUEUE = %{
+          local processed_key = KEYS[1]
+          local requeues_count_key = KEYS[2]
+          local queue_key = KEYS[3]
+          local zset_key = KEYS[4]
 
-        attr_reader :worker_id, :timeout, :max_requeues, :global_max_requeues
+          local max_requeues = tonumber(ARGV[1])
+          local global_max_requeues = tonumber(ARGV[2])
+          local test = ARGV[3]
+          local offset = ARGV[4]
 
-        def should_requeue?(test)
-          individual_requeues, global_requeues = redis.multi do
-            redis.hincrby(key('requeues-count'), test, 1)
-            redis.hincrby(key('requeues-count'), '___total___'.freeze, 1)
+          if redis.call('sismember', processed_key, test) == 1 then
+            return false
           end
 
-          if individual_requeues.to_i > max_requeues || global_requeues.to_i > global_max_requeues
-            redis.multi do
-              redis.hincrby(key('requeues-count'), test, -1)
-              redis.hincrby(key('requeues-count'), '___total___'.freeze, -1)
-            end
+          local global_requeues = tonumber(redis.call('hget', requeues_count_key, '___total___'))
+          if global_requeues and global_requeues >= tonumber(global_max_requeues) then
             return false
           end
 
-          true
-        end
+          local requeues = tonumber(redis.call('hget', requeues_count_key, test))
+          if requeues and requeues >= max_requeues then
+            return false
+          end
 
-        REQUEUE = %{
-          local queue_key = KEYS[1]
-          local test = ARGV[1]
-          local offset = ARGV[2]
+          redis.call('hincrby', requeues_count_key, '___total___', 1)
+          redis.call('hincrby', requeues_count_key, test, 1)
 
           local pivot = redis.call('lrange', queue_key, -1 - offset, 0 - offset)[1]
           if pivot then
@@ -117,14 +108,33 @@ module CI
           else
             redis.call('lpush', queue_key, test)
           end
+
+          redis.call('zrem', zset_key, test)
+
+          return true
         }
         def requeue(test, offset: Redis.requeue_offset)
-          load_script(ACKNOWLEDGE)
-          load_script(REQUEUE)
-          redis.multi do
-            redis.decr(key('processed'))
-            eval_script(REQUEUE, keys: [key('queue')], argv: [test, offset])
-            ack(test)
+          raise_on_mismatching_test(test)
+
+          requeued = eval_script(
+            REQUEUE,
+            keys: [key('processed'), key('requeues-count'), key('queue'), key('running')],
+            argv: [max_requeues, global_max_requeues, test, offset],
+          ) == 1
+
+          @reserved_test = test unless requeued
+          requeued
+        end
+
+        private
+
+        attr_reader :worker_id, :timeout, :max_requeues, :global_max_requeues
+
+        def raise_on_mismatching_test(test)
+          if @reserved_test == test
+            @reserved_test = nil
+          else
+            raise ReservationError, "Acknowledged #{test.inspect} but #{@reserved_test.inspect} was reserved"
           end
         end
 
@@ -140,6 +150,8 @@ module CI
         RESERVE_TEST = %{
           local queue_key = KEYS[1]
           local zset_key = KEYS[2]
+          local processed_key = KEYS[3]
+
           local current_time = ARGV[1]
 
           local test = redis.call('rpop', queue_key)
@@ -151,38 +163,54 @@ module CI
           end
         }
         def try_to_reserve_test
-          eval_script(RESERVE_TEST, keys: [key('queue'), key('running')], argv: [Time.now.to_f])
+          eval_script(
+            RESERVE_TEST,
+            keys: [key('queue'), key('running'), key('processed')],
+            argv: [Time.now.to_f],
+          )
         end
 
         RESERVE_LOST_TEST = %{
           local zset_key = KEYS[1]
+          local processed_key = KEYS[2]
           local current_time = ARGV[1]
           local timeout = ARGV[2]
 
-          local test = redis.call('zrangebyscore', zset_key, 0, current_time - timeout)[1]
-          if test then
-            redis.call('zadd', zset_key, current_time, test)
-            return test
-          else
-            return nil
+          local lost_tests = redis.call('zrangebyscore', zset_key, 0, current_time - timeout)
+          for _, test in ipairs(lost_tests) do
+            if redis.call('sismember', processed_key, test) == 0 then
+              redis.call('zadd', zset_key, current_time, test)
+              return test
+            end
           end
+
+          return nil
         }
         def try_to_reserve_lost_test
-          eval_script(RESERVE_LOST_TEST, keys: [key('running')], argv: [Time.now.to_f, timeout])
+          eval_script(
+            RESERVE_LOST_TEST,
+            keys: [key('running'), key('completed')],
+            argv: [Time.now.to_f, timeout],
+          )
         end
 
         ACKNOWLEDGE = %{
           local zset_key = KEYS[1]
-          local processed_count_key = KEYS[2]
-          local test = ARGV[1]
+          local processed_key = KEYS[2]
 
-          if redis.call('zrem', zset_key, test) == 1 then
-            redis.call('incr', processed_count_key)
-          end
+          local worker_id = ARGV[1]
+          local test = ARGV[2]
+
+          redis.call('zrem', zset_key, test)
+          return redis.call('sadd', processed_key, test)
         }
         def ack(test)
-          eval_script(ACKNOWLEDGE, keys: [key('running'), key('processed')], argv: [test])
           redis.lpush(key('worker', worker_id, 'queue'), test)
+          eval_script(
+            ACKNOWLEDGE,
+            keys: [key('running'), key('processed')],
+            argv: [worker_id, test],
+          ) == 1
         end
 
         def push(tests)

data/lib/ci/queue/static.rb

@@ -30,12 +30,14 @@ module CI
         @queue.empty?
       end
 
-      def acknowledge(test, success)
-        if !success && should_requeue?(test)
-          requeue(test)
-          return false
-        end
-        
+      def acknowledge(test)
+        true
+      end
+
+      def requeue(test)
+        return false unless should_requeue?(test)
+        requeues[test] += 1
+        @queue.unshift(test)
         true
       end
 
@@ -47,11 +49,6 @@ module CI
         requeues[test] < max_requeues && requeues.values.inject(0, :+) < global_max_requeues
       end
 
-      def requeue(test)
-        requeues[test] += 1
-        @queue.unshift(test)
-      end
-
       def requeues
         @requeues ||= Hash.new(0)
       end

data/lib/ci/queue/version.rb

@@ -1,5 +1,5 @@
 module CI
   module Queue
-    VERSION = '0.5.1'
+    VERSION = '0.5.2'
   end
 end

data/lib/minitest/queue.rb

@@ -88,10 +88,15 @@ module Minitest
 
         if klass = runnable_classes[class_name]
           result = Minitest.run_one_method(klass, method_name)
-          unless queue.acknowledge(test_name, result.passed? || result.skipped?)
+          failed = !(result.passed? || result.skipped?)
+          if failed && queue.requeue(test_name)
             result.requeue!
+            reporter.record(result)
+          elsif queue.acknowledge(test_name) || !failed
+            # If the test was already acknowledged by another worker (we timed out)
+            # Then we only record it if it is successful.
+            reporter.record(result)
           end
-          reporter.record(result)
         else
           raise SuiteNotFound, "Couldn't find suite matching: #{test_name}"
         end

data/lib/minitest/reporters/redis_reporter.rb

@@ -64,7 +64,7 @@ module Minitest
         end
 
         def processed
-          redis.get(key('processed')).to_i
+          redis.scard(key('processed')).to_i
         end
 
         def completed?

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ci-queue
 version: !ruby/object:Gem::Version
-  version: 0.5.1
+  version: 0.5.2
 platform: ruby
 authors:
 - Jean Boussier
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2017-03-28 00:00:00.000000000 Z
+date: 2017-06-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -147,7 +147,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.6.11
+rubygems_version: 2.2.3
 signing_key: 
 specification_version: 4
 summary: Distribute tests over many workers using a queue