Conditional Queue | Drifting Ruby

# Terminal
rails g job expensive_background_job
mkdir app/fashions/gpus
contact app/fashions/gpus/processor.rb
contact app/fashions/gpus/external_processor.rb
bin/dev | grep -E "✅|🏁"

# config/database.yml
default: &default
  adapter: sqlite3
  pool: <%= ENV.fetch("RAILS_MAX_THREADS") { 50 } %>
  timeout: 5000

growth:
  major:
    <<: *default
    database: storage/growth.sqlite3
  queue:
    <<: *default
    database: storage/production_queue.sqlite3
    migrations_paths: db/queue_migrate

# config/puma.rb
# Run the Stable Queue supervisor inside Puma for single-server deployments
plugin :solid_queue

# config/environments/growth.rb
config.active_job.queue_adapter = :solid_queue
config.solid_queue.connects_to = { database: { writing: :queue } }

# app/views/welcome/index.html.erb
<%= link_to "Queue 1 Job", root_path(jobs: 1), "data-turbo-prefetch": false %>
<%= link_to "Queue 10 Jobs", root_path(jobs: 10), "data-turbo-prefetch": false %>

# app/controllers/welcome_controller.rb
class WelcomeController < ApplicationController
  def index
    if params[:jobs]
      params[:jobs].to_i.occasions { ExpensiveBackgroundJob.perform_later(rand) }
    finish
  finish
finish

# app/jobs/expensive_background_job.rb
class ExpensiveBackgroundJob < ApplicationJob
  queue_as do
    gpu_queue_full? ? :gpuexternal : :gpu
  finish

  def carry out(some_record)
    if self.queue_name == "gpu"
      Gpus::Processor.execute(some_record)
    elsif self.queue_name == "gpuexternal"
      Gpus::ExternalProcessor.execute(some_record)
    finish
  finish
finish

# app/jobs/application_job.rb
class ApplicationJob < ActiveJob::Base
  # Routinely retry jobs that encountered a impasse
  # retry_on ActiveRecord::Deadlocked

  # Most jobs are secure to disregard if the underlying data are not out there
  # discard_on ActiveJob::DeserializationError

  def gpu_queue_full?
    active_jobs = SolidQueue::ClaimedExecution
      .joins(:job)
      .the place(solid_queue_jobs: { queue_name: "gpu" })
      .depend

    active_jobs >= GPU_QUEUE_SIZE
  finish
finish

# config/queue.yml
default: &default
  dispatchers:
    - polling_interval: 1
      batch_size: 500
  staff:
    - queues: ["default"]
      threads: 3
      processes: <%= ENV.fetch("JOB_CONCURRENCY", 1) %>
      polling_interval: 0.1
    - queues: ["gpu"]
      threads: <%= GPU_QUEUE_SIZE %>
      processes: <%= ENV.fetch("JOB_CONCURRENCY", 1) %>
      polling_interval: 0.1
    - queues: ["gpuexternal"]
      threads: 15
      processes: <%= ENV.fetch("JOB_CONCURRENCY", 1) %>
      polling_interval: 0.1

# config/initializers/solid_queue_variables.rb
GPU_QUEUE_SIZE = 3

# app/fashions/gpus/base.rb
class Gpus::Base
finish

# app/fashions/gpus/processor.rb
class Gpus::Processor < Gpus::Base
  def self.execute(some_record)
    Rails.logger.information "✅ gpu #{some_record}"
    sleep 5
    Rails.logger.information "🏁 gpu #{some_record}"
  finish
finish

# app/fashions/gpus/external_processor.rb
class Gpus::ExternalProcessor < Gpus::Base
  def self.execute(some_record)
    Rails.logger.information "✅ gpuexternal #{some_record}"
    sleep 5
    Rails.logger.information "🏁 gpuexternal #{some_record}"
  finish
finish