gitbox 2.1.3

Git toolbox to simplify adoption of conventional commits and semantic version, among other things.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74

use std::error::Error;
use std::io::Error as IoError;

use hierrorchy::{error_leaf, error_node};
use indoc::formatdoc;

use super::container_manager::{container_manager, ContainerManagerNotFoundError};

#[error_leaf(format!("image build failed, stderr dump:\n{}", self.stderr))]
pub struct BuildImageCommandError {
    stderr: String,
}

error_node! {
    pub type DockerfileWriteError<IoError> = "failed to write dockerfile"
}

error_node! {
    pub type BaseImageBuildError<
        ContainerManagerNotFoundError,
        DockerfileWriteError,
        BuildImageCommandError
    > = "failed to build base image"
}

pub fn build_base_image(
    msrv: &str,
    bin_name: &str,
    required_packages: &[&str],
) -> Result<String, BaseImageBuildError> {
    let dockerfile_content = formatdoc! { "
        FROM docker.io/library/rust:{msrv}-slim AS builder
        WORKDIR /project
        COPY ./ ./
        RUN cargo build

        FROM docker.io/library/debian:12.9-slim AS runner
        {}
        COPY --from=builder /project/target/debug/{bin_name} /usr/local/bin/{bin_name}
    ",
    if required_packages.is_empty() {
        String::new()
    } else {
        format!("RUN apt-get update && apt-get install -y --no-install-recommends {}", required_packages.join(" "))
    }};
    let package_name = std::env::var("CARGO_PKG_NAME").expect("Package name is present and UTF-8");
    let image_name = format!("{package_name}-integration-tests-base:{msrv}");
    let tmp_dockerfile_path =
        std::env::temp_dir().join(format!("Dockerfile.{package_name}_integration_tests"));
    std::fs::write(&tmp_dockerfile_path, dockerfile_content)
        .map_err(DockerfileWriteError::from)?;
    let result = std::process::Command::new(&container_manager()?)
        .args([
            "build",
            "-t",
            &image_name,
            "-f",
            tmp_dockerfile_path
                .to_str()
                .expect("Temp dockerfile path exists"),
            ".",
        ])
        .output()
        .expect("Building the image does not fail");
    if !result.status.success() {
        return Err(BuildImageCommandError {
            stderr: std::str::from_utf8(&result.stderr)
                .expect("result stderr is a valid string")
                .to_owned(),
        }
        .into());
    }
    Ok(image_name)
}