dope-runtime 0.15.0

The manifold runtime
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

use std::{io, mem, os::fd};

use dope_core::platform::wake;

mod sealed;

pub(super) use sealed::Descriptor;

#[repr(transparent)]
pub(crate) struct Wait(fd::OwnedFd);

#[repr(transparent)]
pub(crate) struct Notify(fd::OwnedFd);

pub(crate) struct Ends<R> {
    read: R,
    notify: Notify,
}

impl Ends<Wait> {
    pub(crate) fn blocking() -> io::Result<Self> {
        let (read, write) = wake::Pair::blocking()?.split();
        Ok(Self {
            read: Wait(read),
            notify: Notify(write),
        })
    }
}

impl Ends<fd::OwnedFd> {
    pub(crate) fn event() -> io::Result<Self> {
        let (read, write) = wake::Pair::nonblocking()?.split();
        Ok(Self {
            read,
            notify: Notify(write),
        })
    }
}

impl<R> Ends<R> {
    pub(crate) fn split(self) -> (R, Notify) {
        (self.read, self.notify)
    }
}

impl Wait {
    pub(crate) fn wait(self) -> io::Result<()> {
        let descriptor = Descriptor::new(fd::AsFd::as_fd(&self.0));
        let mut byte = 0u8;
        loop {
            match descriptor.read(&mut byte) {
                1 => return Ok(()),
                -1 => {
                    let error = io::Error::last_os_error();
                    if error.kind() != io::ErrorKind::Interrupted {
                        return Err(error);
                    }
                }
                _ => return Err(io::Error::from(io::ErrorKind::UnexpectedEof)),
            }
        }
    }
}

impl Notify {
    pub(crate) fn notify(self) -> io::Result<()> {
        let descriptor = Descriptor::new(fd::AsFd::as_fd(&self.0));
        let byte = 1u8;
        loop {
            match descriptor.write(&byte) {
                1 => return Ok(()),
                -1 => {
                    let error = io::Error::last_os_error();
                    if error.kind() != io::ErrorKind::Interrupted {
                        return Err(error);
                    }
                }
                _ => return Err(io::Error::from(io::ErrorKind::WriteZero)),
            }
        }
    }

    pub(crate) fn fork(self) -> io::Result<(Self, Self)> {
        let guard = self.0.try_clone()?;
        Ok((Self(guard), self))
    }
}

const _: () = {
    assert!(mem::size_of::<Wait>() == mem::size_of::<fd::OwnedFd>());
    assert!(mem::align_of::<Wait>() == mem::align_of::<fd::OwnedFd>());
    assert!(mem::size_of::<Notify>() == mem::size_of::<fd::OwnedFd>());
    assert!(mem::align_of::<Notify>() == mem::align_of::<fd::OwnedFd>());
};