From 35fe09e6dadcdb818f141596817e4ecaa456a8c1 Mon Sep 17 00:00:00 2001 From: John Coffey Date: Fri, 20 Nov 2026 11:39:49 -0700 Subject: [PATCH] Tenant storage: count what's written where it's stored (#499) Part of the inbuxa/inbuxa-admin#257 remediation (Refs inbuxa/inbuxa-admin#257). Five places where a tenant's usage didn't match what its accounts store: - CalDAV/CardDAV COPY and MOVE of a single event or card into another account now check that account's quota and its tenant's, as copying a whole calendar or address book already did. A member could copy items one at a time into a group account or a shared calendar past both limits. A move within one account adds nothing and isn't checked. Both checks, and the whole-collection one, now use the size the item is charged (its stored bytes plus names and properties), not the bare iCalendar or vCard length, so they don't run a few hundred bytes per item past the limit. - A tenant's usage counter now moves with the account that owns the data, not the tenant of whoever made the change (MT-20). The index builder still emits the change, with TENANT_OF_ACCOUNT when the writer has no tenant; commit_batch looks up each account's tenant (a kept deleted account's from its kept record) and points the change there, or drops it for an account with none. A change still unresolved when a batch is built is dropped rather than written under the placeholder. Writes by a sharee, a delegate or a server administrator no longer move the wrong tenant's counter, or none. - Destroying an account takes its usage off its tenant: the account's counter (kept archive bytes included) is read before the data goes and subtracted after, so a retried destroy takes it off once. The tenant comes from the kept record, or from the account's domain. - Destroying an account no longer clears the usage counter of the tenant with the same number. Accounts and tenants are numbered apart, and the tenant's counter key sits inside the account's range in the counter subspace, so destroying account 5 set tenant 5's usage to 0. danger_destroy_account now skips that one key. - A tenant recount (recalculateQuota, resetTenantQuotas, a domain moving in) now includes deleted members still kept (UD-15): their data stays until they're destroyed, which takes it off then. Tests: webdav Test 20 (COPY/MOVE of events and cards into a group with 2 KiB left: refused once full; failed before the fix with 200 copies in), store unit tests for the retargeting, and the tenant suite checks a kept member stays counted through a recount, a destroyed one comes off, destroying an account numbered like a tenant leaves that tenant's usage alone, and a tenant with every member destroyed is back to 0. Fixes #499 --- crates/common/src/storage/index.rs | 20 ++- crates/common/src/storage/quota.rs | 38 ++++- crates/common/src/storage/transaction.rs | 4 + crates/dav/src/calendar/copy_move.rs | 18 ++- crates/dav/src/card/copy_move.rs | 18 ++- crates/features/src/tenancy/quota.rs | 13 +- .../src/task_manager/destroy_account.rs | 37 ++++- crates/store/src/dispatch/store.rs | 24 ++- crates/store/src/write/batch.rs | 149 +++++++++++++++++- crates/store/src/write/mod.rs | 6 + tests/src/system/tenant.rs | 90 ++++++++++- tests/src/webdav/copy_move.rs | 87 +++++++++- 12 files changed, 478 insertions(+), 26 deletions(-) diff --git a/crates/common/src/storage/index.rs b/crates/common/src/storage/index.rs index 9b305caa..41a5dc65 100644 --- a/crates/common/src/storage/index.rs +++ b/crates/common/src/storage/index.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 crate::{auth::AccountTenantIds, sharing::notification::ShareNotification}; @@ -19,7 +21,7 @@ use store::{ Serialize, SerializeInfallible, write::{ Archive, Archiver, BatchBuilder, BlobLink, BlobOp, IntoOperations, Params, SearchIndex, - ValueClass, + TENANT_OF_ACCOUNT, ValueClass, }, }; use types::{ @@ -510,9 +512,11 @@ fn build_index( batch.add(ValueClass::Quota, value); - if let Some(tenant_id) = tenant_id { - batch.add(ValueClass::TenantQuota(tenant_id), value); - } + // inbuxa: MT-20: the tenant is the data owner's, set at commit + batch.add( + ValueClass::TenantQuota(tenant_id.unwrap_or(TENANT_OF_ACCOUNT)), + value, + ); } IndexValue::LogItem { sync_collection, @@ -731,9 +735,11 @@ fn merge_index( let value = new_used as i64 - old_used as i64; batch.add(ValueClass::Quota, value); - if let Some(tenant_id) = tenant_id { - batch.add(ValueClass::TenantQuota(tenant_id), value); - } + // inbuxa: MT-20: the tenant is the data owner's, set at commit + batch.add( + ValueClass::TenantQuota(tenant_id.unwrap_or(TENANT_OF_ACCOUNT)), + value, + ); } ( IndexValue::LogItem { diff --git a/crates/common/src/storage/quota.rs b/crates/common/src/storage/quota.rs index a8189b94..af1815f7 100644 --- a/crates/common/src/storage/quota.rs +++ b/crates/common/src/storage/quota.rs @@ -16,7 +16,10 @@ use registry::{ types::EnumImpl, }; use std::sync::Arc; -use store::{ValueKey, write::ValueClass}; +use store::{ + ValueKey, + write::{BatchBuilder, ValueClass}, +}; use trc::AddContext; // inbuxa: the disk quota of the account a request writes into, with the bytes @@ -52,6 +55,39 @@ impl Server { .add_context(|err| err.caused_by(trc::location!()).account_id(account_id)) } + // inbuxa: MT-20: a batch's tenant storage changes go to the tenant of the + // account whose data changed, not the writer's: a sharee or delegate in + // another tenant, or a server administrator with none, would otherwise + // move the wrong counter. A deleted account still kept (UD-15) is its + // kept record's tenant's. Run before every write that carries them. + pub async fn resolve_tenant_quota(&self, batch: &mut BatchBuilder) -> trc::Result<()> { + let accounts = batch.tenant_quota_accounts(); + if accounts.is_empty() { + return Ok(()); + } + let mut tenants = Vec::with_capacity(accounts.len()); + for account_id in accounts { + let tenant_id = match self.try_account(account_id).await? { + Some(account) => account.id_tenant, + None => inbuxa_features::undelete::data::kept_account( + &self.core.storage.data, + account_id, + ) + .await? + .and_then(|kept| kept.member_tenant_id) + .map(|tenant_id| tenant_id as u32), + }; + tenants.push((account_id, tenant_id)); + } + batch.retarget_tenant_quota(|account_id| { + tenants + .iter() + .find(|(id, _)| *id == account_id) + .and_then(|(_, tenant_id)| *tenant_id) + }); + Ok(()) + } + // inbuxa: MT-20: storage used by all a tenant's members together pub async fn get_used_quota_tenant(&self, tenant_id: u32) -> trc::Result { inbuxa_features::tenancy::quota::used(&self.core.storage.data, tenant_id).await diff --git a/crates/common/src/storage/transaction.rs b/crates/common/src/storage/transaction.rs index f8e6fc01..aa71faf9 100644 --- a/crates/common/src/storage/transaction.rs +++ b/crates/common/src/storage/transaction.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 crate::{Server, ipc::PushNotification}; @@ -20,6 +22,8 @@ use utils::{map::bitmap::Bitmap, snowflake::SnowflakeIdGenerator}; impl Server { pub async fn commit_batch(&self, mut builder: BatchBuilder) -> trc::Result { let mut assigned_ids = AssignedIds::default(); + // inbuxa: MT-20: tenant storage changes follow the data's owner + self.resolve_tenant_quota(&mut builder).await?; let mut commit_points = builder.commit_points(); for commit_point in commit_points.iter() { diff --git a/crates/dav/src/calendar/copy_move.rs b/crates/dav/src/calendar/copy_move.rs index 2f4fc5da..41745cd8 100644 --- a/crates/dav/src/calendar/copy_move.rs +++ b/crates/dav/src/calendar/copy_move.rs @@ -559,6 +559,14 @@ async fn copy_event( name: new_name.to_string(), parent_id: to_calendar_id, }]; + // inbuxa: into another account, it counts against that account's + // quota and its tenant's, as a whole calendar or address book does + server + .has_available_quota( + server.account(to_account_id).await?.as_ref(), + new_event.size() as u64, + ) + .await?; let to_document_id = server .store() .assign_document_ids(to_account_id, Collection::CalendarEvent, 1) @@ -750,6 +758,14 @@ async fn move_event( ) .caused_by(trc::location!())?; + // inbuxa: into another account, it counts against that account's + // quota and its tenant's, as a whole calendar or address book does + server + .has_available_quota( + server.account(to_account_id).await?.as_ref(), + new_event.size() as u64, + ) + .await?; let to_document_id = server .store() .assign_document_ids(to_account_id, Collection::CalendarEvent, 1) @@ -1086,7 +1102,7 @@ async fn copy_container( .await .caused_by(trc::location!())?; new_event.names = vec![new_name]; - required_space += new_event.size as u64; + required_space += new_event.size() as u64; new_event .insert( access_token.account_tenant_ids(), diff --git a/crates/dav/src/card/copy_move.rs b/crates/dav/src/card/copy_move.rs index 97b9364b..5e99a65b 100644 --- a/crates/dav/src/card/copy_move.rs +++ b/crates/dav/src/card/copy_move.rs @@ -530,6 +530,14 @@ async fn copy_card( name: new_name.to_string(), parent_id: to_addressbook_id, }]; + // inbuxa: into another account, it counts against that account's + // quota and its tenant's, as a whole calendar or address book does + server + .has_available_quota( + server.account(to_account_id).await?.as_ref(), + new_card.size() as u64, + ) + .await?; let to_document_id = server .store() .assign_document_ids(to_account_id, Collection::ContactCard, 1) @@ -692,6 +700,14 @@ async fn move_card( ) .caused_by(trc::location!())?; + // inbuxa: into another account, it counts against that account's + // quota and its tenant's, as a whole calendar or address book does + server + .has_available_quota( + server.account(to_account_id).await?.as_ref(), + new_card.size() as u64, + ) + .await?; let to_document_id = server .store() .assign_document_ids(to_account_id, Collection::ContactCard, 1) @@ -1007,7 +1023,7 @@ async fn copy_container( .await .caused_by(trc::location!())?; new_card.names = vec![new_name]; - required_space += new_card.size as u64; + required_space += new_card.size() as u64; new_card .insert( access_token.account_tenant_ids(), diff --git a/crates/features/src/tenancy/quota.rs b/crates/features/src/tenancy/quota.rs index 18ddd4b7..17e2c889 100644 --- a/crates/features/src/tenancy/quota.rs +++ b/crates/features/src/tenancy/quota.rs @@ -214,7 +214,8 @@ pub async fn used(data: &Store, tenant_id: u32) -> trc::Result { } /// Recomputes a tenant's storage usage from its members' own usage -/// (MT-21). Safe on a live server: the stored figure is corrected by the +/// (MT-21), deleted members still kept (UD-15) included: their data stays +/// until they're destroyed, which takes it off then. Safe on a live server: the stored figure is corrected by the /// difference, so deliveries counted while this runs aren't lost. One that /// lands between reading the members and reading the total can leave the /// figure off by that message until the next run. @@ -228,11 +229,17 @@ pub async fn recalculate( .await .caused_by(trc::location!())?; + let kept = crate::undelete::data::kept_accounts(data) + .await? + .into_iter() + .filter(|(_, kept)| kept.member_tenant_id == Some(tenant_id as u64)) + .map(|(account_id, _)| account_id); + let mut total = 0i64; - for member in members { + for member in members.into_iter().map(|id| id.document_id()).chain(kept) { total += data .get_counter(ValueKey { - account_id: member.document_id(), + account_id: member, collection: 0, document_id: 0, class: ValueClass::Quota, diff --git a/crates/services/src/task_manager/destroy_account.rs b/crates/services/src/task_manager/destroy_account.rs index bf31d1b7..99c59db6 100644 --- a/crates/services/src/task_manager/destroy_account.rs +++ b/crates/services/src/task_manager/destroy_account.rs @@ -57,12 +57,12 @@ async fn destroy_account(server: &Server, task: &TaskDestroyAccount) -> trc::Res // inbuxa: LH-8, LH-10: a kept account waits for its time, and a held one // for its release; "destroy now" clears the kept record first - if let Some(kept) = - inbuxa_features::undelete::data::kept_account(&server.core.storage.data, account_id).await? - { + let kept = inbuxa_features::undelete::data::kept_account(&server.core.storage.data, account_id) + .await?; + if let Some(kept) = &kept { let now = store::write::now(); let held = inbuxa_features::hold::is_held_until(kept.kept_until) - || server.is_kept_held(account_id, &kept).await?; + || server.is_kept_held(account_id, kept).await?; if held || kept.kept_until > now { let retry = if held { now + 86_400 } else { kept.kept_until }; return Ok(TaskResult::deferred( @@ -179,6 +179,21 @@ async fn destroy_account(server: &Server, task: &TaskDestroyAccount) -> trc::Res // Unlink all accounts's blobs destroy_account_blobs(server, account_id).await?; + // inbuxa: MT-20: what the account stored leaves its tenant's usage with + // it. Read before the data goes and taken off after, so a retry after a + // failed destroy (the counter still there) or a finished one (gone, so + // zero) takes it off once. + let tenant_id = match &kept { + Some(kept) => kept.member_tenant_id.map(|id| id as u32), + None => server + .registry() + .object::(task.account_domain_id) + .await? + .and_then(|domain| domain.member_tenant_id) + .map(|id| id.document_id()), + }; + let used = server.get_used_quota_account(account_id).await?.max(0); + // Destroy account data server .store() @@ -186,6 +201,20 @@ async fn destroy_account(server: &Server, task: &TaskDestroyAccount) -> trc::Res .await .caused_by(trc::location!())?; + if let Some(tenant_id) = tenant_id + && used > 0 + { + let mut batch = BatchBuilder::new(); + batch.add(ValueClass::TenantQuota(tenant_id), -used); + server + .core + .storage + .data + .write(batch.build_all()) + .await + .caused_by(trc::location!())?; + } + Ok(TaskResult::Success(vec![])) } diff --git a/crates/store/src/dispatch/store.rs b/crates/store/src/dispatch/store.rs index ff7682da..4e75363a 100644 --- a/crates/store/src/dispatch/store.rs +++ b/crates/store/src/dispatch/store.rs @@ -520,15 +520,33 @@ impl Store { } pub async fn danger_destroy_account(&self, account_id: u32) -> trc::Result<()> { - for subspace in [SUBSPACE_LOGS, SUBSPACE_INDEXES, SUBSPACE_COUNTER] { + // inbuxa: MT-20: a tenant's usage counter sits beside the account + // with the same number, [id][u8::MAX - 1], and accounts and tenants + // are numbered apart, so clearing the account's counters skips it + let tenant_quota = KeySerializer::new(U32_LEN + 1) + .write(account_id) + .write(u8::MAX - 1) + .finalize(); + let after_tenant_quota = KeySerializer::new(U32_LEN + 1) + .write(account_id) + .write(u8::MAX) + .finalize(); + let start = KeySerializer::new(U32_LEN).write(account_id).finalize(); + let end = KeySerializer::new(U32_LEN).write(account_id + 1).finalize(); + for (subspace, from, to) in [ + (SUBSPACE_LOGS, &start, &end), + (SUBSPACE_INDEXES, &start, &end), + (SUBSPACE_COUNTER, &start, &tenant_quota), + (SUBSPACE_COUNTER, &after_tenant_quota, &end), + ] { self.delete_range( AnyKey { subspace, - key: KeySerializer::new(U32_LEN).write(account_id).finalize(), + key: from.as_slice(), }, AnyKey { subspace, - key: KeySerializer::new(U32_LEN).write(account_id + 1).finalize(), + key: to.as_slice(), }, ) .await diff --git a/crates/store/src/write/batch.rs b/crates/store/src/write/batch.rs index 8dc0865a..181a4082 100644 --- a/crates/store/src/write/batch.rs +++ b/crates/store/src/write/batch.rs @@ -7,8 +7,8 @@ */ use super::{ - Batch, BatchBuilder, ChangedCollection, IntoOperations, Operation, ValueClass, ValueOp, - assert::ToAssertValue, log::VanishedItem, + Batch, BatchBuilder, ChangedCollection, IntoOperations, Operation, TENANT_OF_ACCOUNT, + ValueClass, ValueOp, assert::ToAssertValue, log::VanishedItem, }; use crate::{ SerializeInfallible, U32_LEN, @@ -26,6 +26,61 @@ use types::{ }; use utils::{map::vec_map::VecMap, snowflake::SnowflakeIdGenerator}; +/// inbuxa: MT-20: sets each tenant storage change's tenant from the account +/// it's under; one with no tenant becomes a repeat of its account switch, +/// which writes nothing. +fn retarget_tenant_quota(ops: &mut [Operation], tenant_of: impl Fn(u32) -> Option) { + let mut current = None; + for op in ops.iter_mut() { + let account_id = match op { + Operation::AccountId { account_id } => { + current = Some(*account_id); + continue; + } + Operation::Value { + class: ValueClass::TenantQuota(_), + .. + } => match current { + Some(account_id) => account_id, + None => continue, + }, + _ => continue, + }; + match tenant_of(account_id) { + Some(tenant_id) => { + if let Operation::Value { + class: ValueClass::TenantQuota(tenant), + .. + } = op + { + *tenant = tenant_id; + } + } + None => *op = Operation::AccountId { account_id }, + } + } +} + +/// inbuxa: MT-20: a tenant storage change never resolved is dropped rather +/// than written under the placeholder. +fn drop_unresolved_tenant_quota(ops: &mut [Operation]) { + let mut current = None; + for op in ops.iter_mut() { + match op { + Operation::AccountId { account_id } => current = Some(*account_id), + Operation::Value { + class: ValueClass::TenantQuota(TENANT_OF_ACCOUNT), + .. + } => { + if let Some(account_id) = current { + *op = Operation::AccountId { account_id }; + } + } + _ => {} + } + } +} + impl BatchBuilder { pub fn new() -> Self { Self { @@ -436,7 +491,42 @@ impl BatchBuilder { } } + /// inbuxa: MT-20: the accounts whose data this batch's tenant storage + /// changes are for, so their tenants can be looked up. + pub fn tenant_quota_accounts(&self) -> Vec { + let mut accounts = Vec::new(); + let mut current = None; + for op in &self.ops { + match op { + Operation::AccountId { account_id } => current = Some(*account_id), + Operation::Value { + class: ValueClass::TenantQuota(_), + .. + } => { + if let Some(account_id) = current + && !accounts.contains(&account_id) + { + accounts.push(account_id); + } + } + _ => {} + } + } + accounts + } + + /// inbuxa: MT-20: points each tenant storage change at the tenant of the + /// account whose data it is, whoever made the change, so an account's + /// usage and its tenant's always move together. A change for an account + /// with no tenant is dropped. + pub fn retarget_tenant_quota(&mut self, tenant_of: impl Fn(u32) -> Option) { + retarget_tenant_quota(&mut self.ops, tenant_of); + } + pub fn build_one(&mut self, commit_point: CommitPoint) -> Batch<'_> { + drop_unresolved_tenant_quota( + &mut self.ops[commit_point.offset_start..commit_point.offset_end], + ); Batch { changes: &self.changed_collections, ops: &mut self.ops[commit_point.offset_start..commit_point.offset_end], @@ -445,6 +535,7 @@ impl BatchBuilder { pub fn build_all(&mut self) -> Batch<'_> { self.serialize_changes(); + drop_unresolved_tenant_quota(&mut self.ops); Batch { changes: &self.changed_collections, ops: self.ops.as_mut_slice(), @@ -556,3 +647,57 @@ impl Default for BatchBuilder { Self::new() } } + +#[cfg(test)] +mod tenant_quota_tests { + use super::*; + + fn tenant_changes(batch: &mut BatchBuilder) -> Vec<(u32, i64)> { + let mut out = Vec::new(); + for op in batch.build_all().ops.iter() { + if let Operation::Value { + class: ValueClass::TenantQuota(tenant), + op: ValueOp::AtomicAdd(by), + } = op + { + out.push((*tenant, *by)); + } + } + out + } + + #[test] + fn tenant_changes_follow_the_owner() { + let mut batch = BatchBuilder::new(); + // A writer in tenant 5 into account 1 (tenant 7); a writer with no + // tenant into account 2 (tenant 8); account 3 has none + batch + .with_account_id(1) + .add(ValueClass::Quota, 10) + .add(ValueClass::TenantQuota(5), 10) + .with_account_id(2) + .add(ValueClass::Quota, -4) + .add(ValueClass::TenantQuota(TENANT_OF_ACCOUNT), -4) + .with_account_id(3) + .add(ValueClass::Quota, 6) + .add(ValueClass::TenantQuota(5), 6); + assert_eq!(batch.tenant_quota_accounts(), vec![1, 2, 3]); + batch.retarget_tenant_quota(|account| match account { + 1 => Some(7), + 2 => Some(8), + _ => None, + }); + assert_eq!(tenant_changes(&mut batch), vec![(7, 10), (8, -4)]); + } + + #[test] + fn an_unresolved_change_is_dropped() { + let mut batch = BatchBuilder::new(); + batch + .with_account_id(1) + .add(ValueClass::Quota, 10) + .add(ValueClass::TenantQuota(TENANT_OF_ACCOUNT), 10) + .add(ValueClass::TenantQuota(4), 10); + assert_eq!(tenant_changes(&mut batch), vec![(4, 10)]); + } +} diff --git a/crates/store/src/write/mod.rs b/crates/store/src/write/mod.rs index 93dae48b..7b68ddd9 100644 --- a/crates/store/src/write/mod.rs +++ b/crates/store/src/write/mod.rs @@ -205,6 +205,12 @@ pub enum ValueClass { NodeId(u16), } +/// inbuxa: MT-20: a tenant storage change whose tenant isn't known yet. The +/// change belongs to the tenant of the account whose data it is, which +/// `BatchBuilder::retarget_tenant_quota` fills in before the write; one +/// still unresolved when the batch is built is dropped. +pub const TENANT_OF_ACCOUNT: u32 = u32::MAX; + #[derive(Debug, PartialEq, Clone, Eq, Hash)] pub enum IndexPropertyClass { Hash { property: u8, hash: CheekyHash }, diff --git a/tests/src/system/tenant.rs b/tests/src/system/tenant.rs index 0412eea2..783968ed 100644 --- a/tests/src/system/tenant.rs +++ b/tests/src/system/tenant.rs @@ -1264,13 +1264,95 @@ pub async fn test(test: &mut TestServer) { .unwrap() .clear(); + // MT-21: a deleted member still kept holds its data, so a recount keeps + // counting it; destroying it for good takes its usage off (MT-20) + let d1 = d_users[0].id(); + let d1_used = test + .server + .get_used_quota_account(d1.document_id()) + .await + .unwrap(); + assert!(d1_used > 0, "MT-20: d1 holds a message"); + admin + .registry_update_setting( + structs::DataRetention { + archive_deleted_accounts_for: Some( + registry::types::duration::Duration::from_millis(86_400_000), + ), + ..Default::default() + }, + &[Property::ArchiveDeletedAccountsFor], + ) + .await; + admin + .registry_destroy(ObjectType::Account, [d1]) + .await + .assert_destroyed(&[d1]); + test.wait_for_tasks_skip_not_due().await; + assert_eq!( + admin.tenant_usage(d_id).await, + two, + "MT-20: kept, still counted" + ); + admin + .registry_create_object(Task::TenantMaintenance(TaskTenantMaintenance { + tenant_id: d_id, + maintenance_type: TaskTenantMaintenanceType::RecalculateQuota, + status: TaskStatus::now(), + })) + .await; + test.wait_for_tasks_skip_not_due().await; + assert_eq!( + admin.tenant_usage(d_id).await, + two, + "MT-21: a recount keeps a kept member" + ); + let response = admin + .jmap_request( + &["urn:ietf:params:jmap:core", "urn:inbuxa:jmap"], + json!([["inbuxa:DeletedAccount/set", { + "accountId": admin.id_string(), "destroy": [d1.to_string()] + }, "0"]]), + ) + .await + .to_string(); + assert!(response.contains("destroyed"), "destroy now: {response}"); + test.wait_for_tasks_skip_not_due().await; + assert_eq!( + admin.tenant_usage(d_id).await, + two - d1_used, + "MT-20: a destroyed member's usage leaves its tenant" + ); + admin + .registry_update_setting( + structs::DataRetention::default(), + &[Property::ArchiveDeletedAccountsFor], + ) + .await; + // Clean up, leaving the server as the other tests expect it - for account in [ + let d_usage = admin.tenant_usage(d_id).await; + let cleanup = [ t_admin, t_user, t_group, u_admin, u_user, u_group, p_admin, p_user, s_user, d_admin, - ] { + ]; + // MT-20: accounts and tenants are numbered apart, so one of these has + // tenant D's number, and destroying it leaves D's usage alone + assert!( + cleanup + .iter() + .any(|account| account.id().document_id() == d_id.document_id()), + "MT-20: no account shares tenant D's number" + ); + for account in cleanup { admin.destroy_account(account).await; } - for name in ["d1", "d2", "d3"] { + test.wait_for_tasks().await; + assert_eq!( + admin.tenant_usage(d_id).await, + d_usage, + "MT-20: destroying another account changed tenant D's usage" + ); + for name in ["d2", "d3"] { let id = admin.account_id_by_name(name).await; admin .registry_destroy(ObjectType::Account, [id]) @@ -1282,6 +1364,8 @@ pub async fn test(test: &mut TestServer) { .await .assert_destroyed(&[q1, q2]); test.wait_for_tasks().await; + // MT-20: with every member destroyed, nothing is left counted + assert_eq!(admin.tenant_usage(d_id).await, 0, "MT-20: all destroyed"); for domain in admin .registry_query_ids( ObjectType::Domain, diff --git a/tests/src/webdav/copy_move.rs b/tests/src/webdav/copy_move.rs index b9490958..7f08e458 100644 --- a/tests/src/webdav/copy_move.rs +++ b/tests/src/webdav/copy_move.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 crate::utils::{ @@ -12,7 +14,15 @@ use ahash::AHashSet; use dav_proto::Depth; use groupware::DavResourceName; use hyper::StatusCode; -use registry::schema::structs::Action; +use registry::{ + schema::{ + enums::StorageQuota, + prelude::{ObjectType, Property}, + structs::Action, + }, + types::EnumImpl, +}; +use serde_json::json; pub async fn test(test: &TestServer, assisted_discovery: bool) { let admin = test.account("admin@example.com"); @@ -796,6 +806,81 @@ pub async fn test(test: &TestServer, assisted_discovery: bool) { .with_status(StatusCode::NO_CONTENT); } } + + // inbuxa: Test 20: an event or card copied or moved one at a time into + // another account counts against that account's quota (and its + // tenant's), as a whole calendar or address book does + if resource_type != DavResourceName::File { + let support = test.account("support@example.com").id(); + let used = test + .server + .get_used_quota_account(support.document_id()) + .await + .unwrap() + .max(0); + admin + .registry_update_object( + ObjectType::Account, + support, + json!({ + Property::Quotas: { StorageQuota::MaxDiskQuota.as_str(): used + 2048 } + }), + ) + .await; + let src = format!("{user_base_path}/quota-src/"); + let dst = format!("{group_base_path}/quota-dst/"); + for path in [&src, &dst] { + client + .mkcol("MKCOL", path, [], []) + .await + .with_status(StatusCode::CREATED); + } + let (mut copied, mut refused) = (Vec::new(), false); + for i in 0..200 { + let item = format!("{src}item{i}"); + client + .request_with_headers("PUT", &item, [], &resource_type.generate()) + .await + .with_status(StatusCode::CREATED); + // An item moved away before it's indexed can leave its + // search entries behind; that race isn't what this checks + test.wait_for_tasks().await; + let method = if i % 2 == 0 { "COPY" } else { "MOVE" }; + let to = format!("{dst}item{i}"); + let response = client + .request_with_headers(method, &item, [("destination", to.as_str())], "") + .await; + match response.status { + StatusCode::CREATED => copied.push(to), + StatusCode::PRECONDITION_FAILED | StatusCode::INSUFFICIENT_STORAGE => { + refused = true; + break; + } + status => panic!("Test 20: {method} gave {status:?}"), + } + } + assert!( + refused && !copied.is_empty(), + "Test 20: {} copied into a 2 KiB quota and none refused", + copied.len() + ); + // The copies are indexed in the background; let that finish + // before they go, or the index outlives them + test.wait_for_tasks().await; + for path in [&src, &dst] { + client + .request("DELETE", path, "") + .await + .with_status(StatusCode::NO_CONTENT); + } + admin + .registry_update_object( + ObjectType::Account, + support, + json!({ Property::Quotas: {} }), + ) + .await; + } } client.delete_default_containers().await; -- 2.54.0