use crate::error::Result;
use crate::store::metadata::SqliteMetadataStore;
use crate::store::segment::SegmentReader;
use crate::types::{ChunkId, ChunkStatus, TenantId};
#[derive(Debug, Clone)]
pub struct AuditResult {
pub total_deleted: usize,
pub tombstone_leaks: Vec<ChunkId>,
pub paths_audited: Vec<String>,
pub passed: bool,
}
impl AuditResult {
pub fn passed(paths_audited: Vec<String>) -> Self {
Self {
total_deleted: 0,
tombstone_leaks: Vec::new(),
paths_audited,
passed: true,
}
}
pub fn failed(
total_deleted: usize,
tombstone_leaks: Vec<ChunkId>,
paths_audited: Vec<String>,
) -> Self {
Self {
total_deleted,
tombstone_leaks,
paths_audited,
passed: false,
}
}
pub fn combine(results: Vec<AuditResult>) -> AuditResult {
let mut combined = AuditResult {
total_deleted: 0,
tombstone_leaks: Vec::new(),
paths_audited: Vec::new(),
passed: true,
};
for result in results {
combined.total_deleted += result.total_deleted;
combined.tombstone_leaks.extend(result.tombstone_leaks);
combined.paths_audited.extend(result.paths_audited);
if !result.passed {
combined.passed = false;
}
}
combined
}
}
pub struct TombstoneAudit;
impl TombstoneAudit {
pub fn new() -> Self {
Self
}
pub fn audit_segment_reader(
&self,
reader: &SegmentReader,
metadata: &SqliteMetadataStore,
tenant_id: &TenantId,
segment_id: u64,
) -> Result<AuditResult> {
use crate::store::metadata::MetadataStore;
let chunks = metadata.get_by_segment(tenant_id, segment_id)?;
let mut total_deleted = 0;
let mut tombstone_leaks = Vec::new();
for chunk_meta in chunks {
if chunk_meta.status == ChunkStatus::Deleted {
total_deleted += 1;
match reader.read_chunk(chunk_meta.ordinal) {
Ok(Some(_data)) => {
tombstone_leaks.push(chunk_meta.chunk_id);
}
Ok(None) => {
}
Err(e) => {
tracing::warn!(
"Error reading chunk {} during audit: {}",
chunk_meta.chunk_id,
e
);
}
}
}
}
let paths_audited = vec!["SegmentReader::read_chunk".to_string()];
if tombstone_leaks.is_empty() {
Ok(AuditResult {
total_deleted,
tombstone_leaks,
paths_audited,
passed: true,
})
} else {
Ok(AuditResult::failed(
total_deleted,
tombstone_leaks,
paths_audited,
))
}
}
pub fn audit_metadata_store(
&self,
metadata: &SqliteMetadataStore,
tenant_id: &TenantId,
) -> Result<AuditResult> {
use crate::store::metadata::MetadataStore;
let chunks = metadata.list(tenant_id, 10000, 0)?;
let mut tombstone_leaks = Vec::new();
for chunk_meta in &chunks {
if chunk_meta.status == ChunkStatus::Deleted {
tombstone_leaks.push(chunk_meta.chunk_id.clone());
}
}
let paths_audited = vec!["SqliteMetadataStore::list".to_string()];
if tombstone_leaks.is_empty() {
Ok(AuditResult::passed(paths_audited))
} else {
Ok(AuditResult::failed(
tombstone_leaks.len(),
tombstone_leaks,
paths_audited,
))
}
}
}
impl Default for TombstoneAudit {
fn default() -> Self {
Self::new()
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn audit_result_passed() {
let result = AuditResult::passed(vec!["test_path".to_string()]);
assert!(result.passed);
assert!(result.tombstone_leaks.is_empty());
assert_eq!(result.paths_audited.len(), 1);
}
#[test]
fn audit_result_failed() {
let chunk_id = ChunkId::new();
let result = AuditResult::failed(5, vec![chunk_id], vec!["test_path".to_string()]);
assert!(!result.passed);
assert_eq!(result.tombstone_leaks.len(), 1);
assert_eq!(result.total_deleted, 5);
}
#[test]
fn combine_results() {
let result1 = AuditResult::passed(vec!["path1".to_string()]);
let result2 = AuditResult::passed(vec!["path2".to_string()]);
let combined = AuditResult::combine(vec![result1, result2]);
assert!(combined.passed);
assert_eq!(combined.paths_audited.len(), 2);
}
#[test]
fn combine_results_one_failed() {
let result1 = AuditResult::passed(vec!["path1".to_string()]);
let chunk_id = ChunkId::new();
let result2 = AuditResult::failed(1, vec![chunk_id], vec!["path2".to_string()]);
let combined = AuditResult::combine(vec![result1, result2]);
assert!(!combined.passed);
assert_eq!(combined.tombstone_leaks.len(), 1);
}
}