Read Stdout and Stderr parallel and kill process on timeout - multithreading

Question

I need to interact with a another process.
I want to use thread two threads, one for reading in stdout and one for reading on stderr, these threads pass every line the read to a channel.
The main thread collects the lines and checks for a timeout, if a timeout occurs the process should be killed.
My Problem is how to share the std-out/err handles and be still able to kill the process later if a timeout occurs.
let mut stdout = process.stdout.unwrap();
let (tx_stdout, rx_stdout): (Sender<Result<Vec<u8>, ExecutionError>>, Receiver<Result<Vec<u8>, ExecutionError>>) = mpsc::channel();
std::thread::spawn(move || {
PowerShell::read_lines(&tx_stdout, stdout);
});
let mut stderr = process.stderr.unwrap();
let (tx_stderr, rx_stderr): (Sender<Result<Vec<u8>, ExecutionError>>, Receiver<Result<Vec<u8>, ExecutionError>>) = mpsc::channel();
std::thread::spawn(move || {
PowerShell::read_lines(&tx_stderr, &mut stderr);
});
process.kill(); // this is not possible
I understand why compiler has a problem with that, but I don't know how to solve the problem.
Using Arc causes the same issue properly.
Do you have some suggestions for me?

Answer 1

First of all, two things which are rather helpful and useful when asking for Rust help is to set up a reduced test case (if possible) and post it on https://play.rust-lang.org, and read and post compilation errors.
Here a reduced test case would be this:
use std::process::{Command, Stdio};
fn main() {
let mut process = Command::new("echo")
.stdout(Stdio::piped())
.stderr(Stdio::piped())
.spawn().expect("Failed to start echo process");
let stdout = process.stdout.unwrap();
std::thread::spawn(move || {
drop(stdout);
});
let stderr = process.stderr.unwrap();
std::thread::spawn(move || {
drop(stderr);
});
process.kill(); // this is not possible
}
and the compilation error is
error[E0382]: borrow of partially moved value: `process`
--> src/lib.rs:19:4
|
14 | let stderr = process.stderr.unwrap();
| -------- `process.stderr` partially moved due to this method call
...
19 | process.kill(); // this is not possible
| ^^^^^^^ value borrowed here after partial move
|
note: this function consumes the receiver `self` by taking ownership of it, which moves `process.stderr`
which is rather clear: process.stderr is an Option, Option::unwrap has the following signature:
pub fn unwrap(self) -> T
meaning it takes its subject by value. Meaning after the two unwrap calls the process object is not valid anymore: it's been stripped for parts. Some of the parts are still available, but methods can only be called when the object is known to be valid which is not the case here.
Hence the "partially moved" compilation error, you can't strip something for parts and still use it as-is. Well maybe you can depending on the parts, but Rust doesn't express partial dependencies so the compiler has to assume Child::kill needs the child alive and well, not just some of the bits.
There are various possibilities depending on the exact situation: in some cases you can Copy or Clone the bits you want out, or maybe you can use scoped threads to borrow them. None of these are possible here, but there is still a possibility: Option::take lets you take the content of an option, and replace it with a None. So here you could move the ChildStd* out of the structure *while leaving the structure intact`, that just requires the ability to modify the structure:
use std::process::{Command, Stdio};
fn main() {
let mut process = Command::new("echo")
.stdout(Stdio::piped())
.stderr(Stdio::piped())
.spawn().expect("Failed to start echo process");
let stdout = process.stdout.take().unwrap();
std::thread::spawn(move || {
drop(stdout);
});
let stderr = process.stderr.take().unwrap();
std::thread::spawn(move || {
drop(stderr);
});
process.kill(); // this is not possible
}