cmd_cache.rs

use std::{
    collections::HashSet,
    time::{Duration, SystemTime},
};

use anyhow::anyhow;

use crate::{Context, Error};

#[derive(Debug, clap::Subcommand)]
pub enum CacheArgs {
    /// Remove stale entries from the local cache
    ///
    /// Deletes cached build artifacts whose last recorded use is older than
    /// `--older-than`, or that have no recorded use at all. Packages needed
    /// by the current project's tasks and stack are always kept. Also removes
    /// sandbox, task, and temporary build directories whose owning process is
    /// no longer running.
    Clean {
        /// Only delete cache entries last used at least this long ago.
        /// Takes a whole number of days, hours, or minutes: e.g. `30d`,
        /// `12h`, `45m`
        #[arg(long, value_parser = parse_duration, default_value = "14d")]
        older_than: Duration,
    },
}

fn parse_duration(arg: &str) -> Result<std::time::Duration, anyhow::Error> {
    if let Some(v) = arg.strip_suffix("d") {
        let days: u64 = v.parse().map_err(|e| anyhow!("parsing days: {}", e))?;
        Ok(std::time::Duration::from_hours(24 * days))
    } else if let Some(v) = arg.strip_suffix("h") {
        let hours: u64 = v.parse().map_err(|e| anyhow!("parsing hours: {}", e))?;
        Ok(std::time::Duration::from_hours(hours))
    } else if let Some(v) = arg.strip_suffix("m") {
        let minutes: u64 = v.parse().map_err(|e| anyhow!("parsing minutes: {}", e))?;
        Ok(std::time::Duration::from_mins(minutes))
    } else {
        Err(anyhow!("invalid duration: {}", arg))
    }
}

pub async fn cmd_cache(args: CacheArgs, ctx: &mut Context) -> Result<(), Error> {
    let graph = ctx.graph_from_all_packages()?;
    let need_objs = ctx
        .scaffolding_packages()?
        .into_iter()
        .map(|bsr| graph.spec_hash(&bsr))
        .collect::<HashSet<_>>();

    let cache = ctx.local_cache();
    let rt = cache.atimes().unwrap();
    let candidates = cache.iter_entries().filter_map(|e| {
        if need_objs.contains(&e) {
            None
        } else {
            let last_use = rt.last_read(&e);
            Some((e, last_use))
        }
    });

    let now = SystemTime::now();
    match args {
        CacheArgs::Clean { older_than } => {
            let cutoff = now.checked_sub(older_than).unwrap();
            for (spec_hash, last_used) in candidates {
                if last_used.is_none() || last_used.as_ref().unwrap() < &cutoff {
                    let ident = if let Ok(meta) = cache.read_meta(&spec_hash) {
                        format!("{} [{}]", meta.inner, spec_hash.0)
                    } else {
                        format!("Object [{}]", spec_hash.0)
                    };

                    println!("Deleting {}", ident);
                    cache
                        .invalidate_dir(&spec_hash)
                        .map_err(|e| Error::Other(anyhow!(e)))?;
                }
            }
        }
    }

    for sandbox in std::fs::read_dir(ctx.builds_base_dir())
        .map_err(|e| Error::IO("reading sandboxes dir", ctx.builds_base_dir(), e))?
    {
        let entry = sandbox.map_err(|e| Error::IO("sandbox entry", ctx.builds_base_dir(), e))?;
        cleanup_stale("sandbox", entry)?;
    }
    for task in std::fs::read_dir(ctx.tasks_base_dir())
        .map_err(|e| Error::IO("reading tasks dir", ctx.tasks_base_dir(), e))?
    {
        let entry = task.map_err(|e| Error::IO("task entry", ctx.tasks_base_dir(), e))?;
        cleanup_stale("task", entry)?;
    }
    for at in std::fs::read_dir(ctx.cache_base_dir().join("temp"))
        .map_err(|e| Error::IO("reading artifact temp dir", ctx.tasks_base_dir(), e))?
    {
        let entry = at.map_err(|e| Error::IO("artifact temp entry", ctx.tasks_base_dir(), e))?;
        cleanup_stale("tempdir", entry)?;
    }

    Ok(())
}

/// Remove a sandbox/task/temp directory whose owning process is gone.
///
/// Ownership comes from the marker the sandbox writes
/// ([`common::sandbox_owner`]), not from the trailing `-<pid>` in the directory
/// name. That suffix is the pid of whatever *created* the sandbox, which is the
/// right answer only when the creator is also the thing whose lifetime the
/// sandbox tracks — true for this CLI, false for a long-lived daemon. Reading
/// the marker means one rule works for both.
///
/// A directory with no marker is left alone: it predates the marker, or was
/// abandoned before its leader spawned, and neither is distinguishable here
/// from a sandbox mid-construction.
fn cleanup_stale(kind: &str, entry: std::fs::DirEntry) -> Result<(), Error> {
    let name = entry.file_name();
    let s = name.to_str().unwrap();
    if common::sandbox_owner::owner_is_gone(&entry.path()) {
        // No such proc entry, therefore the owner is dead. Clean up directory.
        println!("Cleaning up stale {} {}", kind, s);
        common::remove_dir_all(entry.path())
            .map_err(|e| Error::IO("rm stale sandbox", entry.path(), e))?;
    }

    Ok(())
}