Struct ArtifactCachePrunePolicy 

pub struct ArtifactCachePrunePolicy { /* private fields */ }

Caller-selected retention limits for content-addressed artifact entries.

Age pruning runs before size pruning. A policy without either limit scans the selected cache namespace and updates its cache metadata without removing entries. Entries retained by live acquisition records are skipped, even when this temporarily exceeds the limits. They become eligible for the next maintenance pass after their final owner drops or its process exits.

Implementations

impl ArtifactCachePrunePolicy

pub const fn new() -> Self

Create a policy that records cache metadata without removing entries.

Examples found in repository

examples/transactional_artifact_cache.rs (line 63)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let arguments = std::env::args_os().skip(1).collect::<Vec<_>>();
    let [tool, sha256, version, input, output, cache_root] = arguments.as_slice() else {
        eprintln!(
            "usage: transactional_artifact_cache <tool-path> <sha256> <exact-version-stdout> <input> <public-output> <cache-root>"
        );
        return Ok(());
    };
    let current_dir = std::env::current_dir()?;
    let tool = resolve_executable(&current_dir.join(tool), &current_dir, &[])?;
    let context = ExecutionContext {
        current_dir: &current_dir,
        environment: &[],
    };
    let limits = OutputLimits {
        stdout: OutputLimit::Terminate(64 * 1024),
        stderr: OutputLimit::Terminate(64 * 1024),
        timeout: Some(Duration::from_secs(60)),
    };
    // Admission uses caller authority, never a digest computed from untrusted
    // selected bytes. Transform tools must work with this empty environment.
    let admitted = AdmittedTool::admit(
        &ToolSpec {
            executable: &tool,
            sha256: sha256
                .to_str()
                .ok_or("SHA-256 must be UTF-8")?
                .parse::<Sha256Digest>()?,
            executable_bytes: 256 * 1024 * 1024,
            version_arguments: &["--version".into()],
            version_identity: version.to_str().ok_or("version must be UTF-8")?,
        },
        &context,
        limits,
    )?;
    let input = current_dir.join(input);
    let output = current_dir.join(output);
    let cache_root = current_dir.join(cache_root);
    let spec = ArtifactCacheSpec::new(
        &cache_root,
        "example-transform",
        "example/admitted-transform/v1",
    )
    .with_input("source", &input)
    .with_tool("transformer", &tool)
    .with_arguments(["<input>", "<output>"])
    .with_output("result", &output)
    .with_prune_policy(
        ArtifactCachePrunePolicy::new()
            .with_max_age(Duration::from_secs(7 * 24 * 60 * 60))
            .with_max_size_bytes(2 * 1024 * 1024 * 1024),
    );

    let outcome = match prepare_artifact_cache(&spec)? {
        ArtifactCachePreparation::Reused(record) => ArtifactCacheOutcome::Reused(record),
        ArtifactCachePreparation::Build(transaction) => {
            let staged_output = transaction.output_path("result")?;
            admitted
                .run(
                    &[input.into_os_string(), staged_output.into_os_string()],
                    &context,
                    limits,
                )?
                .require_success()?;
            transaction.commit()?
        }
    };

    let disposition = if outcome.is_reused() {
        "reused"
    } else {
        "built"
    };
    println!("{disposition} artifact set {}", outcome.record().key());
    Ok(())
}

pub const fn with_max_age(self, max_age: Duration) -> Self

Remove entries older than max_age before applying the size limit.

Examples found in repository

examples/transactional_artifact_cache.rs (line 64)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let arguments = std::env::args_os().skip(1).collect::<Vec<_>>();
    let [tool, sha256, version, input, output, cache_root] = arguments.as_slice() else {
        eprintln!(
            "usage: transactional_artifact_cache <tool-path> <sha256> <exact-version-stdout> <input> <public-output> <cache-root>"
        );
        return Ok(());
    };
    let current_dir = std::env::current_dir()?;
    let tool = resolve_executable(&current_dir.join(tool), &current_dir, &[])?;
    let context = ExecutionContext {
        current_dir: &current_dir,
        environment: &[],
    };
    let limits = OutputLimits {
        stdout: OutputLimit::Terminate(64 * 1024),
        stderr: OutputLimit::Terminate(64 * 1024),
        timeout: Some(Duration::from_secs(60)),
    };
    // Admission uses caller authority, never a digest computed from untrusted
    // selected bytes. Transform tools must work with this empty environment.
    let admitted = AdmittedTool::admit(
        &ToolSpec {
            executable: &tool,
            sha256: sha256
                .to_str()
                .ok_or("SHA-256 must be UTF-8")?
                .parse::<Sha256Digest>()?,
            executable_bytes: 256 * 1024 * 1024,
            version_arguments: &["--version".into()],
            version_identity: version.to_str().ok_or("version must be UTF-8")?,
        },
        &context,
        limits,
    )?;
    let input = current_dir.join(input);
    let output = current_dir.join(output);
    let cache_root = current_dir.join(cache_root);
    let spec = ArtifactCacheSpec::new(
        &cache_root,
        "example-transform",
        "example/admitted-transform/v1",
    )
    .with_input("source", &input)
    .with_tool("transformer", &tool)
    .with_arguments(["<input>", "<output>"])
    .with_output("result", &output)
    .with_prune_policy(
        ArtifactCachePrunePolicy::new()
            .with_max_age(Duration::from_secs(7 * 24 * 60 * 60))
            .with_max_size_bytes(2 * 1024 * 1024 * 1024),
    );

    let outcome = match prepare_artifact_cache(&spec)? {
        ArtifactCachePreparation::Reused(record) => ArtifactCacheOutcome::Reused(record),
        ArtifactCachePreparation::Build(transaction) => {
            let staged_output = transaction.output_path("result")?;
            admitted
                .run(
                    &[input.into_os_string(), staged_output.into_os_string()],
                    &context,
                    limits,
                )?
                .require_success()?;
            transaction.commit()?
        }
    };

    let disposition = if outcome.is_reused() {
        "reused"
    } else {
        "built"
    };
    println!("{disposition} artifact set {}", outcome.record().key());
    Ok(())
}

pub const fn with_max_size_bytes(self, bytes: u64) -> Self

Remove least-recently-used entries until retained logical size is at most bytes.

Examples found in repository

examples/transactional_artifact_cache.rs (line 65)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let arguments = std::env::args_os().skip(1).collect::<Vec<_>>();
    let [tool, sha256, version, input, output, cache_root] = arguments.as_slice() else {
        eprintln!(
            "usage: transactional_artifact_cache <tool-path> <sha256> <exact-version-stdout> <input> <public-output> <cache-root>"
        );
        return Ok(());
    };
    let current_dir = std::env::current_dir()?;
    let tool = resolve_executable(&current_dir.join(tool), &current_dir, &[])?;
    let context = ExecutionContext {
        current_dir: &current_dir,
        environment: &[],
    };
    let limits = OutputLimits {
        stdout: OutputLimit::Terminate(64 * 1024),
        stderr: OutputLimit::Terminate(64 * 1024),
        timeout: Some(Duration::from_secs(60)),
    };
    // Admission uses caller authority, never a digest computed from untrusted
    // selected bytes. Transform tools must work with this empty environment.
    let admitted = AdmittedTool::admit(
        &ToolSpec {
            executable: &tool,
            sha256: sha256
                .to_str()
                .ok_or("SHA-256 must be UTF-8")?
                .parse::<Sha256Digest>()?,
            executable_bytes: 256 * 1024 * 1024,
            version_arguments: &["--version".into()],
            version_identity: version.to_str().ok_or("version must be UTF-8")?,
        },
        &context,
        limits,
    )?;
    let input = current_dir.join(input);
    let output = current_dir.join(output);
    let cache_root = current_dir.join(cache_root);
    let spec = ArtifactCacheSpec::new(
        &cache_root,
        "example-transform",
        "example/admitted-transform/v1",
    )
    .with_input("source", &input)
    .with_tool("transformer", &tool)
    .with_arguments(["<input>", "<output>"])
    .with_output("result", &output)
    .with_prune_policy(
        ArtifactCachePrunePolicy::new()
            .with_max_age(Duration::from_secs(7 * 24 * 60 * 60))
            .with_max_size_bytes(2 * 1024 * 1024 * 1024),
    );

    let outcome = match prepare_artifact_cache(&spec)? {
        ArtifactCachePreparation::Reused(record) => ArtifactCacheOutcome::Reused(record),
        ArtifactCachePreparation::Build(transaction) => {
            let staged_output = transaction.output_path("result")?;
            admitted
                .run(
                    &[input.into_os_string(), staged_output.into_os_string()],
                    &context,
                    limits,
                )?
                .require_success()?;
            transaction.commit()?
        }
    };

    let disposition = if outcome.is_reused() {
        "reused"
    } else {
        "built"
    };
    println!("{disposition} artifact set {}", outcome.record().key());
    Ok(())
}

pub const fn max_age(self) -> Option<Duration>

Configured maximum entry age, if any.

pub const fn max_size_bytes(self) -> Option<u64>

Configured maximum logical cache size in bytes, if any.

Trait Implementations

impl Clone for ArtifactCachePrunePolicy

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Copy for ArtifactCachePrunePolicy

impl Debug for ArtifactCachePrunePolicy

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for ArtifactCachePrunePolicy

fn default() -> Self

Returns the “default value” for a type.

impl Eq for ArtifactCachePrunePolicy

impl PartialEq for ArtifactCachePrunePolicy

fn eq(&self, other: &Self) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl StructuralPartialEq for ArtifactCachePrunePolicy