trapeze 0.3.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

use std::ffi::OsString;
use std::io::Result as IoResult;
use std::mem::replace;
use std::time::Duration;

use async_trait::async_trait;
use tokio::net::windows::named_pipe::{
    ClientOptions, NamedPipeClient, NamedPipeServer, ServerOptions,
};
use tokio::time::sleep;
use windows_sys::Win32::Foundation::ERROR_PIPE_BUSY;

pub struct Listener {
    inner: NamedPipeServer,
    name: OsString,
}

#[async_trait]
impl super::Listener for Listener {
    async fn accept(&mut self) -> IoResult<Box<dyn super::Connection>> {
        self.inner.connect().await?;

        let server = replace(&mut self.inner, ServerOptions::new().create(&self.name)?);

        Ok(Box::new(server))
    }
}

pub async fn bind(name: impl AsRef<str>) -> IoResult<Listener> {
    let name = name.as_ref().into();
    let inner = ServerOptions::new()
        .first_pipe_instance(true)
        .create(&name)?;

    Ok(Listener { name, inner })
}

pub async fn connect(name: impl AsRef<str>) -> IoResult<NamedPipeClient> {
    let name = name.as_ref();
    let client = loop {
        match ClientOptions::new().open(name) {
            Ok(client) => break client,
            Err(e) if e.raw_os_error() == Some(ERROR_PIPE_BUSY as i32) => (),
            Err(e) => return Err(e),
        }
        sleep(Duration::from_millis(50)).await;
    };
    Ok(client)
}