rust_on_background 0.1.1

data/lib/generators/install/templates/main.rs

@@ -0,0 +1,144 @@
+mod worker;
+mod jobs;
+mod scheduler;
+
+use std::sync::Arc;
+use clap::Parser;
+use serde::Deserialize;
+use tokio::sync::watch;
+
+#[derive(Parser, Debug)]
+#[command(author, version, about)]
+struct Args {
+    #[arg(short, long)]
+    config: String,
+
+    #[arg(short, long)]
+    workers: usize,
+
+    #[arg(short, long)]
+    queue: String,
+
+    #[arg(long, default_value = "false")]
+    scheduler: bool,
+}
+
+#[derive(Debug, Deserialize)]
+struct Config {
+    database: DatabaseConfig,
+    redis: RedisConfig,
+    #[serde(default)]
+    scheduler: SchedulerConfig,
+}
+
+#[derive(Debug, Deserialize)]
+struct DatabaseConfig {
+    url: String,
+}
+
+#[derive(Debug, Deserialize)]
+struct RedisConfig {
+    url: String,
+}
+
+#[derive(Debug, Clone, Deserialize)]
+pub struct SchedulerConfig {
+    #[serde(default = "default_poll_interval")]
+    pub poll_interval_ms: u64,
+    #[serde(default = "default_batch_size")]
+    pub batch_size: i64,
+}
+
+fn default_poll_interval() -> u64 { 1000 }
+fn default_batch_size() -> i64 { 100 }
+
+impl Default for SchedulerConfig {
+    fn default() -> Self {
+        Self {
+            poll_interval_ms: default_poll_interval(),
+            batch_size: default_batch_size(),
+        }
+    }
+}
+
+impl Config {
+    fn load(path: &str) -> Result<Self, Box<dyn std::error::Error>> {
+        let content = std::fs::read_to_string(path).unwrap_or_else(|e| {
+            panic!(
+                "\n\nFailed to load config file: {}\nError: {}\n\nMake sure the config file exists. Run: rails generate rust_on_background:install\n",
+                path, e
+            )
+        });
+        let config: Config = toml::from_str(&content)?;
+        Ok(config)
+    }
+}
+
+#[tokio::main]
+async fn main() -> Result<(), Box<dyn std::error::Error>> {
+    tracing_subscriber::fmt()
+        .with_env_filter(
+            tracing_subscriber::EnvFilter::from_default_env().add_directive("rust_on_background=info".parse()?)
+        ).init();
+
+    let args = Args::parse();
+    let config = Config::load(&args.config)?;
+
+    let worker_count = args.workers;
+    let queue_name = args.queue;
+
+    let redis_url = Arc::new(config.redis.url.clone());
+    let database_url = Arc::new(config.database.url.clone());
+    let queue_name = Arc::new(format!("queue:{}", queue_name));
+
+    tracing::info!("Starting {} workers on {}", worker_count, queue_name);
+
+    let (shutdown_tx, shutdown_rx) = watch::channel(false);
+    let mut handles = Vec::new();
+
+    // Spawn scheduler if enabled (only one instance should run per Redis)
+    if args.scheduler {
+        let redis_url = Arc::clone(&redis_url);
+        let scheduler_config = config.scheduler.clone();
+        let shutdown_rx = shutdown_rx.clone();
+
+        let handle = tokio::spawn(async move {
+            tracing::info!("Starting scheduler");
+            if let Err(e) = scheduler::run(redis_url, scheduler_config, shutdown_rx).await {
+                tracing::error!("Scheduler error: {}", e);
+            }
+            tracing::info!("Scheduler stopped");
+        });
+
+        handles.push(handle);
+    }
+
+    for i in 0..worker_count {
+        let redis_url = Arc::clone(&redis_url);
+        let database_url = Arc::clone(&database_url);
+        let queue_name = Arc::clone(&queue_name);
+        let shutdown_rx = shutdown_rx.clone();
+
+        let handle = tokio::spawn(async move {
+            tracing::info!("Worker {} started", i);
+            if let Err(e) = worker::run(i, redis_url, database_url, queue_name, shutdown_rx).await {
+                tracing::error!("Worker {} error: {}", i, e);
+            }
+            tracing::info!("Worker {} stopped", i);
+        });
+
+        handles.push(handle);
+    }
+
+    tokio::signal::ctrl_c().await?;
+    tracing::info!("Shutdown signal received, stopping workers.");
+
+    shutdown_tx.send(true)?;
+
+    for handle in handles {
+        let _ = handle.await;
+    }
+
+    tracing::info!("All workers stopped");
+    Ok(())
+}

data/lib/generators/install/templates/rust_on_background.rake

@@ -0,0 +1,215 @@
+# frozen_string_literal: true
+
+require "toml-rb"
+
+namespace :rust_on_background do
+  RUST_DIR = Rails.root.join("app/jobs/rust")
+  PID_DIR = Rails.root.join("tmp/pids")
+
+  def config_file
+    RUST_DIR.join("config.#{Rails.env}.toml")
+  end
+
+  def config
+    @config ||= TomlRB.load_file(config_file)
+  end
+
+  def queues
+    config["queues"] || [{ "name" => "default", "workers" => 4 }]
+  end
+
+  def log_file
+    path = config.dig("logging", "path")
+    return "/dev/null" if path.nil? || path.empty?
+
+    file = Rails.root.join(path)
+    FileUtils.mkdir_p(File.dirname(file))
+    file
+  end
+
+  def pid_file(queue)
+    PID_DIR.join("#{queue}_#{Rails.env}.pid")
+  end
+
+  def running?(queue)
+    file = pid_file(queue)
+    return false unless File.exist?(file)
+    pid = File.read(file).strip.to_i
+    Process.kill(0, pid)
+    true
+  rescue Errno::ESRCH, Errno::ENOENT
+    false
+  end
+
+  def running_queues
+    pattern = "*_#{Rails.env}.pid"
+    Dir.glob(PID_DIR.join(pattern)).map do |f|
+      File.basename(f, ".pid").sub("_#{Rails.env}", "")
+    end
+  end
+
+  desc "Build Rust worker (release mode)"
+  task :build do
+    Dir.chdir(RUST_DIR) do
+      puts "Building Rust worker..."
+      system("cargo build --release") || abort("Build failed")
+      puts "Build complete"
+    end
+  end
+
+  desc "Start Rust workers"
+  task :start, [:queue] do |_t, args|
+    binary = RUST_DIR.join("target/release/rust_on_background")
+    abort "Worker not built. Run: rake rust_on_background:build" unless File.exist?(binary)
+
+    FileUtils.mkdir_p(PID_DIR)
+
+    to_start = args[:queue] ? [queues.find { |q| q["name"] == args[:queue] }].compact : queues
+    abort "Queue '#{args[:queue]}' not found in #{config_file}" if to_start.empty?
+
+    to_start.each do |q|
+      queue = q["name"]
+      workers = q["workers"]
+
+      if running?(queue)
+        puts "Queue '#{queue}': already running (PID: #{File.read(pid_file(queue)).strip})"
+        next
+      end
+
+      Dir.chdir(RUST_DIR) do
+        cmd = [binary.to_s, "--config", config_file.to_s, "--queue", queue, "--workers", workers.to_s]
+        log = File.open(log_file, "a")
+        pid = spawn(*cmd, out: log, err: log)
+        Process.detach(pid)
+        File.write(pid_file(queue), pid.to_s)
+        puts "Queue '#{queue}': started (PID: #{pid}, workers: #{workers})"
+      end
+    end
+  end
+
+  desc "Stop Rust workers"
+  task :stop, [:queue] do |_t, args|
+    to_stop = args[:queue] ? [args[:queue]] : running_queues
+
+    if to_stop.empty?
+      puts "No workers running"
+      next
+    end
+
+    to_stop.each do |queue|
+      file = pid_file(queue)
+      unless File.exist?(file)
+        puts "Queue '#{queue}': not running"
+        next
+      end
+
+      pid = File.read(file).strip.to_i
+      begin
+        Process.kill("TERM", pid)
+        File.delete(file)
+        puts "Queue '#{queue}': stopped, PID: #{pid}"
+      rescue Errno::ESRCH
+        File.delete(file)
+        puts "Queue '#{queue}': was not running (stale PID removed)"
+      end
+    end
+  end
+
+  desc "Restart Rust workers"
+  task :restart, [:queue] do |_t, args|
+    Rake::Task["rust_on_background:stop"].invoke(args[:queue])
+    Rake::Task["rust_on_background:stop"].reenable
+    Rake::Task["rust_on_background:start"].invoke(args[:queue])
+    Rake::Task["rust_on_background:start"].reenable
+  end
+
+  desc "Build and start Rust workers"
+  task :run do
+    Rake::Task["rust_on_background:build"].invoke
+    Rake::Task["rust_on_background:start"].invoke
+  end
+
+  desc "Stop, rebuild and start Rust workers"
+  task :rebuild do
+    Rake::Task["rust_on_background:stop"].invoke
+    Rake::Task["rust_on_background:build"].invoke
+    Rake::Task["rust_on_background:start"].invoke
+  end
+
+  desc "Check Rust worker status"
+  task :status do
+    binary = RUST_DIR.join("target/release/rust_on_background")
+
+    puts "Environment: #{Rails.env}"
+    puts "Config: #{config_file}"
+
+    if File.exist?(binary)
+      puts "Binary: built (#{File.mtime(binary).strftime('%Y-%m-%d %H:%M')})"
+    else
+      puts "Binary: not built"
+    end
+
+    puts ""
+    puts "Scheduler:"
+    scheduler_status = running?("scheduler") ? "running PID: #{File.read(pid_file("scheduler")).strip}" : "stopped"
+    puts "#{scheduler_status}"
+
+    puts ""
+    puts "Configured queues:"
+    queues.each do |q|
+      status = running?(q["name"]) ? "running (PID: #{File.read(pid_file(q["name"])).strip})" : "stopped"
+      puts "  #{q["name"]}: #{q["workers"]} workers - #{status}"
+    end
+  end
+
+  namespace :scheduler do
+    desc "Start the scheduler (only run one instance per Redis)"
+    task :start do
+      binary = RUST_DIR.join("target/release/rust_on_background")
+      abort "Worker not built. Run: rake rust_on_background:build" unless File.exist?(binary)
+
+      FileUtils.mkdir_p(PID_DIR)
+
+      if running?("scheduler")
+        puts "Scheduler already running (PID: #{File.read(pid_file("scheduler")).strip})"
+        next
+      end
+
+      Dir.chdir(RUST_DIR) do
+        cmd = [binary.to_s, "--config", config_file.to_s, "--queue", "default", "--workers", "0", "--scheduler"]
+        log = File.open(log_file, "a")
+        pid = spawn(*cmd, out: log, err: log)
+        Process.detach(pid)
+        File.write(pid_file("scheduler"), pid.to_s)
+        puts "Scheduler started (PID: #{pid})"
+      end
+    end
+
+    desc "Stop the scheduler"
+    task :stop do
+      file = pid_file("scheduler")
+      unless File.exist?(file)
+        puts "Scheduler not running"
+        next
+      end
+
+      pid = File.read(file).strip.to_i
+      begin
+        Process.kill("TERM", pid)
+        File.delete(file)
+        puts "Scheduler stopped, PID: #{pid}"
+      rescue Errno::ESRCH
+        File.delete(file)
+        puts "Scheduler was not running"
+      end
+    end
+
+    desc "Restart the scheduler"
+    task :restart do
+      Rake::Task["rust_on_background:scheduler:stop"].invoke
+      Rake::Task["rust_on_background:scheduler:stop"].reenable
+      Rake::Task["rust_on_background:scheduler:start"].invoke
+      Rake::Task["rust_on_background:scheduler:start"].reenable
+    end
+  end
+end

data/lib/generators/install/templates/scheduler.rs

@@ -0,0 +1,135 @@
+use std::sync::Arc;
+use tokio::sync::watch;
+use redis::AsyncCommands;
+use serde::Deserialize;
+use thiserror::Error;
+use crate::SchedulerConfig;
+
+#[derive(Error, Debug)]
+pub enum SchedulerError {
+    #[error("Redis error: {0}")]
+    Redis(#[from] redis::RedisError),
+
+    #[error("JSON error: {0}")]
+    Json(#[from] serde_json::Error),
+}
+
+#[derive(Debug, Clone, Deserialize)]
+struct ScheduledJob {
+    job: String,
+    args: serde_json::Value,
+    #[serde(default = "default_retry")]
+    retry: u32,
+    created_at: i64,
+    queue: String,
+    #[serde(default)]
+    scheduled_at: Option<i64>
+}
+
+fn default_retry() -> u32 { 3 }
+
+const SCHEDULE_KEY: &str = "rust_on_background:schedule";
+
+// Lua script for atomic remove-and-enqueue
+const ENQUEUE_SCRIPT: &str = r#"
+    local removed = redis.call('ZREM', KEYS[1], ARGV[1])
+    if removed == 1 then
+        redis.call('LPUSH', KEYS[2], ARGV[2])
+        return 1
+    end
+    return 0
+"#;
+
+pub async fn run(redis_url: Arc<String>, config: SchedulerConfig, mut shutdown_rx: watch::Receiver<bool>) -> Result<(), SchedulerError> {
+    let client = redis::Client::open(redis_url.as_str())?;
+    let mut conn = client.get_multiplexed_async_connection().await?;
+
+    tracing::info!("Scheduler started, polling {} every {}ms (batch size: {})", SCHEDULE_KEY, config.poll_interval_ms, config.batch_size);
+
+    loop {
+        tokio::select! {
+            result = poll_and_enqueue(&mut conn, config.batch_size) => {
+                if let Err(e) = result {
+                    tracing::error!("Scheduler error: {}", e);
+                    tokio::time::sleep(tokio::time::Duration::from_secs(5)).await;
+                }
+            }
+            _ = shutdown_rx.changed() => {
+                tracing::info!("Scheduler shutting down");
+                break;
+            }
+        }
+
+        tokio::time::sleep(tokio::time::Duration::from_millis(config.poll_interval_ms)).await;
+    }
+
+    Ok(())
+}
+
+async fn poll_and_enqueue(
+    conn: &mut redis::aio::MultiplexedConnection,
+    batch_size: i64,
+) -> Result<(), SchedulerError> {
+    let now = std::time::SystemTime::now()
+        .duration_since(std::time::UNIX_EPOCH)
+        .unwrap()
+        .as_secs_f64();
+
+    // Get all due jobs
+    let jobs: Vec<String> = redis::cmd("ZRANGEBYSCORE")
+        .arg(SCHEDULE_KEY)
+        .arg("-inf")
+        .arg(now)
+        .arg("LIMIT")
+        .arg(0)
+        .arg(batch_size)
+        .query_async(conn)
+        .await?;
+
+    if jobs.is_empty() {
+        return Ok(());
+    }
+
+    tracing::debug!("Found {} scheduled jobs ready for processing", jobs.len());
+
+    let script = redis::Script::new(ENQUEUE_SCRIPT);
+
+    for job_json in jobs {
+        let scheduled_job: ScheduledJob = match serde_json::from_str(&job_json) {
+            Ok(job) => job,
+            Err(e) => { // Remove malformed job from schedule
+                tracing::error!("Failed to parse scheduled job: {}", e);
+                let _: () = conn.zrem(SCHEDULE_KEY, &job_json).await?;
+                continue;
+            }
+        };
+
+        let queue_key = format!("queue:{}", scheduled_job.queue);
+
+        // Convert to regular job payload - remove scheduling fields
+        let job_payload = serde_json::json!({
+            "job": scheduled_job.job,
+            "args": scheduled_job.args,
+            "retry": scheduled_job.retry,
+            "created_at": scheduled_job.created_at,
+        });
+
+        let result: i32 = script
+            .key(SCHEDULE_KEY)
+            .key(&queue_key)
+            .arg(&job_json)
+            .arg(job_payload.to_string())
+            .invoke_async(conn)
+            .await?;
+
+        if result == 1 {
+            tracing::info!(
+                "Enqueued scheduled job '{}' to queue '{}'",
+                scheduled_job.job,
+                scheduled_job.queue
+            );
+        }
+    }
+
+    Ok(())
+}

data/lib/generators/install/templates/worker.rs

@@ -0,0 +1,140 @@
+use std::sync::Arc;
+use tokio::sync::watch;
+use redis::AsyncCommands;
+use serde::{Deserialize, Serialize};
+use thiserror::Error;
+
+#[derive(Error, Debug)]
+pub enum WorkerError {
+    #[error("Redis error: {0}")]
+    Redis(#[from] redis::RedisError),
+
+    #[error("JSON error: {0}")]
+    Json(#[from] serde_json::Error),
+
+    #[error("Job error: {0}")]
+    Job(String),
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct Job {
+    pub job: String,
+    pub args: serde_json::Value,
+    #[serde(default = "default_retry")]
+    pub retry: u32,
+    pub created_at: i64,
+}
+
+fn default_retry() -> u32 { 3 }
+
+#[derive(Debug)]
+pub enum JobResult {
+    Success,
+    Retry(String),
+    Failed(String),
+}
+
+pub async fn run(
+    worker_id: usize,
+    redis_url: Arc<String>,
+    database_url: Arc<String>,
+    queue_name: Arc<String>,
+    mut shutdown_rx: watch::Receiver<bool>,
+) -> Result<(), WorkerError> {
+    let client = redis::Client::open(redis_url.as_str())?;
+    let mut conn = client.get_multiplexed_async_connection().await?;
+
+    tracing::info!("Worker {} connected to Redis, listening on queue: {}", worker_id, queue_name);
+
+    loop {
+        if *shutdown_rx.borrow() {
+            break;
+        }
+
+        tokio::select! {
+            result = pop_job(&mut conn, &queue_name) => {
+                match result {
+                    Ok(Some(job_json)) => {
+                        process_job(&job_json, &database_url, &queue_name, &mut conn).await;
+                    }
+                    Ok(None) => {}
+                    Err(e) => {
+                        tracing::error!("Worker {} Redis error: {}", worker_id, e);
+                        tokio::time::sleep(tokio::time::Duration::from_secs(1)).await;
+                    }
+                }
+            }
+            _ = shutdown_rx.changed() => {
+                tracing::info!("Worker {} received shutdown signal", worker_id);
+                break;
+            }
+        }
+    }
+
+    Ok(())
+}
+
+async fn pop_job(
+    conn: &mut redis::aio::MultiplexedConnection,
+    queue_name: &str,
+) -> Result<Option<String>, WorkerError> {
+    let result: Option<(String, String)> = redis::cmd("BLPOP").arg(queue_name).arg(1.0).query_async(conn).await?;
+
+    Ok(result.map(|(_, value)| value))
+}
+
+async fn process_job(
+    job_json: &str,
+    database_url: &str,
+    queue_name: &str,
+    conn: &mut redis::aio::MultiplexedConnection,
+) {
+    let failed_queue = format!("{}:failed", queue_name);
+
+    let job: Job = match serde_json::from_str(job_json) {
+        Ok(job) => job,
+        Err(e) => {
+            tracing::error!("Failed to parse job JSON: {}", e);
+            let _ = push_to_queue(conn, &failed_queue, job_json).await;
+            return;
+        }
+    };
+
+    tracing::info!("Processing job: {} (retries left: {})", job.job, job.retry);
+
+    let result = crate::jobs::dispatch(&job, database_url).await;
+
+    match result {
+        JobResult::Success => {
+            tracing::info!("Job {} completed successfully", job.job);
+        }
+        JobResult::Retry(reason) => {
+            if job.retry > 0 {
+                tracing::warn!("Job {} will retry: {}", job.job, reason);
+                let retry_job = Job {
+                    retry: job.retry - 1,
+                    ..job
+                };
+                if let Ok(retry_json) = serde_json::to_string(&retry_job) {
+                    let _ = push_to_queue(conn, queue_name, &retry_json).await;
+                }
+            } else {
+                tracing::error!("Job {} failed after all retries: {}", job.job, reason);
+                let _ = push_to_queue(conn, &failed_queue, job_json).await;
+            }
+        }
+        JobResult::Failed(reason) => {
+            tracing::error!("Job {} failed: {}", job.job, reason);
+            let _ = push_to_queue(conn, &failed_queue, job_json).await;
+        }
+    }
+}
+
+async fn push_to_queue(
+    conn: &mut redis::aio::MultiplexedConnection,
+    queue_name: &str,
+    job_json: &str,
+) -> Result<(), WorkerError> {
+    conn.lpush::<_, _, ()>(queue_name, job_json).await?;
+    Ok(())
+}