feat: buildscript to embed targetted platform

Author: kristof-mattei

Cargo.toml

@@ -10,6 +10,7 @@ categories = ["starter", "seed"]
 keywords = ["integrity", "seed", "starter", "docker", "release"]
 repository = "https://github.com/kristof-mattei/rust-seed"
 include = ["src/**", "/LICENSE", "/LICENSE-*"]
+build = "src/build.rs"
 
 [dependencies]
 color-eyre = "0.6.5"

Dockerfile

@@ -47,6 +47,8 @@ RUN cargo init --name ${APPLICATION_NAME}
 
 COPY ./.cargo ./Cargo.toml ./Cargo.lock ./
 
+RUN echo "fn main() {}" > ./src/build.rs
+
 # We use `fetch` to pre-download the files to the cache
 # Notice we do this in the target arch specific branch
 # We do this because we want to do it after `setup-env.sh`,
@@ -63,18 +65,21 @@ RUN --mount=type=cache,target=/build/target/${TARGET},sharing=locked \
     --mount=type=cache,id=cargo-git,target=/usr/local/cargo/git/db \
     --mount=type=cache,id=cargo-registry-index,target=/usr/local/cargo/registry/index \
     --mount=type=cache,id=cargo-registry-cache,target=/usr/local/cargo/registry/cache \
-    /build-scripts/build.sh build --release --target ${TARGET} --target-dir ./target/${TARGET}
+    /build-scripts/build.sh build --release --target-dir ./target/${TARGET}
 
 # Rust full build
 FROM rust-cargo-build AS rust-build
 
+# to expose into `build.sh`
+ARG TARGETVARIANT
+
 WORKDIR /build
 
 # now we copy in the source which is more prone to changes and build it
 COPY ./src ./src
 
-# ensure cargo picks up on the change
-RUN touch ./src/main.rs
+# ensure cargo picks up on the fact that we copied in our code
+RUN touch ./src/main.rs ./src/build.rs
 
 ENV PATH="/output/bin:$PATH"
 
@@ -83,7 +88,7 @@ RUN --mount=type=cache,target=/build/target/${TARGET},sharing=locked \
     --mount=type=cache,id=cargo-git,target=/usr/local/cargo/git/db \
     --mount=type=cache,id=cargo-registry-index,target=/usr/local/cargo/registry/index \
     --mount=type=cache,id=cargo-registry-cache,target=/usr/local/cargo/registry/cache \
-    /build-scripts/build.sh install --path . --locked --target ${TARGET} --target-dir ./target/${TARGET} --root /output
+    /build-scripts/build.sh install --path . --locked --target-dir ./target/${TARGET} --root /output
 
 # Container user setup
 FROM --platform=${BUILDPLATFORM} alpine:3.22.2@sha256:4b7ce07002c69e8f3d704a9c5d6fd3053be500b7f1c69fc0d80990c2ad8dd412 AS passwd-build
@@ -99,8 +104,6 @@ RUN cat /etc/passwd | grep appuser > /tmp/passwd_appuser
 FROM scratch
 
 ARG APPLICATION_NAME
-ARG TARGETARCH
-ARG TARGETVARIANT
 
 COPY --from=passwd-build /tmp/group_appuser /etc/group
 COPY --from=passwd-build /tmp/passwd_appuser /etc/passwd
@@ -110,8 +113,6 @@ COPY --from=rust-build /output/bin/${APPLICATION_NAME} /app/entrypoint
 USER appuser
 
 ENV RUST_BACKTRACE=full
-ENV TARGETARCH=${TARGETARCH}
-ENV TARGETVARIANT=${TARGETVARIANT}
 
 WORKDIR /app
 

build-all.sh

@@ -4,17 +4,13 @@ set -e
 build() {
     APPLICATION_NAME=$1
     PLATFORM=$2
-    docker build \
+    docker buildx \
+        build \
         --file Dockerfile . \
-        --tag $APPLICATION_NAME:latest-${2//\//-} \
+        --tag $APPLICATION_NAME:latest \
         --build-arg APPLICATION_NAME=$APPLICATION_NAME \
         --platform $PLATFORM \
         --progress=plain
 }
 
-name=$(basename ${PWD})
-
-build $name linux/amd64/v3
-build $name linux/amd64/v2
-build $name linux/amd64
-build $name linux/arm64
+build $(basename ${PWD}) linux/amd64/v3,linux/amd64/v2,linux/amd64,linux/arm64

build-scripts/build.sh

@@ -25,7 +25,7 @@ case $TARGET in
         ;;
 esac
 
-rust_flags="-Clink-self-contained=yes -Clinker=rust-lld ${target_cpu}"
+rustflags="-Clink-self-contained=yes -Clinker=rust-lld ${target_cpu}"
 
 # replace - with _ in the Rust target
 target_lower=${TARGET//-/_}
@@ -41,4 +41,4 @@ declare -x "${cxx_var}=${cpp_compiler}"
 cargo_target_linker_var=CARGO_TARGET_${target_upper}_LINKER
 declare -x "${cargo_target_linker_var}=${c_compiler}"
 
-RUSTFLAGS=$rust_flags cargo $@
+RUSTFLAGS=$rustflags cargo $@ --target ${TARGET}

src/build.rs

@@ -0,0 +1,46 @@
+use std::env;
+use std::ffi::OsStr;
+
+fn main() {
+    export_var(
+        "COMPILE_TIME_HOST",
+        &env::var("HOST").expect("HOST is set for build scripts"),
+    );
+    export_var(
+        "COMPILE_TIME_TARGET",
+        &env::var("TARGET").expect("TARGET is set for build scripts"),
+    );
+    export_var(
+        "COMPILE_TIME_TARGET_CPU",
+        &extract_target_cpu_from_rustflags(
+            &env::var_os("CARGO_ENCODED_RUSTFLAGS").unwrap_or_default(),
+        )
+        .unwrap_or_default(),
+    );
+
+    println!("cargo:rerun-if-changed-env=HOST");
+    println!("cargo:rerun-if-changed-env=TARGET");
+    println!("cargo:rerun-if-changed-env=CARGO_ENCODED_RUSTFLAGS");
+}
+
+fn extract_target_cpu_from_rustflags(rustflags: &OsStr) -> Option<String> {
+    const ASCII_SEPARATOR: char = '\x1f';
+
+    let rustflags = rustflags.to_string_lossy();
+
+    let mut cpu = None;
+
+    for flag in rustflags.split(ASCII_SEPARATOR) {
+        let stripped_c = flag.strip_prefix("-C").unwrap_or(flag);
+
+        if let Some(target_cpu) = stripped_c.strip_prefix("target-cpu=") {
+            cpu = Some(target_cpu);
+        }
+    }
+
+    cpu.map(str::to_owned)
+}
+
+fn export_var(name: &str, value: &str) {
+    println!("cargo:rustc-env={}={}", name, value);
+}

src/build_env.rs

@@ -0,0 +1,33 @@
+pub const COMPILE_TIME_HOST: &str = env!("COMPILE_TIME_HOST");
+pub const COMPILE_TIME_TARGET: &str = env!("COMPILE_TIME_TARGET");
+pub const COMPILE_TIME_TARGET_CPU: Option<&str> = const {
+    let cttc = env!("COMPILE_TIME_TARGET_CPU");
+
+    if cttc.is_empty() { None } else { Some(cttc) }
+};
+
+pub struct BuildEnv {
+    host: &'static str,
+    target: &'static str,
+    target_cpu: Option<&'static str>,
+}
+
+pub fn get_build_env() -> BuildEnv {
+    BuildEnv {
+        host: COMPILE_TIME_HOST,
+        target: COMPILE_TIME_TARGET,
+        target_cpu: COMPILE_TIME_TARGET_CPU,
+    }
+}
+
+impl std::fmt::Display for BuildEnv {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "Built on `{}`, targeting `{}`", self.host, self.target)?;
+
+        if let Some(target_cpu) = self.target_cpu {
+            write!(f, " (target-cpu `{}`)", target_cpu)?;
+        }
+
+        Ok(())
+    }
+}

src/main.rs

@@ -1,3 +1,9 @@
+use color_eyre::config::HookBuilder;
+use color_eyre::eyre;
+
+use crate::build_env::get_build_env;
+mod build_env;
+
 #[global_allocator]
 static GLOBAL: mimalloc::MiMalloc = mimalloc::MiMalloc;
 
@@ -13,21 +19,22 @@ fn quz() -> &'static str {
     "Quz"
 }
 
-#[expect(clippy::todo, reason = "Seed code")]
-fn main() -> Result<(), color_eyre::Report> {
-    color_eyre::install()?;
+fn i_will_error() -> Result<(), eyre::Report> {
+    Err(eyre::Report::msg("I promised you, I'd error!"))
+}
+
+fn main() -> Result<(), eyre::Report> {
+    HookBuilder::default()
+        .capture_span_trace_by_default(true)
+        .install()?;
 
     println!("{}", foo());
     println!("{}", bar());
     println!("{}", quz());
 
-    println!(
-        "BUILT FOR {} {}",
-        std::env::var("TARGETARCH").unwrap(),
-        std::env::var("TARGETVARIANT").unwrap()
-    );
+    println!("Build setup: {}", get_build_env());
 
-    todo!("TODO");
+    i_will_error()
 }
 
 #[cfg(test)]