shellflip 2.1.2

Graceful process restarts in Rust
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106

use libc::c_int;
use std::fs::File;
use std::io::{self, Read, Write};
use std::os::fd::{AsRawFd, FromRawFd};

pub(crate) enum PipeMode {
    ParentWrites,
    ChildWrites,
}

/// Create a pair of pipes.
/// The first element is the read side, and the second element is the write side.
/// `mode` determines whether the read or write end will be inherited by the child.
pub(crate) fn create_paired_pipes(mode: PipeMode) -> io::Result<(File, File)> {
    let mut fds: [c_int; 2] = [0; 2];
    let res = unsafe { libc::pipe(fds.as_mut_ptr()) };
    if res != 0 {
        return Err(io::Error::last_os_error());
    }

    match mode {
        PipeMode::ParentWrites => {
            set_cloexec(fds[1])?;
        }
        PipeMode::ChildWrites => {
            set_cloexec(fds[0])?;
        }
    };

    let reader = unsafe { File::from_raw_fd(fds[0]) };
    let writer = unsafe { File::from_raw_fd(fds[1]) };

    Ok((reader, writer))
}

fn set_cloexec(fd: c_int) -> io::Result<()> {
    let res = unsafe { libc::fcntl(fd, libc::F_SETFD, libc::FD_CLOEXEC) };
    if res != 0 {
        return Err(io::Error::last_os_error());
    }
    Ok(())
}

pub(crate) fn completion_pipes() -> io::Result<(CompletionReceiver, CompletionSender)> {
    let (reader, writer) = create_paired_pipes(PipeMode::ChildWrites)?;

    let reader = CompletionReceiver(reader);
    let writer = CompletionSender(writer);

    Ok((reader, writer))
}

pub(crate) struct CompletionReceiver(File);

impl CompletionReceiver {
    pub(crate) fn recv(&mut self) -> io::Result<()> {
        let mut buf = [0u8; 1];

        if self.0.read(&mut buf)? != 1 {
            Err(io::Error::new(
                io::ErrorKind::Other,
                "child failed to notify parent",
            ))
        } else {
            Ok(())
        }
    }
}

pub(crate) struct CompletionSender(pub(crate) File);

impl CompletionSender {
    pub(crate) fn send(&mut self) -> io::Result<()> {
        if self.0.write(b"1")? != 1 {
            Err(io::Error::new(
                io::ErrorKind::Other,
                "failed to signal parent to close",
            ))
        } else {
            Ok(())
        }
    }
}

pub(crate) trait FdStringExt {
    fn fd_string(&self) -> String;
    unsafe fn from_fd_string(fd_str: &str) -> io::Result<Self>
    where
        Self: Sized;
}

impl<T: AsRawFd + FromRawFd> FdStringExt for T {
    unsafe fn from_fd_string(fd_str: &str) -> io::Result<Self> {
        match fd_str.parse() {
            Ok(fd) => Ok(Self::from_raw_fd(fd)),
            Err(_) => Err(io::Error::new(
                io::ErrorKind::InvalidInput,
                "invalid notify socket fd",
            )),
        }
    }

    fn fd_string(&self) -> String {
        self.as_raw_fd().to_string()
    }
}