capy-framework 0.10.0

An opinionated full-stack Rust web framework with strong conventions and sensible defaults.
Documentation
use crate::{AppConfig, AppContext, AppError, Result, Services};
use capy_jobs::{Jobs, Queue, QueueName, Worker};
use std::sync::Arc;

pub(crate) async fn run(
    command: &str,
    args: &[String],
    mut config: AppConfig,
    jobs: Jobs,
    services: Services,
) -> Result<()> {
    jobs.validate()?;
    let mut queues = Vec::new();
    let mut id = None;
    match command {
        "queue:work" => {
            let mut args = args.iter();
            let mut concurrency = false;
            while let Some(flag) = args.next() {
                let value = args.next().ok_or_else(usage)?;
                match flag.as_str() {
                    "--queue" => queues.push(QueueName::new(value.clone())?),
                    "--concurrency" if !concurrency => {
                        config.jobs.concurrency = value.parse().map_err(|_| usage())?;
                        concurrency = true;
                    }
                    _ => return Err(usage()),
                }
            }
        }
        "queue:failed" | "queue:check" if args.is_empty() => {}
        "queue:retry" | "queue:forget" if args.len() == 1 => {
            id = Some(args[0].as_str());
        }
        _ => return Err(usage()),
    }
    config.validate()?;
    config.jobs.validate_database(&config.database)?;
    crate::app::init_logging(&config);
    let db = capy_db::connect(&config.database).await?;
    let queue = Queue::new(db.clone());
    match command {
        "queue:work" => {
            let mut worker = Worker::new(
                AppContext {
                    db,
                    config: Arc::new(config),
                },
                jobs,
            )?
            .with_services(services);
            if !queues.is_empty() {
                worker = worker.queues(queues)?;
            }
            worker.run(crate::app::shutdown_signal()).await?;
        }
        "queue:failed" => {
            println!("ID  JOB  VERSION  QUEUE  ATTEMPTS  FAILED_AT_MS  CATEGORY  ERROR");
            for job in queue.failed(100).await? {
                println!(
                    "{}  {}  {}  {}  {}  {}  {}  {}",
                    job.id,
                    job.job_type,
                    job.version,
                    job.queue,
                    job.attempts,
                    job.failed_at,
                    job.error_category,
                    job.last_error
                );
            }
            println!("Showing at most 100 oldest failures; inspect older/larger history through the database or Queue::failed.");
        }
        "queue:retry" => {
            if !queue.retry(id.expect("validated id")).await? {
                return Err(AppError::NotFound);
            }
            println!("Failed job returned to its original queue; attempts reset.");
        }
        "queue:forget" => {
            if !queue.forget(id.expect("validated id")).await? {
                return Err(AppError::NotFound);
            }
            println!("Failed job deleted.");
        }
        "queue:check" => {
            let _ = Worker::new(
                AppContext {
                    db,
                    config: Arc::new(config),
                },
                jobs,
            )?
            .with_services(services);
            queue.check_schema().await?;
            println!("Jobs: queue tables available; registry and worker configuration valid.");
        }
        _ => unreachable!(),
    }
    Ok(())
}
fn usage() -> AppError {
    AppError::Configuration("Use queue:work [--queue NAME ...] [--concurrency N], queue:failed, queue:retry UUID, queue:forget UUID, or queue:check.".into())
}