@@ -1,0 +1,271 @@
use crate::runner::log_reporter::LogReporter;
use sha2::{Digest, Sha256};
use std::process::Command;
use tokio::io::{AsyncBufReadExt, BufReader};
/// Compute a deterministic image tag from the base image and prepare commands.
pub fn compute_prepared_tag(image: &str, prepare: &[String]) -> String {
let mut hasher = Sha256::new();
hasher.update(image.as_bytes());
for cmd in prepare {
hasher.update(b"\n");
hasher.update(cmd.as_bytes());
}
let hash = hasher.finalize();
let hex = format!("{hash:x}");
format!("anvil-prepared:{}", &hex[..12])
}
/// Check if a Docker image exists locally.
fn image_exists_locally(tag: &str) -> bool {
Command::new("docker")
.args(["image", "inspect", tag])
.stdout(std::process::Stdio::null())
.stderr(std::process::Stdio::null())
.status()
.map(|s| s.success())
.unwrap_or(false)
}
/// Prepare a Docker image by running prepare commands on the base image.
/// Returns the tag of the prepared image (either cached or freshly built).
pub async fn prepare_image(
image: &str,
prepare: &[String],
log_reporter: &LogReporter,
) -> Result<String, Box<dyn std::error::Error + Send + Sync>> {
let tag = compute_prepared_tag(image, prepare);
if image_exists_locally(&tag) {
let msg = format!("Using cached prepared image: {tag}");
eprintln!("{msg}");
log_reporter.append(&msg).await;
return Ok(tag);
}
log_reporter
.append(&format!("Building prepared image from {image}..."))
.await;
// Pull the base image first
eprintln!("Pulling base image: {image}");
log_reporter
.append(&format!("Pulling base image: {image}"))
.await;
let pull_output = Command::new("docker").args(["pull", image]).output();
match pull_output {
Ok(output) if output.status.success() => {
eprintln!("Base image ready: {image}");
}
Ok(output) => {
let stderr = String::from_utf8_lossy(&output.stderr);
let msg = format!("Warning: docker pull failed: {stderr}");
eprintln!("{msg}");
log_reporter.append(&msg).await;
}
Err(e) => {
let msg = format!("Warning: docker pull error: {e}");
eprintln!("{msg}");
log_reporter.append(&msg).await;
}
}
// Join all prepare commands with && so they run in sequence and fail fast
let combined = prepare.join(" && ");
let container_name = format!("anvil-prepare-{}", &tag["anvil-prepared:".len()..]);
// Remove any leftover container from a previous failed attempt
let _ = Command::new("docker")
.args(["rm", "-f", &container_name])
.stdout(std::process::Stdio::null())
.stderr(std::process::Stdio::null())
.status();
// Run prepare commands in the base image, streaming output
log_reporter.append("Running prepare commands...").await;
let mut child = tokio::process::Command::new("docker")
.args([
"run",
"--name",
&container_name,
image,
"/bin/sh",
"-c",
&combined,
])
.stdout(std::process::Stdio::piped())
.stderr(std::process::Stdio::piped())
.spawn()?;
// Stream stdout and stderr
let reporter_out = log_reporter.clone();
let stdout = child.stdout.take();
let stdout_task = tokio::spawn(async move {
if let Some(stdout) = stdout {
let mut lines = BufReader::new(stdout).lines();
while let Ok(Some(line)) = lines.next_line().await {
reporter_out.append(&line).await;
}
}
});
let reporter_err = log_reporter.clone();
let stderr = child.stderr.take();
let stderr_task = tokio::spawn(async move {
if let Some(stderr) = stderr {
let mut lines = BufReader::new(stderr).lines();
while let Ok(Some(line)) = lines.next_line().await {
reporter_err.append(&line).await;
}
}
});
let _ = stdout_task.await;
let _ = stderr_task.await;
let status = child.wait().await?;
log_reporter.flush().await;
if !status.success() {
// Clean up failed container
let _ = Command::new("docker")
.args(["rm", "-f", &container_name])
.stdout(std::process::Stdio::null())
.stderr(std::process::Stdio::null())
.status();
return Err(format!(
"Prepare commands failed with exit code {}",
status.code().unwrap_or(1)
)
.into());
}
// Commit the container as the prepared image
log_reporter
.append(&format!("Committing prepared image as {tag}..."))
.await;
let commit_output = Command::new("docker")
.args(["commit", &container_name, &tag])
.output()?;
// Remove the build container
let _ = Command::new("docker")
.args(["rm", "-f", &container_name])
.stdout(std::process::Stdio::null())
.stderr(std::process::Stdio::null())
.status();
if !commit_output.status.success() {
let stderr = String::from_utf8_lossy(&commit_output.stderr);
return Err(format!("docker commit failed: {stderr}").into());
}
let msg = format!("Prepared image ready: {tag}");
eprintln!("{msg}");
log_reporter.append(&msg).await;
Ok(tag)
}
/// Prune old prepared images beyond max_count or older than max_age_days.
pub fn prune_prepared_images(max_age_days: u64, max_count: usize) {
let output = Command::new("docker")
.args([
"images",
"anvil-prepared",
"--format",
"{{.ID}} {{.CreatedAt}} {{.Repository}}:{{.Tag}}",
])
.output();
let output = match output {
Ok(o) if o.status.success() => o,
_ => return,
};
let stdout = String::from_utf8_lossy(&output.stdout);
let mut images: Vec<(&str, &str)> = stdout
.lines()
.filter_map(|line| {
let parts: Vec<&str> = line.splitn(3, ' ').collect();
if parts.len() >= 3 {
Some((parts[2], parts[1]))
} else {
None
}
})
.collect();
// Sort by creation date descending (newest first) — lexicographic on ISO date works
images.sort_by(|a, b| b.1.cmp(a.1));
// Remove images beyond max_count
for (tag, _) in images.iter().skip(max_count) {
eprintln!("Pruning old prepared image: {tag}");
let _ = Command::new("docker")
.args(["rmi", tag])
.stdout(std::process::Stdio::null())
.stderr(std::process::Stdio::null())
.status();
}
// Also remove images older than max_age_days
if max_age_days > 0 {
let cutoff = chrono::Utc::now() - chrono::Duration::days(max_age_days as i64);
let cutoff_str = cutoff.format("%Y-%m-%d").to_string();
for (tag, created_at) in &images {
if *created_at < cutoff_str.as_str() {
eprintln!("Pruning expired prepared image: {tag}");
let _ = Command::new("docker")
.args(["rmi", tag])
.stdout(std::process::Stdio::null())
.stderr(std::process::Stdio::null())
.status();
}
}
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test_compute_prepared_tag_deterministic() {
let tag1 = compute_prepared_tag(
"elixir:1.17",
&["apt-get update".into(), "mix local.hex --force".into()],
);
let tag2 = compute_prepared_tag(
"elixir:1.17",
&["apt-get update".into(), "mix local.hex --force".into()],
);
assert_eq!(tag1, tag2);
assert!(tag1.starts_with("anvil-prepared:"));
assert_eq!(tag1.len(), "anvil-prepared:".len() + 12);
}
#[test]
fn test_compute_prepared_tag_differs_on_image() {
let tag1 = compute_prepared_tag("elixir:1.17", &["apt-get update".into()]);
let tag2 = compute_prepared_tag("elixir:1.18", &["apt-get update".into()]);
assert_ne!(tag1, tag2);
}
#[test]
fn test_compute_prepared_tag_differs_on_commands() {
let tag1 = compute_prepared_tag("elixir:1.17", &["apt-get update".into()]);
let tag2 = compute_prepared_tag("elixir:1.17", &["apt-get install -y git".into()]);
assert_ne!(tag1, tag2);
}
#[test]
fn test_compute_prepared_tag_order_matters() {
let tag1 = compute_prepared_tag("elixir:1.17", &["cmd1".into(), "cmd2".into()]);
let tag2 = compute_prepared_tag("elixir:1.17", &["cmd2".into(), "cmd1".into()]);
assert_ne!(tag1, tag2);
}
}