Function run_stack

packages/app/src-tauri/src/cli.rs:486–708

Runs a software stack from a stack bundle based on its flavor. # Arguments `name` - The name of the software stack. `path` - A reference to the path of the extracted bundle directory. `flavor` - The flavor of the software stack. `callback` - A function to receive progress updates.

(name: &str, path: &Path, flavor: Flavor, callback: impl Fn(String))

/// * `flavor` - The flavor of the software stack.
/// * `callback` - A function to receive progress updates.
fn run_stack(name: &str, path: &Path, flavor: Flavor, callback: impl Fn(String)) {
    info!("Running flavor: {:?} in path: {:?}", flavor, path);

    // Collect environment variables
    let env_vars = get_docker_env_vars();

    match flavor {
        Flavor::DockerCompose => {
            let mut cmd = Command::new("docker");
            cmd.args([
                "compose",
                "--project-name",
                &name,
                "up",
                "-d",
                "--wait",
                "--remove-orphans",
            ])
            .current_dir(path)
            .envs(env_vars)
            .stdout(std::process::Stdio::piped())
            .stderr(std::process::Stdio::piped());
            debug!("> {:?}", cmd);
            callback(format!("Running command: {:?}", cmd));

            match cmd.spawn() {
                Ok(mut child) => {
                    let stdout = child.stdout.take().unwrap();
                    let stderr = child.stderr.take().unwrap();

                    // Stream stdout
                    let stdout_reader = std::io::BufReader::new(stdout);
                    for line in stdout_reader.lines() {
                        if let Ok(line) = line {
                            debug!("out: {}", line);
                            callback(format!("| {}", line));
                        }
                    }

                    // Stream stderr
                    let stderr_reader = std::io::BufReader::new(stderr);
                    for line in stderr_reader.lines() {
                        if let Ok(line) = line {
                            error!("err: {}", line);
                            callback(format!("| {}", line));
                        }
                    }

                    // Wait for completion
                    match child.wait() {
                        Ok(status) => {
                            if !status.success() {
                                error!("Docker compose failed with status: {}", status);
                                callback(format!("Docker compose failed with status: {}", status));
                            } else {
                                debug!("Docker compose completed successfully");
                                callback("Docker compose completed successfully".to_string());
                            }