testcontainers-build 0.1.0

Build Testcontainers images from folders, remote contexts, and pluggable Git providers
Documentation
use anyhow::{Context, ensure};
use std::{path::Path, process::Command, time::Duration};
use testcontainers_build::{GitRequest, GitSource, ImageBuilder};

#[path = "../common/mod.rs"]
mod common;

#[tokio::main]
async fn main() -> anyhow::Result<()> {
    let args: Vec<_> = std::env::args().skip(1).collect();
    if let Some(repository) = args.first() {
        return build(
            GitRequest::new(repository)
                .with_revision(args.get(1).map(String::as_str).unwrap_or("HEAD"))
                .with_subdirectory(args.get(2).map(String::as_str).unwrap_or(".")),
        )
        .await;
    }

    let repository = tempfile::tempdir()?;
    let app = repository.path().join("services/app");
    std::fs::create_dir_all(app.join("container"))?;
    for file in [
        "container/Dockerfile",
        "payload.txt",
        ".dockerignore",
        "excluded.txt",
    ] {
        std::fs::copy(common::context().join(file), app.join(file))?;
    }
    git(repository.path(), &["init", "--quiet"])?;
    git(repository.path(), &["add", "."])?;
    git(
        repository.path(),
        &[
            "-c",
            "user.name=Example",
            "-c",
            "user.email=example@example.invalid",
            "-c",
            "commit.gpgsign=false",
            "commit",
            "--quiet",
            "-m",
            "example source",
        ],
    )?;
    let revision = git(repository.path(), &["rev-parse", "HEAD"])?;
    println!("Build pinned revision {}", revision.trim());
    build(
        GitRequest::new(repository.path().to_string_lossy())
            .with_revision(revision.trim())
            .with_subdirectory("services/app"),
    )
    .await
}

async fn build(request: GitRequest) -> anyhow::Result<()> {
    let image = ImageBuilder::default()
        .with_source(GitSource::new(request))
        .with_dockerfile("container/Dockerfile")
        .with_build_argument("GREETING", "hello from the Rust Git example")
        .with_target("runtime")
        .with_timeout(Duration::from_secs(120))
        .build()
        .await?;
    common::image::run_and_remove(image).await
}

fn git(directory: &Path, args: &[&str]) -> anyhow::Result<String> {
    let output = Command::new("git")
        .current_dir(directory)
        .args(args)
        .output()
        .context("run Git")?;
    ensure!(
        output.status.success(),
        "Git failed: {}",
        String::from_utf8_lossy(&output.stderr)
    );
    Ok(String::from_utf8(output.stdout)?)
}