use anyhow::{Result, ensure}; use fs2::FileExt; use prost::Message; use rmm_protocol::Envelope; use rusqlite::{Connection, OptionalExtension, params}; use std::{fs::OpenOptions, path::Path}; pub struct Journal { db: Connection, _lock: std::fs::File, } impl Journal { pub fn open(directory: &Path) -> Result { ensure!(directory.is_dir(), "STATE_DIRECTORY_REQUIRED"); let lock = OpenOptions::new() .read(true) .write(true) .create(true) .truncate(false) .open(directory.join("agent.lock"))?; lock.try_lock_exclusive()?; let db = Connection::open(directory.join("telemetry.sqlite"))?; // Bound the existing file without resetting sequence, identity, or // unacknowledged bytes. Unexpected page sizes fail closed. rmm_agent_core::ledger::bounded_journal_capacity(&db)?; db.execute_batch( "PRAGMA journal_mode=WAL; PRAGMA synchronous=FULL; PRAGMA foreign_keys=ON; CREATE TABLE IF NOT EXISTS metadata(key TEXT PRIMARY KEY,value INTEGER NOT NULL); INSERT OR IGNORE INTO metadata VALUES('sequence',0); CREATE TABLE IF NOT EXISTS events(id TEXT PRIMARY KEY,payload BLOB NOT NULL);", )?; // Add the shared durable-job schema to the same database; old inventory // bytes and identity remain in place. Both names reference one sequence // through atomic, monotonic triggers, including old passive clients. db.execute_batch("BEGIN IMMEDIATE; CREATE TABLE IF NOT EXISTS counter(id INTEGER PRIMARY KEY CHECK(id=1),seq INTEGER NOT NULL CHECK(seq>=0)); INSERT OR IGNORE INTO counter SELECT 1,value FROM metadata WHERE key='sequence'; CREATE TRIGGER IF NOT EXISTS counter_monotonic BEFORE UPDATE OF seq ON counter WHEN NEW.seq=0 AND seq=(SELECT value FROM metadata WHERE key='sequence') FROM counter WHERE id=1", [], |r|r.get(0))?; ensure!(consistent, "JOURNAL_SEQUENCE_DIVERGED"); rmm_agent_core::reconcile::initialize(&db)?; ensure!( db.query_row("PRAGMA integrity_check", [], |r| r.get::<_, String>(0))? == "ok", "JOURNAL_INTEGRITY" ); Ok(Self { db, _lock: lock }) } pub fn next_sequence(&mut self) -> Result { let tx = self.db.transaction()?; let sequence: i64 = tx.query_row("SELECT seq FROM counter WHERE id=1", [], |r| r.get(0))?; let next = sequence .checked_add(1) .ok_or_else(|| anyhow::anyhow!("SEQUENCE_EXHAUSTED"))?; tx.execute("UPDATE counter SET seq=?1 WHERE id=1", [next])?; tx.commit()?; Ok(u64::try_from(next)?) } pub fn connection(&self) -> &Connection { &self.db } pub fn connection_mut(&mut self) -> &mut Connection { &mut self.db } pub fn save(&self, envelope: &Envelope) -> Result<()> { // This slice never deletes a durable event to make room for telemetry. // At the fixed cap it stops collecting until concrete ACKs release room. ensure!(self.count()? < 8, "TELEMETRY_BACKPRESSURE"); ensure!( matches!( envelope.payload, Some(rmm_protocol::Payload::InventorySnapshot(_)) ), "PASSIVE_INVENTORY_ONLY" ); let bytes = envelope.encode_to_vec(); ensure!(bytes.len() <= 512 * 1024, "TELEMETRY_LIMIT"); self.db.execute( "INSERT INTO events(id,payload) VALUES(?1,?2)", params![envelope.message_id, bytes], )?; Ok(()) } pub fn events(&self) -> Result> { let mut q = self .db .prepare("SELECT payload FROM events ORDER BY rowid")?; q.query_map([], |r| r.get::<_, Vec>(0))? .map(|v| Ok(Envelope::decode(v?.as_slice())?)) .collect() } pub fn count(&self) -> Result { Ok(self .db .query_row("SELECT count(*) FROM events", [], |r| r.get(0))?) } pub fn ack(&self, message_id: &str) -> Result<()> { // Unknown IDs have no effect. An HTTP status never calls this function. self.db .execute("DELETE FROM events WHERE id=?1", [message_id])?; Ok(()) } pub fn pin_identity(&self, id: &str) -> Result<()> { self.db .execute_batch("CREATE TABLE IF NOT EXISTS identity(agent TEXT PRIMARY KEY)")?; let old: Option = self .db .query_row("SELECT agent FROM identity", [], |r| r.get(0)) .optional()?; if let Some(old) = old { ensure!(old == id, "JOURNAL_IDENTITY_MISMATCH"); } else { self.db.execute("INSERT INTO identity VALUES(?1)", [id])?; } Ok(()) } } #[cfg(test)] mod tests { use super::*; #[test] fn durable_reopen_ack_identity_and_single_process() { let directory = std::env::temp_dir().join(format!("rmm-windows-journal-{}", uuid::Uuid::new_v4())); std::fs::create_dir(&directory).unwrap(); let mut j = Journal::open(&directory).unwrap(); assert!(Journal::open(&directory).is_err()); j.pin_identity("a").unwrap(); assert!(j.pin_identity("b").is_err()); let first = j.next_sequence().unwrap(); let e = Envelope { message_id: uuid::Uuid::new_v4().to_string(), sequence: first, payload: Some(rmm_protocol::Payload::InventorySnapshot(Default::default())), ..Default::default() }; j.save(&e).unwrap(); drop(j); let mut j = Journal::open(&directory).unwrap(); assert!(j.next_sequence().unwrap() > first); assert_eq!(j.events().unwrap()[0].message_id, e.message_id); j.ack("unrelated").unwrap(); assert_eq!(j.count().unwrap(), 1); j.ack(&e.message_id).unwrap(); assert_eq!(j.count().unwrap(), 0); let heartbeat = Envelope { payload: Some(rmm_protocol::Payload::Heartbeat(Default::default())), ..Default::default() }; assert!(j.save(&heartbeat).is_err()); drop(j); std::fs::remove_dir_all(directory).unwrap(); } #[test] fn bounded_existing_journal_preserves_identity_sequence_and_unacked_bytes() { let directory = std::env::temp_dir().join(format!("rmm-windows-capacity-{}", uuid::Uuid::new_v4())); std::fs::create_dir(&directory).unwrap(); let mut journal = Journal::open(&directory).unwrap(); journal.pin_identity("preserved-device").unwrap(); let sequence = journal.next_sequence().unwrap(); let envelope = Envelope { message_id: uuid::Uuid::new_v4().to_string(), sequence, payload: Some(rmm_protocol::Payload::InventorySnapshot(Default::default())), ..Default::default() }; journal.save(&envelope).unwrap(); let original: Vec = journal .db .query_row( "SELECT payload FROM events WHERE id=?1", [&envelope.message_id], |r| r.get(0), ) .unwrap(); // Simulate an earlier lower bound; reopening changes only the budget. journal .db .execute_batch("PRAGMA max_page_count=65536") .unwrap(); drop(journal); let mut journal = Journal::open(&directory).unwrap(); assert_eq!( journal .db .query_row("PRAGMA max_page_count", [], |r| r.get::<_, u32>(0)) .unwrap(), 262144 ); assert_eq!( journal .db .query_row("PRAGMA page_size", [], |r| r.get::<_, u32>(0)) .unwrap(), 4096 ); journal.pin_identity("preserved-device").unwrap(); assert_eq!(journal.next_sequence().unwrap(), sequence + 1); // Core checkpoints and the old passive counter cannot diverge. journal .db .execute("UPDATE counter SET seq=seq+1 WHERE id=1", []) .unwrap(); assert_eq!( journal .db .query_row("SELECT value FROM metadata WHERE key='sequence'", [], |r| r .get::<_, i64>(0)) .unwrap(), sequence as i64 + 2 ); journal .db .execute("UPDATE metadata SET value=value+1 WHERE key='sequence'", []) .unwrap(); assert_eq!( journal .db .query_row("SELECT seq FROM counter WHERE id=1", [], |r| r .get::<_, i64>(0)) .unwrap(), sequence as i64 + 3 ); assert!( journal .db .execute("UPDATE counter SET seq=0 WHERE id=1", []) .is_err() ); assert!( journal .db .execute("UPDATE metadata SET value=0 WHERE key='sequence'", []) .is_err() ); assert_eq!( journal .db .query_row( "SELECT payload FROM events WHERE id=?1", [&envelope.message_id], |r| r.get::<_, Vec>(0) ) .unwrap(), original ); journal.ack("different-message-id").unwrap(); assert_eq!(journal.count().unwrap(), 1); drop(journal); std::fs::remove_dir_all(directory).unwrap(); } #[test] fn unsupported_page_size_is_refused_without_mutating_existing_data() { let directory = std::env::temp_dir().join(format!("rmm-windows-page-size-{}", uuid::Uuid::new_v4())); std::fs::create_dir(&directory).unwrap(); let path = directory.join("telemetry.sqlite"); let db = Connection::open(&path).unwrap(); db.execute_batch("PRAGMA page_size=8192; CREATE TABLE retained(value BLOB); INSERT INTO retained VALUES(x'010203');").unwrap(); drop(db); let error = Journal::open(&directory).err().expect("must refuse"); assert_eq!(error.to_string(), "JOURNAL_PAGE_SIZE_UNSUPPORTED"); let db = Connection::open(&path).unwrap(); assert_eq!( db.query_row("SELECT value FROM retained", [], |r| r.get::<_, Vec>(0)) .unwrap(), vec![1, 2, 3] ); drop(db); std::fs::remove_dir_all(directory).unwrap(); } #[test] fn migrates_original_passive_schema_without_rewriting_pending_envelopes() { let directory = std::env::temp_dir().join(format!("rmm-windows-migrate-{}", uuid::Uuid::new_v4())); std::fs::create_dir(&directory).unwrap(); let db = Connection::open(directory.join("telemetry.sqlite")).unwrap(); db.execute_batch("CREATE TABLE metadata(key TEXT PRIMARY KEY,value INTEGER NOT NULL); INSERT INTO metadata VALUES('sequence',42); CREATE TABLE events(id TEXT PRIMARY KEY,payload BLOB NOT NULL); CREATE TABLE identity(agent TEXT PRIMARY KEY); INSERT INTO identity VALUES('original-device');").unwrap(); let envelope = Envelope { message_id: uuid::Uuid::new_v4().to_string(), sequence: 42, payload: Some(rmm_protocol::Payload::InventorySnapshot(Default::default())), ..Default::default() }; let bytes = envelope.encode_to_vec(); db.execute( "INSERT INTO events VALUES(?1,?2)", params![envelope.message_id, bytes], ) .unwrap(); drop(db); let mut journal = Journal::open(&directory).unwrap(); journal.pin_identity("original-device").unwrap(); assert_eq!(journal.next_sequence().unwrap(), 43); assert_eq!(journal.events().unwrap()[0].encode_to_vec(), bytes); assert_eq!( journal .connection() .query_row("SELECT count(*) FROM job_attempts", [], |r| r .get::<_, i64>(0)) .unwrap(), 0 ); let journal_id: String = journal .connection() .query_row( "SELECT journal_id FROM reconcile_meta WHERE id=1", [], |r| r.get(0), ) .unwrap(); drop(journal); let journal = Journal::open(&directory).unwrap(); assert_eq!( journal .connection() .query_row( "SELECT journal_id FROM reconcile_meta WHERE id=1", [], |r| r.get::<_, String>(0) ) .unwrap(), journal_id ); drop(journal); std::fs::remove_dir_all(directory).unwrap(); } }