solid_queue 0.3.0 → 0.3.1

data/lib/solid_queue/recurring_tasks/schedule.rb

@@ -1,58 +0,0 @@
-# frozen_string_literal: true
-
-module SolidQueue
-  module RecurringTasks
-    class Schedule
-      include AppExecutor
-
-      attr_reader :configured_tasks, :scheduled_tasks
-
-      def initialize(tasks)
-        @configured_tasks = Array(tasks).map { |task| Task.wrap(task) }
-        @scheduled_tasks = Concurrent::Hash.new
-      end
-
-      def load_tasks
-        configured_tasks.each do |task|
-          load_task(task)
-        end
-      end
-
-      def load_task(task)
-        scheduled_tasks[task.key] = schedule(task)
-      end
-
-      def unload_tasks
-        scheduled_tasks.values.each(&:cancel)
-        scheduled_tasks.clear
-      end
-
-      def tasks
-        configured_tasks.each_with_object({}) { |task, hsh| hsh[task.key] = task.to_h }
-      end
-
-      def inspect
-        configured_tasks.map(&:to_s).join(" | ")
-      end
-
-      private
-        def schedule(task)
-          scheduled_task = Concurrent::ScheduledTask.new(task.delay_from_now, args: [ self, task, task.next_time ]) do |thread_schedule, thread_task, thread_task_run_at|
-            thread_schedule.load_task(thread_task)
-
-            wrap_in_app_executor do
-              thread_task.enqueue(at: thread_task_run_at)
-            end
-          end
-
-          scheduled_task.add_observer do |_, _, error|
-            # Don't notify on task cancellation before execution, as this will happen normally
-            # as part of unloading tasks
-            handle_thread_error(error) if error && !error.is_a?(Concurrent::CancelledOperationError)
-          end
-
-          scheduled_task.tap(&:execute)
-        end
-    end
-  end
-end

data/lib/solid_queue/recurring_tasks/task.rb

@@ -1,87 +0,0 @@
-require "fugit"
-
-module SolidQueue
-  module RecurringTasks
-    class Task
-      class << self
-        def wrap(args)
-          args.is_a?(self) ? args : from_configuration(args.first, **args.second)
-        end
-
-        def from_configuration(key, **options)
-          new(key, class_name: options[:class], schedule: options[:schedule], arguments: options[:args])
-        end
-      end
-
-      attr_reader :key, :schedule, :class_name, :arguments
-
-      def initialize(key, class_name:, schedule:, arguments: nil)
-        @key = key
-        @class_name = class_name
-        @schedule = schedule
-        @arguments = Array(arguments)
-      end
-
-      def delay_from_now
-        [ (next_time - Time.current).to_f, 0 ].max
-      end
-
-      def next_time
-        parsed_schedule.next_time.utc
-      end
-
-      def enqueue(at:)
-        if using_solid_queue_adapter?
-          perform_later_and_record(run_at: at)
-        else
-          perform_later
-        end
-      end
-
-      def valid?
-        parsed_schedule.instance_of?(Fugit::Cron)
-      end
-
-      def to_s
-        "#{class_name}.perform_later(#{arguments.map(&:inspect).join(",")}) [ #{parsed_schedule.original.to_s} ]"
-      end
-
-      def to_h
-        {
-          schedule: schedule,
-          class_name: class_name,
-          arguments: arguments
-        }
-      end
-
-      private
-        def using_solid_queue_adapter?
-          job_class.queue_adapter_name.inquiry.solid_queue?
-        end
-
-        def perform_later_and_record(run_at:)
-          RecurringExecution.record(key, run_at) { perform_later.provider_job_id }
-        end
-
-        def perform_later
-          job_class.perform_later(*arguments_with_kwargs)
-        end
-
-        def arguments_with_kwargs
-          if arguments.last.is_a?(Hash)
-            arguments[0...-1] + [ Hash.ruby2_keywords_hash(arguments.last) ]
-          else
-            arguments
-          end
-        end
-
-        def parsed_schedule
-          @parsed_schedule ||= Fugit.parse(schedule)
-        end
-
-        def job_class
-          @job_class ||= class_name.safe_constantize
-        end
-    end
-  end
-end