solid_queue_mongoid 0.3.0

data/lib/solid_queue_mongoid/models/process/prunable.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module SolidQueue
+  class Process
+    module Prunable
+      extend ActiveSupport::Concern
+
+      included do
+        # Processes whose heartbeat is older than the alive threshold
+        scope :prunable, lambda {
+          where(:last_heartbeat_at.lte => SolidQueue.process_alive_threshold.ago)
+        }
+      end
+
+      class_methods do
+        # Called by supervisor maintenance loop.
+        # +excluding+ is the current supervisor Process record (or nil).
+        def prune(excluding: nil)
+          SolidQueue.instrument(:prune_processes, size: 0) do |payload|
+            scope = prunable
+            scope = scope.not.where(id: excluding.id) if excluding.present?
+
+            scope.each do |process|
+              payload[:size] += 1
+              process.prune
+            end
+          end
+        end
+
+        # Integration-spec compatible helper: prune processes whose heartbeat
+        # is older than +timeout+ ago.
+        def prune_stale_processes(timeout: SolidQueue.process_alive_threshold)
+          where(:last_heartbeat_at.lte => timeout.ago).each(&:prune)
+        end
+      end
+
+      def prune
+        error = begin
+          ::SolidQueue::Processes::ProcessPrunedError.new(last_heartbeat_at)
+        rescue NameError
+          RuntimeError.new("Process pruned: last heartbeat at #{last_heartbeat_at}")
+        end
+
+        fail_all_claimed_executions_with(error)
+        deregister(pruned: true)
+      end
+    end
+  end
+end

data/lib/solid_queue_mongoid/models/process.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+module SolidQueue
+  class Process < Record
+    include Process::Executor
+    include Process::Prunable
+
+    field :kind, type: String
+    field :name, type: String
+    field :hostname, type: String
+    field :pid, type: Integer
+    field :supervisor_id, type: BSON::ObjectId
+    field :metadata, type: Hash, default: {}
+    field :last_heartbeat_at, type: Time
+
+    belongs_to :supervisor, class_name: "SolidQueue::Process", optional: true,
+                            inverse_of: :supervisees
+    has_many :supervisees, class_name: "SolidQueue::Process",
+                           inverse_of: :supervisor, foreign_key: :supervisor_id
+
+    index({ hostname: 1, pid: 1 })
+    index({ last_heartbeat_at: 1 })
+    index({ kind: 1 })
+    index({ supervisor_id: 1 }, { sparse: true })
+
+    validates :hostname, :pid, presence: true
+
+    class << self
+      # Called by SolidQueue::Processes::Registrable#register.
+      # Must accept: kind:, name:, pid:, hostname:, and optional metadata:/supervisor:
+      def register(kind:, name:, pid:, hostname:, supervisor: nil, metadata: {}, **rest)
+        attrs = { kind: kind, name: name, pid: pid, hostname: hostname,
+                  supervisor: supervisor, metadata: (metadata || {}).merge(rest),
+                  last_heartbeat_at: Time.current }
+        SolidQueue.instrument(:register_process, kind: kind, name: name, pid: pid, hostname: hostname) do |payload|
+          create!(attrs).tap do |process|
+            payload[:process_id] = process.id
+          end
+        rescue StandardError => e
+          payload[:error] = e
+          raise
+        end
+      end
+    end
+
+    def heartbeat
+      # Reload to clear any stale state before updating heartbeat
+      begin
+        reload
+      rescue StandardError
+        nil
+      end
+      update!(last_heartbeat_at: Time.current)
+    end
+
+    def deregister(pruned: false)
+      SolidQueue.instrument(:deregister_process, process: self, pruned: pruned) do |payload|
+        destroy!
+
+        supervisees.each(&:deregister) unless supervised? || pruned
+      rescue StandardError => e
+        payload[:error] = e
+        raise
+      end
+    end
+
+    private
+
+    def supervised?
+      supervisor_id.present?
+    end
+  end
+end

data/lib/solid_queue_mongoid/models/queue.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+module SolidQueue
+  # Plain Ruby class — mirrors upstream SolidQueue::Queue (1.3.x).
+  # State is derived from actual Job/Pause/ReadyExecution documents;
+  # no separate Queue collection is maintained.
+  class Queue
+    attr_accessor :name
+
+    class << self
+      def all
+        Job.distinct(:queue_name).map { |queue_name| new(queue_name) }
+      end
+
+      def find_by_name(name)
+        new(name)
+      end
+    end
+
+    def initialize(name)
+      @name = name
+    end
+
+    def paused?
+      Pause.where(queue_name: name).exists?
+    end
+
+    def pause
+      Pause.pause_queue(name)
+    end
+
+    def resume
+      Pause.resume_queue(name)
+    end
+
+    def clear
+      ReadyExecution.queued_as(name).discard_all_in_batches
+    end
+
+    def size
+      @size ||= ReadyExecution.queued_as(name).count
+    end
+
+    def latency
+      @latency ||= begin
+        now = Time.current
+        oldest_enqueued_at = ReadyExecution.queued_as(name).min(:created_at) || now
+        (now - oldest_enqueued_at).to_i
+      end
+    end
+
+    def human_latency
+      ActiveSupport::Duration.build(latency).inspect
+    end
+
+    def ==(other)
+      name == (other.respond_to?(:name) ? other.name : other)
+    end
+    alias eql? ==
+
+    def hash
+      name.hash
+    end
+  end
+end

data/lib/solid_queue_mongoid/models/queue_selector.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+module SolidQueue
+  # Mirrors SolidQueue::QueueSelector but uses Mongo queries for wildcard resolution.
+  class QueueSelector
+    attr_reader :raw_queues, :relation
+
+    def initialize(queue_list, relation)
+      @raw_queues = Array(queue_list).map { |q| q.to_s.strip }.presence || ["*"]
+      @relation = relation
+    end
+
+    # Returns an array of Mongoid criteria scoped to individual queue names,
+    # or a single all/none criteria when appropriate.
+    def scoped_relations
+      if all?
+        [relation.all]
+      elsif none?
+        []
+      else
+        queue_names.map { |queue_name| relation.queued_as(queue_name) }
+      end
+    end
+
+    private
+
+    def all?
+      include_all_queues? && paused_queues.empty?
+    end
+
+    def none?
+      queue_names.empty?
+    end
+
+    def queue_names
+      @queue_names ||= eligible_queues - paused_queues
+    end
+
+    def eligible_queues
+      if include_all_queues?
+        all_queues
+      else
+        in_raw_order(exact_names + prefixed_names)
+      end
+    end
+
+    def include_all_queues?
+      raw_queues.include?("*")
+    end
+
+    # Pull all distinct queue names currently present in this relation.
+    def all_queues
+      relation.distinct(:queue_name)
+    end
+
+    def exact_names
+      raw_queues.select { |q| exact_name?(q) }
+    end
+
+    def prefixed_names
+      return [] if prefixes.empty?
+
+      prefixes.flat_map do |prefix|
+        # Use anchored regex for mongo prefix match
+        relation.where(queue_name: /\A#{Regexp.escape(prefix)}/).distinct(:queue_name)
+      end.uniq
+    end
+
+    def prefixes
+      @prefixes ||= raw_queues.select { |q| prefixed_name?(q) }.map { |q| q.chomp("*") }
+    end
+
+    def exact_name?(queue)
+      !queue.include?("*")
+    end
+
+    def prefixed_name?(queue)
+      queue.end_with?("*")
+    end
+
+    def paused_queues
+      @paused_queues ||= Pause.all.pluck(:queue_name)
+    end
+
+    def in_raw_order(queues)
+      return queues if queues.size <= 1 || prefixes.empty?
+
+      queues = queues.dup
+      raw_queues.flat_map { |raw| delete_in_order(raw, queues) }.compact
+    end
+
+    def delete_in_order(raw_queue, queues)
+      if exact_name?(raw_queue)
+        queues.delete(raw_queue)
+      elsif prefixed_name?(raw_queue)
+        prefix = raw_queue.chomp("*")
+        queues.select { |q| q.start_with?(prefix) }.tap { |matches| queues -= matches }
+      end
+    end
+  end
+end

data/lib/solid_queue_mongoid/models/ready_execution.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+module SolidQueue
+  class ReadyExecution < Execution
+    assumes_attributes_from_job # inherits queue_name and priority
+
+    scope :queued_as, ->(queue_name) { where(queue_name: queue_name) }
+
+    index({ queue_name: 1, priority: 1, created_at: 1 })
+
+    class << self
+      # Primary entry point called by SolidQueue::Worker.
+      # Atomically claims up to +limit+ executions from +queue_list+ for +process_id+.
+      def claim(queue_list, limit, process_id)
+        QueueSelector.new(queue_list, self).scoped_relations.flat_map do |queue_relation|
+          select_and_lock(queue_relation, process_id, limit).tap do |locked|
+            limit -= locked.size
+          end
+        end
+      end
+
+      # Integration spec compatible wrapper:
+      #   claim_batch(limit, process:, queues:)
+      def claim_batch(limit, process:, queues: "*")
+        claim(queues, limit, process.id)
+      end
+
+      # Called by Worker#all_work_completed?.
+      def aggregated_count_across(queue_list)
+        QueueSelector.new(queue_list, self).scoped_relations.sum(&:count)
+      end
+
+      private
+
+      # Atomically remove a ReadyExecution and create a ClaimedExecution.
+      # Uses findOneAndDelete for each slot to guarantee no double-claim.
+      def select_and_lock(queue_relation, process_id, limit)
+        return [] if limit <= 0
+
+        claimed = []
+        ClaimedExecution.claiming(
+          select_candidates(queue_relation, limit),
+          process_id
+        ) do |claimed_set|
+          claimed = claimed_set
+        end
+        claimed
+      end
+
+      def select_candidates(queue_relation, limit)
+        job_ids = []
+        limit.times do
+          raw = queue_relation.collection.find_one_and_delete(
+            queue_relation.selector,
+            sort: { "priority" => -1, "created_at" => 1 }
+          )
+          break unless raw
+
+          job_ids << raw["job_id"]
+        end
+        job_ids
+      end
+
+      def discard_jobs(job_ids)
+        Job.release_all_concurrency_locks(Job.where(:id.in => job_ids).to_a)
+        Job.where(:id.in => job_ids).delete_all
+      end
+    end
+  end
+end

data/lib/solid_queue_mongoid/models/record.rb

@@ -0,0 +1,147 @@
+# frozen_string_literal: true
+
+module SolidQueue
+  class Record
+    include Mongoid::Document
+    include Mongoid::Timestamps
+
+    # Subclasses declare their MySQL index name → MongoDB field spec mappings here.
+    INDEX_HINTS = {}.freeze
+
+    # Override Mongoid's index_specifications to use per-class instance variables
+    # instead of the shared cattr_accessor class variable.
+    # This prevents index cross-contamination between models.
+    class << self
+      def index_specifications
+        @index_specifications ||= []
+      end
+
+      def index_specifications=(val)
+        @_sq_index_specs = val
+      end
+
+      # Override Mongoid's index() to use our per-class storage.
+      def index(spec, options = nil)
+        specification = Mongoid::Indexable::Specification.new(self, spec, options)
+        return if index_specifications.include?(specification)
+
+        index_specifications.push(specification)
+      end
+    end
+
+    # Dynamic collection naming with prefix
+    def self.inherited(subclass)
+      super
+
+      collection_name = subclass.name.demodulize.tableize
+      prefixed_name = "#{SolidQueue.collection_prefix}#{collection_name}"
+
+      subclass.store_in collection: prefixed_name, client: -> { SolidQueue.client.to_s }
+
+      # Each subclass gets its own empty index_specifications array.
+      # Indexes must be explicitly defined in each subclass (not inherited from parent)
+      # because Mongoid::Indexable::Specification stores a reference to the klass,
+      # and copying parent specs would create indexes on the parent's collection.
+      subclass.instance_variable_set(:@_sq_index_specs, [])
+    end
+
+    class << self
+      # MongoDB has no row-level locking; this is a no-op stub so SolidQueue
+      # code that chains .non_blocking_lock still works.
+      def non_blocking_lock
+        all
+      end
+
+      # Translate solid_queue MySQL index names to MongoDB hint specs and apply
+      # via Mongoid's .hint(). Unknown names are ignored (no hint applied).
+      # Subclasses may override INDEX_HINTS to register their own mappings.
+      def use_index(*indexes)
+        specs = indexes.filter_map do |name|
+          name.is_a?(Hash) ? name : self::INDEX_HINTS[name.to_sym]
+        end
+        specs.any? ? hint(specs.first) : all
+      end
+
+      # MongoDB supports unique indexes which serve the same purpose.
+      def supports_insert_conflict_target?
+        true
+      end
+
+      # Mongoid 9 supports multi-document transactions via replica sets.
+      # We wrap in a MongoDB session transaction when available; fall back to a
+      # plain yield for non-replica-set environments (e.g. tests with a standalone).
+      def transaction(_requires_new: false, &block)
+        Mongoid::QueryCache.clear_cache
+        Mongoid.default_client.with_session do |session|
+          session.start_transaction
+          result = yield
+          session.commit_transaction
+          result
+        end
+      rescue Mongo::Error::InvalidSession, Mongo::Error::OperationFailure => e
+        # Not in a replica set or session not supported — execute without transaction
+        raise if e.message.to_s.include?("Transaction numbers are only allowed")
+
+        yield
+      rescue StandardError
+        yield
+      end
+
+      # Mongoid equivalent of ActiveRecord's create_or_find_by!.
+      # Tries to create; on duplicate-key error or uniqueness validation error
+      # finds the existing record. Falls back to finding by job_id alone when
+      # the full attrs lookup would miss the existing record (e.g. queue_name
+      # is not in attrs but was set via a before_create callback).
+      def create_or_find_by!(attrs, &block)
+        record = new(attrs)
+        block.call(record) if block_given?
+        record.save!
+        record
+      rescue Mongoid::Errors::Validations => e
+        # If the only errors are uniqueness-related, fall back to find the existing record
+        raise unless uniqueness_only_error?(e.document)
+
+        find_by_unique_key(attrs) || where(attrs).first || record
+      rescue Mongo::Error::OperationFailure => e
+        raise unless duplicate_key_error?(e)
+
+        find_by_unique_key(attrs) || where(attrs).first || raise(e)
+      end
+
+      # find_by that raises Mongoid::Errors::DocumentNotFound when missing.
+      def find_by!(attrs)
+        find_by(attrs) || raise(Mongoid::Errors::DocumentNotFound.new(self, attrs))
+      end
+
+      private
+
+      def duplicate_key_error?(err)
+        msg = err.respond_to?(:message) ? err.message.to_s : err.to_s
+        msg.include?("E11000") || msg.include?("duplicate key")
+      end
+
+      # Try to find an existing record using just the unique key field(s).
+      # Used as fallback when find_by(full_attrs) misses because some fields
+      # (e.g. queue_name) are only set by callbacks, not passed in attrs.
+      # Uses where().first to avoid DocumentNotFound exceptions.
+      def find_by_unique_key(attrs)
+        return where(job_id: attrs[:job_id]).first if attrs[:job_id]
+        return where(key: attrs[:key]).first if attrs[:key]
+
+        nil
+      end
+
+      def uniqueness_only_error?(document)
+        return false unless document.respond_to?(:errors)
+
+        document.errors.all? do |error|
+          error.type == :taken || error.message.to_s.include?("already been taken") ||
+            (error.attribute.to_s != "base" &&
+              document.class.validators
+                      .select { |v| v.is_a?(Mongoid::Validatable::UniquenessValidator) }
+                      .any? { |v| v.attributes.include?(error.attribute.to_sym) })
+        end
+      end
+    end
+  end
+end

data/lib/solid_queue_mongoid/models/recurring_execution.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module SolidQueue
+  class RecurringExecution < Record
+    class AlreadyRecorded < StandardError; end
+
+    field :task_key, type: String
+    field :run_at, type: Time
+
+    # optional: job may have been purged already
+    belongs_to :job, class_name: "SolidQueue::Job", optional: true
+
+    index({ task_key: 1, run_at: 1 }, { unique: true })
+    index({ job_id: 1 })
+
+    # Clearable when the associated job no longer exists.
+    scope :clearable, lambda {
+      existing_job_ids = SolidQueue::Job.all.pluck(:id)
+      where(:job_id.nin => existing_job_ids).or(job_id: nil)
+    }
+
+    class << self
+      # Called by RecurringTask#enqueue_and_record.
+      # Wraps the block; records the execution only if the job was successfully enqueued.
+      def record(task_key, run_at, &block)
+        Mongoid.transaction do
+          block.call.tap do |active_job|
+            if active_job&.successfully_enqueued?
+              create_or_insert!(
+                task_key: task_key,
+                run_at: run_at,
+                job_id: active_job.provider_job_id
+              )
+            end
+          end
+        end
+      end
+
+      # Atomic insert — raises AlreadyRecorded on duplicate (same task_key + run_at).
+      def create_or_insert!(task_key:, run_at:, job_id: nil)
+        create!(task_key: task_key, run_at: run_at, job_id: job_id)
+      rescue Mongoid::Errors::Validations, Mongo::Error::OperationFailure => e
+        raise AlreadyRecorded if duplicate_key_error?(e)
+
+        raise
+      end
+
+      def clear_in_batches(batch_size: 500)
+        loop do
+          deleted = clearable.limit(batch_size).delete_all
+          break if deleted.zero?
+        end
+      end
+
+      private
+
+      def duplicate_key_error?(err)
+        err.message.to_s.include?("E11000") || err.message.to_s.include?("duplicate key")
+      end
+    end
+  end
+end

data/lib/solid_queue_mongoid/models/recurring_task/arguments.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require "active_job/serializers"
+require "active_job/arguments"
+
+module SolidQueue
+  class RecurringTask
+    # Serializer for recurring task arguments — stores as an ActiveJob-serialized
+    # JSON array in MongoDB. Matches solid_queue 1.3.2 RecurringTask::Arguments exactly.
+    module Arguments
+      class << self
+        # Called when writing to MongoDB: serialize ActiveJob arguments to an Array.
+        def mongoize(data)
+          data.nil? ? [] : ActiveJob::Arguments.serialize(Array(data))
+        end
+
+        # Called when reading from MongoDB: deserialize back to Ruby objects.
+        def demongoize(data)
+          data.nil? ? [] : ActiveJob::Arguments.deserialize(Array(data))
+        end
+
+        # Called for query conditions.
+        def evolve(data)
+          mongoize(data)
+        end
+      end
+    end
+  end
+end