//! The service log's checkpoint (`spec/STORE.md`, "Bounds" and "Scale"): //! what the service log holds now, folded from the checkpoint before and the //! sealed logs after it into a sorted table (`pds_store::table`), read as it //! is needed through the block cache the accounts' tables share, never //! whole. Its entries, by key: //! //! - `A` + DID: the account's **row**, `[ordinal, u64 big-endian][a JSON //! array]`: the entries that make the account again (`One::entries`), its //! `account` entry with the handle, email and password it has now, its //! app passwords and the sessions it keeps, what is known of its email //! and the tokens mailed for it, its state, and its preferences as last //! put. The ordinal is its place in the order accounts were made, given //! once: a deleted account's is never given again; //! - `H` + handle + NUL + DID, `M` + email + NUL + DID and `T` + password //! reset token + NUL + DID, each with no value: **hints**, the accounts //! that may have that handle, email or token. What an account has is what //! its row says, so whoever follows a hint loads the account and looks; //! - `O` + ordinal, u64 big-endian: the DID, every account's, which //! `listRepos` reads in order; //! - `R` + index, u64 big-endian: a JSON array of at most `ROW_ENTRIES` //! entries that are not one account's, in the order they are replayed: //! the invite codes and their uses, the single-use values still held, //! each deletion whose event is in the backfill window and the firehose //! events the log holds in it, OAuth's entries with only each session's //! latest refresh and what each device's last entries leave, the marks //! standing (`cache`), and with blobs in a bucket, the objects of deleted //! accounts not yet deleted (`blobstore`); //! - `S`: one JSON object, the `Summary`: its generation, the last event's //! seq and the greatest reserved, the next ordinal, and how many accounts //! there are, and of them deactivated and taken down. //! //! The fold reads the logs, not memory, so that it is exactly what replay //! would make of them: a frame at a time, keeping what is not one account's //! as it is replayed, and of the accounts only the entries the logs hold, //! as text, by DID. Then one pass over the rows before in order of DID: a //! row no log touched is copied as it is, unparsed; one a log touched is //! its entries and the logs' folded (`One`) and written; a deleted //! account's is left out. The hints and ordinals before are copied but //! those of the accounts the logs touched, which are written as their rows //! now say. So what a fold holds follows the logs it folds, not the //! accounts there are (`spec/STORE.md`, "Scale"). It leaves out sessions //! that expired more than `MARGIN` ago, and single-use values held no //! longer than that: none of those can be named by an entry still to come. //! //! A checkpoint of the format before this one, a log of frames whose first //! names its generation, is folded alone into a table of the same //! generation when a start finds it (`convert`). use crate::email::Mail; use crate::lifecycle::State; use crate::log::AccountEntry; use crate::sessions::{self, Keep}; use pds_store::Layout; use pds_store::table::{BlockCache, Table, TableWriter}; use serde_json::{Value as Json, json}; use std::collections::{BTreeMap, BTreeSet, HashMap, HashSet}; use std::fs::File; use std::io::{self, Write}; use std::path::{Path, PathBuf}; use std::sync::Arc; /// How long past its expiry a session is kept on disk. pub(crate) const MARGIN: u64 = 60 * 60; /// How many entries go in one `R` row: few, so that a start, which parses a /// row whole before it replays it, holds little of it at once /// (`spec/STORE.md`, "Scale"). const ROW_ENTRIES: usize = 32; /// The format's version, the only one this server knows. const VERSION: u64 = 1; /// The kind of the first entry of a service checkpoint of the format before. const HEADER: &str = "checkpoint"; /// The bytes of the table before a fold holds as it reads it. const FOLD_CACHE: u64 = 4 << 20; const ROW: u8 = b'A'; pub(crate) const HANDLE: u8 = b'H'; pub(crate) const EMAIL: u8 = b'M'; const ORDER: u8 = b'O'; const REST: u8 = b'R'; const SUMMARY: &[u8] = b"S"; pub(crate) const TOKEN: u8 = b'T'; fn row_key(did: &str) -> Vec { [&[ROW], did.as_bytes()].concat() } /// The start of every hint of `name` in `section`. fn hint_prefix(section: u8, name: &str) -> Vec { [&[section], name.as_bytes(), &[0]].concat() } /// The hint that `did` may have `name`: no name holds a NUL. fn hint_key(section: u8, name: &str, did: &str) -> Result, String> { if name.contains('\0') || did.contains('\0') { return Err(format!("{did}: {name:?} holds a NUL")); } Ok([&hint_prefix(section, name), did.as_bytes()].concat()) } fn numbered(section: u8, n: u64) -> Vec { [&[section][..], &n.to_be_bytes()].concat() } fn number_of(key: &[u8]) -> Option { Some(u64::from_be_bytes(key.get(1..)?.try_into().ok()?)) } /// The DID a hint or an ordinal names. fn named_did<'a>(section: u8, key: &'a [u8], value: &'a [u8]) -> Option<&'a str> { let did = if section == ORDER { value } else { let nul = key.iter().position(|b| *b == 0)?; &key[nul + 1..] }; std::str::from_utf8(did).ok() } fn row_value(ordinal: u64, entries: &[Json]) -> Vec { let mut out = ordinal.to_be_bytes().to_vec(); serde_json::to_writer(&mut out, entries).expect("entries serialize"); out } /// A row's ordinal and entries. fn parse_row(v: &[u8]) -> Result<(u64, Vec), String> { let ordinal = v .get(..8) .and_then(|n| n.try_into().ok()) .map(u64::from_be_bytes) .ok_or("a row with no ordinal")?; let entries = serde_json::from_slice(&v[8..]).map_err(|e| format!("a row: {e}"))?; Ok((ordinal, entries)) } /// The `S` entry: what a start reads of a table before anything else. #[derive(Clone, Debug, Default, PartialEq, Eq)] pub(crate) struct Summary { pub generation: u64, /// The greatest seq of the events the service log has held. pub last_seq: u64, /// The greatest seq reserved (`events::SEQS`), if any was. pub ceiling: Option, /// The ordinal the next account made is given. pub next_ordinal: u64, /// How many accounts there are, and of them deactivated, and taken down. pub accounts: u64, pub deactivated: u64, pub takendown: u64, } impl Summary { fn encode(&self) -> Vec { let mut s = json!({ "version": VERSION, "generation": self.generation, "lastSeq": self.last_seq, "nextOrdinal": self.next_ordinal, "accounts": { "count": self.accounts, "deactivated": self.deactivated, "takendown": self.takendown }, }); if let Some(c) = self.ceiling { s["ceiling"] = json!(c); } s.to_string().into_bytes() } fn decode(bytes: &[u8]) -> Result { let s: Json = serde_json::from_slice(bytes).map_err(|e| format!("its summary: {e}"))?; if s["version"].as_u64() != Some(VERSION) { return Err(format!("a checkpoint of version {}", s["version"])); } let number = |v: &Json, what: &str| { v.as_u64() .ok_or_else(|| format!("a summary with no {what}: {s}")) }; let ceiling = match s.get("ceiling") { None => None, Some(c) => Some(number(c, "ceiling that is a number")?), }; Ok(Summary { generation: number(&s["generation"], "generation")?, last_seq: number(&s["lastSeq"], "lastSeq")?, ceiling, next_ordinal: number(&s["nextOrdinal"], "nextOrdinal")?, accounts: number(&s["accounts"]["count"], "count of accounts")?, deactivated: number( &s["accounts"]["deactivated"], "count of accounts deactivated", )?, takendown: number(&s["accounts"]["takendown"], "count of accounts taken down")?, }) } /// Count an account in, or out as its row before had it. fn count(&mut self, one: &One, add: bool) { let (deactivated, takendown) = ( u64::from(one.state.deactivated), u64::from(one.state.takedown.is_some()), ); if add { self.accounts += 1; self.deactivated += deactivated; self.takendown += takendown; } else { self.accounts = self.accounts.saturating_sub(1); self.deactivated = self.deactivated.saturating_sub(deactivated); self.takendown = self.takendown.saturating_sub(takendown); } } } /// The most bytes the first frame of a service checkpoint of the format /// before takes: its header's, a few numbers. const LEGACY_HEADER: u64 = 1024; /// What the header of the file at `path` says, if the file is a service /// checkpoint of the format before: a log whose first frame is its header. /// Told by that frame, whose check no table's first bytes pass, not by how /// the file ends, which is entries an account wrote. fn legacy_header(path: &Path) -> io::Result)>> { use std::os::unix::fs::FileExt; let file = File::open(path)?; let mut len = [0u8; 4]; if file.read_exact_at(&mut len, 0).is_err() { return Ok(None); } let len = (pds_store::HEADER + u32::from_le_bytes(len) as usize) as u64; if len > LEGACY_HEADER.min(file.metadata()?.len()) { return Ok(None); } Ok(pds_store::read_frame(path, 0, len) .ok() .and_then(|first| header_of(&first).ok())) } /// A service checkpoint, read: its summary held, its rows, hints and /// ordinals read as they are asked for, through `blocks`. pub(crate) struct ServiceTable { table: Table, file: File, blocks: Arc, pub summary: Summary, } impl Drop for ServiceTable { fn drop(&mut self) { self.blocks.forget(self.table.id()); } } impl ServiceTable { /// The table at `path`, if there is a file there. pub fn open(path: &Path, blocks: Arc) -> Result, String> { match File::open(path) { Ok(file) => ServiceTable::open_file(path, file, blocks).map(Some), Err(e) if e.kind() == io::ErrorKind::NotFound => Ok(None), Err(e) => Err(format!("{}: {e}", path.display())), } } /// The table `file` holds, which is, or is about to be, at `path`. pub fn open_file( path: &Path, file: File, blocks: Arc, ) -> Result { let at = |why: String| format!("{}: {why}", path.display()); let table = Table::open_file(path, &file).map_err(|e| e.to_string())?; let summary = table .get_in(SUMMARY, Some(&file), &blocks) .map_err(|e| e.to_string())? .ok_or_else(|| at("a checkpoint with no summary".into()))?; let summary = Summary::decode(&summary).map_err(at)?; Ok(ServiceTable { table, file, blocks, summary, }) } /// Its file's bytes. pub fn size(&self) -> u64 { self.table.size() } fn get(&self, key: &[u8]) -> Result>, String> { self.table .get_in(key, Some(&self.file), &self.blocks) .map_err(|e| e.to_string()) } /// The entries of `section` from the first whose key is `from` or after. fn section<'a>( &'a self, section: u8, from: &[u8], ) -> impl Iterator, Vec), String>> + use<'a> { self.table .iter(from, Some(&self.file), &self.blocks) .map(|r| r.map_err(|e| e.to_string())) .take_while(move |r| { r.as_ref() .map_or(true, |(k, _)| k.first() == Some(§ion)) }) } /// Whether it may hold a row of `did`: false only if it holds none. /// Reads nothing. pub fn may_hold(&self, did: &str) -> bool { self.table.may_hold(&row_key(did)) } /// Whether it holds a row of `did`. pub fn has(&self, did: &str) -> Result { Ok(self.get(&row_key(did))?.is_some()) } /// The row of `did`: its ordinal and entries. pub fn row(&self, did: &str) -> Result)>, String> { match self.get(&row_key(did))? { Some(v) => parse_row(&v) .map(Some) .map_err(|why| format!("{}: {did}: {why}", self.table.path().display())), None => Ok(None), } } /// The accounts hinted to have `name`, a handle (`HANDLE`), an email /// (`EMAIL`) or a password reset token (`TOKEN`). pub fn hints(&self, section: u8, name: &str) -> Result, String> { let prefix = hint_prefix(section, name); let mut out = Vec::new(); for r in self.section(section, &prefix) { let (k, _) = r?; let Some(did) = k.strip_prefix(prefix.as_slice()) else { break; }; out.push(String::from_utf8_lossy(did).into_owned()); } Ok(out) } /// Each account's ordinal and DID, in order, from ordinal `from` on. pub fn order(&self, from: u64) -> impl Iterator> + '_ { self.section(ORDER, &numbered(ORDER, from)).map(|r| { let (k, v) = r?; let n = number_of(&k).ok_or("an ordinal that does not parse")?; Ok((n, String::from_utf8_lossy(&v).into_owned())) }) } /// Give `f` each `R` row's entries, in order. pub fn rest(&self, mut f: impl FnMut(Vec) -> Result<(), String>) -> Result<(), String> { for r in self.section(REST, &[REST]) { let (_, v) = r?; f(serde_json::from_slice(&v).map_err(|e| format!("a row of entries: {e}"))?)?; } Ok(()) } } /// The DID of the account an entry of the service log is of, if it is one /// account's, kept in its row: its `account` entry, a change to its /// sessions and app passwords, to its email, password and mailed tokens, to /// its state or its preferences, or a mark that gives its handle. pub(crate) fn of_account(e: &Json) -> Result, String> { let Some(t) = e["t"].as_str() else { return Ok(None); }; let one = t == "account" || sessions::ENTRIES.contains(&t) || crate::email::ENTRIES.contains(&t) || crate::lifecycle::STATES.contains(&t) || t == crate::preferences::ENTRY || (t == crate::cache::DIR && e.get("handle").is_some()); if !one { return Ok(None); } e["did"] .as_str() .map(Some) .ok_or_else(|| format!("an entry with no did: {e}")) } /// One account, as the entries of its row and of the logs after leave it. #[derive(Default)] pub(crate) struct One { /// Its `account` entry, as logged. account: Option, /// Its email and password, and what is known of the email: of an account made. mail: Option, keep: Keep, state: State, /// Its preferences as last put: the entry. prefs: Option, /// The handle its marks last gave it, if any did. handle: Option, } /// What an account is made of, parsed: what `One` leaves of it. pub(crate) struct Parts { pub entry: AccountEntry, pub mail: Mail, pub keep: Keep, pub state: State, pub prefs: Option>, } impl One { /// Make the change an entry of the account's says (`of_account`). pub fn apply(&mut self, e: Json) -> Result<(), String> { let t = e["t"].as_str().unwrap_or_default(); if t == "account" { if self.account.is_some() { return Err(format!("a second account with the DID of {}", e["did"])); } let text = |k: &str| e[k].as_str().map(str::to_string); self.mail = Some(Mail::new(text("email"), text("password"))); self.account = Some(e); return Ok(()); } let Some(mail) = &mut self.mail else { return Err(format!("a {t} entry of {}, which no account has", e["did"])); }; if sessions::ENTRIES.contains(&t) { self.keep.apply(&e) } else if crate::email::ENTRIES.contains(&t) { mail.apply(&e) } else if crate::lifecycle::STATES.contains(&t) { self.state.apply(&e) } else if t == crate::preferences::ENTRY { crate::preferences::parse(&e)?; self.prefs = Some(e); Ok(()) } else if t == crate::cache::DIR { if let Some(h) = e.get("handle") { let h = h .as_str() .ok_or_else(|| format!("a mark whose handle is not a string: {e}"))?; self.handle = Some(h.to_string()); } Ok(()) } else { Err(format!("a log entry that is not one account's: {t:?}")) } } /// Whether its `account` entry made it. pub fn is_made(&self) -> bool { self.account.is_some() } /// Its handle: the last its marks gave it, or else its entry's. fn handle(&self) -> Option<&str> { self.handle .as_deref() .or_else(|| self.account.as_ref()?.get("handle")?.as_str()) } /// The entries that make it again, for its row: its `account` entry /// with the handle, email and password it has now, then its sessions /// and app passwords but the sessions that expired before `before`, its /// mail, its state, and its preferences. fn entries(&self, did: &str, before: u64) -> Result, String> { let (Some(account), Some(mail)) = (&self.account, &self.mail) else { return Err(format!("{did}: no account entry made it")); }; let mut a = account.clone(); a["email"] = json!(mail.email); a["password"] = json!(mail.password); if let Some(h) = &self.handle { a["handle"] = json!(h); } let mut out = vec![a]; out.extend(self.keep.entries(did, before)); out.extend(mail.entries(did)); out.extend(self.state.entries(did)); out.extend(self.prefs.clone()); Ok(out) } /// The account, parsed: an error if what made it does not parse. pub fn parts(self) -> Result { let (Some(account), Some(mail)) = (self.account, self.mail) else { return Err("no account entry made it".into()); }; let mut entry = AccountEntry::parse(&account)?; if let Some(h) = self.handle { entry.handle = h; } let prefs = match &self.prefs { Some(e) => Some(crate::preferences::parse(e)?), None => None, }; Ok(Parts { entry, mail, keep: self.keep, state: self.state, prefs, }) } } /// The service checkpoint of `generation`, written to `out` as it is made: /// the checkpoint before, the file at `checkpoint` if there is one, a table /// or of the format before, and the sealed logs after it, `logs` in order, /// read a frame at a time and folded, at `now` in seconds, keeping the /// events `keep` keeps. pub(crate) fn fold_files( checkpoint: Option<&Path>, logs: &[PathBuf], generation: u64, now: u64, keep: impl Fn(u64, &[u8]) -> bool, out: &mut dyn Write, ) -> Result<(), String> { let mut folder = Folder::new(now.saturating_sub(MARGIN), now); let mut before = Summary::default(); let mut old = None; if let Some(path) = checkpoint { let at = |why: String| format!("{}: {why}", path.display()); if legacy_header(path) .map_err(|e| at(e.to_string()))? .is_some() { let mut first = true; let (whole, size) = pds_store::scan_file(path, |_, _, entries| { if std::mem::take(&mut first) { (_, before.last_seq, before.ceiling) = header_of(&entries)?; return Ok(()); } entries.into_iter().try_for_each(|e| folder.apply(e)) }) .map_err(|e| at(e.to_string()))? .map_err(at)?; if first || whole != size { return Err(at("a checkpoint that is not whole".into())); } } else { let table = ServiceTable::open(path, Arc::new(BlockCache::new(FOLD_CACHE)))? .ok_or_else(|| at("no longer there".into()))?; before = table.summary.clone(); table.rest(|entries| entries.into_iter().try_for_each(|e| folder.apply(e)))?; old = Some(table); } } for log in logs { pds_store::read_sealed(log, |_, _, entries| { entries.into_iter().try_for_each(|e| folder.apply(e)) })?; } folder.finish(keep, old.as_ref(), &before, generation, out) } /// Make a service checkpoint of the format before a table of the same /// generation, folded alone at `now` in seconds, keeping the events `keep` /// keeps; one that is a table already, or none, is left as it is. The table /// is written beside it, made durable and renamed over it, so that a kill /// at any point leaves one or the other whole. pub(crate) fn convert( layout: &Layout, now: u64, keep: impl Fn(u64, &[u8]) -> bool, ) -> Result<(), String> { let path = layout.checkpoint(); let at = |p: &Path, e: io::Error| format!("{}: {e}", p.display()); let generation = match legacy_header(&path) { Ok(Some((generation, _, _))) => generation, Ok(None) => return Ok(()), Err(e) if e.kind() == io::ErrorKind::NotFound => return Ok(()), Err(e) => return Err(at(&path, e)), }; let tmp = layout.tmp(); let mut out = io::BufWriter::new( pds_store::open_private( &tmp, std::fs::OpenOptions::new() .create(true) .write(true) .truncate(true), ) .map_err(|e| at(&tmp, e))?, ); fold_files(Some(&path), &[], generation, now, keep, &mut out)?; let file = out.into_inner().map_err(|e| at(&tmp, e.into_error()))?; pds_store::sync_file(&file).map_err(|e| at(&tmp, e))?; drop(file); std::fs::rename(&tmp, &path).map_err(|e| at(&tmp, e))?; pds_store::sync_dir(&layout.dir).map_err(|e| at(&layout.dir, e)) } /// What the first frame of a service checkpoint of the format before says: /// its generation, the last seq it names, and the greatest seq reserved, if /// any was. fn header_of(first: &[Json]) -> Result<(u64, u64, Option), String> { let h = match first { [h] if h["t"] == HEADER => h, _ => return Err("a checkpoint whose first frame is not its header".into()), }; let (Some(generation), Some(last_seq)) = (h["generation"].as_u64(), h["lastSeq"].as_u64()) else { return Err(format!( "a checkpoint header with no generation or lastSeq: {h}" )); }; let ceiling = match h.get("ceiling") { None => None, Some(c) => Some( c.as_u64() .ok_or_else(|| format!("a checkpoint header whose ceiling is not a number: {h}"))?, ), }; Ok((generation, last_seq, ceiling)) } /// What the logs folded hold of one account. #[derive(Default)] struct Touched { /// Its entries, as JSON text, one after another with commas between: /// less than they take parsed. text: String, /// Its place among the accounts the logs made, if they made it. made: Option, /// Whether the logs deleted it: its row before, if it had one, does not count. void: bool, /// Whether it is deleted now: not made again since. deleted: bool, } impl Touched { fn push(&mut self, e: &Json) { if !self.text.is_empty() { self.text.push(','); } self.text.push_str(&e.to_string()); } } /// What the entries given so far hold now. Of what is not one account's: /// without anything of the accounts deleted but their deletions whose /// events are kept, nor single-use values and revocations whose `until` is /// not after `now`; the marks kept are those standing (`cache`). Of each /// account an entry names, its entries. struct Folder { /// Sessions that expired before this are left out. before: u64, now: u64, marked: BTreeSet, ceiling: Option, /// Each account the entries name, by DID. touched: BTreeMap, /// How many accounts the entries made: each is given the next ordinal. made: u64, held: Vec, invites: crate::invites::Invites, lifecycle: crate::lifecycle::Replayed, oauth: Vec, spent: Vec, /// Deleted accounts' objects in a bucket not yet deleted, kept apart from /// what the fold drops of the accounts deleted. doomed: crate::blobstore::Doomed, } impl Folder { fn new(before: u64, now: u64) -> Folder { Folder { before, now, marked: Default::default(), ceiling: None, touched: BTreeMap::new(), made: 0, held: Vec::new(), invites: Default::default(), lifecycle: Default::default(), oauth: Vec::new(), spent: Vec::new(), doomed: Default::default(), } } /// Keep an entry of the account `did`, unless it is deleted. fn touch(&mut self, did: &str, e: &Json) { let t = self.touched.entry(did.to_string()).or_default(); if !t.deleted { t.push(e); } } /// Fold one entry in. fn apply(&mut self, e: Json) -> Result<(), String> { let did_of = |e: &Json, what: &str| { e["did"] .as_str() .map(str::to_string) .ok_or_else(|| format!("{what} with no did: {e}")) }; match e["t"].as_str() { Some("account") => { let did = did_of(&e, "an account")?; let t = self.touched.entry(did).or_default(); t.deleted = false; t.made.get_or_insert(self.made); t.push(&e); self.made += 1; } Some(crate::cache::DIR) => { let did = did_of(&e, "a mark")?; if self.touched.get(&did).is_some_and(|t| t.deleted) { return Ok(()); } if e.get("handle").is_some() { self.touch(&did, &e); } if e["eager"].as_bool() == Some(true) { self.marked.insert(did); } else { self.marked.remove(&did); } } Some(t) if crate::lifecycle::ENTRIES.contains(&t) && !crate::lifecycle::STATES.contains(&t) => { if let Some(did) = self.lifecycle.replay(&e)? { let t = self.touched.entry(did.clone()).or_default(); *t = Touched { void: true, deleted: true, ..Touched::default() }; self.marked.remove(&did); // OAuth forgets the account as it is deleted: what it // logs of one made again with the DID after is kept. self.oauth = crate::oauth::without_accounts( std::mem::take(&mut self.oauth), &HashSet::from([did]), ); } } Some(crate::events::SEQS) => { let upto = e["upto"] .as_u64() .ok_or_else(|| format!("seqs with no upto: {e}"))?; self.ceiling = Some(self.ceiling.unwrap_or(0).max(upto)); } Some(t) if crate::invites::ENTRIES.contains(&t) => self.invites.replay(&e)?, Some(t) if crate::oauth::ENTRIES.contains(&t) => self.oauth.push(e), Some(crate::replay::ENTRY) => { if e["until"].as_u64().is_none_or(|u| u > self.before) { self.spent.push(e); } } Some(t) if t == crate::single_use::ENTRY || t == crate::space_credentials::ENTRY => { let until = e["until"] .as_u64() .ok_or_else(|| format!("a {t} entry with no until: {e}"))?; if until > self.now { self.held.push(e); } } Some(t) if crate::blobstore::ENTRIES.contains(&t) => self.doomed.replay(&e)?, t => match of_account(&e)? { Some(did) => { let did = did.to_string(); self.touch(&did, &e); } None => return Err(format!("a log entry of no known type: {t:?}")), }, } Ok(()) } /// Write the table of `generation` to `out`: the rows of `old`, the /// table before, whose summary is `before`, merged with what the /// entries given hold of each account; then the hints and ordinals, the /// entries that are not one account's, the events those `keep` keeps, /// and the summary. fn finish( self, keep: impl Fn(u64, &[u8]) -> bool, old: Option<&ServiceTable>, before: &Summary, generation: u64, out: &mut dyn Write, ) -> Result<(), String> { let werr = |e: io::Error| e.to_string(); let mut summary = Summary { generation, last_seq: self.lifecycle.last_seq().max(before.last_seq), ceiling: self.ceiling.max(before.ceiling), next_ordinal: before.next_ordinal + self.made, ..before.clone() }; let mut w = TableWriter::new( out, old.map_or(0, |t| t.table.len()) + self.touched.len() as u64 * 5 + 64, ); let mut hints = Hints::default(); // The accounts marked that are accounts still, in order of DID. let mut standing: Vec<&str> = Vec::new(); let mut rows = old .into_iter() .flat_map(|t| t.section(ROW, &[ROW])) .peekable(); let mut touched = self.touched.iter().peekable(); loop { let (row, t) = match (rows.peek(), touched.peek()) { (None, None) => break, (Some(Err(_)), _) | (Some(Ok(_)), None) => (rows.next(), None), (None, Some(_)) => (None, touched.next()), (Some(Ok((k, _))), Some((did, _))) => match k[1..].cmp(did.as_bytes()) { std::cmp::Ordering::Less => (rows.next(), None), std::cmp::Ordering::Equal => (rows.next(), touched.next()), std::cmp::Ordering::Greater => (None, touched.next()), }, }; let row = row.transpose()?; let Some((did, t)) = t else { // A row no log touched: as it is. let (k, v) = row.expect("a row, where no account is touched"); if let Some(did) = std::str::from_utf8(&k[1..]) .ok() .and_then(|did| self.marked.get(did)) { standing.push(did); } w.add(&k, &v).map_err(werr)?; continue; }; let row = row.as_ref().map(|(_, v)| v.as_slice()); let Some((ordinal, one)) = settle(did, row, t, before.next_ordinal, &mut summary)? else { continue; }; w.add( &row_key(did), &row_value(ordinal, &one.entries(did, self.before)?), ) .map_err(werr)?; hints.note(did, ordinal, &one)?; if self.marked.contains(did) { standing.push(did); } } drop(rows); let Hints { handles, emails, order, tokens, } = hints; merge(&mut w, old, HANDLE, &self.touched, handles)?; merge(&mut w, old, EMAIL, &self.touched, emails)?; merge(&mut w, old, ORDER, &self.touched, order)?; let mut rest: Vec = self.invites.entries(); rest.extend(self.held); rest.extend(self.lifecycle.entries(keep)); rest.extend(latest_devices(latest_refreshes(latest_passkey_uses( self.oauth, )))); rest.extend(self.spent); rest.extend( standing .iter() .map(|did| crate::cache::dir_entry(did, None, true)), ); rest.extend(self.doomed.entries()); for (i, entries) in rest.chunks(ROW_ENTRIES).enumerate() { let row = serde_json::to_vec(entries).expect("entries serialize"); w.add(&numbered(REST, i as u64), &row).map_err(werr)?; } w.add(SUMMARY, &summary.encode()).map_err(werr)?; merge(&mut w, old, TOKEN, &self.touched, tokens)?; let (out, _) = w.finish().map_err(werr)?; out.flush().map_err(werr) } } /// An account the logs touched, as its row before, `row`, and their /// entries leave it, with its ordinal: the one its row has, or for one the /// logs made, its place among those after `base`. None for one deleted. /// It is counted in `summary`, in place of what its row before counted. fn settle( did: &str, row: Option<&[u8]>, t: &Touched, base: u64, summary: &mut Summary, ) -> Result, String> { let at = |why: String| format!("{did}: {why}"); let mut one = One::default(); let mut ordinal = None; if let Some(v) = row { let (n, entries) = parse_row(v).map_err(at)?; for e in entries { one.apply(e).map_err(at)?; } summary.count(&one, false); if t.void { one = One::default(); } else { ordinal = Some(n); } } if !t.text.is_empty() { let entries: Vec = serde_json::from_str(&format!("[{}]", t.text)) .map_err(|e| at(format!("an entry kept as text: {e}")))?; for e in entries { one.apply(e).map_err(at)?; } } if t.deleted { return Ok(None); } if let Some(n) = t.made { ordinal = Some(base + n); } let (true, Some(ordinal)) = (one.is_made(), ordinal) else { return Err(at("entries of an account no account entry made".into())); }; summary.count(&one, true); Ok(Some((ordinal, one))) } /// The hints and ordinals of the accounts a fold wrote rows of, each as /// its key and value. #[derive(Default)] struct Hints { handles: Vec<(Vec, Vec)>, emails: Vec<(Vec, Vec)>, order: Vec<(Vec, Vec)>, tokens: Vec<(Vec, Vec)>, } impl Hints { fn note(&mut self, did: &str, ordinal: u64, one: &One) -> Result<(), String> { let mail = one.mail.as_ref(); for (section, name, into) in [ (HANDLE, one.handle(), &mut self.handles), ( EMAIL, mail.and_then(|m| m.email.as_deref()), &mut self.emails, ), (TOKEN, mail.and_then(Mail::reset_token), &mut self.tokens), ] { if let Some(name) = name { into.push((hint_key(section, name, did)?, Vec::new())); } } self.order .push((numbered(ORDER, ordinal), did.as_bytes().to_vec())); Ok(()) } } /// Write a section of hints or ordinals: those of `old`, the table before, /// but of the accounts `touched`, merged in order of key with `new`, theirs /// as they are now. fn merge( w: &mut TableWriter, old: Option<&ServiceTable>, section: u8, touched: &BTreeMap, mut new: Vec<(Vec, Vec)>, ) -> Result<(), String> { new.sort(); new.dedup(); let mut new = new.into_iter().peekable(); let mut kept = old .into_iter() .flat_map(|t| t.section(section, &[section])) .filter(|r| { r.as_ref().map_or(true, |(k, v)| { !named_did(section, k, v).is_some_and(|did| touched.contains_key(did)) }) }) .peekable(); loop { let take_new = match (kept.peek(), new.peek()) { (None, None) => break, (Some(_), None) => false, (None, Some(_)) => true, (Some(Err(_)), Some(_)) => false, (Some(Ok((k, _))), Some((n, _))) => n < k, }; let (k, v) = if take_new { new.next().expect("peeked") } else { kept.next().expect("peeked")? }; w.add(&k, &v).map_err(|e| e.to_string())?; } Ok(()) } /// What `fold` answers: the entries kept, in the frames a checkpoint has /// them in, the greatest seq of the events they hold, and of the seqs /// reserved, if any were. #[cfg(test)] type Folded = (Vec>, u64, Option); /// What `frames` hold now, as a table folded from them has it: each /// account's row, in the order the accounts were made, then the entries /// that are not one account's. #[cfg(test)] fn fold( frames: Vec>, before: u64, now: u64, keep: impl Fn(u64, &[u8]) -> bool, ) -> Result { let mut folder = Folder::new(before, now); for e in frames.into_iter().flatten() { folder.apply(e)?; } let mut out = Vec::new(); folder.finish(keep, None, &Summary::default(), 1, &mut out)?; static N: std::sync::atomic::AtomicU64 = std::sync::atomic::AtomicU64::new(0); let path = std::env::temp_dir().join(format!( "pds-test-{}-fold-{}", std::process::id(), N.fetch_add(1, std::sync::atomic::Ordering::Relaxed) )); std::fs::write(&path, out).map_err(|e| e.to_string())?; let table = ServiceTable::open(&path, Arc::new(BlockCache::new(FOLD_CACHE)))? .ok_or("a table just written")?; let _ = std::fs::remove_file(&path); let mut entries = Vec::new(); for r in table.order(0) { let (ordinal, did) = r?; let (n, row) = table.row(&did)?.ok_or("an ordinal of no row")?; assert_eq!(n, ordinal); entries.extend(row); } table.rest(|row| { entries.extend(row); Ok(()) })?; Ok(( entries.chunks(ROW_ENTRIES).map(<[Json]>::to_vec).collect(), table.summary.last_seq, table.summary.ceiling, )) } /// OAuth's entries, in order, but each session's refreshes before its last: /// a refresh sets all a session's tokens and its last token answer, so only /// the last counts in a replay. fn latest_refreshes(oauth: Vec) -> Vec { let is_refresh = |e: &Json| e["t"] == "oauthRefresh"; let mut last: HashMap = HashMap::new(); for (i, e) in oauth.iter().enumerate() { if is_refresh(e) && let Some(sid) = e["sid"].as_str() { last.insert(sid.to_string(), i); } } oauth .into_iter() .enumerate() .filter(|(i, e)| { !is_refresh(e) || e["sid"].as_str().is_none_or(|sid| last.get(sid) == Some(i)) }) .map(|(_, e)| e) .collect() } /// OAuth's entries, in order, but each passkey's sign-ins before its last: /// a sign-in sets all that one keeps of a passkey's (its count, BS and last /// use), so only the last counts in a replay, and however often a passkey /// signs in, what is kept of it stays the same. fn latest_passkey_uses(oauth: Vec) -> Vec { let is_use = |e: &Json| e["t"] == "oauthPasskeyUse"; let mut last: HashMap = HashMap::new(); for (i, e) in oauth.iter().enumerate() { if is_use(e) && let Some(id) = e["id"].as_str() { last.insert(id.to_string(), i); } } oauth .into_iter() .enumerate() .filter(|(i, e)| !is_use(e) || e["id"].as_str().is_none_or(|id| last.get(id) == Some(i))) .map(|(_, e)| e) .collect() } /// OAuth's entries, in order, but of each device only what its entries /// leave: each account's last sign-in on it, unless a sign-out of that /// account or the device's end came after, and its last cookies' key, unless /// its end came after. What is left out sets nothing a replay keeps, and the /// sign-outs and ends, which then end nothing, go too; so however often a /// device signs in, what is kept of it stays the same. fn latest_devices(oauth: Vec) -> Vec { let text = |e: &Json, k: &str| e[k].as_str().unwrap_or_default().to_string(); // Each device's accounts, each with the place of its last sign-in, and its last key's place. let mut signed: HashMap> = HashMap::new(); let mut keys: HashMap = HashMap::new(); for (i, e) in oauth.iter().enumerate() { match e["t"].as_str() { Some("oauthSignIn") => { signed .entry(text(e, "device")) .or_default() .insert(text(e, "did"), i); } Some("oauthSignOut") => { if let Some(s) = signed.get_mut(&text(e, "device")) { s.remove(&text(e, "did")); } } Some("oauthDeviceKey") => { keys.insert(text(e, "device"), i); } Some("oauthDeviceEnd") => { let device = text(e, "device"); signed.remove(&device); keys.remove(&device); } _ => {} } } let kept: std::collections::HashSet = signed .into_values() .flat_map(HashMap::into_values) .chain(keys.into_values()) .collect(); let of_devices = |e: &Json| { matches!( e["t"].as_str(), Some("oauthSignIn" | "oauthSignOut" | "oauthDeviceKey" | "oauthDeviceEnd") ) }; oauth .into_iter() .enumerate() .filter(|(i, e)| !of_devices(e) || kept.contains(i)) .map(|(_, e)| e) .collect() } #[cfg(test)] mod tests { use super::*; use crate::Service; use crate::testing::*; use serde_json::json; /// The bytes of the service log's files. fn service_files(dir: &std::path::Path) -> u64 { std::fs::read_dir(dir) .unwrap() .flatten() .filter(|e| e.file_name().to_string_lossy().starts_with("accounts.")) .map(|e| e.metadata().unwrap().len()) .sum() } /// Fold the table at `old`, if given, and a sealed log of `frames`, /// into the table of `generation`, at a `now` of 50: where it is. fn table_of(dir: &Path, old: Option<&Path>, frames: &[Vec], generation: u64) -> PathBuf { std::fs::create_dir_all(dir).unwrap(); let log = dir.join(format!("accounts.{generation}.log")); let mut bytes: Vec = frames.iter().flat_map(|f| pds_store::frame(f)).collect(); bytes.extend(pds_store::frame(&[json!({ "t": "seal" })])); std::fs::write(&log, bytes).unwrap(); let path = dir.join(format!("table.{generation}")); let mut out = File::create(&path).unwrap(); fold_files(old, &[log], generation, 50, |_, _| true, &mut out).unwrap(); path } fn open_table(path: &Path) -> ServiceTable { ServiceTable::open(path, Arc::new(BlockCache::new(FOLD_CACHE))) .unwrap() .unwrap() } /// Every key of a section, as text, a NUL shown as a space. fn keys(t: &ServiceTable, section: u8) -> Vec { t.section(section, &[section]) .map(|r| String::from_utf8_lossy(&r.unwrap().0[1..]).replace('\0', " ")) .collect() } fn made(did: &str) -> Json { json!({ "t": "account", "did": did, "handle": format!("{did}.test"), "email": format!("{did}@mail.com"), "password": "hash" }) } /// A fold of a table and the log after it: a row no log touched is /// copied as it is, one a log touched is as its entries and the log's /// leave it, a deleted account's is gone, and the hints, the ordinals /// and the summary are those of the accounts there are now. #[test] fn fold_merges_the_table_before_with_the_logs() { let dir = scratch("fold-merge"); let token = |did: &str, token: &str| json!({ "t": "mailToken", "did": did, "purpose": "reset_password", "token": token, "made": 1 }); let first = table_of( &dir, None, &[ vec![made("a")], vec![made("b"), made("c")], vec![made("d"), made("e")], vec![token("a", "AAAAA-AAAAA"), token("d", "DDDDD-DDDDD")], vec![json!({ "t": "deactivated", "did": "e", "applied": true })], vec![json!({ "t": "seqs", "upto": 40 })], ], 1, ); let t = open_table(&first); assert_eq!( t.summary, Summary { generation: 1, last_seq: 0, ceiling: Some(40), next_ordinal: 5, accounts: 5, deactivated: 1, takendown: 0, } ); assert_eq!(keys(&t, ROW), ["a", "b", "c", "d", "e"]); assert_eq!( keys(&t, HANDLE), ["a.test a", "b.test b", "c.test c", "d.test d", "e.test e"] ); assert_eq!(keys(&t, TOKEN), ["AAAAA-AAAAA a", "DDDDD-DDDDD d"]); assert_eq!(t.hints(EMAIL, "c@mail.com").unwrap(), ["c"]); assert_eq!(t.hints(EMAIL, "c@mail.co").unwrap(), Vec::::new()); let order = |t: &ServiceTable, from: u64| -> Vec<(u64, String)> { t.order(from).map(Result::unwrap).collect() }; assert_eq!(order(&t, 3), [(3, "d".to_string()), (4, "e".to_string())]); // The log after it: an email and a handle changed, a token used, // an account deleted, one made, one made and deleted, a state // changed; `a` is not touched. let deleted = |did: &str, seq: u64| json!({ "t": "deleted", "did": did, "gaps": [], "seq": seq, "frame": "00" }); let second = table_of( &dir, Some(&first), &[ vec![json!({ "t": "updateEmail", "did": "b", "email": "new@mail.com" })], vec![crate::cache::dir_entry("e", Some("eve.test"), false)], vec![json!({ "t": "useToken", "did": "d", "purpose": "reset_password" })], vec![deleted("c", 7)], vec![made("f"), made("g")], vec![deleted("g", 9)], vec![json!({ "t": "takedown", "did": "b", "ref": "x" })], vec![json!({ "t": "deactivated", "did": "e", "applied": false })], // Of an account deleted: nothing is kept of it. vec![json!({ "t": "confirmEmail", "did": "c" })], ], 2, ); let u = open_table(&second); assert_eq!( u.summary, Summary { generation: 2, last_seq: 9, ceiling: Some(40), next_ordinal: 7, accounts: 5, deactivated: 0, takendown: 1, } ); assert_eq!(keys(&u, ROW), ["a", "b", "d", "e", "f"]); assert_eq!( keys(&u, HANDLE), ["a.test a", "b.test b", "d.test d", "eve.test e", "f.test f"] ); assert_eq!( keys(&u, EMAIL), [ "a@mail.com a", "d@mail.com d", "e@mail.com e", "f@mail.com f", "new@mail.com b" ] ); assert_eq!(keys(&u, TOKEN), ["AAAAA-AAAAA a"]); let ordered: Vec<(u64, String)> = [(0, "a"), (1, "b"), (3, "d"), (4, "e"), (5, "f")] .map(|(n, did)| (n, did.to_string())) .into(); assert_eq!(order(&u, 0), ordered); // The row no log touched is the same bytes; the others say what is so now. assert_eq!(u.get(&row_key("a")).unwrap(), t.get(&row_key("a")).unwrap()); let (ordinal, row) = u.row("e").unwrap().unwrap(); assert_eq!((ordinal, &row[0]["handle"]), (4, &json!("eve.test"))); assert_eq!(row.len(), 1); let (_, row) = u.row("b").unwrap().unwrap(); assert_eq!(row[0]["email"], json!("new@mail.com")); assert_eq!(row[1], json!({ "t": "takedown", "did": "b", "ref": "x" })); assert!(u.row("c").unwrap().is_none() && !u.has("g").unwrap()); // The deletions, whose events are kept, are among what is not one account's. let mut rest = Vec::new(); u.rest(|row| { rest.extend(row); Ok(()) }) .unwrap(); let kinds: Vec<&str> = rest.iter().map(|e| e["t"].as_str().unwrap()).collect(); assert_eq!(kinds, ["deleted", "deleted"]); // Folded again with nothing new, it holds the same. let third = open_table(&table_of(&dir, Some(&second), &[], 3)); for section in [ROW, HANDLE, EMAIL, ORDER, TOKEN] { assert_eq!(keys(&third, section), keys(&u, section)); } assert_eq!( third.summary, Summary { generation: 3, ..u.summary.clone() } ); // A second account entry of a DID, and an entry of no account, fail the fold. for bad in [made("a"), json!({ "t": "confirmEmail", "did": "nobody" })] { let log = dir.join("bad.log"); let mut bytes = pds_store::frame(std::slice::from_ref(&bad)); bytes.extend(pds_store::frame(&[json!({ "t": "seal" })])); std::fs::write(&log, bytes).unwrap(); let folded = fold_files(Some(&second), &[log], 3, 50, |_, _| true, &mut Vec::new()); assert!(folded.is_err(), "{bad}"); } let _ = std::fs::remove_dir_all(&dir); } /// A table's summary is read back as written, and one of a version /// this server does not know is refused. #[test] fn a_summary_round_trips() { let s = Summary { generation: 3, last_seq: 9, ceiling: None, next_ordinal: 12, accounts: 10, deactivated: 2, takendown: 1, }; assert_eq!(Summary::decode(&s.encode()).unwrap(), s); let with = Summary { ceiling: Some(64), ..s }; assert_eq!(Summary::decode(&with.encode()).unwrap(), with); let mut other: Json = serde_json::from_slice(&with.encode()).unwrap(); other["version"] = json!(VERSION + 1); assert!(Summary::decode(other.to_string().as_bytes()).is_err()); } /// Refreshing a session again and again leaves the service log's files /// no larger than twice its checkpoint and the floor, and a frame; a /// restart finds every account, session, app password, invite code, /// single-use value and credential revocation as before. #[tokio::test] async fn refreshing_leaves_the_log_bounded() { let plc = plc().await; let dir = scratch("compact"); const FLOOR: u64 = 16 * 1024; let s: crate::Shared = std::sync::Arc::new( Service::open( &dir, crate::Config { log_floor: FLOOR, ..config(&plc) }, ) .unwrap(), ); let (did, token) = create(&s, "alice").await; create(&s, "bob").await; let admin = format!( "Basic {}", base64::Engine::encode( &base64::engine::general_purpose::STANDARD, format!("admin:{ADMIN_PASSWORD}") ) ); let code = call_raw( &s, "com.atproto.server.createInviteCode", crate::sessions::Bearer::of(Some(&admin)), &[], r#"{"useCount":2}"#, ) .await .unwrap(); let app = call( &s, "com.atproto.server.createAppPassword", Some(&token), json!({ "name": "phone" }), ) .await .unwrap(); let login = json!({ "identifier": "alice.test", "password": app["password"] }); let mut refresh = call(&s, "com.atproto.server.createSession", None, login) .await .unwrap()["refreshJwt"] .as_str() .unwrap() .to_string(); let now = s.sessions.now(); assert!(crate::single_use::SingleUse::check_and_record( &*s, "nonce", now + 3600 )); s.space_credentials .revoke(&s.log, "at://did:plc:a/space/a.b.c/x", &["j"], now) .unwrap(); let mut largest = 0; for _ in 0..1500 { let got = call( &s, "com.atproto.server.refreshSession", Some(&refresh), Json::Null, ) .await .unwrap(); refresh = got["refreshJwt"].as_str().unwrap().to_string(); // Between compactions. s.log.wait_compacted(); largest = largest.max(service_files(&dir).saturating_sub(2 * s.log.checkpoint_bytes())); } assert!(s.log.checkpoint_generation() > 0, "never compacted"); assert!( largest <= FLOOR + 4096, "{largest} bytes past twice the checkpoint" ); // The account keeps at most its sessions' limit, so the checkpoint stays small. assert!(s.sessions.count(&did) <= crate::sessions::MAX_SESSIONS); assert!( s.log.checkpoint_bytes() < 200 * 1024, "{}", s.log.checkpoint_bytes() ); let held = |s: &Service| { ( s.single_use.snapshot(now), s.space_credentials.snapshot(now), ) }; let before = (s.sessions.snapshot(), s.invites.snapshot(), held(&s)); drop(s); let s = open(&dir, &plc); assert_eq!( (s.sessions.snapshot(), s.invites.snapshot(), held(&s)), before ); assert!(!crate::single_use::SingleUse::check_and_record( &*s, "nonce", now + 3600 )); // The latest token works, and the code can still be used. call( &s, "com.atproto.server.refreshSession", Some(&refresh), Json::Null, ) .await .unwrap(); let body = json!({ "handle": "carol.test", "email": "carol@mail.com", "password": "pw", "inviteCode": code["code"] }); call(&s, "com.atproto.server.createAccount", None, body) .await .unwrap(); let _ = std::fs::remove_dir_all(&dir); } /// Sessions long expired are left out of a compacted log; those within /// the margin, and every other, are kept. #[test] fn fold_leaves_out_long_expired_sessions() { let did = "did:plc:a"; let session = |id: &str, exp: u64| json!({ "t": "session", "did": did, "id": id, "app": null, "scope": "com.atproto.access", "exp": exp }); let frames = vec![ vec![json!({ "t": "account", "did": did })], vec![ session("old", 10), session("recent", 100), session("live", 1000), ], vec![ json!({ "t": "refresh", "did": did, "id": "live", "next": "after", "exp": 1000, "nextExp": 2000 }), ], ]; let folded = fold(frames, 50, 50, |_, _| true).unwrap().0; let ids: Vec<&str> = folded .iter() .flatten() .filter(|e| e["t"] == "session") .map(|e| e["id"].as_str().unwrap()) .collect(); // In the order they were made, so that a replay orders them alike. assert_eq!(ids, ["recent", "live", "after"]); let live = folded.iter().flatten().find(|e| e["id"] == "live").unwrap(); assert_eq!(live["next"], json!("after")); } /// OAuth's entries are kept in order but for each session's superseded /// refreshes, and single-use values long past their time are left out. #[test] fn fold_keeps_oauth_and_held_values() { let did = "did:plc:a"; let refresh = |sid: &str, n: u64| json!({ "t": "oauthRefresh", "sid": sid, "access": format!("a{n}"), "accessExp": n, "refresh": format!("r{n}"), "at": n }); let frames = vec![ vec![json!({ "t": "account", "did": did })], vec![ json!({ "t": "oauthSession", "sid": "s1" }), json!({ "t": "spent", "ns": "dpop", "v": "x", "until": 40 }), ], vec![ refresh("s1", 1), json!({ "t": "oauthSession", "sid": "s2" }), refresh("s2", 2), refresh("s1", 3), ], vec![ refresh("s1", 4), json!({ "t": "spent", "ns": "dpop", "v": "y", "until": 60 }), ], ]; let folded: Vec = fold(frames, 50, 50, |_, _| true) .unwrap() .0 .into_iter() .flatten() .collect(); let kinds: Vec = folded .iter() .map(|e| { format!( "{} {}", e["t"].as_str().unwrap(), e["at"].as_u64().or(e["until"].as_u64()).unwrap_or(0) ) }) .collect(); assert_eq!( kinds, [ "account 0", "oauthSession 0", "oauthSession 0", "oauthRefresh 2", "oauthRefresh 4", "spent 60" ] ); } /// Of each device, only its accounts' last sign-ins still standing and /// its last key not ended are kept, in order. #[test] fn fold_keeps_each_devices_last() { let (a, b) = ("did:plc:a", "did:plc:b"); let sign_in = |device: &str, did: &str, at: u64| json!({ "t": "oauthSignIn", "device": device, "did": did, "at": at }); let key = |device: &str, at: u64| json!({ "t": "oauthDeviceKey", "device": device, "key": format!("k{at}"), "at": at }); let devices = vec![ vec![ sign_in("d1", a, 1), key("d1", 1), sign_in("d1", b, 2), key("d1", 2), sign_in("d1", a, 3), key("d1", 3), ], vec![ sign_in("d2", a, 4), key("d2", 4), json!({ "t": "oauthSignOut", "device": "d2", "did": a }), ], vec![ sign_in("d3", b, 5), key("d3", 5), json!({ "t": "oauthDeviceEnd", "device": "d3" }), key("d3", 6), ], vec![ sign_in("d4", a, 7), json!({ "t": "oauthDeviceEnd", "device": "d4" }), ], ]; let mut frames = vec![vec![ json!({ "t": "account", "did": a }), json!({ "t": "account", "did": b }), ]]; frames.extend(devices.clone()); let folded: Vec = fold(frames, 0, 0, |_, _| true) .unwrap() .0 .into_iter() .flatten() .skip(2) .collect(); let kinds: Vec = folded .iter() .map(|e| format!("{} {}", e["t"].as_str().unwrap(), e["at"])) .collect(); assert_eq!( kinds, [ "oauthSignIn 2", "oauthSignIn 3", "oauthDeviceKey 3", "oauthDeviceKey 4", "oauthDeviceKey 6" ] ); // Replayed, they make what all of them make. let replayed = |entries: &[Json]| { let o = crate::oauth::OAuth::open(&scratch("fold-devices"), "https://pds.test", None) .unwrap(); for e in entries { o.replay(e, &|_| true).unwrap(); } o.snapshot() }; assert_eq!(replayed(&folded), replayed(&devices.concat())); } /// Single-use values and revocations are kept until their `until` passes. #[test] fn fold_keeps_held_values_until_they_pass() { let frames = vec![vec![ json!({ "t": crate::single_use::ENTRY, "v": "a", "until": 40 }), json!({ "t": crate::single_use::ENTRY, "v": "b", "until": 60 }), json!({ "t": crate::space_credentials::ENTRY, "space": "s", "credentials": ["old"], "until": 50 }), json!({ "t": crate::space_credentials::ENTRY, "space": "s", "credentials": ["new"], "until": 51 }), ]]; let folded: Vec = fold(frames, 0, 50, |_, _| true) .unwrap() .0 .into_iter() .flatten() .collect(); assert_eq!(folded.len(), 2); assert_eq!(folded[0]["v"], json!("b")); assert_eq!(folded[1]["credentials"], json!(["new"])); } /// A deleted account's OAuth sessions, sign-ins and approved requests are /// forgotten when it is deleted, after a restart, and in a compacted log, /// which replays to the same; the other account's stay, and work. #[tokio::test] async fn a_deleted_accounts_oauth_is_forgotten() { use crate::email::testing::{last_token, open_with_sink}; use crate::oauth::tests::{App, Browser, approved, kept, serve, text}; let plc = plc().await; let dir = scratch("compact-deleted-oauth"); let sink = scratch("compact-deleted-oauth-mail"); let srv = serve(open_with_sink(&dir, &plc, &sink)).await; let (alice, _) = create(&srv.svc, "alice").await; let (bob, bob_token) = create(&srv.svc, "bob").await; let mut app = App::new(&srv, "atproto"); let mut browser = Browser::new(&srv); let (pushed, code) = approved(&mut app, &mut browser, "alice").await; let alice_tokens = app.exchange(&code, &pushed).await.json(); let (pushed, code) = approved(&mut app, &mut browser, "bob").await; let bob_tokens = app.exchange(&code, &pushed).await.json(); app.refresh(&text(&bob_tokens, "refresh_token")).await; // A request approved for bob, its code not exchanged. let (pushed, code) = approved(&mut app, &mut browser, "bob").await; call( &srv.svc, "com.atproto.server.requestAccountDelete", Some(&bob_token), Json::Null, ) .await .unwrap(); call( &srv.svc, "com.atproto.server.deleteAccount", None, json!({ "did": bob, "password": "bob-pw", "token": last_token(&sink) }), ) .await .unwrap(); let after = kept(&srv.svc); let state = format!("{:?}", after.0); assert!(!state.contains(&bob) && state.contains(&alice), "{state}"); assert_eq!(app.exchange(&code, &pushed).await.status, 400); let restarted = open(&crate::log::copied(&dir), &plc); assert_eq!(restarted.oauth.snapshot(), after.0); drop(restarted); srv.svc.log.compact().unwrap(); assert_eq!( open(&crate::log::copied(&dir), &plc).oauth.snapshot(), after.0 ); // Alice's session works on. assert_eq!( app.refresh(&text(&alice_tokens, "refresh_token")) .await .status, 200 ); let _ = std::fs::remove_dir_all(&dir); let _ = std::fs::remove_dir_all(&sink); } /// A takedown, or its lifting, and a deactivation with an OAuth token end /// every OAuth session of the account, after a restart too; a deactivation /// with a password session ends none. A deactivation with an OAuth token /// deletes the account's app passwords too, but not the sessions made /// with them, after a restart and a compaction too (`spec/LIFECYCLE.md`). #[tokio::test] async fn account_states_end_oauth_sessions() { use crate::oauth::tests::{App, Browser, approved, serve, text}; let plc = plc().await; let dir = scratch("state-ends-oauth"); let srv = serve(open(&dir, &plc)).await; let (did, token) = create(&srv.svc, "alice").await; let mut app = App::new(&srv, "atproto account:status?action=manage"); let mut browser = Browser::new(&srv); async fn session(app: &mut App<'_>, browser: &mut Browser<'_>) -> Json { let (pushed, code) = approved(app, browser, "alice").await; app.exchange(&code, &pushed).await.json() } let admin = format!( "Basic {}", base64::Engine::encode( &base64::engine::general_purpose::STANDARD, format!("admin:{ADMIN_PASSWORD}") ) ); let takedown = |applied: bool| { json!({ "subject": { "$type": "com.atproto.admin.defs#repoRef", "did": did }, "takedown": { "applied": applied } }).to_string() }; let sessions = |s: &Service| { format!("{:?}", s.oauth.snapshot()) .matches("Session {") .count() }; let login = |password: &str| json!({ "identifier": "alice.test", "password": password }); let pw = call( &srv.svc, "com.atproto.server.createAppPassword", Some(&token), json!({ "name": "phone" }), ) .await .unwrap(); let pw = pw["password"].as_str().unwrap().to_string(); // A password session's deactivation ends none, and keeps its app passwords. let kept = session(&mut app, &mut browser).await; call( &srv.svc, "com.atproto.server.deactivateAccount", Some(&token), json!({}), ) .await .unwrap(); assert_eq!( app.get_session(&text(&kept, "access_token")).await.status, 200 ); let app_session = call( &srv.svc, "com.atproto.server.createSession", None, login(&pw), ) .await .unwrap(); call( &srv.svc, "com.atproto.server.activateAccount", Some(&token), Json::Null, ) .await .unwrap(); // An OAuth token's ends both. let other = session(&mut app, &mut browser).await; assert_eq!(sessions(&srv.svc), 2); assert_eq!( app.post( "com.atproto.server.deactivateAccount", &text(&other, "access_token"), json!({}) ) .await .status, 200 ); assert_eq!(sessions(&srv.svc), 0); assert_eq!( app.get_session(&text(&kept, "access_token")).await.error(), "invalid_token" ); assert_eq!( app.refresh(&text(&other, "refresh_token")).await.error(), "invalid_grant" ); assert_eq!(sessions(&open(&crate::log::copied(&dir), &plc)), 0); // Its app password is gone; the session made with it refreshes. assert_eq!( call( &srv.svc, "com.atproto.server.createSession", None, login(&pw) ) .await .unwrap_err(), "AuthenticationRequired" ); assert_eq!( call( &srv.svc, "com.atproto.server.listAppPasswords", Some(&token), Json::Null ) .await .unwrap(), json!({ "passwords": [] }) ); call( &srv.svc, "com.atproto.server.refreshSession", Some(app_session["refreshJwt"].as_str().unwrap()), Json::Null, ) .await .unwrap(); let keeps = srv.svc.sessions.snapshot(); let restarted = || open(&crate::log::copied(&dir), &plc).sessions.snapshot(); assert_eq!(restarted(), keeps); srv.svc.log.compact().unwrap(); assert_eq!(restarted(), keeps); call( &srv.svc, "com.atproto.server.activateAccount", Some(&token), Json::Null, ) .await .unwrap(); // A lifting of a takedown that was not applied ends them too. for applied in [false, true] { session(&mut app, &mut browser).await; assert_eq!(sessions(&srv.svc), 1); call_raw( &srv.svc, "com.atproto.admin.updateSubjectStatus", crate::sessions::Bearer::of(Some(&admin)), &[], &takedown(applied), ) .await .unwrap(); assert_eq!(sessions(&srv.svc), 0); assert_eq!(sessions(&open(&crate::log::copied(&dir), &plc)), 0); } let _ = std::fs::remove_dir_all(&dir); } }