nordisk/edda

crates/nornir-build-thing/examples/probe_container_stdout.rs

//! Probe (throwaway): run the gunnar-server variant over the REAL container road
//! and report what `build_variant_in_container` was actually handed back.
use nornir_build_thing::cargo_container::{
    build_variant_in_container, parse_container_stdout, CargoContainerRunner, CargoRunOutcome,
    CargoRunRequest, DraupnirCargoRunner, HostPaths,
};
use nornir_build_thing::variant::BuildVariantSet;
use std::path::PathBuf;

struct Spy(DraupnirCargoRunner);
impl CargoContainerRunner for Spy {
    fn run(&self, req: &CargoRunRequest) -> anyhow::Result<CargoRunOutcome> {
        let out = self.0.run(req)?;
        eprintln!(
            "[spy] exit={:?} stdout_lines={} stderr_lines={}",
            out.exit_code,
            out.stdout.len(),
            out.stderr.len()
        );
        eprintln!(
            "[spy] stdout lines carrying an `executable` field: {}",
            out.stdout.iter().filter(|l| l.contains("\"executable\":\"/")).count()
        );
        eprintln!(
            "[spy] stdout lines with an EMBEDDED newline: {}",
            out.stdout.iter().filter(|l| l.contains('\n')).count()
        );
        eprintln!(
            "[spy] stdout lines that are `compiler-artifact`: {}",
            out.stdout.iter().filter(|l| l.contains("\"compiler-artifact\"")).count()
        );
        eprintln!(
            "[spy] build-finished seen: {}",
            out.stdout.iter().any(|l| l.contains("\"build-finished\""))
        );
        if let Some(l) = out.stdout.last() {
            eprintln!("[spy] LAST stdout line: {}", &l[..l.len().min(160)]);
        }
        std::fs::write("/tmp/spy-stdout.txt", out.stdout.join("\n")).unwrap();
        std::fs::write("/tmp/spy-stderr.txt", out.stderr.join("\n")).unwrap();
        Ok(out)
    }
}

fn main() -> anyhow::Result<()> {
    let repo = PathBuf::from(std::env::args().nth(1).expect("repo root"));
    let name = std::env::args().nth(2).unwrap_or_else(|| "gunnar-server".into());
    let set = BuildVariantSet::load_file(&repo.join(".nornir/build-variants.toml"))?;
    let tc = set.toolchain.clone().expect("the declaration pins a toolchain");
    let paths = HostPaths::from_env(&repo);
    std::fs::create_dir_all(&paths.target_dir)?;
    eprintln!("[spy] target_dir = {}", paths.target_dir.display());
    let runner = Spy(DraupnirCargoRunner::new());
    let out = build_variant_in_container(
        &set,
        &name,
        &repo,
        &paths.target_dir,
        paths.registry_bind(),
        &tc,
        &runner,
    )?;
    println!("success = {}", out.success);
    println!("artifacts = {:?}", out.artifacts);
    let raw: Vec<String> =
        std::fs::read_to_string("/tmp/spy-stdout.txt")?.lines().map(str::to_string).collect();
    let re = parse_container_stdout(&raw, &paths.target_dir);
    println!("re-parsed from the SAME lines: units={} artifacts={:?}", re.units, re.artifacts);
    Ok(())
}