solid_queue_mongoid 0.3.0

data/lib/solid_queue_mongoid/models/recurring_task.rb

@@ -0,0 +1,194 @@
+# frozen_string_literal: true
+
+require "fugit"
+
+module SolidQueue
+  class RecurringTask < Record
+    field :key, type: String
+    field :schedule, type: String
+    field :command, type: String
+    field :class_name, type: String
+    field :arguments, type: Array, default: []
+    field :queue_name, type: String
+    field :priority, type: Integer, default: 0
+    field :description, type: String
+    field :static, type: Boolean, default: false
+
+    index({ key: 1 }, { unique: true })
+
+    scope :static, -> { where(static: true) }
+    scope :dynamic, -> { where(static: false) }
+
+    validates :key, presence: true
+
+    validate :ensure_schedule_supported
+    validate :ensure_command_or_class_present
+    validate :ensure_existing_job_class
+
+    has_many :recurring_executions, foreign_key: :task_key, primary_key: :key,
+                                    class_name: "SolidQueue::RecurringExecution"
+
+    mattr_accessor :default_job_class
+    self.default_job_class = "SolidQueue::RecurringJob".safe_constantize
+
+    class << self
+      def wrap(args)
+        args.is_a?(self) ? args : from_configuration(args.first, **args.second)
+      end
+
+      def from_configuration(key, **options)
+        new(
+          key: key,
+          class_name: options[:class],
+          command: options[:command],
+          arguments: Array(options[:args]),
+          schedule: options[:schedule],
+          queue_name: options[:queue].presence,
+          priority: options[:priority].presence,
+          description: options[:description],
+          static: options.fetch(:static, true)
+        )
+      end
+
+      def create_dynamic_task(key, **options)
+        from_configuration(key, **options.merge(static: false)).save!
+      end
+
+      def delete_dynamic_task(key)
+        RecurringTask.dynamic.find_by!(key: key).destroy
+      end
+
+      # Upsert all static tasks; used by Scheduler::RecurringSchedule#persist_tasks.
+      def create_or_update_all(tasks)
+        tasks.each do |task|
+          existing = where(key: task.key).first
+          if existing
+            existing.update!(task.attributes_for_upsert)
+          else
+            create!(task.attributes_for_upsert.merge(key: task.key))
+          end
+        end
+      end
+    end
+
+    def delay_from_now
+      [(next_time - Time.current).to_f, 0.1].max
+    end
+
+    def next_time
+      parsed_schedule.next_time.utc
+    end
+
+    def previous_time
+      parsed_schedule.previous_time.utc
+    end
+
+    def last_enqueued_time
+      recurring_executions.maximum(:run_at)
+    end
+
+    def enqueue(at:)
+      SolidQueue.instrument(:enqueue_recurring_task, task: key, at: at) do |payload|
+        active_job = if using_solid_queue_adapter?
+                       enqueue_and_record(run_at: at)
+                     else
+                       payload[:other_adapter] = true
+                       perform_later.tap do |job|
+                         payload[:enqueue_error] = job.enqueue_error&.message unless job.successfully_enqueued?
+                       end
+                     end
+
+        active_job.tap do |enqueued_job|
+          payload[:active_job_id] = enqueued_job.job_id if enqueued_job
+        end
+      rescue RecurringExecution::AlreadyRecorded
+        payload[:skipped] = true
+        false
+      rescue Job::EnqueueError => e
+        payload[:enqueue_error] = e.message
+        false
+      end
+    end
+
+    def to_s
+      "#{class_name}.perform_later(#{arguments.map(&:inspect).join(",")}) [ #{parsed_schedule.original} ]"
+    end
+
+    def attributes_for_upsert
+      attrs = attributes.except("_id", "id", "created_at", "updated_at")
+      attrs.delete("key")
+      attrs
+    end
+
+    private
+
+    def ensure_schedule_supported
+      unless parsed_schedule.instance_of?(Fugit::Cron)
+        errors.add :schedule, :unsupported, message: "is not a supported recurring schedule"
+      end
+    rescue ArgumentError => e
+      message = if e.message.include?("multiple crons")
+                  "generates multiple cron schedules. Please use separate recurring tasks for each schedule, " \
+                    "or use explicit cron syntax (e.g., '40 0,15 * * *' for multiple times with the same minutes)"
+                else
+                  e.message
+                end
+      errors.add :schedule, :unsupported, message: message
+    end
+
+    def ensure_command_or_class_present
+      return if command.present? || class_name.present?
+
+      errors.add :base, :command_and_class_blank, message: "either command or class must be present"
+    end
+
+    def ensure_existing_job_class
+      return unless class_name.present? && job_class.nil?
+
+      errors.add :class_name, :undefined, message: "doesn't correspond to an existing class"
+    end
+
+    def using_solid_queue_adapter?
+      job_class.respond_to?(:queue_adapter_name) &&
+        job_class.queue_adapter_name.inquiry.solid_queue?
+    end
+
+    def enqueue_and_record(run_at:)
+      RecurringExecution.record(key, run_at) do
+        job_class.new(*arguments_with_kwargs).set(enqueue_options).tap do |active_job|
+          active_job.run_callbacks(:enqueue) do
+            Job.enqueue(active_job)
+          end
+        end
+      end
+    end
+
+    def perform_later
+      job_class.new(*arguments_with_kwargs).tap do |active_job|
+        active_job.enqueue(enqueue_options)
+      end
+    end
+
+    def arguments_with_kwargs
+      if class_name.nil?
+        command
+      elsif 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, multi: :fail)
+    end
+
+    def job_class
+      @job_class ||= class_name.present? ? class_name.safe_constantize : self.class.default_job_class
+    end
+
+    def enqueue_options
+      { queue: queue_name, priority: priority }.compact
+    end
+  end
+end

data/lib/solid_queue_mongoid/models/scheduled_execution.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module SolidQueue
+  class ScheduledExecution < Execution
+    include Dispatching
+
+    assumes_attributes_from_job :scheduled_at
+
+    field :scheduled_at, type: Time
+
+    scope :due,        -> { where(:scheduled_at.lte => Time.current) }
+    scope :due_order,  -> { order_by(scheduled_at: :asc, priority: :asc, job_id: :asc) }
+    scope :next_batch, ->(batch_size) { due.due_order.limit(batch_size) }
+
+    index({ scheduled_at: 1, priority: 1 })
+
+    class << self
+      def dispatch_next_batch(batch_size)
+        Mongoid.transaction do
+          SolidQueue.instrument(:dispatch_scheduled, batch_size: batch_size) do |payload|
+            job_ids = next_batch(batch_size).pluck(:job_id)
+            payload[:size] = if job_ids.empty?
+                               0
+                             else
+                               dispatch_jobs(job_ids)
+                             end
+            payload[:size]
+          end
+        end
+      end
+
+      alias dispatch_due_batch dispatch_next_batch
+    end
+
+    # Instance method: dispatch this single execution if the job is due now.
+    # Mirrors the AR behaviour used in tests.
+    def dispatch
+      return unless job.due?
+
+      self.class.dispatch_jobs([job_id])
+    end
+  end
+end

data/lib/solid_queue_mongoid/models/semaphore.rb

@@ -0,0 +1,179 @@
+# frozen_string_literal: true
+
+module SolidQueue
+  # Semaphore for concurrency control.
+  #
+  # Convention (matches spec expectations):
+  #   value = number of USED (acquired) slots   (0 = none in use)
+  #   limit = maximum concurrent slots
+  #
+  #   wait:   acquire a slot — succeeds when value < limit (increments value)
+  #   signal: release a slot — increments value (marks another slot returned)
+  #
+  # NOTE: This intentionally differs from the ActiveRecord original which uses
+  # value = remaining available slots.  The specs and BlockedExecution logic here
+  # both expect the "used slots" convention.
+  class Semaphore < Record
+    field :key, type: String
+    field :value, type: Integer, default: 0 # number of currently USED slots
+    field :limit, type: Integer, default: 1
+    field :expires_at, type: Time
+
+    index({ key: 1 }, { unique: true })
+    index({ expires_at: 1 })
+
+    validates :key, presence: true, uniqueness: true
+
+    # available: value < limit (at least one slot still free to acquire)
+    scope :available, -> { where("$expr" => { "$lt" => ["$value", "$limit"] }) }
+    scope :expired, -> { where(:expires_at.lt => Time.current) }
+
+    class << self
+      def wait(job)
+        Proxy.new(job).wait
+      end
+
+      def signal(job)
+        Proxy.new(job).signal
+      end
+
+      def signal_all(jobs)
+        Proxy.signal_all(jobs)
+      end
+
+      # Requires a unique index on key.
+      # Returns true if created/inserted; false on duplicate.
+      def create_unique_by(attributes)
+        create!(attributes)
+        true
+      rescue Mongoid::Errors::Validations, Mongo::Error::OperationFailure => e
+        raise unless duplicate_key_error?(e)
+
+        false
+      end
+
+      private
+
+      def duplicate_key_error?(err)
+        err.message.to_s.include?("E11000") || err.message.to_s.include?("duplicate key")
+      end
+    end
+
+    # ── Instance methods ──────────────────────────────────────────────────────
+
+    # Atomically acquire one slot (increment value if value < limit).
+    # Returns true on success, false when at limit.
+    def acquire
+      result = self.class.collection.find_one_and_update(
+        { _id: id, "value" => { "$lt" => limit } },
+        { "$inc" => { "value" => 1 } },
+        return_document: :after
+      )
+      result.present?
+    end
+
+    # Release one slot (decrement value). No-op if already at 0.
+    def release
+      self.class.collection.find_one_and_update(
+        { _id: id, "value" => { "$gt" => 0 } },
+        { "$inc" => { "value" => -1 } },
+        return_document: :after
+      )
+      true
+    end
+
+    # True when there is still room to acquire (value < limit).
+    def available?
+      reload
+      value < limit
+    end
+
+    # ── Proxy inner class ─────────────────────────────────────────────────────
+    class Proxy
+      # Decrement value for every job's semaphore key (signal = release a used slot).
+      def self.signal_all(jobs)
+        keys = jobs.map(&:concurrency_key)
+        return if keys.empty?
+
+        Semaphore.in(key: keys).each do |sem|
+          Semaphore.collection.find_one_and_update(
+            { _id: sem.id, "value" => { "$gt" => 0 } },
+            { "$inc" => { "value" => -1 } }
+          )
+        end
+      end
+
+      def initialize(job)
+        @job = job
+      end
+
+      # Acquire a slot: succeeds when value < limit.
+      # Creates the semaphore document on first use.
+      def wait
+        semaphore = Semaphore.where(key: key).first
+
+        if semaphore
+          # Atomically increment if value < limit
+          attempt_acquire(semaphore.id, semaphore.limit)
+        else
+          attempt_creation
+        end
+      end
+
+      # Release a slot: decrement value (marks one used slot as freed).
+      def signal
+        attempt_release_slot
+      end
+
+      private
+
+      attr_reader :job
+
+      # Try to create the semaphore with value=1 (one slot in use).
+      def attempt_creation
+        lim = limit
+        if Semaphore.create_unique_by(key: key, value: 1, limit: lim, expires_at: expires_at)
+          true
+        else
+          # Race: someone else created it first — try to acquire from existing
+          sem = Semaphore.where(key: key).first
+          return false unless sem
+
+          attempt_acquire(sem.id, sem.limit)
+        end
+      end
+
+      # Atomically increment value if currently < limit.
+      def attempt_acquire(semaphore_id, lim)
+        result = Semaphore.collection.find_one_and_update(
+          { _id: semaphore_id, "value" => { "$lt" => lim } },
+          { "$inc" => { "value" => 1 }, "$set" => { "expires_at" => expires_at } },
+          return_document: :after
+        )
+        result.present?
+      end
+
+      # Atomically decrement value if currently > 0 (release one used slot).
+      def attempt_release_slot
+        result = Semaphore.collection.find_one_and_update(
+          { "key" => key, "value" => { "$gt" => 0 } },
+          { "$inc" => { "value" => -1 }, "$set" => { "expires_at" => expires_at } },
+          return_document: :after
+        )
+        result.present?
+      end
+
+      def key
+        job.concurrency_key
+      end
+
+      def expires_at
+        job.respond_to?(:concurrency_duration) ? job.concurrency_duration.from_now : 5.minutes.from_now
+      end
+
+      def limit
+        (job.respond_to?(:concurrency_limit) ? job.concurrency_limit : nil) || 1
+      end
+    end
+  end
+end

data/lib/solid_queue_mongoid/railtie.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module SolidQueueMongoid
+  class Railtie < Rails::Railtie
+    rake_tasks do
+      load "tasks/solid_queue_mongoid.rake"
+    end
+
+    # Prevent SolidQueue's AR models from loading via Zeitwerk.
+    #
+    # Must run BEFORE :set_eager_load_paths (which freezes eager_load_paths)
+    # and before SolidQueue's own Railtie initializer adds its app/ path.
+    initializer "solid_queue_mongoid.shim",
+                before: :set_eager_load_paths do |app|
+      next unless defined?(SolidQueue::Engine)
+
+      sq_app_path = SolidQueue::Engine.root.join("app").to_s
+
+      # Tell Zeitwerk to ignore SolidQueue's app/ tree so it never autoloads
+      # the AR model files.
+      Rails.autoloaders.each do |loader|
+        loader.ignore(sq_app_path) if loader.respond_to?(:ignore)
+      end
+
+      # Remove from eager_load_paths before Rails freezes it.
+      app.config.eager_load_paths.delete_if { |p| p.start_with?(sq_app_path) }
+    end
+  end
+end

data/lib/solid_queue_mongoid/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module SolidQueueMongoid
+  VERSION = "0.3.0"
+end

data/lib/solid_queue_mongoid.rb

@@ -0,0 +1,136 @@
+# frozen_string_literal: true
+
+require_relative "solid_queue_mongoid/version"
+require "mongoid"
+require "active_support/all"
+
+# Load Railtie if in Rails — must happen before SolidQueue loads its AR models
+require_relative "solid_queue_mongoid/railtie" if defined?(Rails::Railtie)
+
+module SolidQueueMongoid
+  class Error < StandardError; end
+
+  # Configuration
+  mattr_accessor :client, :collection_prefix
+
+  @@client            = :default
+  @@collection_prefix = "solid_queue_"
+
+  def self.configure
+    yield self
+  end
+
+  def self.create_indexes
+    all_models.each(&:create_indexes)
+  end
+
+  def self.remove_indexes
+    all_models.each(&:remove_indexes)
+  end
+
+  def self.all_models
+    [
+      SolidQueue::Job,
+      SolidQueue::ReadyExecution,
+      SolidQueue::ClaimedExecution,
+      SolidQueue::BlockedExecution,
+      SolidQueue::ScheduledExecution,
+      SolidQueue::FailedExecution,
+      SolidQueue::RecurringExecution,
+      SolidQueue::Process,
+      SolidQueue::Pause,
+      SolidQueue::Semaphore,
+      SolidQueue::RecurringTask
+    ]
+  end
+end
+
+# ─── Shim: inject SolidQueue namespace helpers before SolidQueue runtime loads ───
+# SolidQueue runtime calls SolidQueue.client, SolidQueue.collection_prefix, etc.
+# We also need clear_finished_jobs_after, process_alive_threshold, preserve_finished_jobs?
+# — if SolidQueue gem is present those will already exist; if not we stub sensible defaults.
+module SolidQueue
+  def self.client
+    SolidQueueMongoid.client
+  end
+
+  def self.collection_prefix
+    SolidQueueMongoid.collection_prefix
+  end
+
+  # These defaults mirror SolidQueue::Configuration defaults and are only
+  # active when solid_queue itself is not loaded.
+  unless respond_to?(:clear_finished_jobs_after)
+    def self.clear_finished_jobs_after
+      1.day
+    end
+  end
+
+  unless respond_to?(:process_alive_threshold)
+    def self.process_alive_threshold
+      5.minutes
+    end
+  end
+
+  unless respond_to?(:preserve_finished_jobs?)
+    def self.preserve_finished_jobs?
+      true
+    end
+  end
+
+  # Stub for SolidQueue.instrument — the real implementation in solid_queue
+  # uses ActiveSupport::Notifications. When solid_queue is loaded it already
+  # defines this, so we only add it when missing.
+  unless respond_to?(:instrument)
+    def self.instrument(_event, payload = {}, &block)
+      yield(payload) if block_given?
+    end
+  end
+end
+
+# ─── Load order ───────────────────────────────────────────────────────────────
+# 1. Base record class
+require_relative "solid_queue_mongoid/models/record"
+
+# 2. Pre-declare all classes (avoids superclass mismatch)
+require_relative "solid_queue_mongoid/models/classes"
+
+# 3. Execution concerns
+require_relative "solid_queue_mongoid/models/execution/job_attributes"
+require_relative "solid_queue_mongoid/models/execution/dispatching"
+
+# 4. Base execution
+require_relative "solid_queue_mongoid/models/execution"
+
+# 5. Job concerns (order matters — ConcurrencyControls/Schedulable/Retryable
+#    must exist before Executable includes them)
+require_relative "solid_queue_mongoid/models/job/clearable"
+require_relative "solid_queue_mongoid/models/job/recurrable"
+require_relative "solid_queue_mongoid/models/job/schedulable"
+require_relative "solid_queue_mongoid/models/job/retryable"
+require_relative "solid_queue_mongoid/models/job/concurrency_controls"
+require_relative "solid_queue_mongoid/models/job/executable"
+
+# 6. Concrete models
+require_relative "solid_queue_mongoid/models/job"
+require_relative "solid_queue_mongoid/models/semaphore" # needed by BlockedExecution
+require_relative "solid_queue_mongoid/models/ready_execution"
+require_relative "solid_queue_mongoid/models/claimed_execution"
+require_relative "solid_queue_mongoid/models/blocked_execution"
+require_relative "solid_queue_mongoid/models/scheduled_execution"
+require_relative "solid_queue_mongoid/models/failed_execution"
+require_relative "solid_queue_mongoid/models/recurring_task/arguments"
+require_relative "solid_queue_mongoid/models/recurring_task"
+require_relative "solid_queue_mongoid/models/recurring_execution"
+require_relative "solid_queue_mongoid/models/process/executor"
+require_relative "solid_queue_mongoid/models/process/prunable"
+require_relative "solid_queue_mongoid/models/process"
+require_relative "solid_queue_mongoid/models/pause"
+require_relative "solid_queue_mongoid/models/queue"
+require_relative "solid_queue_mongoid/models/queue_selector"
+
+# Pull in SolidQueue's runtime (engine, workers, dispatcher, etc.) after our
+# Mongoid models are defined so they claim the SolidQueue::* namespace first.
+# SolidQueue's AR model files live in app/models/ which is never required by
+# solid_queue.rb itself — they're Rails-autoloaded and blocked by our Railtie.
+require "solid_queue"

data/lib/tasks/solid_queue_mongoid.rake

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+namespace :solid_queue_mongoid do
+  desc "Create MongoDB indexes for SolidQueue models"
+  task create_indexes: :environment do
+    require "solid_queue_mongoid"
+
+    puts "Creating indexes for SolidQueue Mongoid models..."
+    SolidQueueMongoid.create_indexes
+  end
+
+  desc "Remove MongoDB indexes for SolidQueue models"
+  task remove_indexes: :environment do
+    require "solid_queue_mongoid"
+
+    puts "Removing indexes for SolidQueue Mongoid models..."
+    SolidQueueMongoid.remove_indexes
+  end
+
+  desc "Show collection names for SolidQueue models"
+  task show_collections: :environment do
+    require "solid_queue_mongoid"
+
+    puts "\nSolidQueue Mongoid Collections:"
+    puts "--------------------------------"
+    puts "Configuration:"
+    puts "  Client: #{SolidQueue.client}"
+    puts "  Prefix: #{SolidQueue.collection_prefix}"
+    puts "\nCollections:"
+
+    models = [
+      SolidQueue::Job,
+      SolidQueue::ReadyExecution,
+      SolidQueue::ClaimedExecution,
+      SolidQueue::BlockedExecution,
+      SolidQueue::ScheduledExecution,
+      SolidQueue::FailedExecution,
+      SolidQueue::RecurringExecution,
+      SolidQueue::Process,
+      SolidQueue::Pause,
+      SolidQueue::Semaphore,
+      SolidQueue::RecurringTask,
+      SolidQueue::Queue
+    ]
+
+    models.each do |model|
+      puts "  #{model.name.ljust(45)} => #{model.collection.name}"
+    end
+    puts ""
+  end
+end

data/release.sh

@@ -0,0 +1,13 @@
+#!/bin/bash
+set -e
+
+# Extract version from version.rb
+VERSION=$(ruby -r ./lib/solid_queue_mongoid/version.rb -e "puts SolidQueueMongoid::VERSION")
+
+echo "Building gem version ${VERSION}..."
+gem build solid_queue_mongoid.gemspec
+
+echo "Pushing to RubyGems..."
+gem push solid_queue_mongoid-${VERSION}.gem
+
+echo "Done!"

data/sig/solid_queue_mongoid.rbs

@@ -0,0 +1,4 @@
+module SolidQueueMongoid
+  VERSION: String
+  # See the writing guide of rbs: https://github.com/ruby/rbs#guides
+end