In che modo eseguire lo streaming da un processo?

Question

Credo di capire, in generale, un modo di fare questo:

• Creare un Command
• Usa Stdio::piped() per creare un nuovo paio di uscita flussi
• Configura command.stdout(), e command.stderr()
• Spawn il processo
• Creare un nuovo thread e passare lo stderr e lo stdout ad esso < - ???
• Nel thread remoto, eseguire il polling continuo per l'input e scriverlo nel flusso di output.
• Nel thread principale, attendere il completamento del processo.

Suona bene?

Le mie due domande attuali:

1. C'è un modo più semplice che non comporta un 'filo leggere' per processo?

2. Se non c'è un modo più semplice, Read::read() richiede &mut self; come lo si passa in una discussione remota?

Si prega di fornire esempi specifici di come lo streaming in realtà l'uscita, non solo consigli generici su come farlo ...

Per essere più precisi, ecco the default example of using spawn:

use std::process::Command; 

let mut child = Command::new("/bin/cat") 
         .arg("file.txt") 
         .spawn() 
         .expect("failed to execute child"); 

let ecode = child.wait() 
       .expect("failed to wait on child"); 

assert!(ecode.success()); 

Come può essere modificato l'esempio precedente per trasmettere l'output di child alla console, invece di aspettare solo un codice di uscita?

Answer 1

Accetto volentieri qualsiasi esempio di generazione di un processo di lunga durata e di output in streaming sulla console, con qualunque mezzo.

Sembra che si desidera Stdio::inherit:

use std::process::{Command, Stdio}; 

fn main() { 
    let mut cmd = 
     Command::new("cat") 
     .args(&["/usr/share/dict/web2"]) 
     .stdout(Stdio::inherit()) 
     .stderr(Stdio::inherit()) 
     .spawn() 
     .unwrap(); 

    // It's streaming here 

    let status = cmd.wait(); 
    println!("Exited with status {:?}", status); 
}