From dfdc47ae9e464d410882371892de6b0cc60cef03 Mon Sep 17 00:00:00 2001 From: John Coffey Date: Sun, 8 Nov 2026 19:00:44 -0700 Subject: [PATCH] Store check: find blobs that are missing, damaged or unlinked (#322) An administrator can now ask the server to check its blobs. A quick check confirms that every blob the data holds a link to is in the blob store. A full check also reads each one back and compares its BLAKE3 hash with its id. Mail is checked from the message side too, so a message whose metadata names a blob that nothing links to any more is reported. That is the case from forum topic 238. The check changes nothing. It is an inbuxa:StoreCheck under urn:inbuxa:jmap. Creating one starts it in the background on the node that was reached. It runs one slice of the blob index at a time, throttled (1,000 blobs/s and 20 MB/s by default, 0 for no limit), and saves its progress every 10 seconds. Only one check runs at a time across the server. A check that goes quiet for five minutes, or whose node restarts, reads as interrupted. The first 1,000 problems are kept with the account, object, blob id and what was wrong, and each problem is also logged as store.data-corruption. An update with action "stop" stops a check. A finished check can be destroyed. The latest 20 checks are kept. The new permission sysStoreCheck (695) is in the superuser and admin grants. A tenant administrator is refused, because a check reads the whole server. Starting and stopping a check are audited. Spec: docs/spec/features/store-check.md. Test: system::store_check. --- crates/common/src/auth/permissions.rs | 5 + .../common/src/manager/granted_permissions.rs | 5 +- crates/features/src/lib.rs | 1 + crates/features/src/store_check/mod.rs | 597 ++++++++++++++++++ .../src/object/inbuxa_store_check.rs | 214 +++++++ crates/jmap-proto/src/object/mod.rs | 1 + crates/jmap-proto/src/references/eval.rs | 3 + crates/jmap-proto/src/references/resolve.rs | 4 + crates/jmap-proto/src/request/method.rs | 8 + crates/jmap-proto/src/request/mod.rs | 2 + crates/jmap-proto/src/request/parser.rs | 15 + crates/jmap-proto/src/response/mod.rs | 15 + crates/jmap/src/api/auth.rs | 11 + crates/jmap/src/api/request.rs | 26 + crates/jmap/src/changes/get.rs | 1 + crates/jmap/src/inbuxa/audit.rs | 15 + crates/jmap/src/inbuxa/mod.rs | 1 + crates/jmap/src/inbuxa/store_check.rs | 310 +++++++++ crates/registry/src/schema/enums.rs | 2 + crates/registry/src/schema/enums_impl.rs | 5 +- crates/services/src/inbuxa_store_check.rs | 556 ++++++++++++++++ crates/services/src/lib.rs | 4 + crates/store/src/write/blob_check.rs | 162 +++++ crates/store/src/write/mod.rs | 3 + docs/spec/SPEC.md | 2 + docs/spec/features/store-check.md | 133 ++++ resources/privacy/catalog.toml | 11 + resources/schema/schema.json.gz | Bin 154738 -> 154768 bytes resources/schema/schema.json.sha256 | 2 +- tests/src/system/mod.rs | 1 + tests/src/system/store_check.rs | 421 ++++++++++++ 31 files changed, 2532 insertions(+), 4 deletions(-) create mode 100644 crates/features/src/store_check/mod.rs create mode 100644 crates/jmap-proto/src/object/inbuxa_store_check.rs create mode 100644 crates/jmap/src/inbuxa/store_check.rs create mode 100644 crates/services/src/inbuxa_store_check.rs create mode 100644 crates/store/src/write/blob_check.rs create mode 100644 docs/spec/features/store-check.md create mode 100644 tests/src/system/store_check.rs diff --git a/crates/common/src/auth/permissions.rs b/crates/common/src/auth/permissions.rs index 4d46efc8..c2cbe544 100644 --- a/crates/common/src/auth/permissions.rs +++ b/crates/common/src/auth/permissions.rs @@ -388,6 +388,11 @@ impl Default for DefaultPermissions { Permission::SysMigrationRun => { default.superuser.push(permission); } + // inbuxa: store-check spec, SV-9: a check reads every + // account's data, so only the server's administrators run one + Permission::SysStoreCheck => { + default.superuser.push(permission); + } // inbuxa: AL-12: tenant administrators lock and delegate // within their tenant Permission::SysAccountLockGet diff --git a/crates/common/src/manager/granted_permissions.rs b/crates/common/src/manager/granted_permissions.rs index be8445dc..b8ce6f29 100644 --- a/crates/common/src/manager/granted_permissions.rs +++ b/crates/common/src/manager/granted_permissions.rs @@ -34,8 +34,8 @@ use types::id::Id; /// the data inventory (personal-data catalog spec), accepting security /// to-do items (security to-do list spec), the deliverability check /// (deliverability spec), scheduled reports (scheduled-reports spec), -/// inbuxa Relays (relay spec), and running migrations (migrations spec, -/// MG-10). +/// inbuxa Relays (relay spec), running migrations (migrations spec, +/// MG-10), and checking the store's blobs (store-check spec, SV-9). const ADMIN_GRANTS: &[Permission] = &[ Permission::SysAiExplain, Permission::SysAuditGet, @@ -69,6 +69,7 @@ const ADMIN_GRANTS: &[Permission] = &[ Permission::SysRelayQueueGet, Permission::SysRelayQueueUpdate, Permission::SysMigrationRun, + Permission::SysStoreCheck, ]; /// Granted to the server-level Compliance Officer role once it exists: diff --git a/crates/features/src/lib.rs b/crates/features/src/lib.rs index 193b1155..e94516d0 100644 --- a/crates/features/src/lib.rs +++ b/crates/features/src/lib.rs @@ -32,5 +32,6 @@ pub mod privacy; pub mod relay; // inbuxa: the downstream side of inbuxa Relay (not a rebuild) pub mod scheduled_reports; // inbuxa: scheduled reports and the weekly digest (not a rebuild) pub mod security; +pub mod store_check; // inbuxa: checking the store's blobs (not a rebuild) pub mod tenancy; pub mod undelete; diff --git a/crates/features/src/store_check/mod.rs b/crates/features/src/store_check/mod.rs new file mode 100644 index 00000000..d1c59fe4 --- /dev/null +++ b/crates/features/src/store_check/mod.rs @@ -0,0 +1,597 @@ +/* + * SPDX-FileCopyrightText: 2026 Coffey Labs LLC + * + * SPDX-License-Identifier: AGPL-3.0-only + */ + +//! Checking the store's blobs (docs/spec/features/store-check.md): the +//! `inbuxa:StoreCheck` objects. A check reports which blobs the server's +//! data needs and doesn't have, and changes nothing. The check itself runs +//! in `services::inbuxa_store_check`; this module keeps what a check is and +//! what it found. +//! +//! Kept in the fork's subspace (`store::SUBSPACE_INBUXA`), never in the +//! registry (SV-1). Every key starts with `V` (verify), then one byte for +//! the kind: +//! +//! - `c` + check id (u32): a check ([`StoreCheck`]), as JSON; +//! - `p` + check id (u32) + number (u32): one of its problems ([`Problem`]), +//! as JSON, kept apart so a check stays small however much it found; +//! - `r`: the id of the check that runs now (u32), so only one runs at a +//! time across the server (SV-2). +//! +//! `Vs` is the store's version (`common::INBUXA_STORE_VERSION_KEY`), so no +//! kind here is `s`. Numbers are big-endian. + +use serde::{Deserialize as SerdeDeserialize, Serialize as SerdeSerialize, de::DeserializeOwned}; +use store::{ + Deserialize, IterateParams, SUBSPACE_INBUXA, Serialize, SerializeInfallible, Store, U32_LEN, + ValueKey, + write::{AnyClass, BatchBuilder, ValueClass, assert::AssertValue}, +}; +use trc::AddContext; + +const FEATURE: u8 = b'V'; +const KIND_CHECK: u8 = b'c'; +const KIND_PROBLEM: u8 = b'p'; +const KIND_RUNNING: u8 = b'r'; +const CREATE_ATTEMPTS: usize = 5; + +/// SV-1: the checks kept; starting another forgets the oldest. +pub const MAX_CHECKS: usize = 20; +/// SV-5: the problems a check keeps; the counts cover all of them. +pub const MAX_PROBLEMS: u64 = 1_000; +/// SV-6: the default limits. +pub const DEFAULT_BLOBS_PER_SECOND: u64 = 1_000; +pub const DEFAULT_BYTES_PER_SECOND: u64 = 20 * 1024 * 1024; +/// SV-8: a running check whose node has been quiet this long has stopped. +pub const STALE_AFTER: u64 = 5 * 60; +const MAX_TEXT: usize = 2_000; + +/// SV-2. +#[derive(Debug, Clone, Copy, PartialEq, Eq, SerdeSerialize, SerdeDeserialize)] +#[serde(rename_all = "lowercase")] +pub enum Mode { + Quick, + Full, +} + +impl Mode { + pub fn parse(value: &str) -> Option { + match value { + "quick" => Some(Mode::Quick), + "full" => Some(Mode::Full), + _ => None, + } + } + + pub fn as_str(&self) -> &'static str { + match self { + Mode::Quick => "quick", + Mode::Full => "full", + } + } +} + +/// SV-8. +#[derive(Debug, Clone, Copy, PartialEq, Eq, SerdeSerialize, SerdeDeserialize)] +#[serde(rename_all = "lowercase")] +pub enum Status { + Running, + Done, + Stopped, + Failed, + Interrupted, +} + +impl Status { + pub fn as_str(&self) -> &'static str { + match self { + Status::Running => "running", + Status::Done => "done", + Status::Stopped => "stopped", + Status::Failed => "failed", + Status::Interrupted => "interrupted", + } + } +} + +/// SV-4. +#[derive(Debug, Clone, Copy, PartialEq, Eq, SerdeSerialize, SerdeDeserialize)] +#[serde(rename_all = "lowercase")] +pub enum ProblemKind { + Missing, + Damaged, + Unlinked, + Unreadable, +} + +impl ProblemKind { + pub fn as_str(&self) -> &'static str { + match self { + ProblemKind::Missing => "missing", + ProblemKind::Damaged => "damaged", + ProblemKind::Unlinked => "unlinked", + ProblemKind::Unreadable => "unreadable", + } + } +} + +/// SV-4: one blob something needs and can't have, as it was found. +#[derive(Debug, Clone, PartialEq, Eq, SerdeSerialize, SerdeDeserialize)] +#[serde(rename_all = "camelCase")] +pub struct Problem { + pub kind: ProblemKind, + /// None for a queued message, which belongs to no account. + pub account_id: Option, + #[serde(default)] + pub account_name: String, + /// `email`, `file`, `queuedMessage`, ... (SV-4). + pub object: String, + /// The object's id: a document id, a queue id or an archived item's id. + pub object_id: u64, + /// The blob id, as hex. + pub blob_id: String, + /// Whether the store still has the blob's commit marker. + pub committed: bool, + #[serde(default)] + pub detail: String, +} + +/// SV-7: how far a check got and what it found. +#[derive(Debug, Clone, Default, PartialEq, Eq, SerdeSerialize, SerdeDeserialize)] +#[serde(rename_all = "camelCase", default)] +pub struct Progress { + /// Slices of the blob index done, of 256. + pub slices: u32, + pub blobs_checked: u64, + pub links_checked: u64, + pub bytes_read: u64, + pub messages_checked: u64, + /// Accounts whose mail metadata is checked, of how many (SV-3). + pub accounts_done: u64, + pub accounts_total: u64, + pub missing: u64, + pub damaged: u64, + pub unlinked: u64, + pub unreadable: u64, +} + +impl Progress { + pub fn problems(&self) -> u64 { + self.missing + self.damaged + self.unlinked + self.unreadable + } + + pub fn count(&mut self, kind: ProblemKind) { + match kind { + ProblemKind::Missing => self.missing += 1, + ProblemKind::Damaged => self.damaged += 1, + ProblemKind::Unlinked => self.unlinked += 1, + ProblemKind::Unreadable => self.unreadable += 1, + } + } + + /// 0 to 1: the 256 slices are the first 90%, the mail metadata after + /// them the rest. A finished check is 1. + pub fn share(&self, status: Status) -> f64 { + if status == Status::Done { + return 1.0; + } + let slices = self.slices.min(256) as f64 / 256.0; + let accounts = if self.accounts_total == 0 { + 0.0 + } else { + self.accounts_done.min(self.accounts_total) as f64 / self.accounts_total as f64 + }; + slices * 0.9 + accounts * 0.1 + } +} + +/// An `inbuxa:StoreCheck` (SV-1). +#[derive(Debug, Clone, PartialEq, SerdeSerialize, SerdeDeserialize)] +#[serde(rename_all = "camelCase")] +pub struct StoreCheck { + pub id: u32, + pub mode: Mode, + pub blobs_per_second: u64, + pub bytes_per_second: u64, + pub status: Status, + pub created_at: u64, + pub created_by: String, + pub finished_at: Option, + /// The node it runs on. + pub node_id: u64, + /// When its node last saved it (SV-7, SV-8). + pub heartbeat: u64, + /// SV-8: an administrator asked it to stop; the running node sees it at + /// its next save. + #[serde(default)] + pub stop_requested: bool, + #[serde(default)] + pub progress: Progress, + /// Problems kept, at most [`MAX_PROBLEMS`]. + #[serde(default)] + pub problems_kept: u64, + #[serde(default)] + pub error: Option, +} + +impl StoreCheck { + pub fn new(mode: Mode, created_by: String, node_id: u64, now: u64) -> Self { + StoreCheck { + id: 0, + mode, + blobs_per_second: DEFAULT_BLOBS_PER_SECOND, + bytes_per_second: DEFAULT_BYTES_PER_SECOND, + status: Status::Running, + created_at: now, + created_by, + finished_at: None, + node_id, + heartbeat: now, + stop_requested: false, + progress: Progress::default(), + problems_kept: 0, + error: None, + } + } + + /// SV-8: as it reads now. A running check whose node went quiet has + /// stopped with it, even before anything marked it so. + pub fn status_at(&self, now: u64) -> Status { + if self.status == Status::Running && self.heartbeat + STALE_AFTER < now { + Status::Interrupted + } else { + self.status + } + } + + pub fn set_error(&mut self, error: &str) { + self.error = Some(error.trim().chars().take(MAX_TEXT).collect()); + } +} + +struct Json(T); + +impl Serialize for Json<&T> { + fn serialize(&self) -> trc::Result> { + serde_json::to_vec(self.0).map_err(|err| { + trc::StoreEvent::UnexpectedError + .into_err() + .details("Could not serialize a store check") + .reason(err) + }) + } +} + +impl Deserialize for Json { + fn deserialize(bytes: &[u8]) -> trc::Result { + serde_json::from_slice(bytes).map(Json).map_err(|err| { + trc::StoreEvent::DataCorruption + .into_err() + .details("Invalid store check") + .reason(err) + }) + } +} + +fn any(key: Vec) -> ValueClass { + ValueClass::Any(AnyClass { + subspace: SUBSPACE_INBUXA, + key, + }) +} + +fn class(id: u32) -> ValueClass { + let mut key = Vec::with_capacity(2 + U32_LEN); + key.extend_from_slice(&[FEATURE, KIND_CHECK]); + key.extend_from_slice(&id.to_be_bytes()); + any(key) +} + +fn problem_class(id: u32, number: u32) -> ValueClass { + let mut key = Vec::with_capacity(2 + U32_LEN * 2); + key.extend_from_slice(&[FEATURE, KIND_PROBLEM]); + key.extend_from_slice(&id.to_be_bytes()); + key.extend_from_slice(&number.to_be_bytes()); + any(key) +} + +fn running_class() -> ValueClass { + any(vec![FEATURE, KIND_RUNNING]) +} + +pub async fn get(data: &Store, id: u32) -> trc::Result> { + Ok(data + .get_value::>(ValueKey::from(class(id))) + .await + .caused_by(trc::location!())? + .map(|Json(check)| check)) +} + +/// Every check, oldest first. +pub async fn all(data: &Store) -> trc::Result> { + let mut checks = Vec::new(); + data.iterate( + IterateParams::new(ValueKey::from(class(0)), ValueKey::from(class(u32::MAX))), + |_, value| { + if let Ok(Json(check)) = Json::::deserialize(value) { + checks.push(check); + } + Ok(true) + }, + ) + .await + .caused_by(trc::location!())?; + checks.sort_by_key(|c| c.id); + Ok(checks) +} + +/// The id of the check that runs now, if any. +pub async fn running(data: &Store) -> trc::Result> { + Ok(data + .get_value::(ValueKey::from(running_class())) + .await + .caused_by(trc::location!())?) +} + +/// SV-2: why a check can't start. +#[derive(Debug, Clone, PartialEq, Eq)] +pub enum Refusal { + /// This check runs now. + Running(u32), +} + +/// Writes a new check under the next free id, which it returns, and makes +/// it the one that runs. Refused while another runs (SV-2): a running +/// check whose node went quiet is marked interrupted first (SV-8). The +/// oldest checks past [`MAX_CHECKS`] are forgotten (SV-1). +pub async fn create( + data: &Store, + check: &StoreCheck, + now: u64, +) -> trc::Result> { + let mut attempt = 0; + loop { + attempt += 1; + let checks = all(data).await?; + let current = running(data).await?; + if let Some(current) = current { + match checks.iter().find(|c| c.id == current) { + Some(c) if c.status_at(now) == Status::Running => { + return Ok(Err(Refusal::Running(current))); + } + _ => { + // Gone, finished or quiet: it no longer holds the place + if let Some(c) = checks.iter().find(|c| c.id == current) + && c.status == Status::Running + { + update(data, current, |c| { + if c.status != Status::Running { + return false; + } + c.status = Status::Interrupted; + c.finished_at = Some(now); + true + }) + .await?; + } + release(data, current).await?; + } + } + } + + let id = checks.iter().map(|c| c.id).max().unwrap_or(0) + 1; + let stored = StoreCheck { + id, + ..check.clone() + }; + let mut batch = BatchBuilder::new(); + batch.assert_value(class(id), AssertValue::None); + batch.assert_value(running_class(), AssertValue::None); + batch.set(class(id), Json(&stored).serialize()?); + batch.set(running_class(), SerializeInfallible::serialize(&id)); + match data.write(batch.build_all()).await { + Ok(_) => { + // SV-1: the newest MAX_CHECKS stay + let mut checks = checks; + checks.push(stored); + let over = checks.len().saturating_sub(MAX_CHECKS); + for old in checks.iter().take(over) { + if old.status != Status::Running { + remove(data, old.id).await?; + } + } + return Ok(Ok(id)); + } + Err(err) + if attempt < CREATE_ATTEMPTS + && matches!( + err.as_ref(), + trc::EventType::Store(trc::StoreEvent::AssertValueFailed) + ) => {} + Err(err) => return Err(err.caused_by(trc::location!())), + } + } +} + +/// Lets another check run, if `id` is the one that runs now. +pub async fn release(data: &Store, id: u32) -> trc::Result<()> { + let mut batch = BatchBuilder::new(); + batch.assert_value(running_class(), AssertValue::U32(id)); + batch.clear(running_class()); + match data.write(batch.build_all()).await { + Ok(_) => Ok(()), + Err(err) + if matches!( + err.as_ref(), + trc::EventType::Store(trc::StoreEvent::AssertValueFailed) + ) => + { + Ok(()) + } + Err(err) => Err(err.caused_by(trc::location!())), + } +} + +/// A check as stored, with the version [`replace`] checks: a hash of the +/// stored bytes. +struct Versioned(StoreCheck, u64); + +impl Deserialize for Versioned { + fn deserialize(bytes: &[u8]) -> trc::Result { + let Json(check) = Json::::deserialize(bytes)?; + Ok(Versioned(check, xxhash_rust::xxh3::xxh3_64(bytes))) + } +} + +async fn get_versioned(data: &Store, id: u32) -> trc::Result> { + Ok(data + .get_value::(ValueKey::from(class(id))) + .await + .caused_by(trc::location!())? + .map(|Versioned(check, version)| (check, version))) +} + +/// Reads a check, changes it with `change`, and writes it back, again if +/// something else wrote it in between (the running node saving progress +/// while an administrator stops it). `change` returns false to leave it as +/// it is. None if there's no such check. +pub async fn update(data: &Store, id: u32, mut change: F) -> trc::Result> +where + F: FnMut(&mut StoreCheck) -> bool, +{ + loop { + let Some((mut check, version)) = get_versioned(data, id).await? else { + return Ok(None); + }; + if !change(&mut check) { + return Ok(Some(check)); + } + let mut batch = BatchBuilder::new(); + batch.assert_value(class(id), AssertValue::Hash(version)); + batch.set(class(id), Json(&check).serialize()?); + match data.write(batch.build_all()).await { + Ok(_) => return Ok(Some(check)), + Err(err) + if matches!( + err.as_ref(), + trc::EventType::Store(trc::StoreEvent::AssertValueFailed) + ) => {} + Err(err) => return Err(err.caused_by(trc::location!())), + } + } +} + +/// Keeps problems `first..` of a check (SV-5): the caller numbers them and +/// stops at [`MAX_PROBLEMS`]. +pub async fn add_problems( + data: &Store, + id: u32, + first: u64, + problems: &[Problem], +) -> trc::Result<()> { + let mut batch = BatchBuilder::new(); + for (n, problem) in problems.iter().enumerate() { + let number = u32::try_from(first + n as u64).unwrap_or(u32::MAX); + batch.set(problem_class(id, number), Json(problem).serialize()?); + if batch.is_large_batch() { + data.write(batch.build_all()) + .await + .caused_by(trc::location!())?; + batch = BatchBuilder::new(); + } + } + if !batch.is_empty() { + data.write(batch.build_all()) + .await + .caused_by(trc::location!())?; + } + Ok(()) +} + +/// A check's kept problems, in the order they were found. +pub async fn problems(data: &Store, id: u32) -> trc::Result> { + let mut problems = Vec::new(); + data.iterate( + IterateParams::new( + ValueKey::from(problem_class(id, 0)), + ValueKey::from(problem_class(id, u32::MAX)), + ), + |_, value| { + if let Ok(Json(problem)) = Json::::deserialize(value) { + problems.push(problem); + } + Ok(true) + }, + ) + .await + .caused_by(trc::location!())?; + Ok(problems) +} + +/// Forgets a check and its problems (SV-1, SV-10). +pub async fn remove(data: &Store, id: u32) -> trc::Result<()> { + data.delete_range( + ValueKey::from(problem_class(id, 0)), + ValueKey::from(problem_class(id, u32::MAX)), + ) + .await + .caused_by(trc::location!())?; + let mut batch = BatchBuilder::new(); + batch.clear(class(id)); + data.write(batch.build_all()) + .await + .caused_by(trc::location!()) + .map(|_| ()) +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn keys_stay_clear_of_the_store_version() { + for class in [class(1), problem_class(1, 0), running_class()] { + let ValueClass::Any(any) = class else { + unreachable!() + }; + assert_eq!(any.key[0], b'V'); + assert_ne!(any.key[1], b's'); + } + } + + #[test] + fn a_quiet_check_reads_as_interrupted() { + let check = StoreCheck::new(Mode::Quick, "admin".into(), 1, 1_000); + assert_eq!(check.status_at(1_000 + STALE_AFTER), Status::Running); + assert_eq!(check.status_at(1_001 + STALE_AFTER), Status::Interrupted); + let done = StoreCheck { + status: Status::Done, + ..check + }; + assert_eq!(done.status_at(u64::MAX / 2), Status::Done); + } + + #[test] + fn problems_round_trip_as_json() { + let problem = Problem { + kind: ProblemKind::Missing, + account_id: Some(3), + account_name: "ann@example.org".into(), + object: "email".into(), + object_id: 7, + blob_id: "ab".into(), + committed: true, + detail: String::new(), + }; + let bytes = Json(&problem).serialize().unwrap(); + let Json(back) = Json::::deserialize(&bytes).unwrap(); + assert_eq!(back, problem); + assert!( + String::from_utf8(bytes) + .unwrap() + .contains("\"accountId\":3") + ); + } +} diff --git a/crates/jmap-proto/src/object/inbuxa_store_check.rs b/crates/jmap-proto/src/object/inbuxa_store_check.rs new file mode 100644 index 00000000..3ea8f568 --- /dev/null +++ b/crates/jmap-proto/src/object/inbuxa_store_check.rs @@ -0,0 +1,214 @@ +/* + * SPDX-FileCopyrightText: 2026 Coffey Labs LLC + * + * SPDX-License-Identifier: AGPL-3.0-only + */ + +//! `inbuxa:StoreCheck/get` and `/set` under `urn:inbuxa:jmap`: checking that +//! the store has every blob its data needs (store-check spec, SV-1). +//! Creating one starts it; it runs in the background, and `get` says how +//! far it got and what it found. An update with `action: "stop"` stops it. + +use crate::object::{AnyId, JmapObject, JmapObjectId}; +use jmap_tools::{Element, Key, Property}; +use std::{borrow::Cow, str::FromStr}; +use types::id::Id; + +#[derive(Debug, Clone, Default)] +pub struct StoreCheck; + +#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)] +pub enum StoreCheckProperty { + Id, + Mode, + BlobsPerSecond, + BytesPerSecond, + Status, + CreatedAt, + CreatedBy, + FinishedAt, + Node, + Progress, + BlobsChecked, + LinksChecked, + BytesRead, + MessagesChecked, + Missing, + Damaged, + Unlinked, + Unreadable, + Problems, + Error, + Action, +} + +#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)] +pub enum StoreCheckValue { + Id(Id), +} + +impl Property for StoreCheckProperty { + fn try_parse(parent: Option<&Key<'_, Self>>, value: &str) -> Option { + match parent { + None => StoreCheckProperty::parse(value), + Some(_) => None, + } + } + + fn to_cow(&self) -> Cow<'static, str> { + match self { + StoreCheckProperty::Id => "id", + StoreCheckProperty::Mode => "mode", + StoreCheckProperty::BlobsPerSecond => "blobsPerSecond", + StoreCheckProperty::BytesPerSecond => "bytesPerSecond", + StoreCheckProperty::Status => "status", + StoreCheckProperty::CreatedAt => "createdAt", + StoreCheckProperty::CreatedBy => "createdBy", + StoreCheckProperty::FinishedAt => "finishedAt", + StoreCheckProperty::Node => "node", + StoreCheckProperty::Progress => "progress", + StoreCheckProperty::BlobsChecked => "blobsChecked", + StoreCheckProperty::LinksChecked => "linksChecked", + StoreCheckProperty::BytesRead => "bytesRead", + StoreCheckProperty::MessagesChecked => "messagesChecked", + StoreCheckProperty::Missing => "missing", + StoreCheckProperty::Damaged => "damaged", + StoreCheckProperty::Unlinked => "unlinked", + StoreCheckProperty::Unreadable => "unreadable", + StoreCheckProperty::Problems => "problems", + StoreCheckProperty::Error => "error", + StoreCheckProperty::Action => "action", + } + .into() + } +} + +impl StoreCheckProperty { + fn parse(value: &str) -> Option { + hashify::tiny_map!(value.as_bytes(), + b"id" => StoreCheckProperty::Id, + b"mode" => StoreCheckProperty::Mode, + b"blobsPerSecond" => StoreCheckProperty::BlobsPerSecond, + b"bytesPerSecond" => StoreCheckProperty::BytesPerSecond, + b"status" => StoreCheckProperty::Status, + b"createdAt" => StoreCheckProperty::CreatedAt, + b"createdBy" => StoreCheckProperty::CreatedBy, + b"finishedAt" => StoreCheckProperty::FinishedAt, + b"node" => StoreCheckProperty::Node, + b"progress" => StoreCheckProperty::Progress, + b"blobsChecked" => StoreCheckProperty::BlobsChecked, + b"linksChecked" => StoreCheckProperty::LinksChecked, + b"bytesRead" => StoreCheckProperty::BytesRead, + b"messagesChecked" => StoreCheckProperty::MessagesChecked, + b"missing" => StoreCheckProperty::Missing, + b"damaged" => StoreCheckProperty::Damaged, + b"unlinked" => StoreCheckProperty::Unlinked, + b"unreadable" => StoreCheckProperty::Unreadable, + b"problems" => StoreCheckProperty::Problems, + b"error" => StoreCheckProperty::Error, + b"action" => StoreCheckProperty::Action, + ) + } +} + +impl FromStr for StoreCheckProperty { + type Err = (); + + fn from_str(s: &str) -> Result { + StoreCheckProperty::parse(s).ok_or(()) + } +} + +impl Element for StoreCheckValue { + type Property = StoreCheckProperty; + + fn try_parse

(key: &Key<'_, Self::Property>, value: &str) -> Option { + match key { + Key::Property(StoreCheckProperty::Id) => { + Id::from_str(value).ok().map(StoreCheckValue::Id) + } + _ => None, + } + } + + fn to_cow(&self) -> Cow<'static, str> { + match self { + StoreCheckValue::Id(id) => id.to_string().into(), + } + } +} + +impl JmapObject for StoreCheck { + type Property = StoreCheckProperty; + + type Element = StoreCheckValue; + + type Id = Id; + + type Filter = (); + + type Comparator = (); + + type GetArguments = (); + + type SetArguments<'de> = (); + + type QueryArguments = (); + + type CopyArguments = (); + + type ParseArguments = (); + + const ID_PROPERTY: Self::Property = StoreCheckProperty::Id; +} + +impl From for StoreCheckValue { + fn from(id: Id) -> Self { + StoreCheckValue::Id(id) + } +} + +impl JmapObjectId for StoreCheckValue { + fn as_id(&self) -> Option { + match self { + StoreCheckValue::Id(id) => Some(*id), + } + } + + fn as_any_id(&self) -> Option { + match self { + StoreCheckValue::Id(id) => Some(AnyId::Id(*id)), + } + } + + fn as_id_ref(&self) -> Option<&str> { + None + } + + fn try_set_id(&mut self, new_id: AnyId) -> bool { + if let AnyId::Id(id) = new_id { + *self = StoreCheckValue::Id(id); + true + } else { + false + } + } +} + +impl JmapObjectId for StoreCheckProperty { + fn as_id(&self) -> Option { + None + } + + fn as_any_id(&self) -> Option { + None + } + + fn as_id_ref(&self) -> Option<&str> { + None + } + + fn try_set_id(&mut self, _: AnyId) -> bool { + false + } +} diff --git a/crates/jmap-proto/src/object/mod.rs b/crates/jmap-proto/src/object/mod.rs index cd582561..14e67093 100644 --- a/crates/jmap-proto/src/object/mod.rs +++ b/crates/jmap-proto/src/object/mod.rs @@ -50,6 +50,7 @@ pub mod inbuxa_scheduled_report; // inbuxa: scheduled reports pub mod inbuxa_scheduled_report_settings; // inbuxa: scheduled reports pub mod inbuxa_security_acceptance; // inbuxa: accepted security to-do items pub mod inbuxa_sharing_policy; // inbuxa: MA-C, who may share mail +pub mod inbuxa_store_check; // inbuxa: checking the store's blobs pub mod inbuxa_tenant_protocol_policy; // inbuxa: legacy protocols off, per tenant pub mod mailbox; pub mod participant_identity; diff --git a/crates/jmap-proto/src/references/eval.rs b/crates/jmap-proto/src/references/eval.rs index 23353135..d0b35558 100644 --- a/crates/jmap-proto/src/references/eval.rs +++ b/crates/jmap-proto/src/references/eval.rs @@ -91,6 +91,9 @@ impl Response<'_> { GetResponseMethod::Migration(response) => { response.eval_jptr(path, &mut results) } + GetResponseMethod::StoreCheck(response) => { + response.eval_jptr(path, &mut results) + } GetResponseMethod::Relay(response) => { response.eval_jptr(path, &mut results) } diff --git a/crates/jmap-proto/src/references/resolve.rs b/crates/jmap-proto/src/references/resolve.rs index 4755b545..4ce30f4c 100644 --- a/crates/jmap-proto/src/references/resolve.rs +++ b/crates/jmap-proto/src/references/resolve.rs @@ -56,6 +56,7 @@ impl Response<'_> { GetRequestMethod::LegalHold(request) => request.resolve_references(self)?, GetRequestMethod::MailRule(request) => request.resolve_references(self)?, GetRequestMethod::Migration(request) => request.resolve_references(self)?, + GetRequestMethod::StoreCheck(request) => request.resolve_references(self)?, GetRequestMethod::Relay(request) => request.resolve_references(self)?, GetRequestMethod::RelayMessage(request) => request.resolve_references(self)?, GetRequestMethod::SecurityAcceptance(request) => { @@ -155,6 +156,9 @@ impl Response<'_> { SetRequestMethod::Migration(request) => { request.resolve_references(self, 1, false)? } + SetRequestMethod::StoreCheck(request) => { + request.resolve_references(self, 1, false)? + } SetRequestMethod::Relay(request) => request.resolve_references(self, 1, false)?, SetRequestMethod::RelayMessage(request) => { request.resolve_references(self, 1, false)? diff --git a/crates/jmap-proto/src/request/method.rs b/crates/jmap-proto/src/request/method.rs index ad0f1bce..e80cd643 100644 --- a/crates/jmap-proto/src/request/method.rs +++ b/crates/jmap-proto/src/request/method.rs @@ -70,6 +70,8 @@ pub enum MethodObject { MailRule, // inbuxa: migrations into this server Migration, + // inbuxa: checking the store's blobs + StoreCheck, Relay, RelayMessage, // inbuxa: accepted security to-do items @@ -129,6 +131,7 @@ impl MethodObject { | MethodObject::HoldExport | MethodObject::MailRule | MethodObject::Migration + | MethodObject::StoreCheck | MethodObject::Relay | MethodObject::RelayMessage | MethodObject::SecurityAcceptance @@ -345,6 +348,8 @@ impl MethodName { (MethodFunction::Set, MethodObject::MailRule) => "inbuxa:MailRule/set", (MethodFunction::Get, MethodObject::Migration) => "inbuxa:Migration/get", (MethodFunction::Set, MethodObject::Migration) => "inbuxa:Migration/set", + (MethodFunction::Get, MethodObject::StoreCheck) => "inbuxa:StoreCheck/get", + (MethodFunction::Set, MethodObject::StoreCheck) => "inbuxa:StoreCheck/set", (MethodFunction::Get, MethodObject::Relay) => "inbuxa:Relay/get", (MethodFunction::Set, MethodObject::Relay) => "inbuxa:Relay/set", (MethodFunction::Get, MethodObject::RelayMessage) => "inbuxa:RelayMessage/get", @@ -550,6 +555,8 @@ impl MethodName { "inbuxa:MailRule/set" => (MethodObject::MailRule, MethodFunction::Set), "inbuxa:Migration/get" => (MethodObject::Migration, MethodFunction::Get), "inbuxa:Migration/set" => (MethodObject::Migration, MethodFunction::Set), + "inbuxa:StoreCheck/get" => (MethodObject::StoreCheck, MethodFunction::Get), + "inbuxa:StoreCheck/set" => (MethodObject::StoreCheck, MethodFunction::Set), "inbuxa:Relay/get" => (MethodObject::Relay, MethodFunction::Get), "inbuxa:Relay/set" => (MethodObject::Relay, MethodFunction::Set), "inbuxa:RelayMessage/get" => (MethodObject::RelayMessage, MethodFunction::Get), @@ -652,6 +659,7 @@ impl Display for MethodObject { MethodObject::LegalHold => "inbuxa:LegalHold", MethodObject::MailRule => "inbuxa:MailRule", MethodObject::Migration => "inbuxa:Migration", + MethodObject::StoreCheck => "inbuxa:StoreCheck", MethodObject::Relay => "inbuxa:Relay", MethodObject::RelayMessage => "inbuxa:RelayMessage", MethodObject::SecurityAcceptance => "inbuxa:SecurityAcceptance", diff --git a/crates/jmap-proto/src/request/mod.rs b/crates/jmap-proto/src/request/mod.rs index f62e3ee9..5ecf6eeb 100644 --- a/crates/jmap-proto/src/request/mod.rs +++ b/crates/jmap-proto/src/request/mod.rs @@ -128,6 +128,7 @@ pub enum GetRequestMethod { LegalHold(Box>), MailRule(Box>), Migration(Box>), + StoreCheck(Box>), Relay(Box>), RelayMessage(Box>), SecurityAcceptance( @@ -187,6 +188,7 @@ pub enum SetRequestMethod<'x> { LegalHold(Box>), MailRule(Box>), Migration(Box>), + StoreCheck(Box>), Relay(Box>), RelayMessage(Box>), SecurityAcceptance( diff --git a/crates/jmap-proto/src/request/parser.rs b/crates/jmap-proto/src/request/parser.rs index 7e91a7aa..c5591fea 100644 --- a/crates/jmap-proto/src/request/parser.rs +++ b/crates/jmap-proto/src/request/parser.rs @@ -704,6 +704,21 @@ impl<'de> Visitor<'de> for CallVisitor { return Err(de::Error::invalid_length(1, &self)); } }, + // inbuxa: checking the store's blobs + (MethodFunction::Get, MethodObject::StoreCheck) => match seq.next_element() { + Ok(Some(value)) => RequestMethod::Get(GetRequestMethod::StoreCheck(value)), + Err(err) => RequestMethod::invalid(err), + Ok(None) => { + return Err(de::Error::invalid_length(1, &self)); + } + }, + (MethodFunction::Set, MethodObject::StoreCheck) => match seq.next_element() { + Ok(Some(value)) => RequestMethod::Set(SetRequestMethod::StoreCheck(value)), + Err(err) => RequestMethod::invalid(err), + Ok(None) => { + return Err(de::Error::invalid_length(1, &self)); + } + }, // inbuxa: inbuxa Relay (MethodFunction::Get, MethodObject::Relay) => match seq.next_element() { Ok(Some(value)) => RequestMethod::Get(GetRequestMethod::Relay(value)), diff --git a/crates/jmap-proto/src/response/mod.rs b/crates/jmap-proto/src/response/mod.rs index df18050f..77c41731 100644 --- a/crates/jmap-proto/src/response/mod.rs +++ b/crates/jmap-proto/src/response/mod.rs @@ -113,6 +113,7 @@ pub enum GetResponseMethod { LegalHold(GetResponse), MailRule(GetResponse), Migration(GetResponse), + StoreCheck(GetResponse), Relay(GetResponse), RelayMessage(GetResponse), SecurityAcceptance(GetResponse), @@ -170,6 +171,7 @@ pub enum SetResponseMethod { LegalHold(Box>), MailRule(Box>), Migration(Box>), + StoreCheck(Box>), Relay(Box>), RelayMessage(Box>), SecurityAcceptance( @@ -1052,6 +1054,19 @@ impl<'x> From> for Respo } } +// inbuxa: checking the store's blobs +impl<'x> From> for ResponseMethod<'x> { + fn from(value: GetResponse) -> Self { + ResponseMethod::Get(GetResponseMethod::StoreCheck(value)) + } +} + +impl<'x> From> for ResponseMethod<'x> { + fn from(value: SetResponse) -> Self { + ResponseMethod::Set(SetResponseMethod::StoreCheck(Box::new(value))) + } +} + impl<'x> From> for ResponseMethod<'x> { fn from(value: GetResponse) -> Self { ResponseMethod::Get(GetResponseMethod::Relay(value)) diff --git a/crates/jmap/src/api/auth.rs b/crates/jmap/src/api/auth.rs index 896d7ccd..43cab232 100644 --- a/crates/jmap/src/api/auth.rs +++ b/crates/jmap/src/api/auth.rs @@ -118,6 +118,8 @@ impl JmapAuthorization for AccessToken { } // inbuxa: migrations into this server (MG-10) GetRequestMethod::Migration(_) => Permission::SysMigrationRun, + // inbuxa: store-check spec, SV-9 + GetRequestMethod::StoreCheck(_) => Permission::SysStoreCheck, // inbuxa: inbuxa Relay GetRequestMethod::Relay(_) => Permission::SysRelayGet, GetRequestMethod::RelayMessage(_) => Permission::SysRelayQueueGet, @@ -323,6 +325,14 @@ impl JmapAuthorization for AccessToken { Permission::SysMigrationRun, Permission::SysMigrationRun, ), + // inbuxa: store-check spec, SV-9 + SetRequestMethod::StoreCheck(s) => validate_set( + s, + self, + Permission::SysStoreCheck, + Permission::SysStoreCheck, + Permission::SysStoreCheck, + ), // inbuxa: inbuxa Relay; a new join token is an update SetRequestMethod::Relay(s) => validate_set( s, @@ -596,6 +606,7 @@ impl JmapAuthorization for AccessToken { | MethodObject::HoldExport | MethodObject::MailRule | MethodObject::Migration + | MethodObject::StoreCheck | MethodObject::Relay | MethodObject::RelayMessage | MethodObject::SecurityAcceptance diff --git a/crates/jmap/src/api/request.rs b/crates/jmap/src/api/request.rs index 48171ab2..49943280 100644 --- a/crates/jmap/src/api/request.rs +++ b/crates/jmap/src/api/request.rs @@ -293,6 +293,9 @@ impl RequestHandler for Server { SetResponseMethod::Migration(set_response) => { set_response.update_created_ids(&mut response); } + SetResponseMethod::StoreCheck(set_response) => { + set_response.update_created_ids(&mut response); + } SetResponseMethod::Relay(set_response) => { set_response.update_created_ids(&mut response); } @@ -572,6 +575,13 @@ impl RequestHandler for Server { .await? .into() } + // inbuxa: checking the store's blobs + GetRequestMethod::StoreCheck(mut req) => { + resolve_account_id(&mut req.account_id, method_name.obj, access_token)?; + crate::inbuxa::store_check::get(self, access_token, *req) + .await? + .into() + } // inbuxa: inbuxa Relay GetRequestMethod::Relay(mut req) => { resolve_account_id(&mut req.account_id, method_name.obj, access_token)?; @@ -1165,6 +1175,22 @@ impl RequestHandler for Server { .await? .into() } + // inbuxa: store-check spec, SV-9: starting and stopping are audited + SetRequestMethod::StoreCheck(mut req) => { + resolve_account_id(&mut req.account_id, method_name.obj, access_token)?; + crate::inbuxa::audit::recorded( + self, + access_token, + session, + &method_name.obj.to_string(), + None, + None, + *req, + |req| Box::pin(crate::inbuxa::store_check::set(self, access_token, req)), + ) + .await? + .into() + } SetRequestMethod::Relay(mut req) => { resolve_account_id(&mut req.account_id, method_name.obj, access_token)?; let reason = req.arguments.reason.clone(); diff --git a/crates/jmap/src/changes/get.rs b/crates/jmap/src/changes/get.rs index 551dbe16..948fedda 100644 --- a/crates/jmap/src/changes/get.rs +++ b/crates/jmap/src/changes/get.rs @@ -432,6 +432,7 @@ impl IntermediateChangesResponse { | MethodObject::HoldExport | MethodObject::MailRule | MethodObject::Migration + | MethodObject::StoreCheck | MethodObject::Relay | MethodObject::RelayMessage | MethodObject::SecurityAcceptance diff --git a/crates/jmap/src/inbuxa/audit.rs b/crates/jmap/src/inbuxa/audit.rs index 02260045..63a96e29 100644 --- a/crates/jmap/src/inbuxa/audit.rs +++ b/crates/jmap/src/inbuxa/audit.rs @@ -511,6 +511,21 @@ async fn fork_current(server: &Server, object: &str, id: &MaybeInvalid) -> O } MaybeInvalid::Invalid(_) => None, }, + // A store check: what kind, and how it stands (store-check spec, SV-9) + "inbuxa:StoreCheck" => match id { + MaybeInvalid::Value(id) => { + inbuxa_features::store_check::get(data, u32::try_from(id.id()).ok()?) + .await + .ok()? + .map(|c| { + serde_json::json!({ + "mode": c.mode.as_str(), + "status": c.status.as_str(), + }) + }) + } + MaybeInvalid::Invalid(_) => None, + }, // A relay as an administrator sets it: never its keys or token "inbuxa:Relay" => match id { MaybeInvalid::Value(id) => { diff --git a/crates/jmap/src/inbuxa/mod.rs b/crates/jmap/src/inbuxa/mod.rs index 3fd1dd80..425154ff 100644 --- a/crates/jmap/src/inbuxa/mod.rs +++ b/crates/jmap/src/inbuxa/mod.rs @@ -38,6 +38,7 @@ pub mod relay_message; // inbuxa: a relay's queues pub mod scheduled_reports; // inbuxa: scheduled reports and the weekly digest pub mod security_acceptance; pub mod sharing_policy; +pub mod store_check; // inbuxa: checking the store's blobs pub mod telemetry; pub mod tenant_protocol_policy; pub mod undelete; diff --git a/crates/jmap/src/inbuxa/store_check.rs b/crates/jmap/src/inbuxa/store_check.rs new file mode 100644 index 00000000..ae550ba5 --- /dev/null +++ b/crates/jmap/src/inbuxa/store_check.rs @@ -0,0 +1,310 @@ +/* + * SPDX-FileCopyrightText: 2026 Coffey Labs LLC + * + * SPDX-License-Identifier: AGPL-3.0-only + */ + +//! `inbuxa:StoreCheck` (store-check spec): starting a check of the store's +//! blobs, seeing how far it got and what it found, stopping it, and +//! forgetting it. The run is `services::inbuxa_store_check`. Starting and +//! stopping one are audited by the request layer (SV-9). + +use super::relay::json_to_value; +use common::{Server, auth::AccessToken}; +use inbuxa_features::store_check::{self as model, Mode, Refusal, Status, StoreCheck as Stored}; +use jmap_proto::{ + error::set::SetError, + method::{ + get::{GetRequest, GetResponse}, + set::{SetRequest, SetResponse}, + }, + object::inbuxa_store_check::{StoreCheck, StoreCheckProperty as P, StoreCheckValue}, + request::IntoValid, + types::date::UTCDate, +}; +use jmap_tools::{Key, Map, Value}; +use serde_json::json; +use services::inbuxa_store_check as runs; +use store::write::now; +use types::id::Id; + +type CValue = Value<'static, P, StoreCheckValue>; + +const ALL: &[P] = &[ + P::Id, + P::Mode, + P::BlobsPerSecond, + P::BytesPerSecond, + P::Status, + P::CreatedAt, + P::CreatedBy, + P::FinishedAt, + P::Node, + P::Progress, + P::BlobsChecked, + P::LinksChecked, + P::BytesRead, + P::MessagesChecked, + P::Missing, + P::Damaged, + P::Unlinked, + P::Unreadable, + P::Problems, + P::Error, +]; + +/// SV-9: a check reads every account's data, so only the server's own +/// administrators run one. +fn server_level(access_token: &AccessToken) -> trc::Result<()> { + if access_token.tenant_id().is_some() { + Err(trc::JmapEvent::Forbidden + .into_err() + .details("A store check reads the whole server, not a tenant.")) + } else { + Ok(()) + } +} + +fn date(seconds: u64) -> serde_json::Value { + json!(UTCDate::from_timestamp(seconds as i64).to_string()) +} + +async fn to_value(server: &Server, c: &Stored, properties: &[P], now: u64) -> trc::Result { + let status = c.status_at(now); + let mut out = Map::with_capacity(properties.len()); + for property in properties { + let p = &c.progress; + let json = match property { + P::Id => { + out.insert_unchecked( + Key::Property(P::Id), + Value::Element(StoreCheckValue::Id(Id::from(c.id))), + ); + continue; + } + P::Mode => json!(c.mode.as_str()), + P::BlobsPerSecond => json!(c.blobs_per_second), + P::BytesPerSecond => json!(c.bytes_per_second), + P::Status => json!(status.as_str()), + P::CreatedAt => date(c.created_at), + P::CreatedBy => json!(c.created_by), + P::FinishedAt => c.finished_at.map_or(serde_json::Value::Null, date), + P::Node => json!(c.node_id.to_string()), + P::Progress => json!(p.share(status)), + P::BlobsChecked => json!(p.blobs_checked), + P::LinksChecked => json!(p.links_checked), + P::BytesRead => json!(p.bytes_read), + P::MessagesChecked => json!(p.messages_checked), + P::Missing => json!(p.missing), + P::Damaged => json!(p.damaged), + P::Unlinked => json!(p.unlinked), + P::Unreadable => json!(p.unreadable), + P::Problems => { + let problems = model::problems(server.store(), c.id).await?; + let mut list = serde_json::to_value(&problems).unwrap_or_default(); + // The account as a JMAP id, like every other account id + if let Some(items) = list.as_array_mut() { + for item in items { + if let Some(account) = item.get("accountId").and_then(|v| v.as_u64()) { + item["accountId"] = json!(Id::from(account).to_string()); + } + } + } + list + } + P::Error => json!(c.error), + // Write-only + P::Action => continue, + }; + out.insert_unchecked(Key::Property(property.clone()), json_to_value(json)); + } + Ok(Value::Object(out)) +} + +/// `inbuxa:StoreCheck/get`: every check kept, newest first. +pub async fn get( + server: &Server, + access_token: &AccessToken, + mut request: GetRequest, +) -> trc::Result> { + server_level(access_token)?; + let properties = request.unwrap_properties(ALL); + let (ids, not_found) = request.unwrap_ids(server.core.jmap.get_max_objects)?; + let mut response = GetResponse { + account_id: request.account_id.into(), + state: None, + list: Vec::new(), + not_found, + }; + let mut checks = model::all(server.store()).await?; + checks.reverse(); + let now = now(); + match ids { + None => { + for c in &checks { + response + .list + .push(to_value(server, c, &properties, now).await?); + } + } + Some(ids) => { + for id in ids { + match checks.iter().find(|c| u64::from(c.id) == id.id()) { + Some(c) => response + .list + .push(to_value(server, c, &properties, now).await?), + None => response.push_not_found(id), + } + } + } + } + Ok(response) +} + +fn invalid(property: P, why: impl Into) -> SetError

{ + SetError::invalid_properties() + .with_property(property) + .with_description(why.into()) +} + +/// A limit: a whole number, 0 for none (SV-6). +fn limit(property: P, value: &Value<'_, P, StoreCheckValue>) -> Result> { + match value { + Value::Number(n) => n + .as_u64() + .ok_or_else(|| invalid(property, "A whole number of 0 or more; 0 is no limit.")), + _ => Err(invalid( + property, + "A whole number of 0 or more; 0 is no limit.", + )), + } +} + +/// `inbuxa:StoreCheck/set`: create starts a check; an update can only stop +/// one; destroy forgets a finished one (SV-2, SV-8, SV-10). +pub async fn set( + server: &Server, + access_token: &AccessToken, + mut request: SetRequest<'_, StoreCheck>, +) -> trc::Result> { + server_level(access_token)?; + let mut response = SetResponse::from_request(&request, server.core.jmap.set_max_objects)?; + let data = server.store(); + let actor = server.audit_actor(access_token).await; + + 'create: for (client_id, value) in request.unwrap_create() { + let mut mode = Mode::Quick; + let mut blobs_per_second = None; + let mut bytes_per_second = None; + for (key, value) in value.into_expanded_object() { + let outcome = match &key { + Key::Property(P::Mode) => match value.as_str().and_then(|s| Mode::parse(&s)) { + Some(m) => { + mode = m; + Ok(()) + } + None => Err(invalid(P::Mode, "quick or full.")), + }, + Key::Property(P::BlobsPerSecond) => { + limit(P::BlobsPerSecond, &value).map(|l| blobs_per_second = Some(l)) + } + Key::Property(P::BytesPerSecond) => { + limit(P::BytesPerSecond, &value).map(|l| bytes_per_second = Some(l)) + } + _ => Err(SetError::invalid_properties().with_property(key.clone().into_owned())), + }; + if let Err(error) = outcome { + response.not_created.append(client_id, error); + continue 'create; + } + } + match runs::start( + server, + mode, + blobs_per_second, + bytes_per_second, + actor.name.clone(), + ) + .await? + { + Ok(id) => { + let mut out = Map::with_capacity(1); + out.insert_unchecked( + Key::Property(P::Id), + Value::Element(StoreCheckValue::Id(Id::from(id))), + ); + response.created.insert(client_id, Value::Object(out)); + } + Err(Refusal::Running(id)) => response.not_created.append( + client_id, + SetError::forbidden().with_description(format!( + "Check {} runs now; one check runs at a time. Stop it or wait for it.", + Id::from(id) + )), + ), + } + } + + for (id, value) in request.unwrap_update().into_valid() { + let Ok(check_id) = u32::try_from(id.id()) else { + response.not_updated.append(id, SetError::not_found()); + continue; + }; + let mut action = None; + let mut bad = None; + for (key, value) in value.into_expanded_object() { + match &key { + Key::Property(P::Action) => action = value.as_str().map(|s| s.to_string()), + _ => { + bad = Some( + SetError::invalid_properties() + .with_property(key.clone().into_owned()) + .with_description("A check can't be changed, only stopped."), + ) + } + } + } + if let Some(error) = bad { + response.not_updated.append(id, error); + continue; + } + if action.as_deref() != Some("stop") { + response + .not_updated + .append(id, invalid(P::Action, "The one action is stop.")); + continue; + } + let Some(check) = model::get(data, check_id).await? else { + response.not_updated.append(id, SetError::not_found()); + continue; + }; + if check.status_at(now()) != Status::Running { + response.not_updated.append( + id, + SetError::forbidden().with_description("That check isn't running."), + ); + continue; + } + runs::stop(server, check_id).await?; + response.updated.append(id, None); + } + + for id in request.unwrap_destroy().into_valid() { + let Ok(check_id) = u32::try_from(id.id()) else { + response.not_destroyed.append(id, SetError::not_found()); + continue; + }; + match model::get(data, check_id).await? { + None => response.not_destroyed.append(id, SetError::not_found()), + Some(c) if c.status_at(now()) == Status::Running => response.not_destroyed.append( + id, + SetError::forbidden().with_description("It's running; stop it first."), + ), + Some(_) => { + model::remove(data, check_id).await?; + response.destroyed.push(id); + } + } + } + Ok(response) +} diff --git a/crates/registry/src/schema/enums.rs b/crates/registry/src/schema/enums.rs index eb447ef2..240a66b7 100644 --- a/crates/registry/src/schema/enums.rs +++ b/crates/registry/src/schema/enums.rs @@ -1791,6 +1791,8 @@ pub enum Permission { SysRelayQueueUpdate = 693, // inbuxa: migrations into this server SysMigrationRun = 694, + // inbuxa: checking the store's blobs + SysStoreCheck = 695, SysAccountGet = 219, SysAccountCreate = 220, SysAccountUpdate = 221, diff --git a/crates/registry/src/schema/enums_impl.rs b/crates/registry/src/schema/enums_impl.rs index 74863f17..e5ff1f9b 100644 --- a/crates/registry/src/schema/enums_impl.rs +++ b/crates/registry/src/schema/enums_impl.rs @@ -7171,6 +7171,7 @@ impl EnumImpl for Permission { b"sysRelayQueueGet" => Permission::SysRelayQueueGet, b"sysRelayQueueUpdate" => Permission::SysRelayQueueUpdate, b"sysMigrationRun" => Permission::SysMigrationRun, + b"sysStoreCheck" => Permission::SysStoreCheck, b"sysAccountGet" => Permission::SysAccountGet, b"sysAccountCreate" => Permission::SysAccountCreate, b"sysAccountUpdate" => Permission::SysAccountUpdate, @@ -7882,6 +7883,7 @@ impl EnumImpl for Permission { Permission::SysRelayQueueGet => "sysRelayQueueGet", Permission::SysRelayQueueUpdate => "sysRelayQueueUpdate", Permission::SysMigrationRun => "sysMigrationRun", + Permission::SysStoreCheck => "sysStoreCheck", Permission::SysAccountGet => "sysAccountGet", Permission::SysAccountCreate => "sysAccountCreate", Permission::SysAccountUpdate => "sysAccountUpdate", @@ -8586,6 +8588,7 @@ impl EnumImpl for Permission { 692 => Some(Permission::SysRelayQueueGet), 693 => Some(Permission::SysRelayQueueUpdate), 694 => Some(Permission::SysMigrationRun), + 695 => Some(Permission::SysStoreCheck), 219 => Some(Permission::SysAccountGet), 220 => Some(Permission::SysAccountCreate), 221 => Some(Permission::SysAccountUpdate), @@ -9030,7 +9033,7 @@ impl EnumImpl for Permission { } } - const COUNT: usize = 695; + const COUNT: usize = 696; } impl serde::Serialize for Permission { diff --git a/crates/services/src/inbuxa_store_check.rs b/crates/services/src/inbuxa_store_check.rs new file mode 100644 index 00000000..5486d3c6 --- /dev/null +++ b/crates/services/src/inbuxa_store_check.rs @@ -0,0 +1,556 @@ +/* + * SPDX-FileCopyrightText: 2026 Coffey Labs LLC + * + * SPDX-License-Identifier: AGPL-3.0-only + */ + +//! Checking the store's blobs (docs/spec/features/store-check.md): the run +//! behind an `inbuxa:StoreCheck`. It goes through the blob index one slice +//! at a time and asks the blob store for each blob something holds, then +//! through each account's mail metadata for the blob each message names +//! (SV-3). It reports and never repairs. It runs on the node the check was +//! started on, against the stores every node shares. + +use common::{BuildServer, Inner, Server}; +use email::message::metadata::MessageMetadata; +use inbuxa_features::store_check::{ + self as model, MAX_PROBLEMS, Mode, Problem, ProblemKind, Progress, Refusal, STALE_AFTER, + Status, StoreCheck, +}; +use registry::schema::prelude::ObjectType; + +use std::{ + collections::{BTreeSet, HashMap}, + sync::Arc, + time::{Duration, Instant}, +}; +use store::{ + Deserialize, IterateParams, U32_LEN, ValueKey, + registry::RegistryQuery, + roaring::RoaringBitmap, + write::{ + AlignedBytes, Archive, + blob_check::{BlobHolder, LinkedBlob}, + key::DeserializeBigEndian, + now, + }, +}; +use trc::AddContext; +use types::{blob::BlobClass, blob_hash::BlobHash, collection::Collection, field::EmailField}; + +/// SV-7: how often a running check saves its progress, which is also its +/// heartbeat and when it sees a stop. +const SAVE_EVERY: Duration = Duration::from_secs(10); + +fn node_id(server: &Server) -> u64 { + server.core.network.node_id +} + +/// SV-2: starts a check on this node. Refused while another runs. +pub async fn start( + server: &Server, + mode: Mode, + blobs_per_second: Option, + bytes_per_second: Option, + created_by: String, +) -> trc::Result> { + let now = now(); + let mut check = StoreCheck::new(mode, created_by, node_id(server), now); + if let Some(limit) = blobs_per_second { + check.blobs_per_second = limit; + } + if let Some(limit) = bytes_per_second { + check.bytes_per_second = limit; + } + let id = match model::create(server.store(), &check, now).await? { + Ok(id) => id, + Err(refusal) => return Ok(Err(refusal)), + }; + let check = StoreCheck { id, ..check }; + let server = server.clone(); + tokio::spawn(async move { + run(&server, check).await; + }); + Ok(Ok(id)) +} + +/// SV-8: asks a running check to stop. Any node can: the one running it +/// sees the request at its next save. None if there's no such check. +pub async fn stop(server: &Server, id: u32) -> trc::Result> { + model::update(server.store(), id, |c| { + if c.status != Status::Running || c.stop_requested { + return false; + } + c.stop_requested = true; + true + }) + .await +} + +/// SV-8: at start-up, a check this node ran stopped with it. Then, now and +/// then, a check on a node that went quiet is taken to have stopped too. +pub fn spawn_store_checks(inner: Arc) { + tokio::spawn(async move { + let server = inner.build_server(); + let node = node_id(&server); + mark_interrupted(&server, |c| c.node_id == node).await; + loop { + tokio::time::sleep(Duration::from_secs(60)).await; + let server = inner.build_server(); + let cutoff = now().saturating_sub(STALE_AFTER); + mark_interrupted(&server, |c| c.node_id != node && c.heartbeat < cutoff).await; + } + }); +} + +async fn mark_interrupted(server: &Server, which: impl Fn(&StoreCheck) -> bool) { + let checks = match model::all(server.store()).await { + Ok(checks) => checks, + Err(err) => { + trc::error!(err.details("Failed to read the store checks")); + return; + } + }; + for check in checks + .into_iter() + .filter(|c| c.status == Status::Running && which(c)) + { + let result = model::update(server.store(), check.id, |c| { + if c.status != Status::Running || !which(c) { + return false; + } + c.status = Status::Interrupted; + c.finished_at = Some(now()); + true + }) + .await; + if let Err(err) = result.and(model::release(server.store(), check.id).await) { + trc::error!(err.details("Failed to mark an interrupted store check")); + } + } +} + +/// SV-6: keeps a rate, a second at a time, so a slow stretch isn't made +/// up for with a burst. +struct Pace { + per_second: u64, + window: Instant, + used: u64, +} + +impl Pace { + fn new(per_second: u64) -> Self { + Pace { + per_second, + window: Instant::now(), + used: 0, + } + } + + async fn take(&mut self, amount: u64) { + if self.per_second == 0 { + return; + } + if self.window.elapsed() >= Duration::from_secs(1) { + self.window = Instant::now(); + self.used = 0; + } + self.used += amount; + if self.used >= self.per_second { + let rest = Duration::from_secs(1).saturating_sub(self.window.elapsed()); + tokio::time::sleep(rest).await; + self.window = Instant::now(); + self.used = self.used.saturating_sub(self.per_second); + } + } +} + +/// What a blob turned out to be (SV-4). +enum Found { + Fine, + Problem(ProblemKind, String), +} + +/// The name a problem gives an object (SV-4). +fn object_name(collection: u8) -> String { + match Collection::from(collection) { + Collection::Email => "email".into(), + Collection::FileNode => "file".into(), + Collection::SieveScript => "sieveScript".into(), + Collection::CalendarEvent => "calendarEvent".into(), + Collection::ContactCard => "contactCard".into(), + _ => format!("collection{collection}"), + } +} + +struct Run<'x> { + server: &'x Server, + check: StoreCheck, + progress: Progress, + found: Vec, + kept: u64, + names: HashMap, + blobs: Pace, + bytes: Pace, + saved: Instant, +} + +/// How a run ended before it finished. +enum Halt { + Stopped, + Failed(trc::Error), +} + +impl From for Halt { + fn from(err: trc::Error) -> Self { + Halt::Failed(err) + } +} + +impl<'x> Run<'x> { + async fn account_name(&mut self, account_id: u32) -> String { + if let Some(name) = self.names.get(&account_id) { + return name.clone(); + } + let name = self.server.audit_account_name(account_id).await; + self.names.insert(account_id, name.clone()); + name + } + + /// SV-4, SV-5: counts a problem, logs it, and keeps the first ones. + async fn problem( + &mut self, + kind: ProblemKind, + account_id: Option, + object: String, + object_id: u64, + hash: &BlobHash, + committed: bool, + detail: String, + ) { + self.progress.count(kind); + let account_name = match account_id { + Some(id) => self.account_name(id).await, + None => String::new(), + }; + let blob_id = hash.to_hex(); + trc::event!( + Store(trc::StoreEvent::DataCorruption), + Id = self.check.id, + AccountId = account_id, + Collection = object.clone(), + DocumentId = object_id, + BlobId = blob_id.clone(), + Reason = kind.as_str(), + Details = detail.clone(), + ); + if self.kept < MAX_PROBLEMS { + self.kept += 1; + self.found.push(Problem { + kind, + account_id, + account_name, + object, + object_id, + blob_id, + committed, + detail, + }); + } + } + + /// SV-7, SV-8: saves progress and the problems found since, now and + /// then; a stop asked for meanwhile ends the run. + async fn save(&mut self, force: bool) -> Result<(), Halt> { + if !force && self.saved.elapsed() < SAVE_EVERY { + return Ok(()); + } + let data = self.server.store(); + let first = self.kept - self.found.len() as u64; + model::add_problems(data, self.check.id, first, &self.found).await?; + self.found.clear(); + let progress = self.progress.clone(); + let kept = self.kept; + let saved = model::update(data, self.check.id, |c| { + c.progress = progress.clone(); + c.problems_kept = kept; + c.heartbeat = now(); + true + }) + .await?; + self.saved = Instant::now(); + match saved { + Some(c) if c.stop_requested => Err(Halt::Stopped), + Some(_) => Ok(()), + // Forgotten under it: nothing left to report to + None => Err(Halt::Stopped), + } + } + + /// SV-2: whether the blob is there and, in a full check, intact. + async fn look_at(&mut self, hash: &BlobHash) -> Found { + let store = self.server.blob_store(); + match self.check.mode { + Mode::Quick => match store.blob_present(hash.as_slice()).await { + Ok(true) => Found::Fine, + Ok(false) => Found::Problem(ProblemKind::Missing, String::new()), + Err(err) => Found::Problem(ProblemKind::Unreadable, err.to_string()), + }, + Mode::Full => match store.get_blob(hash.as_slice(), 0..usize::MAX).await { + Ok(Some(content)) => { + let size = content.len() as u64; + self.progress.bytes_read += size; + self.bytes.take(size).await; + let actual = BlobHash::generate(&content); + if &actual == hash { + Found::Fine + } else { + Found::Problem( + ProblemKind::Damaged, + format!("its {size} bytes hash to {}", actual.to_hex()), + ) + } + } + Ok(None) => Found::Problem(ProblemKind::Missing, String::new()), + Err(err) + if matches!( + err.as_ref(), + trc::EventType::Store(trc::StoreEvent::DecompressError) + ) => + { + Found::Problem(ProblemKind::Damaged, "it doesn't decompress".into()) + } + Err(err) => Found::Problem(ProblemKind::Unreadable, err.to_string()), + }, + } + } + + /// SV-3, links: one slice of the blob index. + async fn slice(&mut self, slice: u8, mail: &mut BTreeSet) -> Result<(), Halt> { + let blobs: Vec = self.server.store().linked_blobs(slice).await?; + for blob in blobs { + self.blobs.take(1).await; + self.progress.blobs_checked += 1; + self.progress.links_checked += blob.holders.len() as u64; + for holder in &blob.holders { + if let BlobHolder::Document { + account_id, + collection, + .. + } = holder + && Collection::from(*collection) == Collection::Email + { + mail.insert(*account_id); + } + } + if let Found::Problem(kind, detail) = self.look_at(&blob.hash).await { + // A shared blob is read once and reported for each holder + for holder in &blob.holders { + let (account_id, object, object_id) = match holder { + BlobHolder::Document { + account_id, + collection, + document_id, + } => ( + Some(*account_id), + object_name(*collection), + *document_id as u64, + ), + BlobHolder::Queue { id } => (None, "queuedMessage".to_string(), *id), + BlobHolder::Archived { account_id, item } => ( + Some(*account_id), + "archivedItem".to_string(), + item.id().id(), + ), + }; + self.problem( + kind, + account_id, + object, + object_id, + &blob.hash, + blob.committed, + detail.clone(), + ) + .await; + } + } + self.save(false).await?; + } + Ok(()) + } + + /// SV-3, mail metadata: each message names its blob; it must hold a + /// link to it, or nothing keeps the blob from being purged. + async fn mail(&mut self, account_id: u32) -> Result<(), Halt> { + let data = self.server.store(); + let mut messages: Vec<(u32, BlobHash)> = Vec::new(); + data.iterate( + IterateParams::new( + ValueKey::property(account_id, Collection::Email, 0, EmailField::Metadata), + ValueKey::property( + account_id, + Collection::Email, + u32::MAX, + EmailField::Metadata, + ), + ), + |key, value| { + let document_id = key.deserialize_be_u32(key.len() - U32_LEN)?; + let archive = as Deserialize>::deserialize(value)?; + let metadata = archive.unarchive::()?; + messages.push((document_id, BlobHash::from(&metadata.blob_hash))); + Ok(true) + }, + ) + .await + .caused_by(trc::location!())?; + + for (document_id, hash) in messages { + self.blobs.take(1).await; + self.progress.messages_checked += 1; + let linked = data + .blob_has_access( + &hash, + BlobClass::Linked { + account_id, + collection: Collection::Email.into(), + document_id, + }, + ) + .await?; + if !linked { + let committed = data.blob_exists(&hash).await?; + let detail = match self.server.blob_store().blob_present(hash.as_slice()).await { + Ok(true) => "the blob is still there".to_string(), + Ok(false) => "the blob is gone".to_string(), + Err(err) => format!("the blob store couldn't say: {err}"), + }; + self.problem( + ProblemKind::Unlinked, + Some(account_id), + "email".into(), + document_id as u64, + &hash, + committed, + detail, + ) + .await; + } + self.save(false).await?; + } + Ok(()) + } + + async fn go(&mut self) -> Result<(), Halt> { + let mut mail = BTreeSet::new(); + for slice in 0u8..=255 { + self.slice(slice, &mut mail).await?; + self.progress.slices = slice as u32 + 1; + self.save(false).await?; + } + + // Every account, and any whose mail is still linked without it + // being in the registry any more (kept after deletion) + let registry: RoaringBitmap = self + .server + .registry() + .query::(RegistryQuery::new(ObjectType::Account)) + .await?; + mail.extend(registry.iter()); + self.progress.accounts_total = mail.len() as u64; + for account_id in mail { + self.mail(account_id).await?; + self.progress.accounts_done += 1; + self.save(false).await?; + } + Ok(()) + } +} + +/// Runs a check to its end and records how it ended (SV-8). +async fn run(server: &Server, check: StoreCheck) { + let id = check.id; + let mut run = Run { + server, + blobs: Pace::new(check.blobs_per_second), + bytes: Pace::new(if check.mode == Mode::Full { + check.bytes_per_second + } else { + 0 + }), + check, + progress: Progress::default(), + found: Vec::new(), + kept: 0, + names: HashMap::new(), + saved: Instant::now(), + }; + let ended = run.go().await; + let (status, error) = match ended { + Ok(()) => (Status::Done, None), + Err(Halt::Stopped) => (Status::Stopped, None), + Err(Halt::Failed(err)) => { + let text = err + .value_as_str(trc::Key::Details) + .map(str::to_string) + .unwrap_or_else(|| err.to_string()); + trc::error!(err.details("A store check failed")); + (Status::Failed, Some(text)) + } + }; + + let data = server.store(); + let first = run.kept - run.found.len() as u64; + let mut result = model::add_problems(data, id, first, &run.found).await; + if result.is_ok() { + let progress = run.progress.clone(); + let kept = run.kept; + result = model::update(data, id, |c| { + c.progress = progress.clone(); + c.problems_kept = kept; + c.status = status; + c.finished_at = Some(now()); + c.heartbeat = now(); + if let Some(error) = &error { + c.set_error(error); + } + true + }) + .await + .map(|_| ()); + } + if let Err(err) = result.and(model::release(data, id).await) { + trc::error!(err.details("Failed to save a store check's result")); + } +} + +#[cfg(test)] +mod tests { + use super::*; + + #[tokio::test] + async fn pace_holds_a_rate() { + let mut pace = Pace::new(100); + let started = Instant::now(); + for _ in 0..250 { + pace.take(1).await; + } + // 250 at 100 a second: two full seconds waited, a bit of a third + assert!(started.elapsed() >= Duration::from_millis(1_900)); + let mut free = Pace::new(0); + let started = Instant::now(); + for _ in 0..10_000 { + free.take(1).await; + } + assert!(started.elapsed() < Duration::from_millis(500)); + } + + #[test] + fn objects_are_named_by_collection() { + assert_eq!(object_name(Collection::Email.into()), "email"); + assert_eq!(object_name(Collection::FileNode.into()), "file"); + assert_eq!(object_name(Collection::SieveScript.into()), "sieveScript"); + assert_eq!(object_name(Collection::Mailbox.into()), "collection1"); + } +} diff --git a/crates/services/src/lib.rs b/crates/services/src/lib.rs index 2f75ca2b..ddb4a75f 100644 --- a/crates/services/src/lib.rs +++ b/crates/services/src/lib.rs @@ -30,6 +30,7 @@ pub mod inbuxa_migrations; // inbuxa: migrations into this server pub mod inbuxa_relay_certificates; // inbuxa: inbuxa Relays' certificates pub mod inbuxa_relay_link; // inbuxa: links to inbuxa Relays pub mod inbuxa_scheduled_reports; // inbuxa: scheduled reports and the weekly digest +pub mod inbuxa_store_check; // inbuxa: checking the store's blobs pub mod state_manager; pub mod task_manager; @@ -84,6 +85,9 @@ impl SpawnServices for IpcReceivers { // inbuxa: migrations spec, MG-11: a run this node had stopped with it inbuxa_migrations::spawn_migrations(inner.clone()); + // inbuxa: store-check spec, SV-8: a check this node ran stopped with it + inbuxa_store_check::spawn_store_checks(inner.clone()); + // inbuxa: relay spec, "The link service": every node links to every relay inbuxa_relay_link::spawn_relay_links(inner.clone()); diff --git a/crates/store/src/write/blob_check.rs b/crates/store/src/write/blob_check.rs new file mode 100644 index 00000000..ebbcb80e --- /dev/null +++ b/crates/store/src/write/blob_check.rs @@ -0,0 +1,162 @@ +/* + * SPDX-FileCopyrightText: 2026 Coffey Labs LLC + * + * SPDX-License-Identifier: AGPL-3.0-only + */ + +//! inbuxa: what the store-check spec (docs/spec/features/store-check.md) +//! reads from the store: each blob the data holds a link to, with who holds +//! it, one slice of the blob index at a time (SV-3), and whether a blob is +//! in the blob store without reading all of it (SV-2, quick). + +use super::{BlobOp, ValueClass, key::DeserializeBigEndian, now}; +use crate::{ + BlobStore, Deserialize, IterateParams, Store, U16_LEN, U32_LEN, U64_LEN, ValueKey, + write::BlobLink, +}; +use registry::types::id::ObjectId; +use trc::AddContext; +use types::blob_hash::{BLOB_HASH_LEN, BlobHash}; + +/// Who holds a link to a blob (SV-3). +#[derive(Debug, Clone, PartialEq, Eq)] +pub enum BlobHolder { + /// A document: an email, a file, a Sieve script, ... + Document { + account_id: u32, + collection: u8, + document_id: u32, + }, + /// A queued message. + Queue { id: u64 }, + /// A deleted item kept to be restored, until its link expires. + Archived { account_id: u32, item: ObjectId }, +} + +/// A blob something holds, and whether the store has its commit marker. +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct LinkedBlob { + pub hash: BlobHash, + pub committed: bool, + pub holders: Vec, +} + +impl Store { + /// Every blob in one slice of the blob index (the first byte of its + /// hash) that something holds a link to. Uploads nothing holds yet and + /// expired links are left out: they're the purge's to clear. + pub async fn linked_blobs(&self, slice: u8) -> trc::Result> { + const TEMP_LINK: usize = BLOB_HASH_LEN + U32_LEN + U64_LEN; + const DOC_LINK: usize = BLOB_HASH_LEN + U32_LEN + 1 + U32_LEN; + const ID_LINK: usize = BLOB_HASH_LEN + U64_LEN; + + let mut from_hash = BlobHash::default(); + let mut to_hash = BlobHash::new_max(); + from_hash.0[0] = slice; + to_hash.0[0] = slice; + let from_key = ValueKey { + account_id: 0, + collection: 0, + document_id: 0, + class: ValueClass::Blob(BlobOp::Commit { hash: from_hash }), + }; + let to_key = ValueKey { + account_id: u32::MAX, + collection: u8::MAX, + document_id: u32::MAX, + class: ValueClass::Blob(BlobOp::Link { + hash: to_hash, + to: BlobLink::Document, + }), + }; + + let now = now(); + let mut blobs: Vec = Vec::new(); + self.iterate( + IterateParams::new(from_key, to_key).ascending(), + |key, value| { + let hash = key + .get(0..BLOB_HASH_LEN) + .and_then(|h| BlobHash::try_from_hash_slice(h).ok()) + .ok_or_else(|| { + trc::Error::corrupted_key(key, value.into(), trc::location!()) + })?; + if blobs.last().is_none_or(|b| b.hash != hash) { + blobs.push(LinkedBlob { + hash, + committed: false, + holders: Vec::new(), + }); + } + let blob = blobs.last_mut().unwrap(); + match key.len() { + BLOB_HASH_LEN => blob.committed = true, + DOC_LINK => blob.holders.push(BlobHolder::Document { + account_id: key.deserialize_be_u32(BLOB_HASH_LEN)?, + collection: key[BLOB_HASH_LEN + U32_LEN], + document_id: key.deserialize_be_u32(BLOB_HASH_LEN + U32_LEN + 1)?, + }), + ID_LINK => blob.holders.push(BlobHolder::Queue { + id: key.deserialize_be_u64(BLOB_HASH_LEN)?, + }), + TEMP_LINK => { + // Only a link that names a kept item: a plain one is + // an upload nothing holds yet + let until = key.deserialize_be_u64(BLOB_HASH_LEN + U32_LEN)?; + if until > now && value.len() == U16_LEN + U64_LEN { + blob.holders.push(BlobHolder::Archived { + account_id: key.deserialize_be_u32(BLOB_HASH_LEN)?, + item: ObjectId::deserialize(value)?, + }); + } + } + _ => { + return Err(trc::Error::corrupted_key( + key, + value.into(), + trc::location!(), + )); + } + } + Ok(true) + }, + ) + .await + .caused_by(trc::location!())?; + + blobs.retain(|b| !b.holders.is_empty()); + Ok(blobs) + } +} + +impl BlobStore { + /// Whether the blob store has anything under `key`, reading as little + /// of it as each backend allows: a file's metadata, one byte of an + /// object, or, in a data store, the blob itself. + pub async fn blob_present(&self, key: &[u8]) -> trc::Result { + match self { + BlobStore::Fs(store) => store.get_blob(key, 0..1).await.map(|b| b.is_some()), + #[cfg(feature = "s3")] + BlobStore::S3(store) => match store.get_blob(key, 0..1).await { + Ok(found) => Ok(found.is_some()), + // An empty object has no first byte to read + Err(_) => self.raw_get(key).await.map(|b| b.is_some()), + }, + #[cfg(feature = "azure")] + BlobStore::Azure(store) => match store.get_blob(key, 0..1).await { + Ok(found) => Ok(found.is_some()), + Err(_) => self.raw_get(key).await.map(|b| b.is_some()), + }, + BlobStore::Sharded(store) => { + // Anywhere in the set: a misplaced blob is still there + for member in &store.members { + if Box::pin(member.blob_present(key)).await? { + return Ok(true); + } + } + Ok(false) + } + BlobStore::Store(_) => self.raw_get(key).await.map(|b| b.is_some()), + } + } +} diff --git a/crates/store/src/write/mod.rs b/crates/store/src/write/mod.rs index d52fda2b..bfb3e808 100644 --- a/crates/store/src/write/mod.rs +++ b/crates/store/src/write/mod.rs @@ -2,6 +2,8 @@ * SPDX-FileCopyrightText: 2020 Stalwart Labs LLC * * SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-SEL + * + * Modified by Coffey Labs in 2026 for INBUXA. */ use self::assert::AssertValue; @@ -27,6 +29,7 @@ pub mod assert; pub mod batch; pub mod bitpack; pub mod blob; +pub mod blob_check; // inbuxa: store-check spec pub mod key; pub mod log; pub mod serialize; diff --git a/docs/spec/SPEC.md b/docs/spec/SPEC.md index 1383ef29..77be579f 100644 --- a/docs/spec/SPEC.md +++ b/docs/spec/SPEC.md @@ -386,6 +386,8 @@ Not a rebuild: **scheduled reports and the weekly digest** are INBUXA's own desi Not a rebuild: **migrations into this server** are INBUXA's own design (`features/migrations.md`, approved 2026-10-30, in progress). An administrator moves a domain in from inbuxa Admin; the server keeps the answers as `inbuxa:Migration` and runs the bundled inbuxa-migrate on them as a child of one node, writing in as that administrator with a run token held in memory only (`crates/jmap/src/inbuxa/migration.rs`, `crates/features/src/migration/`, `crates/services/src/inbuxa_migrations.rs`, `crates/common/src/migration_token.rs`), and the `sysMigrationRun` permission. +Not a rebuild: the **store check** is INBUXA's own design (`features/store-check.md`, inbuxa-server #322, building). An administrator starts a check of the store's blobs, quick (each one is there) or full (each one reads back intact), and gets a list of what's missing, damaged or no longer linked. One node runs it in the background, throttled, and keeps its progress: `inbuxa:StoreCheck` (`crates/jmap/src/inbuxa/store_check.rs`, `crates/features/src/store_check/`, `crates/services/src/inbuxa_store_check.rs`, `crates/store/src/write/blob_check.rs`), and the `sysStoreCheck` permission. + Not a rebuild: **inbuxa-relay** is INBUXA's own design (`features/relay.md`, settled 2026-10-29, in progress). It's a small edge appliance that takes mail in on port 25 for one downstream server or cluster, and sends that downstream's outgoing mail on. The downstream dials out to it over JMAP (`urn:inbuxa:jmap:relay`), so the protected network exposes no mail port, and it is administered only from the downstream's inbuxa-admin. ## 5. The web front ends diff --git a/docs/spec/features/store-check.md b/docs/spec/features/store-check.md new file mode 100644 index 00000000..f50b8979 --- /dev/null +++ b/docs/spec/features/store-check.md @@ -0,0 +1,133 @@ +# Feature spec: checking the store's blobs + +Status: building, 2026-11-08 (inbuxa-server #322). Not a rebuild (SPEC.md +§4): inbuxa's own design. + +## Provenance + +| Source | Used for | +|---|---| +| Forum topic 238 | The need: a mail whose metadata was there and whose blob wasn't, on a server that looked healthy, and a backup that copied it | +| This server's blob links (`crates/store/src/write/blob.rs`) and `BlobHash` (`crates/types/src/blob_hash.rs`) | What a document holds on to, and how a blob proves its content | +| This server's `inbuxa:HoldExport` and `inbuxa:Migration` | How a fork object, a background job and their permission are built | + +Upstream's open code has nothing like it, and nothing here comes from +Enterprise code. + +## What it is + +An administrator asks the server to check that the blobs its data needs are +in the blob store, and, if asked, that each one is intact. The check +reports what it finds and changes nothing. It runs inside the server, on +the node the administrator reached, against the stores every node shares. +So it works while mail flows, on one machine or a cluster, whatever the +stores are. An offline command couldn't: RocksDB lets one process open the +store, and a cluster's data store and blob store may be on other machines. + +## Requirements + +- **SV-1.** A check is an `inbuxa:StoreCheck` under `urn:inbuxa:jmap`. It's + kept in the fork's subspace under `Vc` and its problems under `Vp`, + never in the registry. The latest 20 checks are kept; starting a 21st + forgets the oldest. +- **SV-2.** Creating one starts it. Its `mode` is: + - `quick`: every blob the check covers (SV-3) is in the blob store; + - `full`: also, each one reads back whole and its BLAKE3 hash is its id. + Blob ids are the hash of their content, so this proves the content, + not just that something is stored under the id. + + One check runs at a time across the server; another create is refused + while one runs. +- **SV-3.** What it covers: + - **Links.** Every blob a document holds (`BlobLink::Document`: mail, + files, Sieve scripts and the rest, by collection), every blob a queued + message holds (`BlobLink::Id`), and every blob a kept deleted item + holds (a temporary link that names the archived item, not yet + expired). A blob several documents share is read once and reported + for each of them. + - **Mail metadata.** Each message's stored metadata names its blob. The + check finds the message's own link to it. A message that names a blob + without a link is a problem even when the blob is there, because + nothing stops the blob from being purged. + + Not covered: uploads nothing holds yet (they expire on their own), and + files the server keeps under fixed names (spam model, app bundles). +- **SV-4.** A problem is one of: + - `missing`: the blob store has nothing under the id; + - `damaged` (full only): the content's hash isn't its id, or it doesn't + decompress; + - `unlinked`: a message's metadata names a blob it holds no link to, + with whether the blob is still there; + - `unreadable`: the blob store answered with an error, which is kept. + + Each says the account (id and name), the object (`email`, `file`, + `sieveScript`, `calendarEvent`, `contactCard`, `queuedMessage`, + `archivedItem`, or the collection's number for any other), its id, the + blob id, and whether the store still has the blob's commit marker. A + missing blob with its marker was committed and lost afterwards; one + without it never finished being written. +- **SV-5.** A check keeps its first 1,000 problems. The counts cover all of + them. Every problem is also logged as an event (`store.data-corruption`), + with the account, collection, document and blob id, so problems past the + first 1,000 are in the log. +- **SV-6.** It's throttled, so a full check of a big store doesn't hold up + mail: by default at most 1,000 blobs a second and, in full mode, 20 MB a + second read. `blobsPerSecond` and `bytesPerSecond` set other limits at + create; 0 means no limit. +- **SV-7.** Progress: the share of the blob index done (it goes through it + in 256 slices), blobs and links checked, bytes read, problems by kind, + and accounts whose mail metadata was checked. It's saved at least every + 10 seconds, which is also its heartbeat. +- **SV-8.** A check ends: + - `done`, problems or none; + - `stopped`, by an update with `action: "stop"`, which any node can + take: the running node sees it at its next save; + - `failed`, with the error, when the check itself couldn't go on; + - `interrupted`: its node restarted while it ran, or the node has been + quiet for five minutes. +- **SV-9.** Only administrators check the store: `sysStoreCheck`, in the + built-in Administrator role and granted once to existing administrator + roles. It reads every account's data, so a tenant administrator is + refused. Starting and stopping a check are audited; reading one isn't. +- **SV-10.** A finished check can be destroyed. A running one can't; stop + it first. + +## The object + +| Property | Type | | +|---|---|---| +| `id` | Id | | +| `mode` | String | `quick` or `full`, set at create | +| `blobsPerSecond`, `bytesPerSecond` | UnsignedInt | Limits, set at create (SV-6) | +| `status` | String | `running`, `done`, `stopped`, `failed`, `interrupted` | +| `createdAt`, `finishedAt` | UTCDate | | +| `createdBy` | String | Who started it | +| `node` | String | The node it runs on | +| `progress` | Number | 0 to 1 | +| `blobsChecked`, `linksChecked`, `bytesRead`, `messagesChecked` | UnsignedInt | | +| `missing`, `damaged`, `unlinked`, `unreadable` | UnsignedInt | Counts of each kind | +| `problems` | Object[] | The first 1,000 (SV-4, SV-5) | +| `error` | String | Why a `failed` check failed | + +A problem is `{kind, accountId, accountName, object, objectId, blobId, +committed, detail}`. + +## Tests + +- `system::store_check` (`tests/src/system/store_check.rs`), against a real + server: a clean store reported clean; then blobs deleted from under + messages (missing, including a blob two messages share, reported once per + message), a blob overwritten with other content (damaged in full mode, not + in quick), and a message whose link was taken away (unlinked, with the + blob still there). Over JMAP: the refusal while one check runs, stop, + the destroy rules, bad input, the audit events, a user's refusal and a + tenant administrator's. + +## Not yet + +- The console's page and an `inbuxa-cli` command. +- A test with a queued message and a kept archived item holding a blob. +- Metadata for files and Sieve scripts, as for mail (SV-3): their links are + checked, but not that each one holds the blob its record names. +- Mail metadata of an account that holds no link at all and isn't in the + registry any more. diff --git a/resources/privacy/catalog.toml b/resources/privacy/catalog.toml index a229da8a..1d5e121f 100644 --- a/resources/privacy/catalog.toml +++ b/resources/privacy/catalog.toml @@ -270,6 +270,17 @@ reason = ["content"] createdBy = ["identifier"] blobId = ["content", "identifier", "contact", "metadata"] +[object."inbuxa:StoreCheck"] +file = "inbuxa_store_check.rs" +default = "none" +whose = ["holder", "administrator"] +where = ["data-store"] +scope = "server" +retention = "object-life" +[object."inbuxa:StoreCheck".properties] +createdBy = ["identifier"] +problems = ["identifier", "metadata"] + [object."inbuxa:Migration"] file = "inbuxa_migration.rs" default = "none" diff --git a/resources/schema/schema.json.gz b/resources/schema/schema.json.gz index ce75744db0375e888d8c00da95e691ad3e829441..3889c2d8cc861615923a297db4aacea8230f61d9 100644 GIT binary patch delta 35135 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 D@=lmI delta 35102 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 W&oCIcuDW{4{lBxc<^`zR6%PP-7}GNV diff --git a/resources/schema/schema.json.sha256 b/resources/schema/schema.json.sha256 index 133baa12..ae467ecc 100644 --- a/resources/schema/schema.json.sha256 +++ b/resources/schema/schema.json.sha256 @@ -1 +1 @@ -S4aYPorha42i3aPFKvdSAjZEGGvxIxd5w-xl_naBAJA \ No newline at end of file +Z7m4tA0knFnM6t30zrTSVKWBuNKOEGEMouWPHB3_ED4 \ No newline at end of file diff --git a/tests/src/system/mod.rs b/tests/src/system/mod.rs index 34df806b..69731127 100644 --- a/tests/src/system/mod.rs +++ b/tests/src/system/mod.rs @@ -38,6 +38,7 @@ pub mod scheduled_reports; // inbuxa: scheduled reports and the weekly digest pub mod security; pub mod security_acceptances; // inbuxa: accepted security to-do items pub mod sharing_policy; // inbuxa: MA-C, who may share mail +pub mod store_check; // inbuxa: checking the store's blobs pub mod task; pub mod tenant; pub mod tracer_reload; // inbuxa: tracers start over when their settings change diff --git a/tests/src/system/store_check.rs b/tests/src/system/store_check.rs new file mode 100644 index 00000000..a0881fbb --- /dev/null +++ b/tests/src/system/store_check.rs @@ -0,0 +1,421 @@ +/* + * SPDX-FileCopyrightText: 2026 Coffey Labs LLC + * + * SPDX-License-Identifier: AGPL-3.0-only + */ + +//! `inbuxa:StoreCheck` (docs/spec/features/store-check.md). +//! +//! A clean store checks clean. Then blobs are taken from under messages: +//! one deleted with its commit marker left, one shared by two messages, one +//! overwritten with other content, and one message's link taken away while +//! its blob stays. A quick check finds the missing ones and the unlinked +//! one, each with the account and the message; a full check also finds the +//! damaged one. One check runs at a time, a running one stops when asked +//! and can't be destroyed, a finished one can, and nobody in a tenant or +//! without the permission reaches checks. Starting and stopping are +//! audited. + +use crate::utils::{ + account::Account, + server::{TestServer, TestServerBuilder}, +}; +use email::{mailbox::INBOX_ID, message::metadata::MessageMetadata}; +use registry::schema::{ + enums::CompressionAlgo, + prelude::{ObjectType, Property}, + structs::{CertificateManagement, DkimManagement, DnsManagement, Domain, Tenant, UserRoles}, +}; +use serde_json::{Value, json}; +use std::{str::FromStr, time::Duration}; +use store::{ + ValueKey, + write::{AlignedBytes, Archive, BatchBuilder, BlobLink, BlobOp}, +}; +use types::{blob_hash::BlobHash, collection::Collection, field::EmailField, id::Id}; + +const USING: &[&str] = &[ + "urn:ietf:params:jmap:core", + "urn:inbuxa:jmap", + "urn:inbuxa:jmap:registry", +]; + +async fn call(account: &Account, method: &str, mut arguments: Value) -> (String, Value) { + if arguments.get("accountId").is_none() { + arguments["accountId"] = account.id_string().into(); + } + let response = account + .jmap_request(USING, json!([[method, arguments, "0"]])) + .await; + let call = response + .0 + .pointer("/methodResponses/0") + .cloned() + .unwrap_or_else(|| panic!("{method}: {}", response.0)); + ( + call[0].as_str().unwrap_or_default().to_string(), + call[1].clone(), + ) +} + +async fn start(admin: &Account, check: Value) -> String { + let (_, response) = call( + admin, + "inbuxa:StoreCheck/set", + json!({"create": {"c": check}}), + ) + .await; + response["created"]["c"]["id"] + .as_str() + .unwrap_or_else(|| panic!("not started: {response}")) + .to_string() +} + +async fn get(admin: &Account, id: &str) -> Value { + let (_, response) = call(admin, "inbuxa:StoreCheck/get", json!({"ids": [id]})).await; + response["list"][0].clone() +} + +/// The check once it's over. +async fn settled(admin: &Account, id: &str) -> Value { + for _ in 0..600 { + let check = get(admin, id).await; + if check["status"] != "running" { + return check; + } + tokio::time::sleep(Duration::from_millis(100)).await; + } + panic!("the check didn't finish: {}", get(admin, id).await); +} + +async fn import(client: &jmap_client::client::Client, body: &str) -> u32 { + let id = client + .email_import( + format!("From: a@example.org\r\nSubject: {body}\r\n\r\n{body}\r\n").into_bytes(), + [Id::from(INBOX_ID).to_string()], + None::>, + None, + ) + .await + .unwrap() + .take_id(); + Id::from_str(&id).unwrap().document_id() +} + +async fn blob_of(test: &TestServer, account_id: u32, document_id: u32) -> BlobHash { + let archive = test + .server + .store() + .get_value::>(ValueKey::property( + account_id, + Collection::Email, + document_id, + EmailField::Metadata, + )) + .await + .unwrap() + .expect("the message's metadata"); + let metadata = archive.unarchive::().unwrap(); + BlobHash::from(&metadata.blob_hash) +} + +fn count(check: &Value, kind: &str) -> u64 { + check[kind] + .as_u64() + .unwrap_or_else(|| panic!("no {kind}: {check}")) +} + +/// The problems found for one message, as `kind` strings. +fn kinds_for(check: &Value, document_id: u32) -> Vec { + check["problems"] + .as_array() + .unwrap_or_else(|| panic!("no problems list: {check}")) + .iter() + .filter(|p| p["objectId"].as_u64() == Some(document_id as u64)) + .map(|p| p["kind"].as_str().unwrap_or_default().to_string()) + .collect() +} + +pub async fn test(test: &mut TestServer) { + println!("Running store check tests..."); + let admin = test.account("admin@example.com"); + let ann = test.account("ann@example.com"); + let ann_id = ann.id().document_id(); + let client = ann.jmap_client().await; + + let missing = import(&client, "Missing blob").await; + let shared_a = import(&client, "Shared blob").await; + let shared_b = import(&client, "Shared blob").await; + let damaged = import(&client, "Damaged blob").await; + let unlinked = import(&client, "Unlinked message").await; + let fine = import(&client, "Nothing wrong").await; + assert_eq!( + blob_of(test, ann_id, shared_a).await, + blob_of(test, ann_id, shared_b).await, + "the same message twice shares its blob" + ); + + // A clean store checks clean + let id = start(admin, json!({"mode": "quick"})).await; + let check = settled(admin, &id).await; + assert_eq!(check["status"], "done", "{check}"); + assert_eq!(check["progress"], 1.0, "{check}"); + for kind in ["missing", "damaged", "unlinked", "unreadable"] { + assert_eq!(count(&check, kind), 0, "{kind} in a clean store: {check}"); + } + assert!(count(&check, "blobsChecked") >= 5, "{check}"); + assert!(count(&check, "messagesChecked") >= 6, "{check}"); + assert_eq!(check["problems"], json!([]), "{check}"); + assert_eq!(check["mode"], "quick", "{check}"); + assert_eq!(check["createdBy"], "admin@example.com", "{check}"); + + // Take blobs from under them + let blobs = test.server.blob_store(); + blobs + .delete_blob(blob_of(test, ann_id, missing).await.as_slice()) + .await + .unwrap(); + blobs + .delete_blob(blob_of(test, ann_id, shared_a).await.as_slice()) + .await + .unwrap(); + blobs + .put_blob( + blob_of(test, ann_id, damaged).await.as_slice(), + b"Something else entirely", + CompressionAlgo::None, + ) + .await + .unwrap(); + let mut batch = BatchBuilder::new(); + batch + .with_account_id(ann_id) + .with_collection(Collection::Email) + .with_document(unlinked) + .clear(BlobOp::Link { + hash: blob_of(test, ann_id, unlinked).await, + to: BlobLink::Document, + }); + test.server.store().write(batch.build_all()).await.unwrap(); + + // Quick: what's gone, and the message without its link + let id = start(admin, json!({"mode": "quick"})).await; + let check = settled(admin, &id).await; + assert_eq!(check["status"], "done", "{check}"); + assert_eq!(count(&check, "missing"), 3, "{check}"); + assert_eq!( + count(&check, "damaged"), + 0, + "quick doesn't read content: {check}" + ); + assert_eq!(count(&check, "unlinked"), 1, "{check}"); + assert_eq!(kinds_for(&check, missing), ["missing"], "{check}"); + assert_eq!(kinds_for(&check, shared_a), ["missing"], "{check}"); + assert_eq!(kinds_for(&check, shared_b), ["missing"], "{check}"); + assert_eq!(kinds_for(&check, unlinked), ["unlinked"], "{check}"); + assert!(kinds_for(&check, fine).is_empty(), "{check}"); + let problem = check["problems"] + .as_array() + .unwrap() + .iter() + .find(|p| p["objectId"].as_u64() == Some(missing as u64)) + .unwrap() + .clone(); + assert_eq!(problem["object"], "email", "{problem}"); + assert_eq!(problem["accountId"], ann.id_string(), "{problem}"); + assert_eq!(problem["accountName"], "ann@example.com", "{problem}"); + assert_eq!( + problem["committed"], true, + "lost after it was written: {problem}" + ); + assert_eq!( + problem["blobId"], + blob_of(test, ann_id, missing).await.to_hex(), + "{problem}" + ); + let unlinked_problem = check["problems"] + .as_array() + .unwrap() + .iter() + .find(|p| p["objectId"].as_u64() == Some(unlinked as u64)) + .unwrap() + .clone(); + assert_eq!( + unlinked_problem["detail"], "the blob is still there", + "{unlinked_problem}" + ); + + // Full: the overwritten one too + let id = start(admin, json!({"mode": "full", "bytesPerSecond": 0})).await; + let check = settled(admin, &id).await; + assert_eq!(check["status"], "done", "{check}"); + assert_eq!(count(&check, "missing"), 3, "{check}"); + assert_eq!(count(&check, "damaged"), 1, "{check}"); + assert_eq!(count(&check, "unlinked"), 1, "{check}"); + assert_eq!(kinds_for(&check, damaged), ["damaged"], "{check}"); + assert!(count(&check, "bytesRead") > 0, "{check}"); + let full = id; + + // One at a time; a running one stops when asked, and stays until then + let slow = start(admin, json!({"mode": "quick", "blobsPerSecond": 1})).await; + let (_, response) = call( + admin, + "inbuxa:StoreCheck/set", + json!({"create": {"again": {"mode": "quick"}}}), + ) + .await; + assert!( + response["notCreated"]["again"]["description"] + .as_str() + .is_some_and(|d| d.contains("one check runs at a time")), + "a second check while one runs: {response}" + ); + let (_, response) = call(admin, "inbuxa:StoreCheck/set", json!({"destroy": [&slow]})).await; + assert!(response["notDestroyed"].get(&slow).is_some(), "{response}"); + let (_, response) = call( + admin, + "inbuxa:StoreCheck/set", + json!({"update": {&slow: {"mode": "full"}}}), + ) + .await; + assert!(response["notUpdated"].get(&slow).is_some(), "{response}"); + let (_, response) = call( + admin, + "inbuxa:StoreCheck/set", + json!({"update": {&slow: {"action": "stop"}}}), + ) + .await; + assert!(response["updated"].get(&slow).is_some(), "{response}"); + let check = settled(admin, &slow).await; + assert_eq!(check["status"], "stopped", "{check}"); + assert!(check["progress"].as_f64().unwrap() < 1.0, "{check}"); + let (_, response) = call( + admin, + "inbuxa:StoreCheck/set", + json!({"update": {&slow: {"action": "stop"}}}), + ) + .await; + assert!( + response["notUpdated"].get(&slow).is_some(), + "stopping a stopped check: {response}" + ); + + // A finished one can be forgotten, with its problems + let (_, response) = call(admin, "inbuxa:StoreCheck/set", json!({"destroy": [&full]})).await; + assert_eq!(response["destroyed"], json!([full]), "{response}"); + let (_, response) = call(admin, "inbuxa:StoreCheck/get", json!({"ids": [&full]})).await; + assert_eq!(response["notFound"], json!([full]), "{response}"); + let id = Id::from_str(&full).unwrap().id() as u32; + assert!( + inbuxa_features::store_check::problems(test.server.store(), id) + .await + .unwrap() + .is_empty(), + "a forgotten check's problems are gone too" + ); + + // Bad input + for (create, why) in [ + (json!({"mode": "thorough"}), "mode"), + (json!({"blobsPerSecond": -1}), "blobsPerSecond"), + (json!({"status": "done"}), "status"), + ] { + let (_, response) = call( + admin, + "inbuxa:StoreCheck/set", + json!({"create": {"x": create}}), + ) + .await; + assert!( + response["notCreated"].get("x").is_some(), + "{why}: {response}" + ); + } + + // Starting and stopping are audited + let (_, response) = call( + admin, + "inbuxa:AuditEvent/query", + json!({"filter": {"targetKind": "inbuxa:StoreCheck"}}), + ) + .await; + assert!( + response["ids"].as_array().is_some_and(|ids| ids.len() >= 5), + "creates, the stop and the destroy audited: {response}" + ); + + // Nobody without the permission, or in a tenant, reaches checks + let (name, response) = call(ann, "inbuxa:StoreCheck/get", json!({"ids": null})).await; + assert_eq!(name, "error", "a user: {response}"); + let tenant = admin + .registry_create_object(Tenant { + name: "Store check tenant".to_string(), + ..Default::default() + }) + .await; + admin + .registry_create_object(Domain { + name: "storecheck.example.org".to_string(), + is_enabled: true, + member_tenant_id: Some(tenant), + certificate_management: CertificateManagement::Manual, + dns_management: DnsManagement::Manual, + dkim_management: DkimManagement::Manual, + ..Default::default() + }) + .await; + let t_admin = admin + .create_user_account( + "tadmin@storecheck.example.org", + "tenant-admin-secret-4417", + "Tenant admin", + &[], + vec![], + ) + .await; + admin + .registry_update_object( + ObjectType::Account, + t_admin.id(), + json!({Property::Roles: UserRoles::Admin}), + ) + .await; + for (method, arguments) in [ + ("inbuxa:StoreCheck/get", json!({"ids": null})), + ( + "inbuxa:StoreCheck/set", + json!({"create": {"x": {"mode": "quick"}}}), + ), + ] { + let (name, response) = call(&t_admin, method, arguments).await; + assert_eq!(name, "error", "{method} by a tenant: {response}"); + } +} + +/// Runs these tests alone: `cargo test -p tests store_check_tests -- --ignored`. +#[ignore] +#[tokio::test(flavor = "multi_thread")] +pub async fn store_check_tests() { + let mut test = TestServerBuilder::new("store_check_tests") + .await + .with_default_listeners() + .await + .build() + .await; + let admin = test.create_admin_account("admin@example.com").await; + test.insert_account(admin); + let ann = test + .create_user_account( + "admin@example.com", + "ann@example.com", + "ann-secret-29871", + &[], + "Ann", + ) + .await; + test.insert_account(ann); + self::test(&mut test).await; + if test.is_reset() { + test.temp_dir.delete(); + } +} -- 2.54.0