trapeze 0.4.0

A rust implementation of ttrpc
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

use std::future::poll_fn;
use std::io::Result as IoResult;
use std::os::unix::net::{
    SocketAddr, UnixListener as StdUnixListener, UnixStream as StdUnixStream,
};

use async_trait::async_trait;
use tokio::net::{UnixListener, UnixStream};

pub struct Listener {
    inner: UnixListener,
    addr: String,
}

#[async_trait]
impl super::Listener for Listener {
    async fn accept(&mut self) -> IoResult<Box<dyn super::Connection>> {
        let (conn, _) = self.inner.accept().await?;
        Ok(Box::new(conn))
    }
}

pub fn bind(addr: impl AsRef<str>) -> IoResult<Listener> {
    let addr: String = addr.as_ref().into();
    let inner = {
        let addr = make_socket_addr(&addr)?;
        let inner = StdUnixListener::bind_addr(&addr)?;
        inner.set_nonblocking(true)?;
        UnixListener::from_std(inner)?
    };

    Ok(Listener { inner, addr })
}

pub async fn connect(addr: impl AsRef<str>) -> IoResult<UnixStream> {
    let addr = make_socket_addr(addr.as_ref())?;
    let inner = StdUnixStream::connect_addr(&addr)?;
    inner.set_nonblocking(true)?;
    let inner = UnixStream::from_std(inner)?;
    poll_fn(|cx| inner.poll_write_ready(cx)).await?;
    Ok(inner)
}

impl Drop for Listener {
    fn drop(&mut self) {
        cleanup_socket(&self.addr);
    }
}

fn make_socket_addr(addr: &str) -> IoResult<SocketAddr> {
    #[cfg(any(target_os = "linux", target_os = "android"))]
    if let Some(name) = addr.strip_prefix('@') {
        use std::os::linux::net::SocketAddrExt;
        return SocketAddr::from_abstract_name(name);
    }
    SocketAddr::from_pathname(addr)
}

fn cleanup_socket(addr: &str) {
    #[cfg(any(target_os = "linux", target_os = "android"))]
    if addr.strip_prefix('@').is_some() {
        return;
    }
    let _ = std::fs::remove_file(addr);
}