Refactor scheduler loop and add missing tests

Keep the longer sleep interval when dynamic tasks are disabled.

Add tests for `dynamic_tasks_enabled` opt-in in configuration and for
verifying dynamic tasks are ignored when not enabled.

Author: rosa

app/models/solid_queue/recurring_task.rb

@@ -20,7 +20,7 @@ class RecurringTask < Record
 
     class << self
       def wrap(args)
-        args.is_a?(self) ? args : from_configuration(args.first, **args.second.reverse_merge(static: true))
+        args.is_a?(self) ? args : from_configuration(args.first, **args.second)
       end
 
       def from_configuration(key, **options)
@@ -33,7 +33,7 @@ def from_configuration(key, **options)
           queue_name: options[:queue].presence,
           priority: options[:priority].presence,
           description: options[:description],
-          static: !!options[:static]
+          static: options.fetch(:static, true)
       end
 
       def create_or_update_all(tasks)

lib/solid_queue/configuration.rb

@@ -144,8 +144,8 @@ def dispatchers
       def schedulers
         return [] if skip_recurring_tasks?
 
-        if recurring_tasks.any? || dynamic_tasks_enabled?
-          [ Process.new(:scheduler, { recurring_tasks:, **scheduler_options.with_defaults(SCHEDULER_DEFAULTS) }) ]
+        if recurring_tasks.any? || dynamic_recurring_tasks_enabled?
+          [ Process.new(:scheduler, { recurring_tasks: recurring_tasks, **scheduler_options.with_defaults(SCHEDULER_DEFAULTS) }) ]
         else
           []
         end
@@ -165,7 +165,7 @@ def scheduler_options
         @scheduler_options ||= processes_config.fetch(:scheduler, {}).dup.symbolize_keys
       end
 
-      def dynamic_tasks_enabled?
+      def dynamic_recurring_tasks_enabled?
         scheduler_options.fetch(:dynamic_tasks_enabled, SCHEDULER_DEFAULTS[:dynamic_tasks_enabled])
       end
 

lib/solid_queue/scheduler.rb

@@ -15,9 +15,9 @@ class Scheduler < Processes::Base
 
     def initialize(recurring_tasks:, **options)
       options = options.dup.with_defaults(SolidQueue::Configuration::SCHEDULER_DEFAULTS)
-      @dynamic_tasks = options[:dynamic_tasks_enabled]
+      @dynamic_tasks_enabled = options[:dynamic_tasks_enabled]
       @polling_interval = options[:polling_interval]
-      @recurring_schedule = RecurringSchedule.new(recurring_tasks, dynamic_tasks_enabled: @dynamic_tasks)
+      @recurring_schedule = RecurringSchedule.new(recurring_tasks, dynamic_tasks_enabled: @dynamic_tasks_enabled)
 
       super(**options)
     end
@@ -27,35 +27,20 @@ def metadata
     end
 
     private
-      attr_reader :dynamic_tasks
 
-      def run
-        if dynamic_tasks
-          poll_for_dynamic_tasks
-        else
-          loop do
-            break if shutting_down?
-            interruptible_sleep(polling_interval)
-          end
-        end
-      ensure
-        SolidQueue.instrument(:shutdown_process, process: self) do
-          run_callbacks(:shutdown) { shutdown }
-        end
-      end
+      STATIC_SLEEP_INTERVAL = 60
 
-      def poll_for_dynamic_tasks
+      def run
         loop do
           break if shutting_down?
 
-          recurring_schedule.reload!
-
-          if recurring_schedule.changed?
-            refresh_registered_process
-            recurring_schedule.clear_changes
-          end
+          reload_schedule if dynamic_tasks_enabled?
 
-          interruptible_sleep(polling_interval)
+          interruptible_sleep(sleep_interval)
+        end
+      ensure
+        SolidQueue.instrument(:shutdown_process, process: self) do
+          run_callbacks(:shutdown) { shutdown }
         end
       end
 
@@ -67,10 +52,27 @@ def unschedule_recurring_tasks
         recurring_schedule.unschedule_tasks
       end
 
+      def reload_schedule
+        recurring_schedule.reload!
+
+        if recurring_schedule.changed?
+          refresh_registered_process
+          recurring_schedule.clear_changes
+        end
+      end
+
+      def dynamic_tasks_enabled?
+        @dynamic_tasks_enabled
+      end
+
       def all_work_completed?
         recurring_schedule.empty?
       end
 
+      def sleep_interval
+        dynamic_tasks_enabled? ? polling_interval : STATIC_SLEEP_INTERVAL
+      end
+
       def set_procline
         procline "scheduling #{recurring_schedule.task_keys.join(",")}"
       end

test/unit/configuration_test.rb

@@ -87,6 +87,24 @@ class ConfigurationTest < ActiveSupport::TestCase
     assert_has_recurring_task scheduler, key: "periodic_store_result", class_name: "StoreResultJob", schedule: "every second"
   end
 
+  test "scheduler starts with dynamic_tasks_enabled even without static tasks" do
+    configuration = SolidQueue::Configuration.new(
+      recurring_schedule_file: config_file_path(:empty_configuration),
+      scheduler: { dynamic_tasks_enabled: true }
+    )
+
+    assert_processes configuration, :scheduler, 1, dynamic_tasks_enabled: true
+  end
+
+  test "no scheduler without static tasks or dynamic_tasks_enabled" do
+    configuration = SolidQueue::Configuration.new(
+      recurring_schedule_file: config_file_path(:empty_configuration),
+      scheduler: { dynamic_tasks_enabled: false }
+    )
+
+    assert_processes configuration, :scheduler, 0
+  end
+
   test "no recurring tasks configuration when explicitly excluded" do
     configuration = SolidQueue::Configuration.new(dispatchers: [ { polling_interval: 0.1 } ], skip_recurring: true)
     assert_processes configuration, :dispatcher, 1, polling_interval: 0.1, recurring_tasks: nil

test/unit/scheduler_test.rb

@@ -52,6 +52,22 @@ class SchedulerTest < ActiveSupport::TestCase
     scheduler.stop
   end
 
+  test "dynamic tasks in DB are ignored when dynamic_tasks_enabled is false" do
+    SolidQueue::RecurringTask.create!(
+      key: "ignored_task", static: false, class_name: "AddToBufferJob", schedule: "every second", arguments: [ 42 ]
+    )
+
+    recurring_tasks = { static_task: { class: "AddToBufferJob", schedule: "every hour", args: 42 } }
+    scheduler = SolidQueue::Scheduler.new(recurring_tasks: recurring_tasks).tap(&:start)
+
+    wait_for_registered_processes(1, timeout: 1.second)
+
+    process = SolidQueue::Process.first
+    assert_metadata process, recurring_schedule: [ "static_task" ]
+  ensure
+    scheduler.stop
+  end
+
   test "run more than one instance of the scheduler with recurring tasks" do
     recurring_tasks = { example_task: { class: "AddToBufferJob", schedule: "every second", args: 42 } }
     schedulers = 2.times.collect do