core_lib/exec/

command.rs

#![allow(dead_code)]
use std::{collections::HashMap, fs::OpenOptions, sync::Arc, time::Duration};

use anyhow::Result;
use tokio::{
    process::{Child, Command},
    sync::Mutex,
    time::timeout,
};

use crate::{
    core::watcher::WatchContext,
    exec::{OutpuStrategy, PipeRegistry, metrics::monitor_process},
};

pub struct CommandOutput {
    pub status_code: Option<i32>,
    pub cpu_usage: f32,
    pub mem_usage_kb: u64,
}

pub async fn run_command_with_timeout(
    program: &str,
    args: &[String],
    current_dir: &str,
    timeout_secs: u64,
    output: &OutpuStrategy,
    env: Option<HashMap<String, String>>,
    pipe_registry: Arc<Mutex<PipeRegistry>>,
) -> Result<CommandOutput> {
    // Lance le process avec pipes pour stdout et stderr
    let mut cmd = Command::new(program);

    let full = std::iter::once(program.to_string())
        .chain(args.iter().cloned())
        .collect();

    cmd.args(args).current_dir(current_dir);
    output.configure(&mut cmd, full, pipe_registry).await?;

    if let Some(vars) = env {
        for (k, v) in vars {
            cmd.env(k, v);
        }
    }

    let mut child = cmd.spawn()?;

    // Only monitor the child when we actually have its pid. Sampling PID 1
    // ("init") instead would monitor an unrelated process that never exits,
    // turning every command into a spurious timeout.
    let metrics_rx = match child.id() {
        Some(pid) => {
            let (tx, rx) = tokio::sync::mpsc::channel(1);
            tokio::spawn(async move {
                let metrics = monitor_process(pid).await;
                let _ = tx.send(metrics).await;
            });
            Some(rx)
        }
        None => None,
    };

    let duration = Duration::from_secs(timeout_secs);

    let run_future = async {
        let status = child.wait().await?;

        let (cpu_usage, mem_usage_kb) = match metrics_rx {
            Some(mut rx) => rx.recv().await.unwrap_or((0.0, 0)),
            None => (0.0, 0),
        };
        anyhow::Ok((status, cpu_usage, mem_usage_kb))
    };

    match timeout(duration, run_future).await {
        Ok(Ok((status, cpu_usage, mem_usage_kb))) => Ok(CommandOutput {
            status_code: status.code(),
            cpu_usage,
            mem_usage_kb,
        }),
        Ok(Err(e)) => Err(anyhow::anyhow!("Error during execution : {}", e)),
        Err(_) => {
            child.kill().await.ok();
            Err(anyhow::anyhow!(
                "Command timeout after {} seconds, process killed",
                timeout_secs
            ))
        }
    }
}

pub async fn run_command_background(
    program: &str,
    args: &[String],
    current_dir: &str,
    stdout_file: std::fs::File,
    stderr_file: std::fs::File,
    env: Option<HashMap<String, String>>,
) -> Result<Child> {
    use std::process::Stdio;
    let stdout_stdio = Stdio::from(stdout_file);
    let stderr_stdio = Stdio::from(stderr_file);

    let mut cmd = Command::new(program);
    cmd.args(args)
        .current_dir(current_dir)
        .stdout(stdout_stdio)
        .stderr(stderr_stdio);

    if let Some(vars) = env {
        for (k, v) in vars {
            cmd.env(k, v);
        }
    }

    let child = cmd.spawn()?;

    Ok(child)
}

pub async fn exec_timeout(
    parts: Vec<String>,
    ctx: &WatchContext,
    timeout: u64,
    env: Option<HashMap<String, String>>,
    output_strategy: &OutpuStrategy,
    pipe_registry: Arc<Mutex<PipeRegistry>>,
) -> Result<CommandOutput, anyhow::Error> {
    let program = &parts[0];
    let args = &parts[1..];

    match run_command_with_timeout(
        program,
        args,
        &ctx.project_dir,
        timeout,
        output_strategy,
        env,
        pipe_registry,
    )
    .await
    {
        Ok(output) => {
            if output.status_code != Some(0) {
                tracing::error!(
                    target: "fleet",
                    log_path = %ctx.log_path().display(),
                    message = %format!("Command failed with exit code {:?}", output.status_code),
                );
                return Err(anyhow::anyhow!("Failed command: {:?}", parts));
            }
            tracing::info!(
                target: "fleet",
                log_path = %ctx.log_path().display(),
                message = %format!("Command {program} succeeded"),
            );
            Ok(output)
        }
        Err(e) => {
            tracing::error!(
                target: "fleet",
                log_path = %ctx.log_path().display(),
                message = %format!("Command error or timeout: {parts:?}"),
            );
            tracing::error!(
                target: "fleet",
                log_path = %ctx.log_path().display(),
                message = %e.to_string(),
            );
            Err(anyhow::anyhow!("**Command error:**: `{parts:?}`\n{e}"))
        }
    }
}

pub async fn exec_background(
    parts: Vec<String>,
    ctx: &WatchContext,
    env: Option<HashMap<String, String>>,
) -> Result<(), anyhow::Error> {
    let program = &parts[0];
    let args = &parts[1..];
    tracing::info!(
        target: "fleet",
        log_path = %ctx.log_path().display(),
        message = "Command marked as blocking: running in background without waiting",
    );
    let log_path = ctx.log_path();

    let stdout_file = OpenOptions::new()
        .create(true)
        .append(true)
        .open(&log_path)?;
    let stderr_file = OpenOptions::new()
        .create(true)
        .append(true)
        .open(&log_path)?;

    match run_command_background(
        program,
        args,
        &ctx.project_dir,
        stdout_file,
        stderr_file,
        env,
    )
    .await
    {
        Ok(_child) => {}
        Err(e) => {
            tracing::error!(
                target: "fleet",
                log_path = %ctx.log_path().display(),
                message = %format!("Failed to launch background command: {e}"),
            );
            return Err(e);
        }
    }

    tracing::info!(
        target: "fleet",
        log_path = %ctx.log_path().display(),
        message = "Background command launched",
    );
    Ok(())
}