wip stuff (idk)

src/database/arcade.rs

@@ -0,0 +1,474 @@
+use lazy_static::lazy_static;
+use rusqlite::params;
+use jzon::{array, object, JsonValue};
+use rand::RngExt;
+
+use crate::router::global;
+use crate::sql::SQLite;
+
+lazy_static! {
+    static ref DATABASE: SQLite = SQLite::new("arcade.db", setup_tables);
+}
+
+// A cabinet owns exactly two accounts forever: the MACHINE account (the identity
+// the attract loop and its demo lives run on) and one reusable GUEST account,
+// rewritten from scratch at every credit. Neither is ever handed out twice and
+// neither accumulates, so the arcade never leaves dead users behind.
+//
+// `cards` maps a physical card id to the account it plays as. `last_machine_id`
+// / `last_session` are the "which cabinet is this card sitting at" record: a
+// card account is not owned by any one machine, so /live/end attributes its play
+// to the machine that most recently ran a session for that card. Keeping it as
+// two columns on the row the session already writes is the whole design - no
+// second table, no row to expire, and the attribution can never outlive the
+// mapping it belongs to.
+//
+// `session_until` is the same row's other half and the one that costs money: the
+// moment the credit that /api/arcade/session took stops buying LP-free lives.
+// Before it, a card account plays as a cabinet does; after it, the same account
+// is an ordinary phone account again. It is a stamp rather than a flag so that a
+// cabinet that loses power mid-credit expires on its own with nothing to clean
+// up, and so an operator can size the window with --arcade-session-ttl.
+//
+// `plays` is the bookkeeping ledger: one row per arcade song, cleared or not.
+// `cleared` is 0 for a song whose life gauge emptied: the client plays it out and
+// reports it at /live/retire rather than /live/end (there is no cleared flag on
+// the end wire and live_end_ex records a clear unconditionally), so the retire is
+// the only place the ledger can learn about a failed song. A credit's play is two
+// songs whether they were passed or not, which is what makes the total the number
+// an operator's bookkeeping counts.
+fn setup_tables(conn: &rusqlite::Connection) {
+    conn.execute_batch("
+CREATE TABLE IF NOT EXISTS machines (
+    machine_id       TEXT NOT NULL PRIMARY KEY,
+    name             TEXT NOT NULL,
+    machine_user_id  BIGINT NOT NULL,
+    guest_user_id    BIGINT NOT NULL,
+    created          BIGINT NOT NULL,
+    last_seen        BIGINT NOT NULL
+);
+CREATE TABLE IF NOT EXISTS cards (
+    card_id          TEXT NOT NULL PRIMARY KEY,
+    user_id          BIGINT NOT NULL,
+    created          BIGINT NOT NULL,
+    last_machine_id  TEXT NOT NULL DEFAULT '',
+    last_session     BIGINT NOT NULL DEFAULT 0,
+    session_until    BIGINT NOT NULL DEFAULT 0
+);
+CREATE TABLE IF NOT EXISTS plays (
+    id          INTEGER PRIMARY KEY,
+    machine_id  TEXT NOT NULL,
+    user_id     BIGINT NOT NULL,
+    live_id     BIGINT NOT NULL,
+    level       INT NOT NULL,
+    score       BIGINT NOT NULL,
+    rank        INT NOT NULL,
+    at          BIGINT NOT NULL,
+    cleared     INTEGER NOT NULL DEFAULT 1
+);
+CREATE INDEX IF NOT EXISTS plays_machine ON plays (machine_id);
+    ").unwrap();
+    // Upgrade databases written before the card session record existed. Existing
+    // mappings simply have no cabinet attached until their next session.
+    if conn.prepare("SELECT last_machine_id FROM cards LIMIT 1;").is_err() {
+        println!("Upgrading arcade card table");
+        conn.execute("ALTER TABLE cards ADD COLUMN last_machine_id TEXT NOT NULL DEFAULT '';", []).unwrap();
+        conn.execute("ALTER TABLE cards ADD COLUMN last_session BIGINT NOT NULL DEFAULT 0;", []).unwrap();
+    }
+    // Upgrade databases written before the LP-free window existed. 0 is "this
+    // card is not at a cabinet", so every existing mapping starts closed and
+    // opens at its next session - the safe direction.
+    if conn.prepare("SELECT session_until FROM cards LIMIT 1;").is_err() {
+        println!("Upgrading arcade card table (session window)");
+        conn.execute("ALTER TABLE cards ADD COLUMN session_until BIGINT NOT NULL DEFAULT 0;", []).unwrap();
+    }
+    // Upgrade databases written before failed songs were recorded at all. Every
+    // row already in the ledger got there through /live/end, which is a clear.
+    if conn.prepare("SELECT cleared FROM plays LIMIT 1;").is_err() {
+        println!("Upgrading arcade play table (cleared)");
+        conn.execute("ALTER TABLE plays ADD COLUMN cleared INTEGER NOT NULL DEFAULT 1;", []).unwrap();
+    }
+}
+
+// 16 hex characters, the shape the client stores in ArcadeSaveData.Machine and
+// presents on every later call. It is the only thing that authenticates a
+// cabinet, so it is drawn at full width rather than derived from anything
+// guessable, and re-drawn on the (never observed) collision
+pub fn generate_machine_id() -> String {
+    const CHARSET: &[u8] = b"0123456789abcdef";
+    let mut rng = rand::rng();
+    let id: String = (0..16)
+        .map(|_| CHARSET[rng.random_range(0..CHARSET.len())] as char)
+        .collect();
+    if machine_exists(&id) {
+        return generate_machine_id();
+    }
+    id
+}
+
+pub fn machine_exists(machine_id: &str) -> bool {
+    DATABASE.lock_and_select("SELECT machine_id FROM machines WHERE machine_id=?1", params!(machine_id)).is_ok()
+}
+
+pub fn insert_machine(machine_id: &str, name: &str, machine_user_id: i64, guest_user_id: i64) {
+    let now = global::timestamp() as i64;
+    DATABASE.lock_and_exec(
+        "INSERT INTO machines (machine_id, name, machine_user_id, guest_user_id, created, last_seen) VALUES (?1, ?2, ?3, ?4, ?5, ?5)",
+        params!(machine_id, name, machine_user_id, guest_user_id, now)
+    );
+}
+
+fn machine_row(conn: &rusqlite::Connection, machine_id: &str) -> Option<JsonValue> {
+    let mut stmt = conn.prepare("SELECT machine_id, name, machine_user_id, guest_user_id, created, last_seen FROM machines WHERE machine_id=?1").ok()?;
+    stmt.query_row(params!(machine_id), |row| {
+        Ok(object!{
+            machine_id: row.get::<usize, String>(0)?,
+            name: row.get::<usize, String>(1)?,
+            machine_user_id: row.get::<usize, i64>(2)?,
+            guest_user_id: row.get::<usize, i64>(3)?,
+            created: row.get::<usize, i64>(4)?,
+            last_seen: row.get::<usize, i64>(5)?
+        })
+    }).ok()
+}
+
+pub fn get_machine(machine_id: &str) -> Option<JsonValue> {
+    let conn = rusqlite::Connection::open(DATABASE.get_path()).ok()?;
+    machine_row(&conn, machine_id)
+}
+
+// The cabinet is alive: every session (and every play it records) stamps it, and
+// the purge sweeper measures a machine's age from here
+pub fn touch_machine(machine_id: &str) {
+    DATABASE.lock_and_exec("UPDATE machines SET last_seen=?1 WHERE machine_id=?2", params!(global::timestamp() as i64, machine_id));
+}
+
+// The machine a user account belongs to, when the account IS one of a cabinet's
+// own two identities. A card-bound player account is nobody's, and answers None
+pub fn machine_of_account(user_id: i64) -> Option<JsonValue> {
+    let conn = rusqlite::Connection::open(DATABASE.get_path()).ok()?;
+    let mut stmt = conn.prepare("SELECT machine_id FROM machines WHERE machine_user_id=?1 OR guest_user_id=?1").ok()?;
+    let machine_id: String = stmt.query_row(params!(user_id), |row| row.get(0)).ok()?;
+    machine_row(&conn, &machine_id)
+}
+
+pub fn delete_machine(machine_id: &str) {
+    DATABASE.lock_and_exec("DELETE FROM plays WHERE machine_id=?1", params!(machine_id));
+    DATABASE.lock_and_exec("UPDATE cards SET last_machine_id='', last_session=0, session_until=0 WHERE last_machine_id=?1", params!(machine_id));
+    DATABASE.lock_and_exec("DELETE FROM machines WHERE machine_id=?1", params!(machine_id));
+}
+
+// Every machine with its play count, newest sighting first - the webui list
+pub fn list_machines() -> JsonValue {
+    let Ok(conn) = rusqlite::Connection::open(DATABASE.get_path()) else {
+        return array![];
+    };
+    let Ok(mut stmt) = conn.prepare("
+        SELECT m.machine_id, m.name, m.machine_user_id, m.guest_user_id, m.created, m.last_seen,
+               (SELECT COUNT(*) FROM plays p WHERE p.machine_id = m.machine_id),
+               (SELECT COUNT(*) FROM plays p WHERE p.machine_id = m.machine_id AND p.cleared <> 0)
+        FROM machines m ORDER BY m.last_seen DESC
+    ") else {
+        return array![];
+    };
+    let Ok(mapped) = stmt.query_map(params!(), |row| {
+        Ok(object!{
+            machine_id: row.get::<usize, String>(0)?,
+            name: row.get::<usize, String>(1)?,
+            machine_user_id: row.get::<usize, i64>(2)?,
+            guest_user_id: row.get::<usize, i64>(3)?,
+            created: row.get::<usize, i64>(4)?,
+            last_seen: row.get::<usize, i64>(5)?,
+            play_count: row.get::<usize, i64>(6)?,
+            cleared_count: row.get::<usize, i64>(7)?
+        })
+    }) else {
+        return array![];
+    };
+    let mut rv = array![];
+    for row in mapped.flatten() {
+        rv.push(row).unwrap();
+    }
+    rv
+}
+
+// Machines whose last sighting is older than `cutoff`. The two account ids come
+// back with them: the sweeper deletes the accounts in the same pass
+pub fn machines_last_seen_before(cutoff: i64) -> JsonValue {
+    let Ok(conn) = rusqlite::Connection::open(DATABASE.get_path()) else {
+        return array![];
+    };
+    let Ok(mut stmt) = conn.prepare("SELECT machine_id, machine_user_id, guest_user_id, last_seen FROM machines WHERE last_seen < ?1") else {
+        return array![];
+    };
+    let Ok(mapped) = stmt.query_map(params!(cutoff), |row| {
+        Ok(object!{
+            machine_id: row.get::<usize, String>(0)?,
+            machine_user_id: row.get::<usize, i64>(1)?,
+            guest_user_id: row.get::<usize, i64>(2)?,
+            last_seen: row.get::<usize, i64>(3)?
+        })
+    }) else {
+        return array![];
+    };
+    let mut rv = array![];
+    for row in mapped.flatten() {
+        rv.push(row).unwrap();
+    }
+    rv
+}
+
+pub fn card_user(card_id: &str) -> Option<i64> {
+    DATABASE.lock_and_select_type("SELECT user_id FROM cards WHERE card_id=?1", params!(card_id)).ok()
+}
+
+// Point a card at an account. `created` survives a re-bind: the card is the same
+// physical object, only the account behind it changed. The cabinet record is
+// cleared, because the previous holder's sessions say nothing about this one -
+// and so is the LP-free window, which was bought for the previous account
+pub fn set_card(card_id: &str, user_id: i64) {
+    DATABASE.lock_and_exec(
+        "INSERT INTO cards (card_id, user_id, created, last_machine_id, last_session, session_until) VALUES (?1, ?2, ?3, '', 0, 0)
+         ON CONFLICT(card_id) DO UPDATE SET user_id=?2, last_machine_id='', last_session=0, session_until=0",
+        params!(card_id, user_id, global::timestamp() as i64)
+    );
+}
+
+// The cabinet this card is playing at right now and how long the credit it just
+// paid buys LP-free lives for. Written by /api/arcade/session, and only there:
+// the session is the one moment the server knows a credit was taken
+pub fn open_card_session(card_id: &str, machine_id: &str, until: i64) {
+    DATABASE.lock_and_exec(
+        "UPDATE cards SET last_machine_id=?1, last_session=?2, session_until=?3 WHERE card_id=?4",
+        params!(machine_id, global::timestamp() as i64, until, card_id)
+    );
+}
+
+// The card of this account whose cabinet session is still open at `now`, as
+// (card id, when the session started). None when no card of the account is at a
+// cabinet - which is every phone account, and every card between credits.
+pub fn live_card_session(user_id: i64, now: i64) -> Option<(String, i64)> {
+    let conn = rusqlite::Connection::open(DATABASE.get_path()).ok()?;
+    let mut stmt = conn.prepare(
+        "SELECT card_id, last_session FROM cards WHERE user_id=?1 AND session_until>?2 ORDER BY session_until DESC LIMIT 1"
+    ).ok()?;
+    stmt.query_row(params!(user_id, now), |row| Ok((row.get::<usize, String>(0)?, row.get::<usize, i64>(1)?))).ok()
+}
+
+// A live starting inside the window pushes its end back, so a credit whose songs
+// run long is not cut off mid-play. Only ever forward, and never past the
+// ceiling the caller computed from the session itself: extending without a
+// ceiling would turn one credit into an endless supply of LP-free lives
+pub fn extend_card_session(card_id: &str, until: i64) {
+    DATABASE.lock_and_exec(
+        "UPDATE cards SET session_until=?1 WHERE card_id=?2 AND session_until<?1",
+        params!(until, card_id)
+    );
+}
+
+// Only the session tests need to age a card's window; production code only ever
+// opens one at a session or pushes it forward through extend_card_session
+#[cfg(test)]
+pub fn backdate_card_session_for_test(card_id: &str, last_session: i64, session_until: i64) {
+    DATABASE.lock_and_exec(
+        "UPDATE cards SET last_session=?1, session_until=?2 WHERE card_id=?3",
+        params!(last_session, session_until, card_id)
+    );
+}
+
+// The machine that most recently ran a session for this account through any of
+// its cards. Empty when the account has no card, or has never been at a cabinet
+pub fn last_machine_of_card_account(user_id: i64) -> Option<String> {
+    let machine_id: String = DATABASE.lock_and_select_type(
+        "SELECT last_machine_id FROM cards WHERE user_id=?1 AND last_machine_id<>'' ORDER BY last_session DESC LIMIT 1",
+        params!(user_id)
+    ).ok()?;
+    if machine_id.is_empty() {
+        return None;
+    }
+    Some(machine_id)
+}
+
+pub fn account_has_card(user_id: i64) -> bool {
+    DATABASE.lock_and_select("SELECT card_id FROM cards WHERE user_id=?1", params!(user_id)).is_ok()
+}
+
+pub fn insert_play(machine_id: &str, user_id: i64, live_id: i64, level: i64, score: i64, rank: i64, cleared: bool) {
+    DATABASE.lock_and_exec(
+        "INSERT INTO plays (machine_id, user_id, live_id, level, score, rank, at, cleared) VALUES (?1, ?2, ?3, ?4, ?5, ?6, ?7, ?8)",
+        params!(machine_id, user_id, live_id, level, score, rank, global::timestamp() as i64, i64::from(cleared))
+    );
+}
+
+// Only the sweeper's own test needs to move a cabinet's clock; production code
+// only ever stamps last_seen forward through touch_machine
+#[cfg(test)]
+pub fn backdate_machine_for_test(machine_id: &str, last_seen: i64) {
+    DATABASE.lock_and_exec("UPDATE machines SET last_seen=?1 WHERE machine_id=?2", params!(last_seen, machine_id));
+}
+
+pub fn play_count(machine_id: &str) -> i64 {
+    DATABASE.lock_and_select_type("SELECT COUNT(*) FROM plays WHERE machine_id=?1", params!(machine_id)).unwrap_or(0)
+}
+
+// The cabinet's ledger, newest first. Only the tests read it back today - the
+// webui counts rows rather than listing them - but the ledger exists to be read
+pub fn plays_of_machine(machine_id: &str) -> JsonValue {
+    let Ok(conn) = rusqlite::Connection::open(DATABASE.get_path()) else {
+        return array![];
+    };
+    let Ok(mut stmt) = conn.prepare(
+        "SELECT user_id, live_id, level, score, rank, at, cleared FROM plays WHERE machine_id=?1 ORDER BY id DESC"
+    ) else {
+        return array![];
+    };
+    let Ok(mapped) = stmt.query_map(params!(machine_id), |row| {
+        Ok(object!{
+            user_id: row.get::<usize, i64>(0)?,
+            live_id: row.get::<usize, i64>(1)?,
+            level: row.get::<usize, i64>(2)?,
+            score: row.get::<usize, i64>(3)?,
+            rank: row.get::<usize, i64>(4)?,
+            at: row.get::<usize, i64>(5)?,
+            cleared: row.get::<usize, i64>(6)? != 0
+        })
+    }) else {
+        return array![];
+    };
+    let mut rv = array![];
+    for row in mapped.flatten() {
+        rv.push(row).unwrap();
+    }
+    rv
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    // A cabinet owns its two accounts, is found from either of them, and its
+    // last_seen is what the purge sweeper measures
+    #[test]
+    fn a_machine_owns_its_two_accounts() {
+        let _lock = crate::runtime::lock_test_data_path();
+
+        let id = generate_machine_id();
+        assert_eq!(id.len(), 16);
+        assert!(id.chars().all(|c| c.is_ascii_hexdigit()));
+
+        insert_machine(&id, "Cabinet 1", 111_111_111_111_111, 222_222_222_222_222);
+        let machine = get_machine(&id).unwrap();
+        assert_eq!(machine["name"].as_str(), Some("Cabinet 1"));
+        assert_eq!(machine["machine_user_id"].as_i64(), Some(111_111_111_111_111));
+        assert_eq!(machine["guest_user_id"].as_i64(), Some(222_222_222_222_222));
+
+        // Either of the two identities finds the cabinet; a stranger does not
+        assert_eq!(machine_of_account(111_111_111_111_111).unwrap()["machine_id"].as_str(), Some(id.as_str()));
+        assert_eq!(machine_of_account(222_222_222_222_222).unwrap()["machine_id"].as_str(), Some(id.as_str()));
+        assert!(machine_of_account(999_999_999_999_999).is_none());
+
+        // Aged out by the sweeper's cutoff, and only then
+        let seen = machine["last_seen"].as_i64().unwrap();
+        assert!(machines_last_seen_before(seen + 1).members().any(|m| m["machine_id"] == id.as_str()));
+        assert!(!machines_last_seen_before(seen).members().any(|m| m["machine_id"] == id.as_str()));
+
+        delete_machine(&id);
+        assert!(get_machine(&id).is_none());
+    }
+
+    // A card names an account; a re-bind repoints it and drops the previous
+    // holder's cabinet record; plays are attributed to the cabinet the card last
+    // sat at and die with the machine
+    #[test]
+    fn a_card_names_an_account_and_its_last_cabinet() {
+        let _lock = crate::runtime::lock_test_data_path();
+
+        let machine = generate_machine_id();
+        insert_machine(&machine, "Cabinet 2", 333_333_333_333_333, 444_444_444_444_444);
+        let card = "0123456789012345";
+
+        assert!(card_user(card).is_none());
+        set_card(card, 555_555_555_555_555);
+        assert_eq!(card_user(card), Some(555_555_555_555_555));
+        assert!(account_has_card(555_555_555_555_555));
+        // Never at a cabinet yet
+        assert!(last_machine_of_card_account(555_555_555_555_555).is_none());
+
+        let now = global::timestamp() as i64;
+        open_card_session(card, &machine, now + 60);
+        assert_eq!(last_machine_of_card_account(555_555_555_555_555).as_deref(), Some(machine.as_str()));
+
+        // A re-bind keeps the card, moves the account and forgets the cabinet -
+        // and the window the previous account's credit paid for
+        set_card(card, 666_666_666_666_666);
+        assert_eq!(card_user(card), Some(666_666_666_666_666));
+        assert!(!account_has_card(555_555_555_555_555));
+        assert!(last_machine_of_card_account(666_666_666_666_666).is_none());
+        assert!(live_card_session(666_666_666_666_666, now).is_none(), "a re-bind carried the previous account's credit over");
+
+        assert_eq!(play_count(&machine), 0);
+        insert_play(&machine, 666_666_666_666_666, 1100101, 4, 654_321, 3, true);
+        insert_play(&machine, 666_666_666_666_666, 1100101, 4, 123_456, 2, false);
+        assert_eq!(play_count(&machine), 2);
+        // A failed song is a song: it is in the ledger and in the total, and the
+        // cleared count is what separates the two
+        assert!(list_machines().members().any(|m|
+            m["machine_id"] == machine.as_str() && m["play_count"] == 2 && m["cleared_count"] == 1
+        ));
+        let ledger = plays_of_machine(&machine);
+        assert_eq!(ledger.len(), 2);
+        assert_eq!(ledger[0]["cleared"].as_bool(), Some(false));
+        assert_eq!(ledger[0]["score"].as_i64(), Some(123_456));
+        assert_eq!(ledger[1]["cleared"].as_bool(), Some(true));
+
+        // Removing the cabinet takes its ledger with it and unlinks the card
+        open_card_session(card, &machine, now + 60);
+        delete_machine(&machine);
+        assert_eq!(play_count(&machine), 0);
+        assert!(last_machine_of_card_account(666_666_666_666_666).is_none());
+        assert!(live_card_session(666_666_666_666_666, now).is_none(), "a retired cabinet left a credit open");
+        assert_eq!(card_user(card), Some(666_666_666_666_666));
+    }
+
+    // The credit a card paid for is a window on its own row: open until it is
+    // not, pushed forward but never backward, and never shared with another card
+    // of another account
+    #[test]
+    fn a_credit_opens_a_window_that_closes_on_its_own() {
+        let _lock = crate::runtime::lock_test_data_path();
+
+        let machine = generate_machine_id();
+        insert_machine(&machine, "Cabinet 3", 777_777_777_777_777, 888_888_888_888_888);
+        let card = "1212121212121212";
+        let user = 121_212_121_212_121;
+        let now = global::timestamp() as i64;
+
+        // A mapping with no session behind it is not a cabinet session
+        set_card(card, user);
+        assert!(live_card_session(user, now).is_none());
+
+        open_card_session(card, &machine, now + 600);
+        let (open_card, opened) = live_card_session(user, now).expect("the credit did not open a window");
+        assert_eq!(open_card, card);
+        assert!(opened <= now && opened >= now - 5, "the session start was not stamped: {} vs {}", opened, now);
+
+        // The window closes by itself, with nothing to sweep
+        assert!(live_card_session(user, now + 599).is_some());
+        assert!(live_card_session(user, now + 600).is_none(), "the window outlived its own expiry");
+        assert!(live_card_session(user, now + 601).is_none());
+
+        // A live inside it pushes it forward, and only forward
+        extend_card_session(card, now + 1200);
+        assert!(live_card_session(user, now + 900).is_some());
+        extend_card_session(card, now + 300);
+        assert!(live_card_session(user, now + 900).is_some(), "an extension moved the window backwards");
+
+        // Another account's card is untouched by any of it
+        let other_card = "3434343434343434";
+        let other_user = 343_434_343_434_343;
+        set_card(other_card, other_user);
+        assert!(live_card_session(other_user, now).is_none());
+
+        delete_machine(&machine);
+    }
+}