45 lines
1.5 KiB
Rust
45 lines
1.5 KiB
Rust
use std::io::{self, Read, Write};
|
|
use std::sync::Mutex;
|
|
use std::{mem, process};
|
|
|
|
pub struct SharedChild {
|
|
child: process::Child,
|
|
stdin: Mutex<process::ChildStdin>,
|
|
stdout: Mutex<process::ChildStdout>,
|
|
}
|
|
impl SharedChild {
|
|
pub fn new(cmd: &mut process::Command) -> io::Result<Self> {
|
|
let mut child = cmd.stdin(process::Stdio::piped()).stdout(process::Stdio::piped()).spawn()?;
|
|
let stdin = Mutex::new(child.stdin.take().expect("Piped stdin above"));
|
|
let stdout = Mutex::new(child.stdout.take().expect("Piped stdout above"));
|
|
Ok(Self { stdin, stdout, child })
|
|
}
|
|
|
|
pub fn send_msg(&self, msg: &[u8]) -> io::Result<()> {
|
|
send_msg(&mut *self.stdin.lock().unwrap(), msg)
|
|
}
|
|
|
|
pub fn recv_msg(&self) -> io::Result<Vec<u8>> { recv_msg(&mut *self.stdout.lock().unwrap()) }
|
|
}
|
|
impl Drop for SharedChild {
|
|
fn drop(&mut self) { mem::drop(self.child.kill()) }
|
|
}
|
|
|
|
pub fn send_msg(write: &mut impl Write, msg: &[u8]) -> io::Result<()> {
|
|
write.write_all(&(u32::try_from(msg.len()).unwrap()).to_be_bytes())?;
|
|
write.write_all(msg)?;
|
|
write.flush()
|
|
}
|
|
|
|
pub fn recv_msg(read: &mut impl Read) -> io::Result<Vec<u8>> {
|
|
let mut len = [0u8; 4];
|
|
read.read_exact(&mut len)?;
|
|
let len = u32::from_be_bytes(len);
|
|
let mut msg = vec![0u8; len as usize];
|
|
read.read_exact(&mut msg)?;
|
|
Ok(msg)
|
|
}
|
|
|
|
pub fn send_parent_msg(msg: &[u8]) -> io::Result<()> { send_msg(&mut io::stdout().lock(), msg) }
|
|
pub fn recv_parent_msg() -> io::Result<Vec<u8>> { recv_msg(&mut io::stdin().lock()) }
|