ci-queue 0.84.0 → 0.86.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c47a6b5450a21d7f4fb79a2b9a862ee53d6602d49e61a1e60d0fdaba92e9d0fd
-  data.tar.gz: 217ae043f06406663beff99e415dcf778a1a6cacd47ba6148d9e50504927dcf3
+  metadata.gz: 7708a4b0506c58da9ae1c6681dd335967c584869bf7b4a60546fc43f06a6cfe8
+  data.tar.gz: 22e9a6260641835f028c9952e10c3c0dfa4882156bf393b0b1a13befbee89432
 SHA512:
-  metadata.gz: ca7a1134775424386068df3e1b3c80738f90bbf5a353ed254715cd12194d6dfa39e1313c0fe4ea3e851f84a459ed0c61bbc52045164764fd4941b833ee6d71eb
-  data.tar.gz: 0ddca915e68afcfe1f6a99b41d34d9b46aa731499922ae1556de7db026b5e30dd48de08644df603c99426c430bebb782530825e626cc631f45dc94f0df2db200
+  metadata.gz: 697d15d2ada5cae5ace00714a47b91fbb32ebf61a3abf7b181fb4293b560ba837e02c1f88aef40832a9534fcdc45a049c1ef8d19bf5b4b537f2b53d4ca1d6cf5
+  data.tar.gz: 225d1ec46ad29137111f16f18431212db237eeaa91871fb9ece7e0e35ba34270b4272b2ce26cff3b178214feb6643a75b5266ae86d41aef5ba47952064996a81

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    ci-queue (0.84.0)
+    ci-queue (0.86.0)
       logger
 
 GEM

data/ci-queue.gemspec

@@ -41,9 +41,9 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency 'simplecov', '~> 0.12'
   spec.add_development_dependency 'minitest-reporters', '~> 1.1'
 
+  spec.add_development_dependency 'rexml'
   spec.add_development_dependency 'snappy'
   spec.add_development_dependency 'msgpack'
   spec.add_development_dependency 'benchmark'
-  spec.add_development_dependency 'rexml'
   spec.add_development_dependency 'rubocop'
 end

data/lib/ci/queue/grind.rb

@@ -10,6 +10,12 @@ module CI
         end
       end
 
+      # Grind always eagerly loads test files and populates @index via
+      # Static#populate, so poll uses the @index path. Bypass entry_resolver
+      # to avoid JSON-formatting overhead on potentially millions of entries.
+      def entry_resolver; nil; end
+      def entry_resolver=(_); end
+
       def initialize(path, config)
         io = path == '-' ? STDIN : ::File.open(path)
 

data/lib/ci/queue/redis/acknowledge.lua

@@ -4,12 +4,23 @@ local processed_key = KEYS[2]
 local owners_key = KEYS[3]
 local error_reports_key = KEYS[4]
 local requeued_by_key = KEYS[5]
+local leases_key = KEYS[6]
 
 local entry = ARGV[1]
 local error = ARGV[2]
 local ttl = ARGV[3]
-redis.call('zrem', zset_key, entry)
-redis.call('hdel', owners_key, entry)  -- Doesn't matter if it was reclaimed by another workers
+local lease_id = ARGV[4]
+
+-- Only the current lease holder can remove the entry from the running set.
+-- If the lease was transferred (e.g. via reserve_lost), the stale worker
+-- must not remove the running entry — that would let the supervisor think
+-- the queue is exhausted while the new lease holder is still processing.
+if tostring(redis.call('hget', leases_key, entry)) == lease_id then
+  redis.call('zrem', zset_key, entry)
+  redis.call('hdel', owners_key, entry)
+  redis.call('hdel', leases_key, entry)
+end
+
 redis.call('hdel', requeued_by_key, entry)
 local acknowledged = redis.call('sadd', processed_key, entry) == 1
 

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

@@ -60,10 +60,10 @@ module CI
           [0, 0, 0.1, 0.5, 1, 3, 5]
         end
 
-        def with_heartbeat(id)
+        def with_heartbeat(id, lease: nil)
           if heartbeat_enabled?
             ensure_heartbeat_thread_alive!
-            heartbeat_state.set(:tick, id)
+            heartbeat_state.set(:tick, id, lease)
           end
 
           yield
@@ -264,12 +264,11 @@ module CI
         end
 
         class HeartbeatProcess
-          def initialize(redis_url, zset_key, processed_key, owners_key, worker_queue_key)
+          def initialize(redis_url, zset_key, owners_key, leases_key)
             @redis_url = redis_url
             @zset_key = zset_key
-            @processed_key = processed_key
             @owners_key = owners_key
-            @worker_queue_key = worker_queue_key
+            @leases_key = leases_key
           end
 
           def boot!
@@ -281,9 +280,8 @@ module CI
               ::File.join(__dir__, "monitor.rb"),
               @redis_url,
               @zset_key,
-              @processed_key,
               @owners_key,
-              @worker_queue_key,
+              @leases_key,
               in: child_read,
               out: child_write,
             )
@@ -313,8 +311,8 @@ module CI
             end
           end
 
-          def tick!(id)
-            send_message(:tick!, id: id)
+          def tick!(id, lease)
+            send_message(:tick!, id: id, lease: lease.to_s)
           end
 
           private
@@ -355,9 +353,8 @@ module CI
           @heartbeat_process ||= HeartbeatProcess.new(
             @redis_url,
             key('running'),
-            key('processed'),
             key('owners'),
-            key('worker', worker_id, 'queue'),
+            key('leases'),
           )
         end
 
@@ -369,19 +366,16 @@ module CI
           Thread.current.name = "CI::Queue#heartbeat"
           Thread.current.abort_on_exception = true
 
-          timeout = config.timeout.to_i
           loop do
-            command = nil
             command = heartbeat_state.wait(1) # waits for max 1 second but wakes up immediately if we receive a command
 
             case command&.first
             when :tick
-              if timeout > 0
-                heartbeat_process.tick!(command.last)
-                timeout -= 1
-              end
+              # command = [:tick, entry_id, lease_id]
+              heartbeat_process.tick!(command[1], command[2])
             when :reset
-              timeout = config.timeout.to_i
+              # Test finished, stop ticking until next test starts
+              nil
             when :stop
               break
             end

data/lib/ci/queue/redis/heartbeat.lua

@@ -1,18 +1,17 @@
 -- AUTOGENERATED FILE DO NOT EDIT DIRECTLY
 local zset_key = KEYS[1]
-local processed_key = KEYS[2]
-local owners_key = KEYS[3]
-local worker_queue_key = KEYS[4]
+local leases_key = KEYS[2]
 
 local current_time = ARGV[1]
 local entry = ARGV[2]
+local lease_id = ARGV[3]
 
--- already processed, we do not need to bump the timestamp
-if redis.call('sismember', processed_key, entry) == 1 then
-  return false
-end
-
--- we're still the owner of the test, we can bump the timestamp
-if redis.call('hget', owners_key, entry) == worker_queue_key then
+-- Only the current lease holder can bump the timestamp.
+-- We intentionally do NOT check the processed set. A non-owner worker's
+-- acknowledge can add the entry to processed, which would poison the
+-- current lease holder's heartbeat if we checked it here.
+-- The lease check alone is sufficient — once the lease holder acknowledges,
+-- they zrem + hdel the lease, so the heartbeat will naturally stop.
+if tostring(redis.call('hget', leases_key, entry)) == lease_id then
   return redis.call('zadd', zset_key, current_time, entry)
 end

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

@@ -13,11 +13,10 @@ module CI
         DEV_SCRIPTS_ROOT = ::File.expand_path('../../../../../../redis', __FILE__)
         RELEASE_SCRIPTS_ROOT = ::File.expand_path('../../redis', __FILE__)
 
-        def initialize(pipe, logger, redis_url, zset_key, processed_key, owners_key, worker_queue_key)
+        def initialize(pipe, logger, redis_url, zset_key, owners_key, leases_key)
           @zset_key = zset_key
-          @processed_key = processed_key
           @owners_key = owners_key
-          @worker_queue_key = worker_queue_key
+          @leases_key = leases_key
           @logger = logger
           @redis = ::Redis.new(url: redis_url, reconnect_attempts: [0, 0, 0.1, 0.5, 1, 3, 5])
           @shutdown = false
@@ -36,11 +35,11 @@ module CI
           @self_pipe_writer << '.'
         end
 
-        def process_tick!(id:)
+        def process_tick!(id:, lease:)
           eval_script(
             :heartbeat,
-            keys: [@zset_key, @processed_key, @owners_key, @worker_queue_key],
-            argv: [Time.now.to_f, id]
+            keys: [@zset_key, @leases_key],
+            argv: [Time.now.to_f, id, lease]
           )
         rescue => error
           @logger.info(error)
@@ -151,12 +150,11 @@ end
 
 redis_url = ARGV[0]
 zset_key = ARGV[1]
-processed_key = ARGV[2]
-owners_key = ARGV[3]
-worker_queue_key = ARGV[4]
+owners_key = ARGV[2]
+leases_key = ARGV[3]
 
-logger.debug("Starting monitor: #{redis_url} #{zset_key} #{processed_key}")
-manager = CI::Queue::Redis::Monitor.new($stdin, logger, redis_url, zset_key, processed_key, owners_key, worker_queue_key)
+logger.debug("Starting monitor: #{redis_url} #{zset_key} #{leases_key}")
+manager = CI::Queue::Redis::Monitor.new($stdin, logger, redis_url, zset_key, owners_key, leases_key)
 
 # Notify the parent we're ready
 $stdout.puts(".")

data/lib/ci/queue/redis/release.lua

@@ -2,6 +2,7 @@
 local zset_key = KEYS[1]
 local worker_queue_key = KEYS[2]
 local owners_key = KEYS[3]
+local leases_key = KEYS[4]
 
 -- owned_tests = {"SomeTest", "worker:1", "SomeOtherTest", "worker:2", ...}
 local owned_tests = redis.call('hgetall', owners_key)
@@ -9,6 +10,7 @@ for index, owner_or_test in ipairs(owned_tests) do
   if owner_or_test == worker_queue_key then -- If we owned a test
     local test = owned_tests[index - 1]
     redis.call('zadd', zset_key, "0", test) -- We expire the lease immediately
+    redis.call('hdel', leases_key, test)
     return nil
   end
 end

data/lib/ci/queue/redis/requeue.lua

@@ -7,15 +7,20 @@ local worker_queue_key = KEYS[5]
 local owners_key = KEYS[6]
 local error_reports_key = KEYS[7]
 local requeued_by_key = KEYS[8]
+local leases_key = KEYS[9]
 
 local max_requeues = tonumber(ARGV[1])
 local global_max_requeues = tonumber(ARGV[2])
 local entry = ARGV[3]
 local offset = ARGV[4]
 local ttl = tonumber(ARGV[5])
+local lease_id = ARGV[6]
 
-if redis.call('hget', owners_key, entry) == worker_queue_key then
-   redis.call('hdel', owners_key, entry)
+-- Only the current lease holder can requeue a test.
+-- If the lease was transferred (e.g. via reserve_lost), reject the stale
+-- worker's requeue so the running entry stays intact for the new holder.
+if tostring(redis.call('hget', leases_key, entry)) ~= lease_id then
+  return false
 end
 
 if redis.call('sismember', processed_key, entry) == 1 then
@@ -49,6 +54,8 @@ if ttl and ttl > 0 then
   redis.call('expire', requeued_by_key, ttl)
 end
 
+redis.call('hdel', owners_key, entry)
+redis.call('hdel', leases_key, entry)
 redis.call('zrem', zset_key, entry)
 
 return true

data/lib/ci/queue/redis/reserve.lua

@@ -6,6 +6,8 @@ local worker_queue_key = KEYS[4]
 local owners_key = KEYS[5]
 local requeued_by_key = KEYS[6]
 local workers_key = KEYS[7]
+local leases_key = KEYS[8]
+local lease_counter_key = KEYS[9]
 
 local current_time = ARGV[1]
 local defer_offset = tonumber(ARGV[2]) or 0
@@ -20,6 +22,15 @@ local function insert_with_offset(test)
   end
 end
 
+local function claim_test(test)
+  local lease = redis.call('incr', lease_counter_key)
+  redis.call('zadd', zset_key, current_time, test)
+  redis.call('lpush', worker_queue_key, test)
+  redis.call('hset', owners_key, test, worker_queue_key)
+  redis.call('hset', leases_key, test, lease)
+  return {test, tostring(lease)}
+end
+
 for attempt = 1, max_skip_attempts do
   local test = redis.call('rpop', queue_key)
   if not test then
@@ -31,10 +42,7 @@ for attempt = 1, max_skip_attempts do
     -- If this build only has one worker, allow immediate self-pickup.
     if redis.call('scard', workers_key) <= 1 then
       redis.call('hdel', requeued_by_key, test)
-      redis.call('zadd', zset_key, current_time, test)
-      redis.call('lpush', worker_queue_key, test)
-      redis.call('hset', owners_key, test, worker_queue_key)
-      return test
+      return claim_test(test)
     end
 
     insert_with_offset(test)
@@ -47,10 +55,7 @@ for attempt = 1, max_skip_attempts do
     end
   else
     redis.call('hdel', requeued_by_key, test)
-    redis.call('zadd', zset_key, current_time, test)
-    redis.call('lpush', worker_queue_key, test)
-    redis.call('hset', owners_key, test, worker_queue_key)
-    return test
+    return claim_test(test)
   end
 end
 

data/lib/ci/queue/redis/reserve_lost.lua

@@ -3,6 +3,8 @@ local zset_key = KEYS[1]
 local processed_key = KEYS[2]
 local worker_queue_key = KEYS[3]
 local owners_key = KEYS[4]
+local leases_key = KEYS[5]
+local lease_counter_key = KEYS[6]
 
 local current_time = ARGV[1]
 local timeout = ARGV[2]
@@ -10,10 +12,19 @@ local timeout = ARGV[2]
 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
+    local lease = redis.call('incr', lease_counter_key)
     redis.call('zadd', zset_key, current_time, test)
     redis.call('lpush', worker_queue_key, test)
-    redis.call('hset', owners_key, test, worker_queue_key) -- Take ownership
-    return test
+    redis.call('hset', owners_key, test, worker_queue_key)
+    redis.call('hset', leases_key, test, lease)
+    return {test, tostring(lease)}
+  else
+    -- Test is already processed but still in running (stale). This can happen when
+    -- a non-owner worker acknowledged the test (marking it processed) but could not
+    -- remove it from running due to the lease guard. Clean it up.
+    redis.call('zrem', zset_key, test)
+    redis.call('hdel', owners_key, test)
+    redis.call('hdel', leases_key, test)
   end
 end
 

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

@@ -12,6 +12,22 @@ module CI
           @build ||= CI::Queue::Redis::BuildRecord.new(self, redis, config)
         end
 
+        # Retry queue is pre-populated with failed test entries from the previous run.
+        # Don't replace them with the full preresolved/lazy test list.
+        # QueuePopulationStrategy#configure_lazy_queue will still set entry_resolver,
+        # so poll uses LazyEntryResolver to lazily load test files on demand.
+        # The random/batch_size params are intentionally ignored since we keep
+        # the existing queue contents as-is.
+        #
+        # Note: populate (non-stream) is intentionally NOT overridden here.
+        # RSpec and non-lazy Minitest retries call populate to build the
+        # @index mapping test IDs to runnable objects, which poll needs to
+        # yield proper test/example instances. In those paths, @queue contains
+        # bare test IDs that match @index keys, so populate works correctly.
+        def stream_populate(tests, random: nil, batch_size: nil)
+          self
+        end
+
         private
 
         attr_reader :redis

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

@@ -13,12 +13,18 @@ module CI
       self.requeue_offset = 42
       self.max_sleep_time = 2
 
+      # Minimal wrapper returned by resolve_entry when neither @index nor entry_resolver
+      # is available. Provides the interface callers expect (.id, .queue_entry) so that
+      # downstream code doesn't crash with NoMethodError on a raw String.
+      UnresolvedEntry = Struct.new(:id, :queue_entry)
+
       class Worker < Base
         attr_accessor :entry_resolver
         attr_reader :first_reserve_at
 
         def initialize(redis, config)
           @reserved_tests = Concurrent::Set.new
+          @reserved_leases = Concurrent::Map.new
           @shutdown_required = false
           @first_reserve_at = nil
           super(redis, config)
@@ -147,9 +153,10 @@ module CI
         def retry_queue
           failures = build.failed_tests.to_set
           log = redis.lrange(key('worker', worker_id, 'queue'), 0, -1)
-          log = log.map { |entry| CI::Queue::QueueEntry.test_id(entry) }
-          log.select! { |test_id| failures.include?(test_id) }
-          log.uniq!
+          # Keep full entries (test_id + file_path) so lazy loading can resolve them.
+          # Filter by test_id against failures without stripping file paths.
+          log.select! { |entry| failures.include?(CI::Queue::QueueEntry.test_id(entry)) }
+          log.uniq! { |entry| CI::Queue::QueueEntry.test_id(entry) }
           log.reverse!
           Retry.new(log, config, redis: redis)
         end
@@ -172,6 +179,11 @@ module CI
           nil
         end
 
+        def lease_for(entry)
+          test_id = CI::Queue::QueueEntry.test_id(entry)
+          @reserved_leases[test_id]
+        end
+
         def report_worker_error(error)
           build.report_worker_error(error)
         end
@@ -180,11 +192,12 @@ module CI
           test_id = CI::Queue::QueueEntry.test_id(entry)
           assert_reserved!(test_id)
           entry = reserved_entries.fetch(test_id, entry)
+          lease = @reserved_leases.delete(test_id)
           unreserve_entry(test_id)
           eval_script(
             :acknowledge,
-            keys: [key('running'), key('processed'), key('owners'), key('error-reports'), key('requeued-by')],
-            argv: [entry, error.to_s, config.redis_ttl],
+            keys: [key('running'), key('processed'), key('owners'), key('error-reports'), key('requeued-by'), key('leases')],
+            argv: [entry, error.to_s, config.redis_ttl, lease.to_s],
             pipeline: pipeline,
           ) == 1
         end
@@ -193,6 +206,7 @@ module CI
           test_id = CI::Queue::QueueEntry.test_id(entry)
           assert_reserved!(test_id)
           entry = reserved_entries.fetch(test_id, entry)
+          lease = @reserved_leases.delete(test_id)
           unreserve_entry(test_id)
           global_max_requeues = config.global_max_requeues(total)
 
@@ -207,14 +221,16 @@ module CI
               key('owners'),
               key('error-reports'),
               key('requeued-by'),
+              key('leases'),
             ],
-            argv: [config.max_requeues, global_max_requeues, entry, offset, config.redis_ttl],
+            argv: [config.max_requeues, global_max_requeues, entry, offset, config.redis_ttl, lease.to_s],
           ) == 1
 
           unless requeued
             reserved_tests << test_id
             reserved_entries[test_id] = entry
             reserved_entry_ids[entry] = test_id
+            @reserved_leases[test_id] = lease if lease
           end
           requeued
         end
@@ -222,7 +238,7 @@ module CI
         def release!
           eval_script(
             :release,
-            keys: [key('running'), key('worker', worker_id, 'queue'), key('owners')],
+            keys: [key('running'), key('worker', worker_id, 'queue'), key('owners'), key('leases')],
             argv: [],
           )
           nil
@@ -254,11 +270,12 @@ module CI
           end
         end
 
-        def reserve_entry(entry)
+        def reserve_entry(entry, lease = nil)
           test_id = CI::Queue::QueueEntry.test_id(entry)
           reserved_tests << test_id
           reserved_entries[test_id] = entry
           reserved_entry_ids[entry] = test_id
+          @reserved_leases[test_id] = lease if lease
         end
 
         def unreserve_entry(test_id)
@@ -282,7 +299,7 @@ module CI
 
           return entry_resolver.call(entry) if entry_resolver
 
-          entry
+          UnresolvedEntry.new(test_id, entry)
         end
 
         def still_streaming?
@@ -343,12 +360,12 @@ module CI
         end
 
         def reserve
-          (try_to_reserve_lost_test || try_to_reserve_test).tap do |entry|
-            if entry
-              @first_reserve_at ||= Process.clock_gettime(Process::CLOCK_MONOTONIC)
-              reserve_entry(entry)
-            end
+          entry, lease = try_to_reserve_lost_test || try_to_reserve_test || [nil, nil]
+          if entry
+            @first_reserve_at ||= Process.clock_gettime(Process::CLOCK_MONOTONIC)
+            reserve_entry(entry, lease)
           end
+          entry
         end
 
         def try_to_reserve_test
@@ -362,6 +379,8 @@ module CI
               key('owners'),
               key('requeued-by'),
               key('workers'),
+              key('leases'),
+              key('lease-counter'),
             ],
             argv: [CI::Queue.time_now.to_f, Redis.requeue_offset],
           )
@@ -370,25 +389,28 @@ module CI
         def try_to_reserve_lost_test
           timeout = config.max_missed_heartbeat_seconds ? config.max_missed_heartbeat_seconds : config.timeout
 
-          lost_test = eval_script(
+          result = eval_script(
             :reserve_lost,
             keys: [
               key('running'),
               key('processed'),
               key('worker', worker_id, 'queue'),
               key('owners'),
+              key('leases'),
+              key('lease-counter'),
             ],
             argv: [CI::Queue.time_now.to_f, timeout],
           )
 
-          if lost_test
-            build.record_warning(Warnings::RESERVED_LOST_TEST, test: CI::Queue::QueueEntry.test_id(lost_test), timeout: config.timeout)
+          if result
+            entry = result.is_a?(Array) ? result[0] : result
+            build.record_warning(Warnings::RESERVED_LOST_TEST, test: CI::Queue::QueueEntry.test_id(entry), timeout: config.timeout)
             if CI::Queue.debug?
-              $stderr.puts "[ci-queue][reserve_lost] worker=#{worker_id} test_id=#{CI::Queue::QueueEntry.test_id(lost_test)}"
+              $stderr.puts "[ci-queue][reserve_lost] worker=#{worker_id} test_id=#{CI::Queue::QueueEntry.test_id(entry)}"
             end
           end
 
-          lost_test
+          result
         end
 
         def push(entries)

data/lib/ci/queue/static.rb

@@ -16,6 +16,7 @@ module CI
       TEN_MINUTES = 60 * 10
 
       attr_reader :progress, :total
+      attr_accessor :entry_resolver
 
       def initialize(tests, config)
         @queue = tests
@@ -50,10 +51,24 @@ module CI
         self
       end
 
-      def with_heartbeat(id)
+      # Support lazy loading mode: accept an enumerator of entries and
+      # store them in queue order (no shuffling). This preserves the
+      # exact order from the input file for local reproduction.
+      def stream_populate(tests, random: nil, batch_size: nil)
+        @queue = []
+        tests.each { |entry| @queue << entry }
+        @total = @queue.size
+        self
+      end
+
+      def with_heartbeat(id, lease: nil)
         yield
       end
 
+      def lease_for(entry)
+        nil
+      end
+
       def ensure_heartbeat_thread_alive!; end
 
       def boot_heartbeat_process!; end
@@ -75,11 +90,15 @@ module CI
       end
 
       def populated?
-        !!defined?(@index)
+        !!defined?(@index) || @queue.any?
       end
 
       def to_a
-        @queue.map { |i| index.fetch(i) }
+        if defined?(@index) && @index
+          @queue.map { |i| index.fetch(i) }
+        else
+          @queue.dup
+        end
       end
 
       def size
@@ -97,9 +116,28 @@ module CI
       def poll
         while !@shutdown && config.circuit_breakers.none?(&:open?) && !max_test_failed? && reserved_test = @queue.shift
           reserved_tests << reserved_test
-          yield index.fetch(reserved_test)
+          if entry_resolver
+            resolved = entry_resolver.call(reserved_test)
+            # Track the original queue entry so requeue can push it back
+            # with its full payload (file path, load-error data, etc.).
+            reserved_entries[resolved.id] = reserved_test if resolved.respond_to?(:id)
+            yield resolved
+          elsif defined?(@index) && @index
+            # Queue entries may be JSON-formatted (with test_id + file_path) while
+            # the index is keyed by bare test_id from populate. Try the raw entry
+            # first, then fall back to extracting the test_id.
+            test_id = begin
+              CI::Queue::QueueEntry.test_id(reserved_test)
+            rescue JSON::ParserError
+              reserved_test
+            end
+            yield index.fetch(test_id)
+          else
+            yield reserved_test
+          end
         end
         reserved_tests.clear
+        reserved_entries.clear
       end
 
       def exhausted?
@@ -130,7 +168,10 @@ module CI
         return false unless should_requeue?(test_id)
 
         requeues[test_id] += 1
-        @queue.unshift(test_id)
+        # Push back the original queue entry (with file path / load-error payload)
+        # so entry_resolver can fully resolve it on the next poll iteration.
+        original_entry = reserved_entries.delete(test_id) || test_id
+        @queue.unshift(original_entry)
         true
       end
 
@@ -146,6 +187,10 @@ module CI
         @requeues ||= Hash.new(0)
       end
 
+      def reserved_entries
+        @reserved_entries ||= {}
+      end
+
       def reserved_tests
         @reserved_tests ||= Concurrent::Set.new
       end

data/lib/ci/queue/version.rb

@@ -2,7 +2,7 @@
 
 module CI
   module Queue
-    VERSION = '0.84.0'
+    VERSION = '0.86.0'
     DEV_SCRIPTS_ROOT = ::File.expand_path('../../../../../redis', __FILE__)
     RELEASE_SCRIPTS_ROOT = ::File.expand_path('../redis', __FILE__)
   end

data/lib/minitest/queue/queue_population_strategy.rb

@@ -35,6 +35,7 @@ module Minitest
           configure_lazy_queue
           queue.stream_populate(lazy_test_enumerator, random: ordering_seed, batch_size: queue_config.lazy_load_stream_batch_size)
         else
+          configure_lazy_queue
           queue.populate(Minitest.loaded_tests, random: ordering_seed)
         end
       end

data/lib/minitest/queue/runner.rb

@@ -118,6 +118,15 @@ module Minitest
           # minitest/autorun's at_exit hook, which may not be registered since
           # test files haven't been loaded yet. exit! prevents double-execution
           # if minitest/autorun was loaded by the leader during streaming.
+          #
+          # Re-check exhausted? after booting: slow workers may arrive after the queue
+          # has been fully drained by faster workers. In that case exit cleanly (0)
+          # rather than letting Minitest return false for a 0-test run.
+          if queue.rescue_connection_errors { queue.exhausted? }
+            puts green('All tests were ran already')
+            verify_reporters!(reporters)
+            exit!(0)
+          end
           passed = Minitest.run []
           verify_reporters!(reporters)
           exit!(passed ? 0 : 1)

data/lib/minitest/queue.rb

@@ -163,7 +163,7 @@ module Minitest
         rescue_run_errors do
           begin
             queue.poll do |example|
-              result = queue.with_heartbeat(example.queue_entry) do
+              result = queue.with_heartbeat(example.queue_entry, lease: queue.lease_for(example.queue_entry)) do
                 example.run
               end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ci-queue
 version: !ruby/object:Gem::Version
-  version: 0.84.0
+  version: 0.86.0
 platform: ruby
 authors:
 - Jean Boussier
@@ -122,7 +122,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '1.1'
 - !ruby/object:Gem::Dependency
-  name: snappy
+  name: rexml
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -136,7 +136,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: msgpack
+  name: snappy
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -150,7 +150,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: benchmark
+  name: msgpack
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -164,7 +164,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: rexml
+  name: benchmark
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -291,7 +291,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.8
+rubygems_version: 4.0.9
 specification_version: 4
 summary: Distribute tests over many workers using a queue
 test_files: []