build.rs

use std::env;
use std::path::{Path, PathBuf};
use std::process::Command;
use walkdir::WalkDir;

fn main() {
    let target_platform = "thumbv8m.main-none-eabihf";

    let release_type = if env::var("DEBUG").unwrap() == "true" {
        "debug"
    } else {
        "release"
    };
    let out = PathBuf::from(env::var_os("OUT_DIR").unwrap());

    for e in WalkDir::new("src")
        .into_iter()
        .filter_map(|e| e.ok())
        .filter(|e| e.file_type().is_file())
    {
        println!("cargo:rerun-if-changed={}", e.path().display());
    }

    if env::var("TARGET").unwrap() != target_platform {
        panic!("invalid target");
    }

    let build_artifact_dir = out.join("artifact");
    let _ = std::fs::remove_dir_all(&build_artifact_dir);
    build_binary(&out, release_type);
    copy_artifacts(target_platform, release_type, &build_artifact_dir);
}

fn copy_artifacts(
    target_platform: &str,
    release_type: &str,
    build_artifact_dir: &PathBuf,
) {
    let target_artifact_dir = get_artifact_dir(target_platform, release_type);
    for f in WalkDir::new(build_artifact_dir)
        .max_depth(1)
        .into_iter()
        .filter_map(|e| e.ok())
        .filter(|e| e.file_type().is_file())
    {
        std::fs::copy(
            f.path(),
            PathBuf::from(&target_artifact_dir).join(f.file_name()),
        )
        .unwrap_or_else(|_| {
            panic!(
                "failed to copy artifact {} to {}",
                f.path().display(),
                target_artifact_dir.display()
            )
        });
    }
}

fn get_artifact_dir(target_platform: &str, release_type: &str) -> PathBuf {
    let data = Command::new("cargo")
        .args(["metadata", "--no-deps"])
        .output()
        .expect("failed to execute cargo metadata")
        .stdout;
    let data = json::parse(str::from_utf8(&data).expect("invalid character in metadata"))
        .expect("failed to parse cargo metadata");
    let target_dir = data["target_directory"].as_str().expect("expected string");

    PathBuf::from(target_dir)
        .join(target_platform)
        .join(release_type)
}

fn build_binary(out: &Path, release_type: &str) {
    let status = Command::new("make")
        .current_dir("src")
        .env("OUTPUT_DIR", out.as_os_str())
        .env("MAKEFLAGS", env::var("CARGO_MAKEFLAGS").unwrap())
        .arg("--quiet")
        .args(["-f", "bootloader-apploader.Makefile"])
        .arg(release_type)
        .status()
        .unwrap();
    assert!(status.success(), "make failed");
}