340 lines
14 KiB
Rust
340 lines
14 KiB
Rust
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<Self> {
|
|
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<OLD.seq BEGIN SELECT RAISE(ABORT,'SEQUENCE_ROLLBACK'); END;
|
|
CREATE TRIGGER IF NOT EXISTS metadata_monotonic BEFORE UPDATE OF value ON metadata WHEN NEW.key='sequence' AND NEW.value<OLD.value BEGIN SELECT RAISE(ABORT,'SEQUENCE_ROLLBACK'); END;
|
|
CREATE TRIGGER IF NOT EXISTS counter_to_metadata AFTER UPDATE OF seq ON counter WHEN NEW.seq!=(SELECT value FROM metadata WHERE key='sequence') BEGIN UPDATE metadata SET value=NEW.seq WHERE key='sequence'; END;
|
|
CREATE TRIGGER IF NOT EXISTS metadata_to_counter AFTER UPDATE OF value ON metadata WHEN NEW.key='sequence' AND NEW.value!=(SELECT seq FROM counter WHERE id=1) BEGIN UPDATE counter SET seq=NEW.value WHERE id=1; END;
|
|
CREATE TABLE IF NOT EXISTS job_attempts(job TEXT NOT NULL,attempt TEXT NOT NULL,offer BLOB NOT NULL,state TEXT NOT NULL,revision INTEGER NOT NULL DEFAULT 0,grant_id TEXT NOT NULL DEFAULT '',cancel_requested INTEGER NOT NULL DEFAULT 0,PRIMARY KEY(job,attempt));
|
|
CREATE TABLE IF NOT EXISTS job_events(id TEXT PRIMARY KEY,payload BLOB NOT NULL CHECK(length(payload)<=1048576));
|
|
CREATE TABLE IF NOT EXISTS safety(key TEXT PRIMARY KEY,value TEXT NOT NULL);
|
|
COMMIT;")?;
|
|
let consistent: bool = db.query_row("SELECT 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<u64> {
|
|
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<Vec<Envelope>> {
|
|
let mut q = self
|
|
.db
|
|
.prepare("SELECT payload FROM events ORDER BY rowid")?;
|
|
q.query_map([], |r| r.get::<_, Vec<u8>>(0))?
|
|
.map(|v| Ok(Envelope::decode(v?.as_slice())?))
|
|
.collect()
|
|
}
|
|
pub fn count(&self) -> Result<u64> {
|
|
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<String> = 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<u8> = 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<u8>>(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<u8>>(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();
|
|
}
|
|
}
|