jelq

public

an http based roguelike rpg about jelqing

Star0

Fork 0

Watch0

42 commits 1 branch 0 tags 0 releases1.3 MiB

Commit `159f0998263b`

tarball

atagen <boss@atagen.co>2026-10-12 11:06 UTC

15 files changed+635-92

http: give each run its own lock and keep the dead in sqlite

One mutex over every run serialised the whole server behind whichever
turn was slowest, and under the model oracle that turn was an HTTP call.
Runs now sit behind their own locks in a table that is only held for
lookups, and model turns move to the blocking pool. Finished, cured and
idle-evicted runs are written to a WAL-mode SQLite file (JELQD_DB), so the
graveyard, the leaderboard and a dead run's 410 survive a restart, and
ended runs leave memory at once.

Modified file: .gitignore+1

@@ -1,2 +1,3 @@

11 /target

22 /result

3+/jelqd.sqlite*

Modified file: Cargo.lock+215 additions@@ -88,12 +88,28 @@ dependencies = [
 ]
 
 [[package]]
+name = "bumpalo"
+version = "3.20.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "72f5acc6cb2ba439de613abc23857ec3d78374d8ed5ac84e9d11336e87da8649"
+
+[[package]]
 name = "bytes"
 version = "1.12.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "fc652a48c352aef3ea3aed32080501cf3ef6ed5da78602a020c991775b0aff04"
 
 [[package]]
+name = "cc"
+version = "1.8.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6651c9ed80effdc7db0ff72512157f901af5e3549e341e24b1dd4887d836d838"
+dependencies = [
+ "find-msvc-tools",
+ "shlex",
+]
+
+[[package]]
 name = "cfg-if"
 version = "1.0.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
@@ -150,6 +166,24 @@ dependencies = [
 ]
 
 [[package]]
+name = "fallible-iterator"
+version = "0.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2acce4a10f12dc2fb14a218589d4f1f62ef011b2d0cc4b3cb1bba8e94da14649"
+
+[[package]]
+name = "fallible-streaming-iterator"
+version = "0.1.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7360491ce676a36bf9bb3c56c1aa791658183a54d2744120f27285738d90465a"
+
+[[package]]
+name = "find-msvc-tools"
+version = "0.1.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "aedcfb3409746eddb02b9e19ebda1c3394f759a152e48ee875a0844d1b955484"
+
+[[package]]
 name = "flate2"
 version = "1.1.10"
 source = "registry+https://github.com/rust-lang/crates.io-index"
@@ -161,6 +195,12 @@ dependencies = [
 ]
 
 [[package]]
+name = "foldhash"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "77ce24cb58228fbb8aa041425bb1050850ac19177686ea6e0f41a70416f56fdb"
+
+[[package]]
 name = "form_urlencoded"
 version = "1.2.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
@@ -228,6 +268,33 @@ dependencies = [
 ]
 
 [[package]]
+name = "hashbrown"
+version = "0.16.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "841d1cc9bed7f9236f321df977030373f4a4163ae1a7dbfe1a51a2c1a51d9100"
+dependencies = [
+ "foldhash",
+]
+
+[[package]]
+name = "hashbrown"
+version = "0.17.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ed5909b6e89a2db4456e54cd5f673791d7eca6732202bbf2a9cc504fe2f9b84a"
+dependencies = [
+ "foldhash",
+]
+
+[[package]]
+name = "hashlink"
+version = "0.12.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a596f1b20ed2cc5ecac41a164aaebc7258057060f06c0cf7a2ba3991ee7990fb"
+dependencies = [
+ "hashbrown 0.17.1",
+]
+
+[[package]]
 name = "hmac"
 version = "0.12.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
@@ -437,6 +504,7 @@ dependencies = [
  "hyper",
  "hyper-util",
  "rand",
+ "rusqlite",
  "serde",
  "serde_json",
  "sha2",
@@ -447,12 +515,33 @@ dependencies = [
 ]
 
 [[package]]
+name = "js-sys"
+version = "0.3.106"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7883d941dae510fb2d978fc3fe018c71c9e2892fd38854de3e8b92c2e5ad9cc5"
+dependencies = [
+ "cfg-if",
+ "wasm-bindgen",
+]
+
+[[package]]
 name = "libc"
 version = "0.2.190"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ce5d3ddc6d3fa000eb1536d85e147bfe31aacaba692ed6a876f95cb7c855be78"
 
 [[package]]
+name = "libsqlite3-sys"
+version = "0.38.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f1d20bef17f513b9b3004532233187769cd072d790971f4e4da0e346eb6401e8"
+dependencies = [
+ "cc",
+ "pkg-config",
+ "vcpkg",
+]
+
+[[package]]
 name = "litemap"
 version = "0.8.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
@@ -522,6 +611,12 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "a89322df9ebe1c1578d689c92318e070967d1042b512afbe49518723f4e6d5cd"
 
 [[package]]
+name = "pkg-config"
+version = "0.3.34"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f6b464fbc74e149a392436b17d523f769e057cb6877f6a5c4618bc6f11800548"
+
+[[package]]
 name = "potential_utf"
 version = "0.1.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
@@ -593,6 +688,37 @@ dependencies = [
 ]
 
 [[package]]
+name = "rsqlite-vfs"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c51c9ae4df8a7fba42103df5c621fa3c37eccf3a3c650879e90fc48b11cc192c"
+dependencies = [
+ "hashbrown 0.16.1",
+ "thiserror",
+]
+
+[[package]]
+name = "rusqlite"
+version = "0.40.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "23f2a97da3e3873c73cb2a2e71b35c40ff95e0b1eefa8d72d8499a6928c3b5b3"
+dependencies = [
+ "bitflags",
+ "fallible-iterator",
+ "fallible-streaming-iterator",
+ "hashlink",
+ "libsqlite3-sys",
+ "smallvec",
+ "sqlite-wasm-rs",
+]
+
+[[package]]
+name = "rustversion"
+version = "1.0.23"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cf54715a573b99ac80df0bc206da022bcd442c974952c7b9720069370852e21f"
+
+[[package]]
 name = "ryu"
 version = "1.0.23"
 source = "registry+https://github.com/rust-lang/crates.io-index"
@@ -676,6 +802,12 @@ dependencies = [
 ]
 
 [[package]]
+name = "shlex"
+version = "2.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f8fadd59c855ef2080decdef8ff161eb6661b86933c9d82e5ba29dc602a55aba"
+
+[[package]]
 name = "simd-adler32"
 version = "0.3.10"
 source = "registry+https://github.com/rust-lang/crates.io-index"
@@ -704,6 +836,18 @@ dependencies = [
 ]
 
 [[package]]
+name = "sqlite-wasm-rs"
+version = "0.5.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dc3efc0da82635d7e1ced0053bbbfa8c7ab9645d0bf36ceb4f7127bb85315d75"
+dependencies = [
+ "cc",
+ "js-sys",
+ "rsqlite-vfs",
+ "wasm-bindgen",
+]
+
+[[package]]
 name = "stable_deref_trait"
 version = "1.2.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
@@ -755,6 +899,26 @@ dependencies = [
 ]
 
 [[package]]
+name = "thiserror"
+version = "2.0.21"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "09e52cb86a36cede5cb101bf8908837b3e4c6e5e59fe7fd85c23fb56200d189e"
+dependencies = [
+ "thiserror-impl",
+]
+
+[[package]]
+name = "thiserror-impl"
+version = "2.0.21"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fe5197923287db20a58125f0bc85c062f7f2c892de97b18c356f9efb14b28524"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 3.0.7",
+]
+
+[[package]]
 name = "tinystr"
 version = "0.8.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
@@ -901,6 +1065,12 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "b6c140620e7ffbb22c2dee59cafe6084a59b5ffc27a8859a5f0d494b5d52b6be"
 
 [[package]]
+name = "vcpkg"
+version = "0.2.15"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "accd4ea62f7bb7a82fe23066fb0957d48ef677f6eeb8215f372f52e48bb32426"
+
+[[package]]
 name = "version_check"
 version = "0.9.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
@@ -922,6 +1092,51 @@ dependencies = [
 ]
 
 [[package]]
+name = "wasm-bindgen"
+version = "0.2.129"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9bb54f33acc68fd454578d9820b0bde1a1a3d17aa17bb7b6595806d02886d409"
+dependencies = [
+ "cfg-if",
+ "once_cell",
+ "rustversion",
+ "wasm-bindgen-macro",
+ "wasm-bindgen-shared",
+]
+
+[[package]]
+name = "wasm-bindgen-macro"
+version = "0.2.129"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2e29d0c35b16e224a7eeb5cd2d25e3e1968fbd65604117b44d3b789d00ee8535"
+dependencies = [
+ "quote",
+ "wasm-bindgen-macro-support",
+]
+
+[[package]]
+name = "wasm-bindgen-macro-support"
+version = "0.2.129"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6f501a8bc3719dba86ef8ae4728879c08001bea749eb1333ac5b91e040e2a6b7"
+dependencies = [
+ "bumpalo",
+ "proc-macro2",
+ "quote",
+ "syn 3.0.7",
+ "wasm-bindgen-shared",
+]
+
+[[package]]
+name = "wasm-bindgen-shared"
+version = "0.2.129"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "23f0c9c52aa7cd7d77769a4cfe2a9adb1b331f489a41d912ce14513d5ab995c6"
+dependencies = [
+ "unicode-ident",
+]
+
+[[package]]
 name = "windows-link"
 version = "0.2.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"

Modified file: Cargo.toml+1

@@ -14,6 +14,7 @@ httpdate = "1"

1414 hyper = { version = "1", features = ["http1", "server"] }

1515 hyper-util = { version = "0.1", features = ["tokio"] }

1616 rand = "0.9"

17+rusqlite = { version = "0.40.2", features = ["bundled"] }

1718 serde = { version = "1", features = ["derive"] }

1819 serde_json = "1"

1920 sha2 = "0.10"

Modified file: src/config.rs+9 additions−1 deletions@@ -1,4 +1,4 @@
-use std::time::Duration;
+use std::{path::PathBuf, time::Duration};
 
 use crate::game::oracle::OracleTemplate;
 use crate::secret::Secret;
@@ -8,6 +8,8 @@ pub struct Config {
     pub secret: Secret,
     pub max_runs: usize,
     pub idle_ttl: Duration,
+    /// Where finished runs are kept. `None` keeps them in memory, which only tests want.
+    pub db: Option<PathBuf>,
     pub(crate) oracle: OracleTemplate,
 }
 
@@ -18,6 +20,7 @@ impl Default for Config {
             secret: Secret::random(),
             max_runs: 10_000,
             idle_ttl: Duration::from_secs(6 * 60 * 60),
+            db: None,
             oracle: OracleTemplate::Rng,
         }
     }
@@ -29,6 +32,11 @@ impl Config {
         let defaults = Self::default();
         Self {
             addr: var("JELQD_ADDR").unwrap_or(defaults.addr),
+            db: Some(
+                var("JELQD_DB")
+                    .unwrap_or_else(|| "jelqd.sqlite".into())
+                    .into(),
+            ),
             secret: var("JELQD_SECRET").map_or(defaults.secret, |s| Secret::new(s.into_bytes())),
             oracle: match var("JELQD_ORACLE").as_deref() {
                 Some("clm") => OracleTemplate::Clm {

Modified file: src/game/body.rs+4 additions−4 deletions@@ -144,9 +144,9 @@ impl Run {
     pub fn girth_respected(&self) -> bool {
         self.girth >= GIRTH_RESPECTED
     }
+}
 
-    /// A cylinder whose circumference is the girth.
-    pub fn volume(&self, length: f64) -> f64 {
-        self.girth * self.girth * length / (4.0 * std::f64::consts::PI)
-    }
+/// A cylinder whose circumference is the girth.
+pub fn volume(length: f64, girth: f64) -> f64 {
+    girth * girth * length / (4.0 * std::f64::consts::PI)
 }

Modified file: src/game/clinic.rs+2 additions−2 deletions@@ -1,7 +1,7 @@
 use axum::http::{StatusCode, header};
 use serde_json::json;
 
-use super::{Floor, Outcome, Run, etag_matches, parse_credentials, round2};
+use super::{Floor, Outcome, Run, body::volume, etag_matches, parse_credentials, round2};
 use crate::{
     headers::{SERVER_TIMING, X_DIAGNOSIS},
     problem::Problem,
@@ -63,7 +63,7 @@ impl Run {
                 self.shame += 15;
             }
         }
-        let volume = self.volume(self.length);
+        let volume = volume(self.length, self.girth);
         let foreskin = self.foreskin.unwrap_or(0.0);
         let timing = format!(
             "length;dur={:.2}, girth;dur={:.2}, foreskin;dur={foreskin:.2}, volume;desc=\"cubic inches\";dur={volume:.2}",

Modified file: src/game/mod.rs+1−1

@@ -15,7 +15,7 @@ mod techniques;

1515 mod turn;

1616 mod utility;

1717

18-pub use body::PatchOp;

18+pub use body::{PatchOp, volume};

1919 pub use forum::{ELDER_LAST_MODIFIED, FORUM_THREAD, forum_thread};

2020 pub use items::{Item, Items, SHOP};

2121 pub use outcome::{Outcome, Payload};

Modified file: src/game/oracle.rs+6 additions@@ -26,6 +26,12 @@ pub(crate) enum OracleTemplate {
     Clm { url: String },
 }
 
+impl OracleTemplate {
+    pub(crate) fn blocks(&self) -> bool {
+        matches!(self, Self::Clm { .. })
+    }
+}
+
 pub(crate) struct Clm {
     url: String,
     agent: ureq::Agent,

Modified file: src/http/meta.rs+42 additions−46 deletions@@ -1,7 +1,5 @@
 //! Resources that do not belong to a single run.
 
-use std::time::Instant;
-
 use axum::{
     Json,
     http::{StatusCode, header},
@@ -17,11 +15,14 @@ use super::{
     run,
 };
 use crate::{
-    game::{ELDER_LAST_MODIFIED, FORUM_THREAD, Run, balance::MM_PER_INCH, forum_thread},
+    game::{ELDER_LAST_MODIFIED, FORUM_THREAD, Run, balance::MM_PER_INCH, forum_thread, volume},
     headers::X_SEED,
     problem::{PROBLEM_BASE, Problem},
+    records::Record,
 };
 
+use super::registry::hold;
+
 pub static INDEX: Resource<Shared> = Resource::new(&[Verb::new("GET", index)]);
 pub static RUNS: Resource<Shared> = Resource::new(&[Verb::new("POST", create_run)]);
 pub static THREAD: Resource<Shared> = Resource::new(&[Verb::new("GET", thread)]);
@@ -68,21 +69,10 @@ fn create_run(state: &mut Shared, ctx: &Ctx) -> Response {
         }
     };
     let config = &state.config;
-    let mut runs = state.runs();
-    runs.retain(|_, run| ctx.now.duration_since(run.last_seen) < config.idle_ttl);
-    if runs.len() >= config.max_runs {
-        let mut buried: Vec<(Instant, String)> = runs
-            .iter()
-            .filter(|(_, run)| run.ended.is_some())
-            .map(|(id, run)| (run.last_seen, id.clone()))
-            .collect();
-        buried.sort_unstable();
-        let excess = runs.len() + 1 - config.max_runs;
-        for (_, id) in buried.into_iter().take(excess) {
-            runs.remove(&id);
-        }
+    for slot in state.runs.evict_idle(ctx.now, config.idle_ttl) {
+        state.records.save(&Record::of(&hold(&slot)));
     }
-    if runs.len() >= config.max_runs {
+    if state.runs.len() >= config.max_runs {
         return Problem::new(
             StatusCode::SERVICE_UNAVAILABLE,
             "server-full",
@@ -93,7 +83,7 @@ fn create_run(state: &mut Shared, ctx: &Ctx) -> Response {
     }
     let id = loop {
         let id = format!("{:032x}", rand::rng().random::<u128>());
-        if !runs.contains_key(&id) {
+        if !state.runs.contains(&id) && state.records.find(&id).is_none() {
             break id;
         }
     };
@@ -117,7 +107,7 @@ fn create_run(state: &mut Shared, ctx: &Ctx) -> Response {
     )
         .into_response();
     let response = run::finish(&mut run, ctx, &config.secret, response);
-    runs.insert(id, run);
+    state.runs.insert(run);
     response
 }
 
@@ -146,16 +136,17 @@ fn thread(_: &mut Shared, ctx: &Ctx) -> Response {
 }
 
 fn graveyard(state: &mut Shared, _: &Ctx) -> Response {
-    let runs = state.runs();
-    let dead: Vec<Value> = runs
-        .values()
-        .filter_map(|run| {
-            let ending = run.ended.as_ref()?;
+    let dead: Vec<Value> = state
+        .records
+        .dead()
+        .into_iter()
+        .filter_map(|record| {
+            let ending = record.ending?;
             Some(json!({
-                "public_id": run.public_id,
-                "cause": format!("{PROBLEM_BASE}{}", ending.cause.slug()),
-                "detail": ending.cause.detail(),
-                "turn": ending.turn,
+                "public_id": record.public_id,
+                "cause": format!("{PROBLEM_BASE}{}", ending.cause),
+                "detail": ending.detail,
+                "turn": record.turn,
             }))
         })
         .collect();
@@ -206,33 +197,38 @@ fn leaderboard(state: &mut Shared, ctx: &Ctx) -> Response {
         }
     };
     let include_seeded = ctx.query("seeded") == Some("include");
-    let runs = state.runs();
-    let mut entries: Vec<&Run> = runs
-        .values()
-        .filter(|run| include_seeded || !run.seeded)
-        .collect();
-    let key = |run: &Run| match sort {
-        Sort::SelfReported => run.self_reported(),
-        Sort::ContentLength => run.current_length(),
-        Sort::Volume => run.volume(run.self_reported()),
+    let mut entries: Vec<Record> = state.runs.each(Record::of);
+    entries.extend(
+        state
+            .records
+            .all()
+            .into_iter()
+            .filter(|record| !state.runs.contains(&record.id)),
+    );
+    entries.retain(|record| include_seeded || !record.seeded);
+    let key = |record: &Record| match sort {
+        Sort::SelfReported => record.self_reported,
+        Sort::ContentLength => record.length,
+        Sort::Volume => volume(record.self_reported, record.girth),
     };
     entries.sort_by(|a, b| key(b).total_cmp(&key(a)));
     let entries: Vec<Value> = entries
         .into_iter()
-        .map(|run| {
+        .map(|record| {
             let mut entry = json!({
-                "public_id": run.public_id,
-                "status": run.status(),
-                "floor": run.floor.number(),
-                "self_reported_length": (run.self_reported() * 100.0).round() / 100.0,
-                "ranked": !run.seeded,
-                "viral": run.filmed_at.is_some(),
+                "public_id": record.public_id,
+                "status": record.status,
+                "floor": record.floor,
+                "self_reported_length": (record.self_reported * 100.0).round() / 100.0,
+                "ranked": !record.seeded,
+                "viral": record.viral,
             });
             if sort == Sort::Volume {
-                entry["volume"] = json!((run.volume(run.self_reported()) * 100.0).round() / 100.0);
+                entry["volume"] =
+                    json!((volume(record.self_reported, record.girth) * 100.0).round() / 100.0);
             }
             if sort == Sort::ContentLength {
-                entry["content_length"] = json!((run.current_length() * MM_PER_INCH).round());
+                entry["content_length"] = json!((record.length * MM_PER_INCH).round());
             }
             entry
         })

Modified file: src/http/mod.rs+37 additions−23 deletions@@ -1,52 +1,54 @@
 mod ctx;
 mod meta;
 mod middleware;
+mod registry;
 mod resource;
 mod response;
 mod run;
 mod runs;
 mod ui;
 
-use std::{
-    collections::HashMap,
-    sync::{Arc, Mutex, MutexGuard, PoisonError},
-};
+use std::sync::Arc;
 
 use axum::{
     Router,
     extract::State,
-    response::Redirect,
+    response::{Redirect, Response},
     routing::{MethodRouter, any},
 };
 
 use tower_http::catch_panic::CatchPanicLayer;
 
-use crate::{config::Config, game::Run};
+use crate::{config::Config, records::Records};
 use ctx::Ctx;
+use registry::Registry;
 use resource::Resource;
 use run::RunResource;
 
 pub struct AppState {
-    runs: Mutex<HashMap<String, Run>>,
+    runs: Registry,
+    records: Records,
     config: Config,
 }
 
 impl AppState {
     pub fn new(config: Config) -> Self {
+        let records = match &config.db {
+            Some(path) => Records::open(path).unwrap_or_else(|e| {
+                panic!("the records at {} could not be opened: {e}", path.display())
+            }),
+            None => Records::in_memory(),
+        };
         Self {
-            runs: Mutex::default(),
+            runs: Registry::default(),
+            records,
             config,
         }
     }
 
-    /// A panic mid-request must not take every other run down with it, so a poisoned lock is recovered.
-    fn runs(&self) -> MutexGuard<'_, HashMap<String, Run>> {
-        self.runs.lock().unwrap_or_else(PoisonError::into_inner)
-    }
-
     #[cfg(test)]
-    pub(crate) fn insert(&self, run: Run) {
-        self.runs().insert(run.id.clone(), run);
+    pub(crate) fn insert(&self, run: crate::game::Run) {
+        self.runs.insert(run);
     }
 }
 
@@ -74,17 +76,29 @@ pub fn router(state: Shared) -> Router {
 }
 
 fn global(resource: &'static Resource<Shared>) -> MethodRouter<Shared> {
-    any(
-        move |State(mut state): State<Shared>, ctx: Ctx| async move {
-            resource.dispatch(&mut state, &ctx)
-        },
-    )
+    any(move |State(state): State<Shared>, ctx: Ctx| async move {
+        offload(state, move |mut state| resource.dispatch(&mut state, &ctx)).await
+    })
 }
 
 fn scoped(resource: &'static RunResource) -> MethodRouter<Shared> {
-    any(
-        move |State(state): State<Shared>, ctx: Ctx| async move { run::serve(&state, ctx, resource) },
-    )
+    any(move |State(state): State<Shared>, ctx: Ctx| async move {
+        offload(state, move |state| run::serve(&state, ctx, resource)).await
+    })
+}
+
+/// The model oracle blocks on HTTP for every roll, so its turns run on the blocking pool and
+/// leave the async workers free. Dice are quick enough to roll in place.
+async fn offload<F>(state: Shared, work: F) -> Response
+where
+    F: FnOnce(Shared) -> Response + Send + 'static,
+{
+    if !state.config.oracle.blocks() {
+        return work(state);
+    }
+    tokio::task::spawn_blocking(move || work(state))
+        .await
+        .unwrap_or_else(|e| std::panic::resume_unwind(e.into_panic()))
 }
 
 fn api(state: Shared) -> Router {

Added file: src/http/registry.rs+77 additions@@ -0,0 +1,77 @@
+//! The live runs. The table is only locked long enough to find a run, and each run has its own
+//! lock, so one slow turn never holds up anyone else's.
+
+use std::{
+    collections::HashMap,
+    sync::{Arc, Mutex, MutexGuard, PoisonError, RwLock, TryLockError},
+    time::{Duration, Instant},
+};
+
+use crate::game::Run;
+
+pub type Slot = Arc<Mutex<Run>>;
+
+#[derive(Default)]
+pub struct Registry {
+    runs: RwLock<HashMap<String, Slot>>,
+}
+
+/// A panic mid-request must not take the run down with it, so a poisoned lock is recovered.
+pub fn hold(slot: &Slot) -> MutexGuard<'_, Run> {
+    slot.lock().unwrap_or_else(PoisonError::into_inner)
+}
+
+impl Registry {
+    pub fn get(&self, id: &str) -> Option<Slot> {
+        self.read().get(id).cloned()
+    }
+
+    pub fn len(&self) -> usize {
+        self.read().len()
+    }
+
+    pub fn insert(&self, run: Run) {
+        let id = run.id.clone();
+        self.write().insert(id, Arc::new(Mutex::new(run)));
+    }
+
+    pub fn remove(&self, id: &str) {
+        self.write().remove(id);
+    }
+
+    pub fn contains(&self, id: &str) -> bool {
+        self.read().contains_key(id)
+    }
+
+    /// Every live run, each visited under its own lock.
+    pub fn each<T>(&self, mut visit: impl FnMut(&Run) -> T) -> Vec<T> {
+        let slots: Vec<Slot> = self.read().values().cloned().collect();
+        slots.iter().map(|slot| visit(&hold(slot))).collect()
+    }
+
+    /// Takes out the runs nobody has touched for `ttl`, and hands them back for the record.
+    pub fn evict_idle(&self, now: Instant, ttl: Duration) -> Vec<Slot> {
+        let mut runs = self.write();
+        let idle: Vec<String> = runs
+            .iter()
+            .filter(|(_, slot)| {
+                let idle = |run: &Run| now.duration_since(run.last_seen) >= ttl;
+                match slot.try_lock() {
+                    Ok(run) => idle(&run),
+                    Err(TryLockError::Poisoned(poisoned)) => idle(&poisoned.into_inner()),
+                    Err(TryLockError::WouldBlock) => false,
+                }
+            })
+            .map(|(id, _)| id.clone())
+            .collect();
+        idle.iter().filter_map(|id| runs.remove(id)).collect()
+    }
+
+    fn read(&self) -> std::sync::RwLockReadGuard<'_, HashMap<String, Slot>> {
+        self.runs.read().unwrap_or_else(PoisonError::into_inner)
+    }
+
+    fn write(&self) -> std::sync::RwLockWriteGuard<'_, HashMap<String, Slot>> {
+        self.runs.write().unwrap_or_else(PoisonError::into_inner)
+    }
+}

Modified file: src/http/run.rs+38 additions−15 deletions@@ -7,7 +7,9 @@ use axum::{
 use hyper_util::rt::TokioIo;
 use tokio::io::AsyncWriteExt;
 
-use super::{AppState, ctx::Ctx, meta, middleware::Compress, resource::Resource, runs};
+use super::{
+    AppState, ctx::Ctx, meta, middleware::Compress, registry::hold, resource::Resource, runs,
+};
 use crate::{
     game::{
         Elder, FORUM_THREAD, Floor, Run, SHOP, Story,
@@ -19,6 +21,7 @@ use crate::{
     },
     locale::Locale,
     problem::{PROBLEM_BASE, Problem},
+    records::Record,
     secret::Secret,
 };
 
@@ -41,31 +44,51 @@ pub struct RunResource {
 pub struct Greeting(pub String);
 
 pub fn serve(state: &AppState, mut ctx: Ctx, target: &RunResource) -> Response {
-    let mut runs = state.runs();
-    let Some(run) = runs.get_mut(ctx.param("id")) else {
-        return Problem::new(
-            StatusCode::NOT_FOUND,
-            "no-such-run",
-            "There is no such run. There may never have been.",
-        )
-        .into_response();
+    let id = ctx.param("id").to_owned();
+    let Some(slot) = state.runs.get(&id) else {
+        return match state.records.find(&id) {
+            Some(Record {
+                ending: Some(ending),
+                turn,
+                ..
+            }) => gone(&ending.cause, turn),
+            _ => Problem::new(
+                StatusCode::NOT_FOUND,
+                "no-such-run",
+                "There is no such run. There may never have been.",
+            )
+            .into_response(),
+        };
     };
+    let mut guard = hold(&slot);
+    let run = &mut *guard;
     if let Some(ending) = &run.ended {
-        return Problem::new(StatusCode::GONE, "run-ended", "This run has ended.")
-            .with("cause", format!("{PROBLEM_BASE}{}", ending.cause.slug()))
-            .with("turn", ending.turn)
-            .with("graveyard", "/graveyard")
-            .into_response();
+        return gone(ending.cause.slug(), ending.turn);
     }
     run.last_seen = ctx.now;
     run.observed = None;
     let response =
         gate(run, &ctx, target.scope).unwrap_or_else(|| target.resource.dispatch(run, &ctx));
     let response = finish(run, &ctx, &state.config.secret, response);
-    drop(runs);
+    if run.ended.is_some() || run.clinic.cured {
+        state.records.save(&Record::of(run));
+    }
+    let ended = run.ended.is_some();
+    drop(guard);
+    if ended {
+        state.runs.remove(&id);
+    }
     greet(response, &mut ctx)
 }
 
+fn gone(cause: &str, turn: u32) -> Response {
+    Problem::new(StatusCode::GONE, "run-ended", "This run has ended.")
+        .with("cause", format!("{PROBLEM_BASE}{cause}"))
+        .with("turn", turn)
+        .with("graveyard", "/graveyard")
+        .into_response()
+}
+
 fn gate(run: &mut Run, ctx: &Ctx, scope: Scope) -> Option<Response> {
     if scope == Scope::Pockets {
         return None;

Modified file: src/lib.rs+1

@@ -4,6 +4,7 @@ mod headers;

44 mod http;

55 mod locale;

66 mod problem;

7+mod records;

78 mod secret;

910 #[cfg(test)]

Added file: src/records.rs+176 additions@@ -0,0 +1,176 @@
+//! Finished and finishing runs, kept in SQLite so the graveyard and the leaderboard outlive the process.
+
+use std::{
+    path::Path,
+    sync::{Mutex, MutexGuard, PoisonError},
+    time::{SystemTime, UNIX_EPOCH},
+};
+
+use rusqlite::{Connection, OptionalExtension, Row, params};
+
+use crate::game::Run;
+
+const SCHEMA: &str = "
+CREATE TABLE IF NOT EXISTS runs (
+    id TEXT PRIMARY KEY,
+    public_id TEXT NOT NULL,
+    seeded INTEGER NOT NULL,
+    status TEXT NOT NULL,
+    cause TEXT,
+    detail TEXT,
+    turn INTEGER NOT NULL,
+    floor INTEGER NOT NULL,
+    length REAL NOT NULL,
+    self_reported REAL NOT NULL,
+    girth REAL NOT NULL,
+    viral INTEGER NOT NULL,
+    recorded_at INTEGER NOT NULL
+);
+CREATE INDEX IF NOT EXISTS runs_by_cause ON runs (cause);
+";
+
+/// What the graveyard and the leaderboard need to know about a run, live or long gone.
+pub struct Record {
+    pub id: String,
+    pub public_id: String,
+    pub seeded: bool,
+    pub status: String,
+    pub ending: Option<Ending>,
+    pub turn: u32,
+    pub floor: u8,
+    pub length: f64,
+    pub self_reported: f64,
+    pub girth: f64,
+    pub viral: bool,
+}
+
+pub struct Ending {
+    pub cause: String,
+    pub detail: String,
+}
+
+impl Record {
+    pub fn of(run: &Run) -> Self {
+        Self {
+            id: run.id.clone(),
+            public_id: run.public_id.clone(),
+            seeded: run.seeded,
+            status: run.status().to_owned(),
+            ending: run.ended.as_ref().map(|ending| Ending {
+                cause: ending.cause.slug().to_owned(),
+                detail: ending.cause.detail().to_owned(),
+            }),
+            turn: run.ended.as_ref().map_or(run.turn, |ending| ending.turn),
+            floor: run.floor.number(),
+            length: run.current_length(),
+            self_reported: run.self_reported(),
+            girth: run.girth,
+            viral: run.filmed_at.is_some(),
+        }
+    }
+
+    fn from_row(row: &Row) -> rusqlite::Result<Self> {
+        let cause: Option<String> = row.get("cause")?;
+        let detail: Option<String> = row.get("detail")?;
+        Ok(Self {
+            id: row.get("id")?,
+            public_id: row.get("public_id")?,
+            seeded: row.get("seeded")?,
+            status: row.get("status")?,
+            ending: cause
+                .zip(detail)
+                .map(|(cause, detail)| Ending { cause, detail }),
+            turn: row.get("turn")?,
+            floor: row.get("floor")?,
+            length: row.get("length")?,
+            self_reported: row.get("self_reported")?,
+            girth: row.get("girth")?,
+            viral: row.get("viral")?,
+        })
+    }
+}
+
+pub struct Records {
+    db: Mutex<Connection>,
+}
+
+impl Records {
+    /// WAL lets the leaderboard read while a run is being buried.
+    pub fn open(path: &Path) -> rusqlite::Result<Self> {
+        let db = Connection::open(path)?;
+        db.pragma_update(None, "journal_mode", "WAL")?;
+        db.pragma_update(None, "synchronous", "NORMAL")?;
+        Self::with(db)
+    }
+
+    pub fn in_memory() -> Self {
+        Self::with(Connection::open_in_memory().expect("an in-memory database always opens"))
+            .expect("the schema applies to an empty database")
+    }
+
+    fn with(db: Connection) -> rusqlite::Result<Self> {
+        db.execute_batch(SCHEMA)?;
+        Ok(Self { db: Mutex::new(db) })
+    }
+
+    fn db(&self) -> MutexGuard<'_, Connection> {
+        self.db.lock().unwrap_or_else(PoisonError::into_inner)
+    }
+
+    /// A record that cannot be written is a 500, the same as any other broken promise to persist.
+    pub fn save(&self, record: &Record) {
+        let recorded_at = SystemTime::now()
+            .duration_since(UNIX_EPOCH)
+            .map_or(0, |since| {
+                i64::try_from(since.as_secs()).unwrap_or(i64::MAX)
+            });
+        self.db()
+            .execute(
+                "INSERT OR REPLACE INTO runs (id, public_id, seeded, status, cause, detail, turn,
+                     floor, length, self_reported, girth, viral, recorded_at)
+                 VALUES (?1, ?2, ?3, ?4, ?5, ?6, ?7, ?8, ?9, ?10, ?11, ?12, ?13)",
+                params![
+                    record.id,
+                    record.public_id,
+                    record.seeded,
+                    record.status,
+                    record.ending.as_ref().map(|e| &e.cause),
+                    record.ending.as_ref().map(|e| &e.detail),
+                    record.turn,
+                    record.floor,
+                    record.length,
+                    record.self_reported,
+                    record.girth,
+                    record.viral,
+                    recorded_at,
+                ],
+            )
+            .unwrap_or_else(|e| panic!("run {} could not be recorded: {e}", record.id));
+    }
+
+    pub fn find(&self, id: &str) -> Option<Record> {
+        self.db()
+            .query_row("SELECT * FROM runs WHERE id = ?1", [id], Record::from_row)
+            .optional()
+            .unwrap_or_else(|e| panic!("the records could not be read: {e}"))
+    }
+
+    pub fn dead(&self) -> Vec<Record> {
+        self.query("SELECT * FROM runs WHERE cause IS NOT NULL ORDER BY recorded_at")
+    }
+
+    pub fn all(&self) -> Vec<Record> {
+        self.query("SELECT * FROM runs")
+    }
+
+    fn query(&self, sql: &str) -> Vec<Record> {
+        let db = self.db();
+        let mut statement = db
+            .prepare_cached(sql)
+            .unwrap_or_else(|e| panic!("the records could not be read: {e}"));
+        statement
+            .query_map([], Record::from_row)
+            .and_then(Iterator::collect)
+            .unwrap_or_else(|e| panic!("the records could not be read: {e}"))
+    }
+}

Modified file: src/tests.rs+25 additions@@ -2056,3 +2056,28 @@ async fn the_forum_respects_volume() {
     assert_eq!(board["entries"][0]["public_id"], "stout");
     assert!(board["entries"][0]["volume"].as_f64().unwrap() > 0.0);
 }
+
+#[tokio::test]
+async fn the_dead_outlive_the_server() {
+    let path = std::env::temp_dir().join(format!("jelqd-{}.sqlite", std::process::id()));
+    let config = || Config {
+        db: Some(path.clone()),
+        ..Config::default()
+    };
+    let first = crate::app(config());
+    let created = send(&first, "POST", "/runs", &[], "").await;
+    let location = header(&created, "location").to_owned();
+    send(&first, "DELETE", &location, &[], "").await;
+    drop(first);
+
+    let second = crate::app(config());
+    let gone = send(&second, "GET", &location, &[], "").await;
+    assert_eq!(gone.status(), StatusCode::GONE);
+    let graveyard = json(send(&second, "GET", "/graveyard", &[], "").await).await;
+    assert_eq!(graveyard["runs"].as_array().unwrap().len(), 1);
+    let board = json(send(&second, "GET", "/leaderboard", &[], "").await).await;
+    assert_eq!(board["entries"][0]["status"], "gone");
+    for suffix in ["", "-wal", "-shm"] {
+        let _ = std::fs::remove_file(format!("{}{suffix}", path.display()));
+    }
+}

jelq

Commit 159f0998263b

Commit `159f0998263b`