process_muxer_core/muxer/source/childout/
mod.rs

1use std::{
2    io::{self, BufReader},
3    path::PathBuf,
4    process::{ChildStderr, ChildStdout},
5    rc::Rc,
6};
7
8use mio::{event::Source, unix::pipe, Interest, Token};
9
10use crate::Pid;
11
12#[derive(Debug, Clone, Copy, PartialEq, Eq)]
13pub enum FdTag {
14    Stderr,
15    Stdout,
16}
17
18#[derive(Debug)]
19pub struct ChildOut {
20    pub pid: Pid,
21    pub prog_path: Rc<PathBuf>,
22    pub tag: FdTag,
23    pub buf: String,
24    pub fd: BufReader<pipe::Receiver>,
25}
26
27impl ChildOut {
28    pub(crate) fn from_pipe<T: Into<pipe::Receiver> + TaggedFd>(
29        value: T,
30        pid: Pid,
31        prog_path: Rc<PathBuf>,
32    ) -> Self {
33        let pipe: pipe::Receiver = value.into();
34        pipe.set_nonblocking(true)
35            .expect("setting nonblocking to succeed");
36        ChildOut {
37            pid,
38            prog_path,
39            tag: T::fdtag(),
40            buf: String::with_capacity(1024),
41            fd: BufReader::with_capacity(8192, pipe),
42        }
43    }
44}
45
46impl Source for ChildOut {
47    fn register(
48        &mut self,
49        registry: &mio::Registry,
50        token: Token,
51        interests: Interest,
52    ) -> io::Result<()> {
53        self.fd.get_mut().register(registry, token, interests)
54    }
55
56    fn reregister(
57        &mut self,
58        registry: &mio::Registry,
59        token: Token,
60        interests: Interest,
61    ) -> io::Result<()> {
62        self.fd.get_mut().reregister(registry, token, interests)
63    }
64
65    fn deregister(&mut self, registry: &mio::Registry) -> io::Result<()> {
66        self.fd.get_mut().deregister(registry)
67    }
68}
69
70pub(crate) trait TaggedFd {
71    fn fdtag() -> FdTag;
72}
73
74impl TaggedFd for ChildStdout {
75    fn fdtag() -> FdTag {
76        FdTag::Stdout
77    }
78}
79
80impl TaggedFd for ChildStderr {
81    fn fdtag() -> FdTag {
82        FdTag::Stderr
83    }
84}