//! Managed temporary directory for tasks without repositories.
//!
//! Tasks that don't have a repository URL and aren't subtasks (which inherit
//! from parent) use a managed temp directory in ~/.makima/temp/. The directory
//! is automatically cleaned up when it exceeds a size limit.
use std::path::PathBuf;
use tokio::fs;
use uuid::Uuid;
/// Maximum size of the temp directory before cleanup (5GB).
const MAX_TEMP_SIZE_BYTES: u64 = 5 * 1024 * 1024 * 1024;
/// Manages temporary directories for tasks without repositories.
pub struct TempManager {
/// Base directory for temp task directories (~/.makima/temp/).
temp_dir: PathBuf,
}
impl TempManager {
/// Create a new TempManager.
pub fn new() -> Self {
let home = dirs::home_dir().unwrap_or_else(|| PathBuf::from("."));
Self {
temp_dir: home.join(".makima").join("temp"),
}
}
/// Create a new TempManager with a custom base directory.
#[allow(dead_code)]
pub fn with_base_dir(base_dir: PathBuf) -> Self {
Self { temp_dir: base_dir }
}
/// Get the base temp directory path.
pub fn temp_dir(&self) -> &PathBuf {
&self.temp_dir
}
/// Create a temp directory for a task.
///
/// This creates a directory at ~/.makima/temp/task-{id}/ and triggers
/// cleanup if the total size exceeds the limit.
pub async fn create_task_dir(&self, task_id: Uuid) -> Result<PathBuf, std::io::Error> {
// Ensure base directory exists
fs::create_dir_all(&self.temp_dir).await?;
// Check size and cleanup if needed
if let Err(e) = self.cleanup_if_needed().await {
tracing::warn!("Temp directory cleanup failed: {}", e);
// Continue anyway, cleanup is best-effort
}
// Create task-specific directory
let task_dir = self.temp_dir.join(format!("task-{}", task_id));
fs::create_dir_all(&task_dir).await?;
tracing::info!(
task_id = %task_id,
path = %task_dir.display(),
"Created temp directory for task"
);
Ok(task_dir)
}
/// Calculate total size of temp directory recursively.
async fn get_total_size(&self) -> Result<u64, std::io::Error> {
if !self.temp_dir.exists() {
return Ok(0);
}
let mut total = 0u64;
let mut stack = vec![self.temp_dir.clone()];
while let Some(dir) = stack.pop() {
let mut entries = match fs::read_dir(&dir).await {
Ok(e) => e,
Err(_) => continue,
};
while let Ok(Some(entry)) = entries.next_entry().await {
let metadata = match entry.metadata().await {
Ok(m) => m,
Err(_) => continue,
};
if metadata.is_dir() {
stack.push(entry.path());
} else {
total += metadata.len();
}
}
}
Ok(total)
}
/// Remove oldest directories if total size exceeds limit.
async fn cleanup_if_needed(&self) -> Result<(), std::io::Error> {
let size = self.get_total_size().await?;
if size <= MAX_TEMP_SIZE_BYTES {
return Ok(());
}
tracing::info!(
current_size_mb = size / 1024 / 1024,
limit_mb = MAX_TEMP_SIZE_BYTES / 1024 / 1024,
"Temp directory exceeds size limit, starting cleanup"
);
// Get all task dirs with modification times
let mut dirs: Vec<(PathBuf, std::time::SystemTime, u64)> = vec![];
let mut entries = fs::read_dir(&self.temp_dir).await?;
while let Ok(Some(entry)) = entries.next_entry().await {
let path = entry.path();
if !path.is_dir() {
continue;
}
let metadata = match entry.metadata().await {
Ok(m) => m,
Err(_) => continue,
};
let modified = metadata.modified().unwrap_or(std::time::UNIX_EPOCH);
let dir_size = self.get_dir_size(&path).await.unwrap_or(0);
dirs.push((path, modified, dir_size));
}
// Sort by oldest first
dirs.sort_by(|a, b| a.1.cmp(&b.1));
// Remove oldest until under limit
let mut current_size = size;
for (path, _, dir_size) in dirs {
if current_size <= MAX_TEMP_SIZE_BYTES {
break;
}
tracing::info!(
path = %path.display(),
size_mb = dir_size / 1024 / 1024,
"Removing old temp directory"
);
if let Err(e) = fs::remove_dir_all(&path).await {
tracing::warn!(path = %path.display(), error = %e, "Failed to remove temp directory");
continue;
}
current_size = current_size.saturating_sub(dir_size);
}
tracing::info!(
new_size_mb = current_size / 1024 / 1024,
"Temp directory cleanup complete"
);
Ok(())
}
/// Calculate size of a directory recursively.
async fn get_dir_size(&self, path: &PathBuf) -> Result<u64, std::io::Error> {
let mut total = 0u64;
let mut stack = vec![path.clone()];
while let Some(dir) = stack.pop() {
let mut entries = match fs::read_dir(&dir).await {
Ok(e) => e,
Err(_) => continue,
};
while let Ok(Some(entry)) = entries.next_entry().await {
let metadata = match entry.metadata().await {
Ok(m) => m,
Err(_) => continue,
};
if metadata.is_dir() {
stack.push(entry.path());
} else {
total += metadata.len();
}
}
}
Ok(total)
}
/// Remove a specific task's temp directory.
#[allow(dead_code)]
pub async fn remove_task_dir(&self, task_id: Uuid) -> Result<(), std::io::Error> {
let task_dir = self.temp_dir.join(format!("task-{}", task_id));
if task_dir.exists() {
fs::remove_dir_all(&task_dir).await?;
tracing::info!(
task_id = %task_id,
path = %task_dir.display(),
"Removed temp directory for task"
);
}
Ok(())
}
}
impl Default for TempManager {
fn default() -> Self {
Self::new()
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test_temp_manager_default_dir() {
let manager = TempManager::new();
assert!(manager.temp_dir().ends_with(".makima/temp"));
}
}
