diff --git a/deploy/.env.example b/deploy/.env.example index 93915f8..350f4ca 100644 --- a/deploy/.env.example +++ b/deploy/.env.example @@ -20,3 +20,7 @@ SIGNUP_MODE=invite # Image version; every deployment rewrites it TAG=latest + +# worker-ai: analyses and answers written at the same time. +# QUICK_CONCURRENCY=2 # summaries and answers +# ANALYSIS_CONCURRENCY=4 # detailed analyses and forecasts diff --git a/deploy/README.md b/deploy/README.md index 55d210a..00abbda 100644 --- a/deploy/README.md +++ b/deploy/README.md @@ -82,7 +82,8 @@ A Google OAuth kliensnél a `https://sorsfonalak.hu` címet fel kell venni az en ## Üzemeltetés -- Naplók: `docker compose logs -f backend worker` +- Naplók: `docker compose logs -f backend worker worker-ai` +- A worker két konténerben fut, ugyanabból az image-ből: a `worker` küldi az e-maileket és takarít (`WORKER_TASKS=email,cleanup`, ide kerülnek a további háttérfeladatok is), a `worker-ai` írja az elemzéseket és a válaszokat (`WORKER_TASKS=analyses`, gyors és lassú sáv). A sávok mérete a szerver `.env` fájljában állítható (`QUICK_CONCURRENCY`, `ANALYSIS_CONCURRENCY`). - Visszaállás korábbi verzióra: `.env`-ben `TAG=`, utána `docker compose up -d` - Mentés: naponta egy `pg_dump` a `/opt/sorsfonalak/backups` mappába, 14 napig megmarad. A mentéseket érdemes a szerverről is elvinni (DigitalOcean backup, vagy `rsync` otthonra). - Visszatöltés: `gunzip -c backups/sorsfonalak-.sql.gz | docker compose exec -T postgres psql -U sorsfonalak sorsfonalak` diff --git a/deploy/docker-compose.yml b/deploy/docker-compose.yml index 5312f76..03761a2 100644 --- a/deploy/docker-compose.yml +++ b/deploy/docker-compose.yml @@ -99,10 +99,12 @@ services: logging: *logging restart: unless-stopped + # E-mail delivery, cleanup and the other background jobs. worker: image: ${REGISTRY_PREFIX:-registry.sagifer.com/sagifer/sorsfonalak}-worker:${TAG:-latest} environment: DATABASE_URL: postgres://sorsfonalak:${POSTGRES_PASSWORD}@postgres:5432/sorsfonalak + WORKER_TASKS: email,cleanup # SMTP_URL or the SES credentials come from .env.secrets (docs/levelkuldes.md); # listing them here with an empty default would override that file. SES_REGION: ${SES_REGION:-eu-central-1} @@ -118,6 +120,26 @@ services: logging: *logging restart: unless-stopped + # The same image writing the analyses and answers (quick and slow lane); + # OPENROUTER_API_KEY comes from .env.secrets. + worker-ai: + image: ${REGISTRY_PREFIX:-registry.sagifer.com/sagifer/sorsfonalak}-worker:${TAG:-latest} + environment: + DATABASE_URL: postgres://sorsfonalak:${POSTGRES_PASSWORD}@postgres:5432/sorsfonalak + WORKER_TASKS: analyses + QUICK_CONCURRENCY: ${QUICK_CONCURRENCY:-2} + ANALYSIS_CONCURRENCY: ${ANALYSIS_CONCURRENCY:-4} + PUBLIC_BASE_URL: https://${DOMAIN} + env_file: + - path: .env.secrets + required: false + depends_on: + postgres: + condition: service_healthy + read_only: true + logging: *logging + restart: unless-stopped + frontend: image: ${REGISTRY_PREFIX:-registry.sagifer.com/sagifer/sorsfonalak}-frontend:${TAG:-latest} environment: diff --git a/services/worker/README.md b/services/worker/README.md index e49cc40..ee5c528 100644 --- a/services/worker/README.md +++ b/services/worker/README.md @@ -21,6 +21,11 @@ Háttérmunkák a közös PostgreSQL-adatbázis fölött: e-mail-küldés, szöv **Szöveges elemzések** (`analyses`, `pending` → `running` → `done`/`failed`) - A backend létrehozza a `pending` sort, és levon egy elemzési egységet. Egy trigger (`NOTIFY analyses`) felébreszti a workert; egyszerre `ANALYSIS_CONCURRENCY` elemzés készül. +- **Két sáv**, saját helyekkel, hogy egy rövid szöveg ne várjon a hosszúak mögött: + - *gyors sáv* (`QUICK_CONCURRENCY`, alapból 2): előbb a kérdések, aztán a rövid összefoglalók; + - *lassú sáv* (`ANALYSIS_CONCURRENCY`, alapból 4): a részletes elemzések és az előrejelzések. Ha nincs ilyen, a szabad hely gyors munkát vesz fel, végül az admin próbafuttatásait. + - A 0 kikapcsolja a sávot, így a két sáv külön telepítésként is futhat (például Kubernetesen: egy gyors és egy lassú deployment). +- **Több worker** is dolgozhat ugyanabból a sorból: a sorokat `FOR UPDATE SKIP LOCKED` foglalja, egy munkát csak egy worker kap meg. Leálláskor mindegyik csak a saját félbehagyott munkáit adja vissza a sorba, az elakadt (15 percnél régebben futó) munkákat bármelyik visszateszi. Az e-mail-küldés és a takarítás is biztonságos több példányban. - A prompt a tárolt képletből készül (`src/analysis/compact.rs`). Ez egy tömör szöveg, amely csak a pozíciókat tartalmazza: jegyek, fokok, házak, fényszögek, elemek. **Név, születési dátum, idő, hely és koordináta nem megy ki.** Ismeretlen születési időnél nincsenek házak, Aszcendens és MC. - **5 fokos szabály:** ha egy pont legfeljebb 5°-kal (`CUSP_ORB`) a következő ház csúcsa előtt áll, a szöveg már abban a házban adja meg, és odaírja, hogy formálisan az előzőben van („house 11 (on the cusp: 2°00' before it, formally house 10)”). Így olvassák az asztrológusok. A számított ház, a képlet rajza és a táblázatok nem változnak. Ugyanez érvényes az összevetés házátfedéseire, a szolár Aszcendensre, az év urára és a fogyatkozásokra. - A modell OpenRouteren keresztül válaszol, azzal a modellel, amely a sor `model` mezőjében áll. A válasznak kötött JSON-sémát kell követnie (`crates/analysis-prompt`, `PROMPT_VERSION = v3`; ha a sor `prompt_version`-je `v3-r`, a system prompt az admin által szerkesztett `prompt_revisions` sorból jön): @@ -72,7 +77,9 @@ Ugyanazt a radix-elemzést több modellel is megírja, véletlenszerű betűkkel | `OPENROUTER_API_KEY` | – | OpenRouter-kulcs (compose-ban a `.env.secrets` fájlból); nélküle az elemzések várnak | | `OPENROUTER_BASE_URL` | `https://openrouter.ai/api/v1` | | | `PUBLIC_BASE_URL` | – | `HTTP-Referer` fejléc az OpenRouter felé | -| `ANALYSIS_CONCURRENCY` | `4` | egyszerre írt elemzések | +| `WORKER_TASKS` | `email,cleanup,analyses` | a folyamat feladatai; élesben `worker`: `email,cleanup`, `worker-ai`: `analyses` | +| `ANALYSIS_CONCURRENCY` | `4` | lassú sáv: egyszerre írt részletes elemzések és előrejelzések (0: kikapcsolva) | +| `QUICK_CONCURRENCY` | `2` | gyors sáv: egyszerre írt rövid összefoglalók és válaszok (0: kikapcsolva) | | `MAX_ANALYSIS_ATTEMPTS` | `3` | ennyi próbálkozás után sikertelen az elemzés (az egység visszajár) | | `BIND_ADDR`, `LOG_FORMAT`, `RUST_LOG` | `0.0.0.0:8082`, `text`, `info` | | diff --git a/services/worker/src/analysis/mod.rs b/services/worker/src/analysis/mod.rs index 170e1ff..c682f58 100644 --- a/services/worker/src/analysis/mod.rs +++ b/services/worker/src/analysis/mod.rs @@ -9,6 +9,13 @@ //! Admin test runs of an edited prompt (`prompt_previews`) go through the //! same loop when no analysis is due: one attempt, no credits, no retries. //! +//! Two lanes, each with its own slots, so a short text never waits behind +//! the long ones: the quick lane writes summaries and answers questions, the +//! slow lane writes the detailed analyses and forecasts (and the test runs). +//! A free slow slot also takes quick work. A lane of size 0 is off, so the +//! lanes can run as separate deployments; several workers may share the +//! queue, rows are claimed with `FOR UPDATE SKIP LOCKED`. +//! //! Fallback: when the model chosen on the admin page fails twice (or once with //! a permanent error), the default model (`fallback_model`) takes over with a //! fresh set of attempts; only when that fails too is the unit refunded. @@ -29,6 +36,7 @@ use uuid::Uuid; use self::openrouter::{Completion, LlmError, OpenRouter}; use self::prompt::{Kind, PROMPT_VERSION, Prompt}; +use self::questions::QuestionJob; /// A `running` analysis older than this was left behind by a stopped worker. const STUCK_AFTER_MINUTES: i32 = 15; @@ -101,11 +109,36 @@ pub struct PreviewJob { pub system: String, } +/// Which analyses a claim may take. +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub enum Lane { + /// The short summary of a chart (questions are claimed separately). + Quick, + /// The detailed analyses and the yearly forecast. + Slow, +} + +impl Lane { + fn kinds(self) -> &'static [&'static str] { + match self { + Lane::Quick => &["summary"], + Lane::Slow => &["natal", "synastry", "forecast"], + } + } +} + +/// Slots per lane; 0 turns a lane off. +#[derive(Debug, Clone, Copy)] +pub struct Lanes { + pub quick: usize, + pub slow: usize, +} + pub struct Analyzer { pub db: PgPool, pub llm: OpenRouter, pub max_attempts: i32, - pub concurrency: usize, + pub lanes: Lanes, /// Analyses and previews being written right now (released on shutdown). running: Mutex>, } @@ -117,19 +150,21 @@ pub fn backoff(attempts: i32) -> Duration { } impl Analyzer { - pub fn new(db: PgPool, llm: OpenRouter, max_attempts: i32, concurrency: usize) -> Self { - Self { db, llm, max_attempts, concurrency: concurrency.max(1), running: Mutex::default() } + pub fn new(db: PgPool, llm: OpenRouter, max_attempts: i32, lanes: Lanes) -> Self { + Self { db, llm, max_attempts, lanes, running: Mutex::default() } } - /// Takes the next due analysis, if any. - pub async fn claim(&self) -> Result, sqlx::Error> { + /// Takes the next due analysis of the lane, if any. + pub async fn claim(&self, lane: Lane) -> Result, sqlx::Error> { let job: Option = sqlx::query_as( "UPDATE analyses SET status = 'running', started_at = now(), attempts = attempts + 1 \ WHERE id = (SELECT id FROM analyses WHERE status = 'pending' AND next_attempt_at <= now() \ + AND kind = ANY($1) \ ORDER BY next_attempt_at LIMIT 1 FOR UPDATE SKIP LOCKED) \ RETURNING id, kind, chart_id, synastry_id, forecast_id, language, model, prompt_version, attempts, \ fallback_model, on_fallback, started_at", ) + .bind(lane.kinds()) .fetch_optional(&self.db) .await?; if let Some(job) = &job { @@ -530,8 +565,46 @@ impl Analyzer { } } +/// Work a free slot can take, in order of preference. +pub(crate) enum Work { + Analysis(Job), + Question(QuestionJob), + Preview(PreviewJob), +} + +impl Analyzer { + /// Quick work: a question first (someone is waiting for a short answer), + /// then a summary. + pub(crate) async fn claim_quick(&self) -> Result, sqlx::Error> { + if let Some(job) = self.claim_question().await? { + return Ok(Some(Work::Question(job))); + } + Ok(self.claim(Lane::Quick).await?.map(Work::Analysis)) + } + + /// Slow work: a detailed analysis, else quick work, else a test run. + pub(crate) async fn claim_slow(&self) -> Result, sqlx::Error> { + if let Some(job) = self.claim(Lane::Slow).await? { + return Ok(Some(Work::Analysis(job))); + } + if let Some(work) = self.claim_quick().await? { + return Ok(Some(work)); + } + Ok(self.claim_preview().await?.map(Work::Preview)) + } + + async fn work(&self, work: Work) { + match work { + Work::Analysis(job) => self.handle(job).await, + Work::Question(job) => self.handle_question(job).await, + Work::Preview(job) => self.handle_preview(job).await, + } + } +} + pub async fn run(analyzer: Arc, poll: Duration, stop: watch::Receiver) { - let slots = Arc::new(Semaphore::new(analyzer.concurrency)); + let quick = Arc::new(Semaphore::new(analyzer.lanes.quick)); + let slow = Arc::new(Semaphore::new(analyzer.lanes.slow)); let mut tasks = tokio::task::JoinSet::new(); let mut listener = crate::listen(&analyzer.db, "analyses").await; let mut last_requeue: Option = None; @@ -547,50 +620,27 @@ pub async fn run(analyzer: Arc, poll: Duration, stop: watch::Receiver< Err(e) => tracing::error!(error = %e, "requeueing analyses"), } } - // Fill the free slots. - while let Ok(permit) = slots.clone().try_acquire_owned() { - // Questions first: someone is waiting for a short answer. - match analyzer.claim_question().await { - Ok(Some(job)) => { - let analyzer = analyzer.clone(); - tasks.spawn(async move { - analyzer.handle_question(job).await; - drop(permit); - }); - continue; - } - Ok(None) => {} - Err(e) => { - tracing::error!(error = %e, "claiming a question"); - break; - } - } - match analyzer.claim().await { - Ok(Some(job)) => { - let analyzer = analyzer.clone(); - tasks.spawn(async move { - analyzer.handle(job).await; - drop(permit); - }); - } - // No analysis is due: a prompt test run, if one waits. - Ok(None) => match analyzer.claim_preview().await { - Ok(Some(job)) => { + // Fill the free slots: the quick lane first, then the slow one. + for lane in [Lane::Quick, Lane::Slow] { + let slots = if lane == Lane::Quick { &quick } else { &slow }; + while let Ok(permit) = slots.clone().try_acquire_owned() { + let claimed = match lane { + Lane::Quick => analyzer.claim_quick().await, + Lane::Slow => analyzer.claim_slow().await, + }; + match claimed { + Ok(Some(work)) => { let analyzer = analyzer.clone(); tasks.spawn(async move { - analyzer.handle_preview(job).await; + analyzer.work(work).await; drop(permit); }); } Ok(None) => break, Err(e) => { - tracing::error!(error = %e, "claiming a prompt preview"); + tracing::error!(error = %e, ?lane, "claiming work"); break; } - }, - Err(e) => { - tracing::error!(error = %e, "claiming an analysis"); - break; } } } diff --git a/services/worker/src/config.rs b/services/worker/src/config.rs index 3949841..27030cb 100644 --- a/services/worker/src/config.rs +++ b/services/worker/src/config.rs @@ -5,7 +5,38 @@ use std::time::Duration; use anyhow::Context; use lettre::message::Mailbox; +/// The jobs a worker process runs (`WORKER_TASKS`, comma-separated). +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct Tasks { + /// Sending the e-mails of `email_outbox`. + pub email: bool, + /// The hourly removal of expired data. + pub cleanup: bool, + /// Writing the analyses and answers with the LLM (both lanes). + pub analyses: bool, +} + +impl Tasks { + pub const ALL: Tasks = Tasks { email: true, cleanup: true, analyses: true }; + + pub fn parse(raw: &str) -> anyhow::Result { + let mut tasks = Tasks { email: false, cleanup: false, analyses: false }; + for name in raw.split(',').map(str::trim).filter(|n| !n.is_empty()) { + match name { + "email" => tasks.email = true, + "cleanup" => tasks.cleanup = true, + "analyses" => tasks.analyses = true, + other => anyhow::bail!("unknown task '{other}' in WORKER_TASKS (email, cleanup, analyses)"), + } + } + anyhow::ensure!(tasks != Tasks { email: false, cleanup: false, analyses: false }, "WORKER_TASKS names no task"); + Ok(tasks) + } +} + pub struct Config { + /// What this process does; all of it by default. + pub tasks: Tasks, pub database_url: String, /// `smtp://host:port` (plain, e.g. Mailpit), `smtp://user:pass@host:587?tls=required` /// (STARTTLS) or `smtps://...` (TLS). Without it, Amazon SES from the AWS @@ -24,8 +55,10 @@ pub struct Config { pub openrouter_base_url: String, /// Frontend address, sent to OpenRouter as `HTTP-Referer`. pub public_base_url: Option, - /// Analyses written at the same time. + /// Detailed analyses and forecasts written at the same time (0: none). pub analysis_concurrency: usize, + /// Summaries and answers written at the same time (0: none). + pub quick_concurrency: usize, /// After this many failed attempts an analysis fails and is refunded. pub max_analysis_attempts: i32, } @@ -55,6 +88,7 @@ impl Config { }, }; Ok(Self { + tasks: var("WORKER_TASKS").map(|raw| Tasks::parse(&raw)).transpose()?.unwrap_or(Tasks::ALL), database_url: var("DATABASE_URL").context("DATABASE_URL is required")?, smtp_url, smtp_about, @@ -67,6 +101,7 @@ impl Config { .unwrap_or_else(|| crate::analysis::openrouter::DEFAULT_BASE_URL.into()), public_base_url: var("PUBLIC_BASE_URL"), analysis_concurrency: parsed("ANALYSIS_CONCURRENCY", 4)?, + quick_concurrency: parsed("QUICK_CONCURRENCY", 2)?, max_analysis_attempts: parsed("MAX_ANALYSIS_ATTEMPTS", 3)?, }) } diff --git a/services/worker/src/main.rs b/services/worker/src/main.rs index 2f07250..9594684 100644 --- a/services/worker/src/main.rs +++ b/services/worker/src/main.rs @@ -5,6 +5,9 @@ //! * hourly cleanup of expired sessions, tokens, invites and old e-mails //! * writing the requested text analyses with an LLM (OpenRouter) //! +//! `WORKER_TASKS` (e.g. `email,cleanup` or `analyses`) picks the jobs of one +//! process, so they can run in separate containers; all of them by default. +//! //! Configuration: see [`config::Config`]; plus `BIND_ADDR` (default //! `0.0.0.0:8082`, only `/healthz`), `LOG_FORMAT` and `RUST_LOG`. //! `worker healthcheck` performs a local health check (for Docker); @@ -91,7 +94,10 @@ async fn main() -> anyhow::Result<()> { let (stop_tx, stop) = watch::channel(false); let mut jobs = tokio::task::JoinSet::new(); + let tasks = config.tasks; + tracing::info!(email = tasks.email, cleanup = tasks.cleanup, analyses = tasks.analyses, "worker tasks"); match &config.smtp_url { + _ if !tasks.email => {} Some(url) => { let delivery = email::Delivery::new(pool.clone(), email::Mailer::smtp(url)?, &config); let via = config.smtp_about.clone().unwrap_or_else(|| "SMTP_URL".into()); @@ -101,17 +107,24 @@ async fn main() -> anyhow::Result<()> { None => tracing::warn!("neither SMTP_URL nor SES credentials are set: e-mails stay in the outbox"), } match &config.openrouter_api_key { + _ if !tasks.analyses => {} Some(key) => { let llm = analysis::openrouter::OpenRouter::new(&config.openrouter_base_url, key, config.public_base_url.clone()); - let analyzer = - analysis::Analyzer::new(pool.clone(), llm, config.max_analysis_attempts, config.analysis_concurrency); - tracing::info!(concurrency = analyzer.concurrency, "analyses enabled"); - jobs.spawn(analysis::run(Arc::new(analyzer), config.poll_interval, stop.clone())); + let lanes = analysis::Lanes { quick: config.quick_concurrency, slow: config.analysis_concurrency }; + if lanes.quick + lanes.slow == 0 { + tracing::warn!("QUICK_CONCURRENCY and ANALYSIS_CONCURRENCY are both 0: this worker writes no analyses"); + } else { + let analyzer = analysis::Analyzer::new(pool.clone(), llm, config.max_analysis_attempts, lanes); + tracing::info!(quick = lanes.quick, slow = lanes.slow, "analyses enabled"); + jobs.spawn(analysis::run(Arc::new(analyzer), config.poll_interval, stop.clone())); + } } None => tracing::warn!("OPENROUTER_API_KEY is not set: analyses stay pending"), } - jobs.spawn(cleanup::run(pool.clone(), stop.clone())); + if tasks.cleanup { + jobs.spawn(cleanup::run(pool.clone(), stop.clone())); + } let app = Router::new().route("/healthz", get(healthz)).with_state(pool); let listener = tokio::net::TcpListener::bind(addr).await.with_context(|| format!("binding {addr}"))?; diff --git a/services/worker/src/tests.rs b/services/worker/src/tests.rs index 2079009..7581279 100644 --- a/services/worker/src/tests.rs +++ b/services/worker/src/tests.rs @@ -223,6 +223,16 @@ async fn cleanup_removes_only_expired_data(db: PgPool) { // --- analyses ---------------------------------------------------------------------------- +#[test] +fn worker_tasks_are_chosen_by_name() { + use crate::config::Tasks; + let mail = Tasks::parse("email, cleanup").unwrap(); + assert_eq!(mail, Tasks { email: true, cleanup: true, analyses: false }); + assert_eq!(Tasks::parse("analyses").unwrap(), Tasks { email: false, cleanup: false, analyses: true }); + assert!(Tasks::parse("emails").is_err()); + assert!(Tasks::parse(" , ").is_err()); +} + mod analyses { use std::sync::{Arc, Mutex}; @@ -235,7 +245,7 @@ mod analyses { use crate::analysis::openrouter::OpenRouter; use crate::analysis::prompt::{Kind, schema, validate}; - use crate::analysis::{Analyzer, backoff}; + use crate::analysis::{Analyzer, Lane, Lanes, backoff}; /// Scripted replies (then the last one forever) and the requests received. #[derive(Clone, Default)] @@ -337,11 +347,11 @@ mod analyses { } fn analyzer(db: &PgPool, base_url: &str) -> Analyzer { - Analyzer::new(db.clone(), OpenRouter::new(base_url, "test-key", None), 3, 2) + Analyzer::new(db.clone(), OpenRouter::new(base_url, "test-key", None), 3, Lanes { quick: 1, slow: 2 }) } async fn run_once(a: &Analyzer) -> bool { - match a.claim().await.unwrap() { + match a.claim(Lane::Slow).await.unwrap() { Some(job) => { a.handle(job).await; true @@ -464,10 +474,10 @@ mod analyses { let a = analyzer(&db, &url); // the analysis goes first; the preview only when nothing else is due - let job = a.claim().await.unwrap().expect("the analysis"); + let job = a.claim(Lane::Slow).await.unwrap().expect("the analysis"); assert_eq!(job.id, analysis); a.handle(job).await; - assert!(a.claim().await.unwrap().is_none()); + assert!(a.claim(Lane::Slow).await.unwrap().is_none()); let job = a.claim_preview().await.unwrap().expect("the preview"); a.handle_preview(job).await; let (status, title, model, credits): (String, Option, Option, i64) = sqlx::query_as( @@ -811,7 +821,7 @@ mod analyses { let id = request_analysis(&db, &s).await; let (_, url) = fake_openrouter(vec![reply(&content(Kind::Natal))]).await; let a = analyzer(&db, &url); - let job = a.claim().await.unwrap().expect("a job"); + let job = a.claim(Lane::Slow).await.unwrap().expect("a job"); // an admin restarts it while the worker is still writing it sqlx::query("UPDATE analyses SET status = 'pending', started_at = NULL, attempts = 0 WHERE id = $1") .bind(id) @@ -829,6 +839,40 @@ mod analyses { assert_eq!(status, "done"); } + #[sqlx::test(migrator = "db::MIGRATOR")] + async fn summaries_have_their_own_lane(db: PgPool) { + let s = setup(&db).await; + let natal = request_analysis(&db, &s).await; + let summary = |id: Uuid| { + sqlx::query( + "INSERT INTO analyses (id, kind, chart_id, requested_by, language, model, prompt_version, cache_key, \ + credits_charged) \ + VALUES ($1, 'summary', $2, $3, 'hu', 'test/model', 'v1', 'key', 0)", + ) + .bind(id) + .bind(s.chart) + .bind(s.user) + }; + let first = Uuid::now_v7(); + summary(first).execute(&db).await.unwrap(); + let a = analyzer(&db, "http://127.0.0.1:9"); + + // the quick lane takes the summary, never the detailed analysis + let id_of = |work: Option| match work { + Some(crate::analysis::Work::Analysis(job)) => Some(job.id), + Some(_) => panic!("not an analysis"), + None => None, + }; + assert_eq!(id_of(a.claim_quick().await.unwrap()), Some(first)); + assert_eq!(id_of(a.claim_quick().await.unwrap()), None); + // the slow lane prefers the detailed analysis, then helps with quick work + let second = Uuid::now_v7(); + summary(second).execute(&db).await.unwrap(); + assert_eq!(id_of(a.claim_slow().await.unwrap()), Some(natal)); + assert_eq!(id_of(a.claim_slow().await.unwrap()), Some(second)); + assert_eq!(id_of(a.claim_slow().await.unwrap()), None); + } + #[sqlx::test(migrator = "db::MIGRATOR")] async fn answers_a_question_about_a_relationship_with_both_charts(db: PgPool) { let s = setup(&db).await;