Refactor a bit the concurrency maintenance and stub recurring tasks

In the dispatcher and the configuration.

Author: rosa

lib/solid_queue/configuration.rb

@@ -12,8 +12,9 @@ class Configuration
     DISPATCHER_DEFAULTS = {
       batch_size: 500,
       polling_interval: 1,
-      concurrency_clerk: true,
-      concurrency_maintenance_interval: 600
+      concurrency_maintenance: true,
+      concurrency_maintenance_interval: 600,
+      recurring_tasks: []
     }
 
     def initialize(mode: :work, load_from: nil)

lib/solid_queue/dispatcher.rb

@@ -4,18 +4,19 @@ module SolidQueue
   class Dispatcher < Processes::Base
     include Processes::Runnable, Processes::Poller
 
-    attr_accessor :batch_size, :concurrency_clerk
+    attr_accessor :batch_size, :concurrency_maintenance, :recurring_tasks
 
-    after_boot :launch_concurrency_maintenance, if: :concurrency_clerk?
-    before_shutdown :stop_concurrency_maintenance, if: :concurrency_clerk?
+    after_boot :start_concurrency_maintenance, :schedule_recurring_tasks
+    before_shutdown :stop_concurrency_maintenance, :unschedule_recurring_tasks
 
     def initialize(**options)
       options = options.dup.with_defaults(SolidQueue::Configuration::DISPATCHER_DEFAULTS)
 
       @batch_size = options[:batch_size]
       @polling_interval = options[:polling_interval]
 
-      @concurrency_clerk = ConcurrencyClerk.new(options[:concurrency_maintenance_interval], options[:batch_size]) if options[:concurrency_clerk]
+      @concurrency_maintenance = ConcurrencyMaintenance.new(options[:concurrency_maintenance_interval], options[:batch_size]) if options[:concurrency_maintenance]
+      @recurring_tasks = RecurringTasks.new(options[:recurring_tasks])
     end
 
     private
@@ -34,20 +35,24 @@ def dispatch_next_batch
         end
       end
 
-      def concurrency_clerk?
-        concurrency_clerk.present?
+      def start_concurrency_maintenance
+        concurrency_maintenance&.start
       end
 
-      def launch_concurrency_maintenance
-        concurrency_clerk.start
+      def schedule_recurring_tasks
+        recurring_tasks.schedule
       end
 
       def stop_concurrency_maintenance
-        concurrency_clerk.stop
+        concurrency_maintenance&.stop
+      end
+
+      def unschedule_recurring_tasks
+        recurring_tasks.unschedule
       end
 
       def metadata
-        super.merge(batch_size: batch_size, concurrency_maintenance_interval: concurrency_clerk&.interval)
+        super.merge(batch_size: batch_size, concurrency_maintenance_interval: concurrency_maintenance&.interval)
       end
   end
 end

lib/solid_queue/dispatcher/concurrency_clerk.rb renamed to lib/solid_queue/dispatcher/concurrency_maintenance.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module SolidQueue
-  class Dispatcher::ConcurrencyClerk
+  class Dispatcher::ConcurrencyMaintenance
     include AppExecutor
 
     attr_reader :interval, :batch_size

lib/solid_queue/dispatcher/recurring_tasks.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module SolidQueue
+  class Dispatcher::RecurringTasks
+    include AppExecutor
+
+    attr_reader :interval, :batch_size
+
+    def initialize(configured_tasks)
+      @configured_tasks = configured_tasks
+    end
+
+    def schedule
+    end
+
+    def unschedule
+    end
+  end
+end

test/unit/configuration_test.rb

@@ -31,7 +31,7 @@ class ConfigurationTest < ActiveSupport::TestCase
     assert_equal 1, configuration.dispatchers.count
     dispatcher = configuration.dispatchers.first
     assert_equal SolidQueue::Configuration::DISPATCHER_DEFAULTS[:polling_interval], dispatcher.polling_interval
-    assert_equal SolidQueue::Configuration::DISPATCHER_DEFAULTS[:concurrency_maintenance_interval], dispatcher.concurrency_clerk.interval
+    assert_equal SolidQueue::Configuration::DISPATCHER_DEFAULTS[:concurrency_maintenance_interval], dispatcher.concurrency_maintenance.interval
 
     assert_equal 2, configuration.workers.count
     assert_equal [ "background" ], configuration.workers.flat_map(&:queues).uniq

test/unit/dispatcher_test.rb

@@ -24,8 +24,8 @@ class DispatcherTest < ActiveSupport::TestCase
   end
 
   test "concurrency maintenance is optional" do
-    no_concurrency_clerk = SolidQueue::Dispatcher.new(polling_interval: 0.1, batch_size: 10, concurrency_clerk: false)
-    no_concurrency_clerk.start
+    no_concurrency_maintenance_dispatcher = SolidQueue::Dispatcher.new(polling_interval: 0.1, batch_size: 10, concurrency_maintenance: false)
+    no_concurrency_maintenance_dispatcher.start
 
     wait_for_registered_processes(1, timeout: 1.second)