Simplify recurring schedule with respect to dynamic task reloading

We don't need to track dynamic task changes, we can just reload the
metadata in every case. If it hasn't changed, Rails won't issue any new
update to the process record.

Also, we can just use `dynamic_tasks` everywhere, as an empty AR
relation if dynamic tasks are disabled, avoiding extra queries but
keeping the code simpler.

Author: rosa

lib/solid_queue/processes/registrable.rb

@@ -60,8 +60,8 @@ def heartbeat
         wake_up
       end
 
-      def refresh_registered_process
-        wrap_in_app_executor { process&.update_columns(metadata: metadata.compact) }
+      def reload_metadata
+        wrap_in_app_executor { process&.update(metadata: metadata.compact) }
       end
   end
 end

lib/solid_queue/scheduler.rb

@@ -34,7 +34,7 @@ def run
         loop do
           break if shutting_down?
 
-          reload_schedule if dynamic_tasks_enabled?
+          reload_dynamic_schedule if dynamic_tasks_enabled?
 
           interruptible_sleep(sleep_interval)
         end
@@ -52,13 +52,9 @@ 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
+      def reload_dynamic_schedule
+        recurring_schedule.reload_dynamic_tasks
+        reload_metadata
       end
 
       def dynamic_tasks_enabled?

lib/solid_queue/scheduler/recurring_schedule.rb

@@ -7,26 +7,18 @@ class Scheduler::RecurringSchedule
     attr_reader :scheduled_tasks
 
     def initialize(static_tasks, dynamic_tasks_enabled: false)
-      @static_tasks = Array(static_tasks).map { |task| SolidQueue::RecurringTask.wrap(task) }.select(&:valid?)
-      @scheduled_tasks = Concurrent::Hash.new
-      @changes = Concurrent::Hash.new
+      @static_tasks = Array(static_tasks).map { |task| RecurringTask.wrap(task) }.select(&:valid?)
       @dynamic_tasks_enabled = dynamic_tasks_enabled
+
+      @scheduled_tasks = Concurrent::Hash.new
     end
 
     def configured_tasks
-      if dynamic_tasks_enabled?
-        static_tasks + dynamic_tasks.to_a
-      else
-        static_tasks
-      end
+      static_tasks + dynamic_tasks
     end
 
     def empty?
-      if dynamic_tasks_enabled?
-        scheduled_tasks.empty? && dynamic_tasks.none?
-      else
-        scheduled_tasks.empty?
-      end
+      scheduled_tasks.empty? && dynamic_tasks.empty?
     end
 
     def schedule_tasks
@@ -50,69 +42,55 @@ def unschedule_tasks
     end
 
     def task_keys
-      if dynamic_tasks_enabled?
-        static_task_keys + dynamic_tasks.pluck(:key)
-      else
-        static_task_keys
-      end
+      static_task_keys + dynamic_task_keys
     end
 
-    def reload!
+    def reload_dynamic_tasks
       wrap_in_app_executor do
-        { added_tasks: schedule_new_dynamic_tasks,
-          removed_tasks: unschedule_old_dynamic_tasks }.each do |key, values|
-          if values.any?
-            @changes[key] = values
-          else
-            @changes.delete(key)
-          end
-        end
+        schedule_created_dynamic_tasks
+        unschedule_deleted_dynamic_tasks
       end
     end
 
-    def changed?
-      @changes.any?
-    end
-
-    def clear_changes
-      @changes.clear
-    end
-
     private
       attr_reader :static_tasks
 
-      def dynamic_tasks_enabled?
-        @dynamic_tasks_enabled
+      def static_task_keys
+        static_tasks.map(&:key)
       end
 
       def dynamic_tasks
-        SolidQueue::RecurringTask.dynamic
+        dynamic_tasks_enabled? ? RecurringTask.dynamic : RecurringTask.none
       end
 
-      def static_task_keys
-        static_tasks.map(&:key)
+      def dynamic_task_keys
+        dynamic_tasks.pluck(:key)
+      end
+
+      def dynamic_tasks_enabled?
+        @dynamic_tasks_enabled
       end
 
-      def schedule_new_dynamic_tasks
+      def schedule_created_dynamic_tasks
         dynamic_tasks.where.not(key: scheduled_tasks.keys).each do |task|
           schedule_task(task)
         end
       end
 
-      def unschedule_old_dynamic_tasks
-        (scheduled_tasks.keys - SolidQueue::RecurringTask.pluck(:key)).each do |key|
+      def unschedule_deleted_dynamic_tasks
+        (scheduled_tasks.keys - RecurringTask.pluck(:key)).each do |key|
           scheduled_tasks[key].cancel
           scheduled_tasks.delete(key)
         end
       end
 
       def persist_static_tasks
-        SolidQueue::RecurringTask.static.where.not(key: static_task_keys).delete_all
-        SolidQueue::RecurringTask.create_or_update_all static_tasks
+        RecurringTask.static.where.not(key: static_task_keys).delete_all
+        RecurringTask.create_or_update_all static_tasks
       end
 
       def reload_static_tasks
-        @static_tasks = SolidQueue::RecurringTask.static.where(key: static_task_keys).to_a
+        @static_tasks = RecurringTask.static.where(key: static_task_keys).to_a
       end
 
       def schedule(task)