run_stack/

assets.rs

//! The files a stack is built from, carried inside the binary.
//!
//! docker-compose.yml, the Dockerfiles, the container entrypoints and the env
//! template are part of the tool, not of any workspace. They are embedded so
//! the binary is self-contained, and unpacked on first use because docker needs
//! a real directory for its build contexts.

use std::fs;
use std::path::{Path, PathBuf};

use anyhow::{Context, Result};
use include_dir::{include_dir, Dir};

static ASSETS: Dir<'_> = include_dir!("$CARGO_MANIFEST_DIR/assets");

/// Where the unpacked copy lives: per version, so an upgrade cannot read a
/// stale compose file, and several versions can coexist.
fn cache_dir() -> Result<PathBuf> {
    if let Some(dir) = std::env::var_os("RUN_ASSET_DIR") {
        return Ok(PathBuf::from(dir));
    }
    let base = std::env::var_os("XDG_CACHE_HOME")
        .map(PathBuf::from)
        .or_else(|| dirs_home().map(|home| home.join("Library/Caches")))
        .context("no cache directory — set RUN_ASSET_DIR")?;
    Ok(base.join("run-stack").join(env!("CARGO_PKG_VERSION")))
}

fn dirs_home() -> Option<PathBuf> {
    std::env::var_os("HOME").map(PathBuf::from)
}

/// The directory holding docker-compose.yml, unpacking it if needed.
///
/// RUN_PACKAGE_DIR still wins: it is how the port is checked against the shell
/// version's own copy, and how someone patches a compose file locally.
pub fn package_dir() -> Result<PathBuf> {
    if let Some(dir) = std::env::var("RUN_PACKAGE_DIR").ok().filter(|d| !d.is_empty()) {
        return Ok(PathBuf::from(dir));
    }
    let dir = cache_dir()?;
    let stamp = dir.join(".unpacked");
    if !stamp.is_file() {
        unpack(&dir)?;
        fs::write(&stamp, env!("CARGO_PKG_VERSION"))
            .with_context(|| format!("writing {}", stamp.display()))?;
    }
    Ok(dir)
}

fn unpack(dir: &Path) -> Result<()> {
    fs::create_dir_all(dir).with_context(|| format!("creating {}", dir.display()))?;
    ASSETS
        .extract(dir)
        .with_context(|| format!("unpacking the stack files into {}", dir.display()))?;

    // Entrypoints are mounted into containers and executed; the archive does
    // not carry a mode bit, and they are several directories deep.
    #[cfg(unix)]
    make_scripts_executable(&ASSETS, dir)?;
    Ok(())
}

#[cfg(unix)]
fn make_scripts_executable(source: &Dir<'_>, target: &Path) -> Result<()> {
    use std::os::unix::fs::PermissionsExt;
    for file in source.files() {
        let executable = file
            .path()
            .extension()
            .is_some_and(|extension| extension == "sh" || extension == "py");
        if !executable {
            continue;
        }
        let path = target.join(file.path());
        let mut permissions = fs::metadata(&path)
            .with_context(|| format!("reading {}", path.display()))?
            .permissions();
        permissions.set_mode(0o755);
        fs::set_permissions(&path, permissions)
            .with_context(|| format!("making {} executable", path.display()))?;
    }
    for nested in source.dirs() {
        make_scripts_executable(nested, target)?;
    }
    Ok(())
}

/// One embedded file's contents, for reading without unpacking.
pub fn read(path: &str) -> Option<&'static str> {
    ASSETS.get_file(path).and_then(|file| file.contents_utf8())
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn carries_what_a_stack_is_built_from() {
        assert!(read("docker-compose.yml").is_some_and(|f| f.contains("x-frontend-service")));
        assert!(read(".env.example").is_some());
        assert!(ASSETS.get_file("docker/frontend/entrypoint.sh").is_some());
        assert!(ASSETS.get_file("docker/backend/laravel/Dockerfile").is_some());
        assert!(ASSETS.get_file("docker/dashboard/server.py").is_some());
    }

    #[test]
    fn unpacks_a_usable_tree() {
        let dir = tempfile::tempdir().unwrap();
        unpack(dir.path()).unwrap();
        assert!(dir.path().join("docker-compose.yml").is_file());
        #[cfg(unix)]
        {
            use std::os::unix::fs::PermissionsExt;
            let entrypoint = dir.path().join("docker/frontend/entrypoint.sh");
            let mode = fs::metadata(&entrypoint).unwrap().permissions().mode();
            assert_eq!(mode & 0o111, 0o111, "entrypoints must stay executable");
        }
    }

    /// The embedded copy and the shell version's must not drift apart while
    /// both exist. Skipped when the shell checkout is not next to this one.
    #[test]
    #[test]
    fn the_shell_scripts_pick_an_interpreter_that_can_read_toml() {
        // The config is TOML and tomllib is Python 3.11+. Calling a bare
        // python3 meant an older default read nothing and the tool carried on
        // as if the workspace were unconfigured.
        let common = read("scripts/common.sh").expect("common.sh ships");

        assert!(common.contains("run_python()"), "no interpreter resolver");
        assert!(common.contains("import tomllib"), "resolver does not test for tomllib");

        for name in ["scripts/common.sh", "scripts/init.sh", "scripts/ports.sh"] {
            let text = read(name).unwrap_or_default();
            assert!(
                !text.contains("\npython3 ") && !text.contains("$(python3 "),
                "{name} still calls a bare python3"
            );
        }
    }

    fn matches_the_shell_version() {
        let shell = Path::new(env!("CARGO_MANIFEST_DIR")).join("../run");
        if !shell.join("docker-compose.yml").is_file() {
            return;
        }
        for name in ["docker-compose.yml", ".env.example"] {
            let theirs = fs::read_to_string(shell.join(name)).unwrap();
            assert_eq!(
                read(name).unwrap(),
                theirs,
                "{name} has drifted from ../run — copy it across"
            );
        }
    }
}