use std::path::Path;
use crate::error::{MemdError, Result};
#[derive(Debug, Default)]
pub struct MaintenanceReport {
pub tenants_scanned: usize,
pub orphan_snapshots_removed: u64,
pub orphan_bytes_freed: u64,
pub orphan_snapshots_failed: u64,
pub legacy_mapping_converted: u64,
pub segments_merged: u64,
}
pub fn run(
data_dir: &Path,
tenant_filter: Option<&str>,
dry_run: bool,
aggressive: bool,
) -> Result<MaintenanceReport> {
let mut report = MaintenanceReport::default();
let tenants_root = data_dir.join("tenants");
if !tenants_root.exists() {
return Ok(report);
}
let entries = std::fs::read_dir(&tenants_root).map_err(|e| {
MemdError::StorageError(format!(
"read tenants dir {}: {}",
tenants_root.display(),
e
))
})?;
for entry in entries {
let entry = entry.map_err(|e| MemdError::StorageError(format!("tenant entry: {}", e)))?;
let file_type = entry
.file_type()
.map_err(|e| MemdError::StorageError(format!("file_type: {}", e)))?;
if !file_type.is_dir() {
continue;
}
let tenant = entry.file_name().to_string_lossy().to_string();
if let Some(filter) = tenant_filter {
if tenant != filter {
continue;
}
}
report.tenants_scanned += 1;
sweep_warm_index(&entry.path().join("warm_index"), dry_run, &mut report)?;
if aggressive {
}
}
Ok(report)
}
fn sweep_warm_index(warm: &Path, dry_run: bool, report: &mut MaintenanceReport) -> Result<()> {
if !warm.exists() {
return Ok(());
}
let entries = std::fs::read_dir(warm).map_err(|e| {
MemdError::StorageError(format!("read warm_index {}: {}", warm.display(), e))
})?;
for entry in entries {
let entry =
entry.map_err(|e| MemdError::StorageError(format!("warm_index entry: {}", e)))?;
let file_type = match entry.file_type() {
Ok(ft) => ft,
Err(_) => continue,
};
if !file_type.is_file() {
continue;
}
let name = entry.file_name();
let name = name.to_string_lossy();
if !(name.starts_with("graph-")
&& (name.ends_with(".hnsw.graph") || name.ends_with(".hnsw.data")))
{
continue;
}
let bytes = entry.metadata().map(|m| m.len()).unwrap_or(0);
if dry_run {
report.orphan_snapshots_removed += 1;
report.orphan_bytes_freed += bytes;
} else {
match std::fs::remove_file(entry.path()) {
Ok(()) => {
report.orphan_snapshots_removed += 1;
report.orphan_bytes_freed += bytes;
}
Err(e) => {
report.orphan_snapshots_failed += 1;
tracing::warn!(
path = ?entry.path(),
error = %e,
"failed to remove orphan snapshot"
);
}
}
}
}
Ok(())
}
pub fn render_report(report: &MaintenanceReport, dry_run: bool, aggressive: bool) -> String {
let action = if dry_run { "would_remove" } else { "removed" };
let mut out = String::new();
out.push_str(&format!("tenants_scanned: {}\n", report.tenants_scanned));
out.push_str(&format!(
"{action}_orphan_snapshots: {}\n",
report.orphan_snapshots_removed
));
out.push_str(&format!(
"{action}_orphan_bytes: {}\n",
report.orphan_bytes_freed
));
if !dry_run {
out.push_str(&format!(
"orphan_snapshots_failed: {}\n",
report.orphan_snapshots_failed
));
}
if aggressive {
out.push_str(&format!(
"legacy_mapping_converted: {}\n",
report.legacy_mapping_converted
));
out.push_str(&format!("segments_merged: {}\n", report.segments_merged));
}
out
}