redis_queued_locks 1.12.1 → 1.14.0

data/lib/redis_queued_locks/resource.rb

@@ -21,6 +21,18 @@ module RedisQueuedLocks::Resource
   # @since 1.0.0
   LOCK_QUEUE_PATTERN = 'rql:lock_queue:*'
 
+  # @return [String]
+  #
+  # @api private
+  # @since ?.?.?
+  READ_LOCK_QUEUE_PATTERN = 'rql:lock_queue:*:read'
+
+  # @return [String]
+  #
+  # @api private
+  # @since ?.?.?
+  WRITE_LOCK_QUEUE_PATTERN = 'rql:lock_queue:*:write'
+
   # @return [String]
   #
   # @api private
@@ -55,7 +67,7 @@ module RedisQueuedLocks::Resource
     #
     # @api private
     # @since 1.0.0
-    def acquier_identifier(process_id, thread_id, fiber_id, ractor_id, identity)
+    def acquirer_identifier(process_id, thread_id, fiber_id, ractor_id, identity)
       "rql:acq:#{process_id}/#{thread_id}/#{fiber_id}/#{ractor_id}/#{identity}"
     end
 
@@ -93,20 +105,38 @@ module RedisQueuedLocks::Resource
       "rql:lock_queue:#{lock_name}"
     end
 
+    # @param lock_name [String]
+    # @return [String]
+    #
+    # @api private
+    # @api ?.?.?
+    def prepare_read_lock_queue(lock_name)
+      "rql:lock_queue:#{lock_name}:read"
+    end
+
+    # @param lock_name [String]
+    # @return [String]
+    #
+    # @api private
+    # @api ?.?.?
+    def prepare_write_lock_queue(lock_name)
+      "rql:lock_queue:#{lock_name}:write"
+    end
+
     # @return [Float] Redis's <Set> score that is calculated from the time (epoch) as a float.
     #
     # @api private
     # @since 1.0.0
-    def calc_initial_acquier_position
+    def calc_initial_acquirer_position
       Time.now.to_f
     end
 
-    # @param queue_ttl [Integer] In seconds
-    # @return [Float] Redis's <Set> score barrier for acquiers that should be removed from queue.
+    # @param queue_ttl [Numeric] In seconds
+    # @return [Float] Redis's <Set> score barrier for acquirers that should be removed from queue.
     #
     # @api private
     # @since 1.0.0
-    def acquier_dead_score(queue_ttl)
+    def acquirer_dead_score(queue_ttl)
       Time.now.to_f - queue_ttl
     end
 
@@ -119,9 +149,9 @@ module RedisQueuedLocks::Resource
       Time.now.to_f - zombie_ttl
     end
 
-    # @param acquier_position [Float]
+    # @param acquirer_position [Float]
     #   A time (epoch, seconds.milliseconds) that represents
-    #   the acquier position in lock request queue.
+    #   the acquirer position in lock request queue.
     # @parma queue_ttl [Integer]
     #   In second.
     # @return [Boolean]
@@ -129,8 +159,8 @@ module RedisQueuedLocks::Resource
     #
     # @api private
     # @since 1.0.0
-    def dead_score_reached?(acquier_position, queue_ttl)
-      (acquier_position + queue_ttl) < Time.now.to_f
+    def dead_score_reached?(acquirer_position, queue_ttl)
+      (acquirer_position + queue_ttl) < Time.now.to_f
     end
 
     # @param lock_queue [String]
@@ -186,13 +216,20 @@ module RedisQueuedLocks::Resource
       # NOTE №2: we have no any approach to count Fiber objects in the current process without
       #   object space API (or super memory-expensive) so host identification works without fibers;
       # NOTE №3: we still can extract thread objects via Thread.list API;
+
+      # @type var current_process_id: Integer
       current_process_id = get_process_id
+      # @type var current_threads: Array[Thread]
       current_threads = ::Thread.list
+      # @type var current_ractor_id: Integer
       current_ractor_id = get_ractor_id
 
-      [].tap do |acquiers|
+      # NOTE: steep can't resolve a type of dynamic `[]` literal mutated via inline tap;
+      # steep:ignore:start
+      [].tap do |acquirers|
+        # @type var acquirers: Array[String]
         current_threads.each do |thread|
-          acquiers << host_identifier(
+          acquirers << host_identifier(
             current_process_id,
             thread.object_id,
             current_ractor_id,
@@ -200,6 +237,7 @@ module RedisQueuedLocks::Resource
           )
         end
       end
+      # steep:ignore:end
     end
   end
 end

data/lib/redis_queued_locks/swarm/acquirers.rb

@@ -5,35 +5,36 @@
 module RedisQueuedLocks::Swarm::Acquirers
   class << self
     # Returns the list of swarm acquirers stored as HASH.
-    # Format:
-    #   {
-    #     <acquirer id #1> => {
-    #       zombie: <Boolean>,
-    #       last_probe_time: <Time>,
-    #       last_probe_score: <Numeric>
-    #      },
-    #     <acquirer id #2> => {
-    #       zombie: <Boolean>,
-    #       last_probe_time: <Time>,
-    #       last_probe_score: <Numeric>
-    #      },
-    #     ...
-    #   }
     # Liveness probe time is represented as a float value (Time.now.to_f initially).
     #
     # @param redis_client [RedisClient]
     # @param zombie_ttl [Integer]
-    # @return [Hash<String,Hash<Symbol,Float|Time>>]
+    # @return [Hash<String,Hash<Symbol,Float|Time>>] Format:
+    #   {
+    #      <acquirer id #1> => {
+    #        zombie: <Boolean>,
+    #        last_probe_time: <Time>,
+    #        last_probe_score: <Numeric>
+    #       },
+    #      <acquirer id #2> => {
+    #        zombie: <Boolean>,
+    #        last_probe_time: <Time>,
+    #        last_probe_score: <Numeric>
+    #      },
+    #     ...
+    #   }
     #
     # @api private
     # @since 1.9.0
     def acquirers(redis_client, zombie_ttl)
       redis_client.with do |rconn|
         rconn.call('HGETALL', RedisQueuedLocks::Resource::SWARM_KEY).tap do |swarm_acqs|
+          # @type var swarm_acqs: Hash[String,untyped]
           swarm_acqs.transform_values! do |last_probe|
+            # @type var last_probe: String
             last_probe_score = last_probe.to_f
             last_probe_time = Time.at(last_probe_score)
-            zombie_score = RedisQueuedLocks::Resource.calc_zombie_score(zombie_ttl / 1_000)
+            zombie_score = RedisQueuedLocks::Resource.calc_zombie_score(zombie_ttl / 1_000.0)
             is_zombie = last_probe_score < zombie_score
             { zombie: is_zombie, last_probe_time:, last_probe_score: }
           end

data/lib/redis_queued_locks/swarm/flush_zombies.rb

@@ -8,14 +8,13 @@ class RedisQueuedLocks::Swarm::FlushZombies < RedisQueuedLocks::Swarm::SwarmElem
     # @parma zombie_ttl [Integer]
     # @param lock_scan_size [Integer]
     # @param queue_scan_size [Integer]
-    # @return [
-    #   RedisQueuedLocks::Data[
+    # @return [Hash<Symbol,Boolean|Set<String>]] Format:
+    #   {
     #     ok: <Boolean>,
     #     deleted_zombie_hosts: <Set<String>>,
-    #     deleted_zombie_acquiers: <Set<String>>,
+    #     deleted_zombie_acquirers: <Set<String>>,
     #     deleted_zombie_locks: <Set<String>>
-    #   ]
-    # ]
+    #   }
     #
     # @api private
     # @since 1.9.0
@@ -30,7 +29,7 @@ class RedisQueuedLocks::Swarm::FlushZombies < RedisQueuedLocks::Swarm::SwarmElem
         # Step 1:
         #   calculate zombie score (the time marker that shows acquirers that
         #   have not announced live probes for a long time)
-        zombie_score = RedisQueuedLocks::Resource.calc_zombie_score(zombie_ttl / 1_000)
+        zombie_score = RedisQueuedLocks::Resource.calc_zombie_score(zombie_ttl / 1_000.0)
 
         # Step 2: extract zombie acquirers from the swarm list
         zombie_hosts = rconn.call('HGETALL', RedisQueuedLocks::Resource::SWARM_KEY)
@@ -39,30 +38,32 @@ class RedisQueuedLocks::Swarm::FlushZombies < RedisQueuedLocks::Swarm::SwarmElem
         end
 
         # Step X: exit if we have no any zombie acquirer
-        next RedisQueuedLocks::Data[
+        next {
           ok: true,
           deleted_zombie_hosts: Set.new,
           deleted_zombie_acquirers: Set.new,
-          deleted_zombie_locks: Set.new,
-        ] if zombie_hosts.empty?
+          deleted_zombie_locks: Set.new
+        } if zombie_hosts.empty?
 
         # Step 3: find zombie locks held by zombies and delete them
         # TODO: indexing (in order to prevent full database scan);
         # NOTE: original redis does not support indexing so we need to use
         #   internal data structers to simulate data indexing (such as sorted sets or lists);
-        zombie_locks = Set.new
-        zombie_acquiers = Set.new
+        zombie_locks = Set.new #: Set[String]
+        zombie_acquirers = Set.new #: Set[String]
 
         rconn.scan(
           'MATCH', RedisQueuedLocks::Resource::LOCK_PATTERN, count: lock_scan_size
         ) do |lock_key|
-          acquier_id, host_id = rconn.call('HMGET', lock_key, 'acq_id', 'hst_id')
+          acquirer_id, host_id = rconn.call('HMGET', lock_key, 'acq_id', 'hst_id')
           if zombie_hosts.include?(host_id)
             zombie_locks << lock_key
-            zombie_acquiers << acquier_id
+            zombie_acquirers << acquirer_id
           end
         end
-        rconn.call('DEL', *zombie_locks) if zombie_locks.any?
+
+        # NOTE: (steep) steep can't use <Set>s for splats
+        rconn.call('DEL', *zombie_locks) if zombie_locks.any? # steep:ignore
 
         # Step 4: find zombie requests => and drop them
         # TODO: indexing (in order to prevent full database scan);
@@ -71,8 +72,8 @@ class RedisQueuedLocks::Swarm::FlushZombies < RedisQueuedLocks::Swarm::SwarmElem
         rconn.scan(
           'MATCH', RedisQueuedLocks::Resource::LOCK_QUEUE_PATTERN, count: queue_scan_size
         ) do |lock_queue|
-          zombie_acquiers.each do |zombie_acquier|
-            rconn.call('ZREM', lock_queue, zombie_acquier)
+          zombie_acquirers.each do |zombie_acquirer|
+            rconn.call('ZREM', lock_queue, zombie_acquirer)
           end
         end
 
@@ -80,12 +81,12 @@ class RedisQueuedLocks::Swarm::FlushZombies < RedisQueuedLocks::Swarm::SwarmElem
         rconn.call('HDEL', RedisQueuedLocks::Resource::SWARM_KEY, *zombie_hosts)
 
         # Step 6: inform about deleted zombies
-        RedisQueuedLocks::Data[
+        {
           ok: true,
           deleted_zombie_hosts: zombie_hosts,
-          deleted_zombie_acquiers: zombie_acquiers,
+          deleted_zombie_acquirers: zombie_acquirers,
           deleted_zombie_locks: zombie_locks
-        ]
+        }
       end
     end
     # rubocop:enable Metrics/MethodLength
@@ -96,7 +97,7 @@ class RedisQueuedLocks::Swarm::FlushZombies < RedisQueuedLocks::Swarm::SwarmElem
   # @api private
   # @since 1.9.0
   def enabled?
-    rql_client.config[:swarm][:flush_zombies][:enabled_for_swarm]
+    rql_client.config['swarm.flush_zombies.enabled_for_swarm']
   end
 
   # @return [void]
@@ -105,11 +106,11 @@ class RedisQueuedLocks::Swarm::FlushZombies < RedisQueuedLocks::Swarm::SwarmElem
   # @since 1.9.0
   def swarm!
     @swarm_element = Ractor.new(
-      rql_client.config.slice_value('swarm.flush_zombies.redis_config'),
-      rql_client.config[:swarm][:flush_zombies][:zombie_ttl],
-      rql_client.config[:swarm][:flush_zombies][:zombie_lock_scan_size],
-      rql_client.config[:swarm][:flush_zombies][:zombie_queue_scan_size],
-      rql_client.config[:swarm][:flush_zombies][:zombie_flush_period]
+      rql_client.config.slice('swarm.flush_zombies.redis_config'),
+      rql_client.config['swarm.flush_zombies.zombie_ttl'],
+      rql_client.config['swarm.flush_zombies.zombie_lock_scan_size'],
+      rql_client.config['swarm.flush_zombies.zombie_queue_scan_size'],
+      rql_client.config['swarm.flush_zombies.zombie_flush_period']
     ) do |rc, z_ttl, z_lss, z_qss, z_fl_prd|
       RedisQueuedLocks::Swarm::FlushZombies.swarm_loop do
         Thread.new do

data/lib/redis_queued_locks/swarm/probe_hosts.rb

@@ -4,24 +4,25 @@
 # @since 1.9.0
 class RedisQueuedLocks::Swarm::ProbeHosts < RedisQueuedLocks::Swarm::SwarmElement::Threaded
   class << self
+    # Returns a list of living hosts as a element command result. Result example:
+    # {
+    #   ok: <Boolean>,
+    #   result: {
+    #     host_id1 <String> => score1 <String>,
+    #     host_id2 <String> => score2 <String>,
+    #     etc...
+    #   }
+    # }
+    #
     # @param redis_client [RedisClient]
     # @param uniq_identity [String]
-    # @return [
-    #   RedisQueuedLocks::Data[
-    #     ok: <Boolean>,
-    #     result: {
-    #       host_id1 <String> => score1 <String>,
-    #       host_id2 <String> => score2 <String>,
-    #       etc...
-    #     }
-    #   ]
-    # ]
+    # @return [::Hash]
     #
     # @api private
     # @since 1.9.0
     def probe_hosts(redis_client, uniq_identity)
       possible_hosts = RedisQueuedLocks::Resource.possible_host_identifiers(uniq_identity)
-      probed_hosts = {}
+      probed_hosts = {} #: Hash[String,Float]
 
       redis_client.with do |rconn|
         possible_hosts.each do |host_id|
@@ -33,9 +34,9 @@ class RedisQueuedLocks::Swarm::ProbeHosts < RedisQueuedLocks::Swarm::SwarmElemen
           )
           probed_hosts[host_id] = probe_score
         end
-
-        RedisQueuedLocks::Data[ok: true, result: probed_hosts]
       end
+
+      { ok: true, result: probed_hosts }
     end
   end
 
@@ -44,7 +45,7 @@ class RedisQueuedLocks::Swarm::ProbeHosts < RedisQueuedLocks::Swarm::SwarmElemen
   # @api private
   # @since 1.9.0
   def enabled?
-    rql_client.config[:swarm][:probe_hosts][:enabled_for_swarm]
+    rql_client.config['swarm.probe_hosts.enabled_for_swarm']
   end
 
   # @return [Thread]
@@ -54,15 +55,15 @@ class RedisQueuedLocks::Swarm::ProbeHosts < RedisQueuedLocks::Swarm::SwarmElemen
   def spawn_main_loop!
     Thread.new do
       redis_client = RedisQueuedLocks::Swarm::RedisClientBuilder.build(
-        pooled: rql_client.config[:swarm][:probe_hosts][:redis_config][:pooled],
-        sentinel: rql_client.config[:swarm][:probe_hosts][:redis_config][:sentinel],
-        config: rql_client.config[:swarm][:probe_hosts][:redis_config][:config],
-        pool_config: rql_client.config[:swarm][:probe_hosts][:redis_config][:pool_config]
+        pooled: rql_client.config['swarm.probe_hosts.redis_config.pooled'],
+        sentinel: rql_client.config['swarm.probe_hosts.redis_config.sentinel'],
+        config: rql_client.config['swarm.probe_hosts.redis_config.config'],
+        pool_config: rql_client.config['swarm.probe_hosts.redis_config.pool_config']
       )
 
       loop do
         RedisQueuedLocks::Swarm::ProbeHosts.probe_hosts(redis_client, rql_client.uniq_identity)
-        sleep(rql_client.config[:swarm][:probe_hosts][:probe_period])
+        sleep(rql_client.config['swarm.probe_hosts.probe_period'])
       end
     end
   end

data/lib/redis_queued_locks/swarm/redis_client_builder.rb

@@ -7,7 +7,7 @@ module RedisQueuedLocks::Swarm::RedisClientBuilder
     # @option pooled [Boolean]
     # @option sentinel [Boolean]
     # @option config [Hash]
-    # @return [RedisClient]
+    # @return [RedisClient|RedisClient::Pooled]
     #
     # @api private
     # @since 1.9.0
@@ -28,7 +28,7 @@ module RedisQueuedLocks::Swarm::RedisClientBuilder
     private
 
     # @param config [Hash]
-    # @return [RedisClient::Config]
+    # @return [RedisClient::SentinelConfig]
     #
     # @api private
     # @since 1.9.0
@@ -47,7 +47,7 @@ module RedisQueuedLocks::Swarm::RedisClientBuilder
 
     # @param redis_config [ReidsClient::Config]
     # @param pool_config [Hash]
-    # @return [RedisClient]
+    # @return [RedisClient::Pooled]
     #
     # @api private
     # @since 1.9.0

data/lib/redis_queued_locks/swarm/supervisor.rb

@@ -43,11 +43,11 @@ class RedisQueuedLocks::Swarm::Supervisor
     @observable = observable
     @visor = Thread.new do
       loop do
-        yield rescue nil # TODO/CHECK: may be we need to process exceptions here
-        sleep(rql_client.config[:swarm][:supervisor][:liveness_probing_period])
+        yield rescue nil # TODO: (CHECK): may be we need to process exceptions here
+        sleep(rql_client.config['swarm.supervisor.liveness_probing_period'])
       end
     end
-    # NOTE: need to give a timespot to initialize visor thread;
+    # NOTE: need to give a timespot to initialize a visor thread;
     sleep(0.1)
   end
 
@@ -56,7 +56,11 @@ class RedisQueuedLocks::Swarm::Supervisor
   # @api private
   # @since 1.9.0
   def running?
-    visor != nil && visor.alive?
+    # NOTE:
+    #   steep can not understand that visor.alive? is invoked on
+    #   `::Thread` here (not on `::Thread | nil` after the `nil`-check);
+    #   so we need to ignore this check temporary and wait the best future :)
+    visor != nil && visor.alive? # steep:ignore
   end
 
   # @return [void]
@@ -64,7 +68,11 @@ class RedisQueuedLocks::Swarm::Supervisor
   # @api private
   # @since 1.9.0
   def stop!
-    visor.kill if running?
+    # NOTE:
+    #   steep can not understand that visor.kill is invoked on
+    #   `::Thread` here (not on `::Thread | nil` after the `nil`-check);
+    #   so we need to ignore this check temporary and wait the best future :)
+    visor.kill if running? # steep:ignore
     @visor = nil
     @observable = nil
   end
@@ -74,9 +82,14 @@ class RedisQueuedLocks::Swarm::Supervisor
   # @api private
   # @since 1.9.0
   def status
+    # NOTE:
+    #   steep can not understand that thread_state(visor) is invoked on
+    #   `::Thread` here (not on `::Thread | nil` after the `nil`-check);
+    #   so we need to ignore this check temporary and wait the best future :)
+
     {
       running: running?,
-      state: (visor == nil) ? 'non_initialized' : thread_state(visor),
+      state: (visor == nil) ? 'non_initialized' : thread_state(visor), # steep:ignore
       observable: (observable == nil) ? 'non_initialized' : 'initialized'
     }
   end

data/lib/redis_queued_locks/swarm/swarm_element/isolated.rb

@@ -25,6 +25,7 @@ class RedisQueuedLocks::Swarm::SwarmElement::Isolated
   # @since 1.9.0
   attr_reader :sync
 
+  # @param rql_client [RedisQueuedLocks::Client]
   # @return [void]
   #
   # @api private
@@ -80,12 +81,12 @@ class RedisQueuedLocks::Swarm::SwarmElement::Isolated
   #
   # @api private
   # @since 1.9.0
-  def enabled?
+  def enabled? # steep:ignore
     # NOTE: provide an <is enabled> logic here by analyzing the redis queued locks config.
   end
 
-  # @return [Hash<Symbol,Boolean|Hash<Symbol,String|Boolean>>]
-  #   Format: {
+  # @return [Hash<Symbol,Boolean|Hash<Symbol,String|Boolean>>] Format:
+  #   {
   #     enabled: <Boolean>,
   #     ractor: {
   #       running: <Boolean>,
@@ -102,16 +103,16 @@ class RedisQueuedLocks::Swarm::SwarmElement::Isolated
   def status
     sync.synchronize do
       ractor_running = swarmed__alive?
-      ractor_state = swarmed? ? ractor_status(swarm_element) : 'non_initialized'
+      ractor_state = swarmed? ? ractor_status(swarm_element) : 'non_initialized' # steep:ignore
 
-      main_loop_running = nil
-      main_loop_state = nil
       begin
         main_loop_running = swarmed__running?
+        # steep:ignore:start
         main_loop_state =
           main_loop_running ? swarm_loop__status[:main_loop][:state] : 'non_initialized'
+        # steep:ignore:end
       rescue Ractor::ClosedError
-        # NOTE: it can happend when you run RedisQueuedLocks::Swarm#deswarm!;
+        # NOTE: it can happend when you running RedisQueuedLocks::Swarm#deswarm!
         main_loop_running = false
         main_loop_state = 'non_initialized'
       end
@@ -160,6 +161,7 @@ class RedisQueuedLocks::Swarm::SwarmElement::Isolated
     #   to provide better code readability (it is placed next to the method inside
     #   wich it should be called (see #swarm!)). That's why some rubocop cops are disabled.
 
+    # @type var main_loop: Thread?
     main_loop = nil
 
     loop do
@@ -167,24 +169,24 @@ class RedisQueuedLocks::Swarm::SwarmElement::Isolated
 
       case command
       when :status
-        main_loop_alive = main_loop != nil && main_loop.alive?
+        main_loop_alive = main_loop != nil && main_loop.alive? # steep:ignore
         main_loop_state =
           if main_loop == nil
             'non_initialized'
           else
-            # NOTE: (full name resolution): ractor has no syntax-based constatnt context;
+            # @type var main_loop: Thread
             RedisQueuedLocks::Utilities.thread_state(main_loop)
           end
         Ractor.yield({ main_loop: { alive: main_loop_alive, state: main_loop_state } })
       when :is_active
-        Ractor.yield(main_loop != nil && main_loop.alive?)
+        Ractor.yield(main_loop != nil && main_loop.alive?) # steep:ignore
       when :start
-        main_loop.kill if main_loop != nil
+        main_loop.kill if main_loop != nil # steep:ignore
         main_loop = yield # REFERENCE: `main_loop_spawner.call`
       when :stop
-        main_loop.kill if main_loop != nil
+        main_loop.kill if main_loop != nil # steep:ignore
       when :kill
-        main_loop.kill if main_loop != nil
+        main_loop.kill if main_loop != nil # steep:ignore
         exit
       end
     end
@@ -212,7 +214,7 @@ class RedisQueuedLocks::Swarm::SwarmElement::Isolated
   # @api private
   # @since 1.9.0
   def swarmed__alive?
-    swarm_element != nil && ractor_alive?(swarm_element)
+    swarm_element != nil && ractor_alive?(swarm_element) # steep:ignore
   end
 
   # @return [Boolean]
@@ -220,7 +222,7 @@ class RedisQueuedLocks::Swarm::SwarmElement::Isolated
   # @api private
   # @since 1.9.0
   def swarmed__dead?
-    swarm_element != nil && !ractor_alive?(swarm_element)
+    swarm_element != nil && !ractor_alive?(swarm_element) # steep:ignore
   end
 
   # @return [Boolean]
@@ -228,7 +230,7 @@ class RedisQueuedLocks::Swarm::SwarmElement::Isolated
   # @api private
   # @since 1.9.0
   def swarmed__running?
-    swarm_element != nil && ractor_alive?(swarm_element) && swarm_loop__is_active
+    swarm_element != nil && ractor_alive?(swarm_element) && swarm_loop__is_active # steep:ignore
   end
 
   # @return [Boolean]
@@ -236,7 +238,7 @@ class RedisQueuedLocks::Swarm::SwarmElement::Isolated
   # @api private
   # @since 1.9.0
   def swarmed__stopped?
-    swarm_element != nil && ractor_alive?(swarm_element) && !swarm_loop__is_active
+    swarm_element != nil && ractor_alive?(swarm_element) && !swarm_loop__is_active # steep:ignore
   end
 
   # @return [Boolean]
@@ -244,7 +246,7 @@ class RedisQueuedLocks::Swarm::SwarmElement::Isolated
   # @api private
   # @since 1.9.0
   def swarm_loop__is_active
-    return if idle? || swarmed__dead?
+    return false if idle? || swarmed__dead?
     sync.synchronize { swarm_element.send(:is_active).take }
   end