Rust终端模拟器：PTY读取命令输出挂起的问题解决咨询

问题描述 #

我正在用Rust开发终端模拟器，使用portable_pty crate处理PTY交互，尝试捕获PTY内Shell命令的输出时，程序在reader.read_to_string(&mut output)处挂起，无任何内容打印。预期流程：

• 创建新PTY
• 在PTY中启动bash Shell
• 写入dir命令
• 读取并打印输出

已确认dir命令已写入PTY，bash Shell正常启动，但读取操作始终阻塞。

相关代码 #

use portable_pty::{CommandBuilder, PtySize, native_pty_system};
use std::io::Write;
use anyhow::Result;
use anyhow::Error;

pub fn pyt() -> Result<(), Error> {
    // 使用系统原生的PTY实现
    let pty_system = native_pty_system();
    
    // 创建新PTY
    let mut pair = pty_system.openpty(PtySize {
        rows: 24,
        cols: 80,
        pixel_width: 0,
        pixel_height: 0,
    })?;
    
    // 在PTY中启动bash
    let cmd = CommandBuilder::new("bash");
    let child = pair.slave.spawn_command(cmd)?;
    
    // 克隆PTY主设备的读取器
    let mut reader = pair.master.try_clone_reader()?;
    
    // 向PTY写入dir命令
    writeln!(pair.master.take_writer()?, "dir\n")?;

    // 读取PTY输出（此处挂起）
    let mut output = String::new();
    reader.read_to_string(&mut output)?;
    println!("output: {}", output);

    Ok(())
}

问题原因 #

read_to_string是阻塞式读取，它会一直等待直到输入流的EOF。但PTY的主设备流不会自动发送EOF——bash执行完dir后会回到提示符，保持会话活跃，所以读取操作会一直等待永远不会到来的EOF，导致程序挂起。

另外，写入命令后bash可能还未完成输出，但核心原因是read_to_string依赖EOF才能返回。

解决方案 #

方案1：同步非阻塞读取（轮询） #

将读取器设置为非阻塞模式，循环读取直到获取足够输出或超时退出：

use portable_pty::{CommandBuilder, PtySize, native_pty_system};
use std::io::{Write, Read};
use std::os::unix::io::AsRawFd;
use std::time::Duration;
use nix::fcntl::{fcntl, FcntlArg, O_NONBLOCK};
use anyhow::{Result, Error};

pub fn pyt() -> Result<(), Error> {
    let pty_system = native_pty_system();
    let mut pair = pty_system.openpty(PtySize {
        rows: 24,
        cols: 80,
        pixel_width: 0,
        pixel_height: 0,
    })?;

    let cmd = CommandBuilder::new("bash");
    let _child = pair.slave.spawn_command(cmd)?;

    let mut reader = pair.master.try_clone_reader()?;
    let mut writer = pair.master.take_writer()?;

    // 将读取器设置为非阻塞模式
    let fd = reader.as_raw_fd();
    fcntl(fd, FcntlArg::F_SETFL(O_NONBLOCK))?;

    // 写入命令并刷新缓冲区
    writeln!(writer, "dir")?;
    writer.flush()?;

    // 轮询读取输出，直到超时或无更多数据
    let mut output = String::new();
    let start_time = std::time::Instant::now();
    let timeout = Duration::from_secs(1);

    while start_time.elapsed() < timeout {
        let mut buf = [0; 1024];
        match reader.read(&mut buf) {
            Ok(n) if n > 0 => {
                output.push_str(&String::from_utf8_lossy(&buf[..n]));
            }
            Ok(_) => {
                // 无数据，短暂休眠后重试
                std::thread::sleep(Duration::from_millis(100));
            }
            Err(e) if e.kind() == std::io::ErrorKind::WouldBlock => {
                // 非阻塞模式下无数据可用，休眠后重试
                std::thread::sleep(Duration::from_millis(100));
            }
            Err(e) => return Err(e.into()),
        }
    }

    println!("output: {}", output);
    Ok(())
}

方案2：异步IO（tokio） #

结合tokio异步运行时，将PTY句柄包装为异步IO对象处理：

use portable_pty::{CommandBuilder, PtySize, native_pty_system};
use tokio::io::{AsyncReadExt, AsyncWriteExt};
use tokio::net::unix::AsyncFd;
use anyhow::{Result, Error};

#[tokio::main]
pub async fn pyt() -> Result<(), Error> {
    let pty_system = native_pty_system();
    let mut pair = pty_system.openpty(PtySize {
        rows: 24,
        cols: 80,
        pixel_width: 0,
        pixel_height: 0,
    })?;

    let cmd = CommandBuilder::new("bash");
    let _child = pair.slave.spawn_command(cmd)?;

    // 将PTY主设备的读写端转换为异步句柄
    let master_fd = pair.master.as_raw_fd();
    let mut async_fd = AsyncFd::new(master_fd)?;

    // 写入命令
    let mut writer = pair.master.take_writer()?;
    writeln!(writer, "dir")?;
    writer.flush()?;

    // 异步读取输出，检测到Shell提示符则停止
    let mut output = String::new();
    let mut buf = [0; 1024];

    loop {
        let mut guard = async_fd.readable().await?;
        match guard.try_io(|inner| inner.read(&mut buf)) {
            Ok(Ok(n)) if n > 0 => {
                output.push_str(&String::from_utf8_lossy(&buf[..n]));
                // 简单判断：输出包含bash提示符则停止读取
                if output.contains("$ ") {
                    break;
                }
            }
            Ok(Ok(_)) => break,
            Ok(Err(e)) if e.kind() == std::io::ErrorKind::WouldBlock => continue,
            Ok(Err(e)) => return Err(e.into()),
            Err(_) => break,
        }
    }

    println!("output: {}", output);
    Ok(())
}

额外提示 #

• 终端模拟器场景通常需要持续处理输入输出，异步IO是更合适的选择
• 可以通过检测Shell提示符（如$、#）判断命令执行完成，避免依赖超时
• 写入命令后必须调用flush()，确保数据被发送到PTY

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