Rust实现Shell进程执行命令无输出问题排查求助

问题根源分析 #

你的代码存在三个核心问题：

1. 错误的shell启动参数：使用-c（Unix）或/C（Windows）启动shell时，该参数要求紧跟单个命令并执行后立即退出。但你仅传递了-c//C，未附带初始命令，导致shell启动后直接退出，后续写入stdin的命令根本没有进程接收。
2. 未刷新stdin缓冲区：即使是交互式shell，写入命令后未手动刷新stdin，数据会滞留在用户态缓冲区，无法传递给子进程。
3. 同步读取的阻塞问题：read_to_string会阻塞直到流关闭，若先读stdout但stderr有输出、或反之，程序会无限等待；而shell退出后流已关闭，自然读不到内容。

解决方案 #

方案1：单次命令启动shell（简单直接）

如果不需要保留shell会话（如环境变量、历史命令），每次执行命令时重新启动shell是最稳妥的方式：

use std::io::{self, BufRead, BufReader};
use std::process::{Command, Stdio};

pub struct Shell;

impl Shell {
    pub fn execute(command: &str) -> Result<(String, String), io::Error> {
        #[cfg(unix)]
        let (shell, arg) = ("sh", "-c");
        #[cfg(windows)]
        let (shell, arg) = ("cmd", "/C");

        let mut cmd = Command::new(shell)
            .arg(arg)
            .arg(command)
            .stdout(Stdio::piped())
            .stderr(Stdio::piped())
            .spawn()?;

        // 读取stdout
        let mut stdout_buf = String::new();
        BufReader::new(cmd.stdout.take().unwrap())
            .read_to_string(&mut stdout_buf)?;
        
        // 读取stderr
        let mut stderr_buf = String::new();
        BufReader::new(cmd.stderr.take().unwrap())
            .read_to_string(&mut stderr_buf)?;

        cmd.wait()?;

        Ok((
            stdout_buf.trim_end().to_string(),
            stderr_buf.trim_end().to_string()
        ))
    }
}

方案2：保持交互式shell会话（适合持久场景）

若需要多次执行命令并共享环境，需启动交互式shell（去掉-c//C参数），同时用多线程处理stdout/stderr的并发读取：

use std::io::{self, BufRead, BufReader, Write};
use std::process::{Command, Child, ChildStdin, ChildStdout, ChildStderr};
use std::thread;

pub struct Shell {
    child: Child,
    stdin: ChildStdin,
    stdout: ChildStdout,
    stderr: ChildStderr,
}

impl Shell {
    pub fn new() -> Result<Shell, io::Error> {
        #[cfg(unix)]
        let shell = "sh";
        #[cfg(windows)]
        let shell = "cmd";

        // 启动交互式shell，不传递-c/-C参数
        let mut cmd = Command::new(shell)
            .stdin(Stdio::piped())
            .stdout(Stdio::piped())
            .stderr(Stdio::piped())
            .spawn()?;

        let stdin = cmd.stdin.take().ok_or_else(|| io::Error::new(io::ErrorKind::Other, "Failed to open stdin"))?;
        let stdout = cmd.stdout.take().ok_or_else(|| io::Error::new(io::ErrorKind::Other, "Failed to open stdout"))?;
        let stderr = cmd.stderr.take().ok_or_else(|| io::Error::new(io::ErrorKind::Other, "Failed to open stderr"))?;

        Ok(Shell { child, stdin, stdout, stderr })
    }

    pub fn execute(&mut self, command: &str) -> Result<(String, String), io::Error> {
        // 写入命令并强制刷新缓冲区，确保shell接收
        writeln!(self.stdin, "{}", command)?;
        self.stdin.flush()?;

        // 多线程并发读取stdout和stderr，避免阻塞
        let stdout_clone = self.stdout.try_clone()?;
        let stdout_handle = thread::spawn(move || -> io::Result<String> {
            let mut reader = BufReader::new(stdout_clone);
            let mut buf = String::new();
            // 读取到shell提示符（$或>）时停止，适配交互式输出
            while reader.read_line(&mut buf)? > 0 {
                if buf.ends_with("$ ") || buf.ends_with("> ") {
                    break;
                }
            }
            Ok(buf)
        });

        let stderr_clone = self.stderr.try_clone()?;
        let stderr_handle = thread::spawn(move || -> io::Result<String> {
            let mut reader = BufReader::new(stderr_clone);
            let mut buf = String::new();
            reader.read_to_string(&mut buf)?;
            Ok(buf)
        });

        let mut stdout_buf = stdout_handle.join().unwrap()?;
        let mut stderr_buf = stderr_handle.join().unwrap()?;

        // 移除末尾的shell提示符
        stdout_buf = stdout_buf.trim_end_matches(|c| c == '$' || c == '>' || c == ' ').trim_end().to_string();
        stderr_buf = stderr_buf.trim_end().to_string();

        Ok((stdout_buf, stderr_buf))
    }

    pub fn close(&mut self) -> Result<(), io::Error> {
        writeln!(self.stdin, "exit")?;
        self.stdin.flush()?;
        self.child.wait()?;
        Ok(())
    }
}

关键注意事项 #

• 交互式shell的输出处理需要适配提示符，不同shell的提示符格式可能不同，需根据实际情况调整判断逻辑。
• 必须使用多线程或异步方式同时读取stdout和stderr，否则会出现单向阻塞。
• 写入命令后务必调用flush()，确保stdin缓冲区的数据传递给子进程。

内容的提问来源于stack exchange，提问作者Mario Portilho