runact 1.3.3

A Rust-native actor runtime with BEAM-style processes
Documentation
use crate::net::reactor::{Interest, Reactor};
use std::io::{Read, Write};
use std::net::{
    SocketAddr, TcpListener as StdTcpListener, TcpStream as StdTcpStream, ToSocketAddrs,
};
use std::os::unix::io::AsRawFd;
use std::sync::{Arc, Mutex};
use std::time::Duration;

pub struct TcpListener {
    inner: StdTcpListener,
    reactor: Arc<Mutex<Reactor>>,
}

impl TcpListener {
    pub fn bind<A: ToSocketAddrs>(addr: A) -> std::io::Result<Self> {
        let inner = StdTcpListener::bind(addr)?;
        inner.set_nonblocking(true)?;
        let reactor = Arc::new(Mutex::new(Reactor::new()?));
        let fd = inner.as_raw_fd();
        {
            let mut r = reactor.lock().unwrap();
            r.register(fd, Interest::READABLE)?;
        }
        Ok(Self { inner, reactor })
    }

    pub fn accept(&self) -> std::io::Result<TcpStream> {
        loop {
            match self.inner.accept() {
                Ok((stream, _addr)) => {
                    stream.set_nonblocking(true)?;
                    let fd = stream.as_raw_fd();
                    {
                        let mut r = self.reactor.lock().unwrap();
                        r.register(fd, Interest::READABLE | Interest::WRITABLE)?;
                    }
                    return Ok(TcpStream {
                        inner: stream,
                        reactor: Arc::clone(&self.reactor),
                    });
                }
                Err(ref e) if e.kind() == std::io::ErrorKind::WouldBlock => {
                    std::thread::sleep(Duration::from_millis(1));
                    continue;
                }
                Err(e) => return Err(e),
            }
        }
    }

    pub fn local_addr(&self) -> std::io::Result<SocketAddr> {
        self.inner.local_addr()
    }
}

impl Drop for TcpListener {
    fn drop(&mut self) {
        let fd = self.inner.as_raw_fd();
        let _ = self.reactor.lock().unwrap().unregister(fd);
    }
}

pub struct TcpStream {
    inner: StdTcpStream,
    reactor: Arc<Mutex<Reactor>>,
}

impl TcpStream {
    pub fn connect<A: ToSocketAddrs>(addr: A) -> std::io::Result<Self> {
        let stream = StdTcpStream::connect(&addr)?;
        stream.set_nonblocking(true)?;
        let reactor = Arc::new(Mutex::new(Reactor::new()?));
        let fd = stream.as_raw_fd();
        {
            let mut r = reactor.lock().unwrap();
            r.register(fd, Interest::READABLE | Interest::WRITABLE)?;
        }
        Ok(Self {
            inner: stream,
            reactor,
        })
    }

    pub fn write_all(&mut self, buf: &[u8]) -> std::io::Result<()> {
        self.inner.write_all(buf)
    }

    pub fn flush(&mut self) -> std::io::Result<()> {
        self.inner.flush()
    }

    pub fn read(&mut self, buf: &mut [u8]) -> std::io::Result<usize> {
        match self.inner.read(buf) {
            Ok(n) => Ok(n),
            Err(ref e)
                if e.kind() == std::io::ErrorKind::WouldBlock
                    || e.kind() == std::io::ErrorKind::ConnectionReset =>
            {
                Ok(0)
            }
            Err(e) => Err(e),
        }
    }

    pub fn read_exact(&mut self, buf: &mut [u8]) -> std::io::Result<()> {
        let mut pos = 0;
        while pos < buf.len() {
            match self.inner.read(&mut buf[pos..]) {
                Ok(n) => pos += n,
                Err(ref e) if e.kind() == std::io::ErrorKind::WouldBlock => {
                    std::thread::sleep(Duration::from_millis(1));
                    continue;
                }
                Err(e) => return Err(e),
            }
        }
        Ok(())
    }

    pub fn read_to_end(&mut self, buf: &mut Vec<u8>) -> std::io::Result<usize> {
        let mut total = 0;
        let mut tmp = [0u8; 4096];
        let mut consecutive_would_blocks = 0;
        loop {
            match self.inner.read(&mut tmp) {
                Ok(0) => return Ok(total),
                Ok(n) => {
                    buf.extend_from_slice(&tmp[..n]);
                    total += n;
                    consecutive_would_blocks = 0;
                }
                Err(ref e) if e.kind() == std::io::ErrorKind::WouldBlock => {
                    consecutive_would_blocks += 1;
                    if total > 0 && consecutive_would_blocks > 200 {
                        return Ok(total);
                    }
                    if consecutive_would_blocks > 1000 {
                        return Ok(total);
                    }
                    std::thread::sleep(Duration::from_millis(1));
                    continue;
                }
                Err(ref e) if e.kind() == std::io::ErrorKind::ConnectionReset => {
                    return Ok(total);
                }
                Err(e) => return Err(e),
            }
        }
    }

    pub fn shutdown(&self, how: std::net::Shutdown) -> std::io::Result<()> {
        self.inner.shutdown(how)
    }
}

impl Drop for TcpStream {
    fn drop(&mut self) {
        let fd = self.inner.as_raw_fd();
        let _ = self.reactor.lock().unwrap().unregister(fd);
    }
}