Struct Endpoint

pub struct Endpoint(/* private fields */);

IPC endpoint.

Implementations

impl Endpoint

pub fn incoming(self) -> Result<IpcStream>

Stream of incoming connections

Examples found in repository

examples/server.rs (line 8)

async fn run_server(path: String) {
    let endpoint = Endpoint::new(ServerId::new(path), OnConflict::Overwrite).unwrap();

    let incoming = endpoint.incoming().expect("failed to open new socket");
    futures_util::pin_mut!(incoming);

    while let Some(result) = incoming.next().await {
        match result {
            Ok(stream) => {
                let (mut reader, mut writer) = split(stream);

                tokio::spawn(async move {
                    loop {
                        let mut buf = [0u8; 4];

                        if reader.read_exact(&mut buf).await.is_err() {
                            println!("Closing socket");
                            break;
                        }
                        if let Ok("ping") = std::str::from_utf8(&buf[..]) {
                            println!("RECEIVED: PING");
                            writer
                                .write_all(b"pong")
                                .await
                                .expect("unable to write to socket");
                            println!("SEND: PONG");
                        }
                    }
                });
            }
            _ => unreachable!("ideally"),
        }
    }
}

pub fn security_attributes( self, security_attributes: SecurityAttributes, ) -> Self

Set security attributes for the connection

pub fn path(&self) -> &Path

Returns the path of the endpoint.

pub async fn connect<P>(path: P) -> Result<Connection>

where P: IntoIpcPath,

Make new connection using the provided path and running event pool.

Examples found in repository

examples/client.rs (line 10)

async fn main() {
    let path = std::env::args()
        .nth(1)
        .expect("Run it with server path to connect as argument");

    let mut client = Endpoint::connect(ServerId::new(path))
        .await
        .expect("Failed to connect client.");

    loop {
        let mut buf = [0u8; 4];
        println!("SEND: PING");
        client
            .write_all(b"ping")
            .await
            .expect("Unable to write message to client");
        client
            .read_exact(&mut buf[..])
            .await
            .expect("Unable to read buffer");
        if let Ok("pong") = std::str::from_utf8(&buf[..]) {
            println!("RECEIVED: PONG");
        } else {
            break;
        }

        tokio::time::sleep(std::time::Duration::from_secs(2)).await;
    }
}

pub fn new<P>(path: P, on_conflict: OnConflict) -> Result<Self>

where P: IntoIpcPath,

New IPC endpoint at the given path

Examples found in repository

examples/server.rs (line 6)

async fn run_server(path: String) {
    let endpoint = Endpoint::new(ServerId::new(path), OnConflict::Overwrite).unwrap();

    let incoming = endpoint.incoming().expect("failed to open new socket");
    futures_util::pin_mut!(incoming);

    while let Some(result) = incoming.next().await {
        match result {
            Ok(stream) => {
                let (mut reader, mut writer) = split(stream);

                tokio::spawn(async move {
                    loop {
                        let mut buf = [0u8; 4];

                        if reader.read_exact(&mut buf).await.is_err() {
                            println!("Closing socket");
                            break;
                        }
                        if let Ok("ping") = std::str::from_utf8(&buf[..]) {
                            println!("RECEIVED: PING");
                            writer
                                .write_all(b"pong")
                                .await
                                .expect("unable to write to socket");
                            println!("SEND: PONG");
                        }
                    }
                });
            }
            _ => unreachable!("ideally"),
        }
    }
}