sib 0.0.17

A high-performance, secure, and cross-platform modules optimized for efficiency, scalability, and reliability.
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
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123

#[derive(Debug, Clone)]
pub struct WTConfig {
    pub keep_alive_interval: std::time::Duration,
    pub num_of_shards: usize,
    pub max_sessions: usize,
}

impl Default for WTConfig {
    fn default() -> Self {
        Self {
            keep_alive_interval: std::time::Duration::from_secs(3),
            num_of_shards: 1,
            max_sessions: 1024,
        }
    }
}

pub struct WtSession {
    conn: wtransport::connection::Connection,
}

pub struct WtReadStream {
    recv: wtransport::RecvStream,
}

impl WtReadStream {
    /// Read data from the stream.
    pub async fn read(&mut self, buf: &mut bytes::BytesMut) -> std::io::Result<usize> {
        match self.recv.read(buf).await {
            Ok(Some(n)) => Ok(n),
            Ok(None) => Ok(0), // EOF reached, return 0 bytes read
            Err(e) => Err(std::io::Error::new(
                std::io::ErrorKind::Other,
                format!("wt recv read: {e}"),
            )),
        }
    }
}

pub struct WtWriteStream {
    send: wtransport::SendStream,
}

impl WtWriteStream {
    /// Write data to the stream.
    pub async fn write(&mut self, buf: &bytes::Bytes) -> std::io::Result<usize> {
        self.send.write(buf).await.map_err(|e| {
            std::io::Error::new(std::io::ErrorKind::Other, format!("wt send write: {e}"))
        })
    }

    /// Gracefully finish the stream.
    pub async fn finish(&mut self) -> std::io::Result<()> {
        self.send.finish().await.map_err(|e| {
            std::io::Error::new(std::io::ErrorKind::Other, format!("wt send finish: {e}"))
        })
    }
}

impl WtSession {
    pub fn new(conn: wtransport::connection::Connection) -> Self {
        Self { conn }
    }

    /// Accept a bidi stream
    pub async fn accept_bi(&self) -> std::io::Result<(WtWriteStream, WtReadStream)> {
        self.conn
            .accept_bi()
            .await
            .map(|(send, recv)| (WtWriteStream { send }, WtReadStream { recv }))
            .map_err(|e| {
                std::io::Error::new(std::io::ErrorKind::Other, format!("wt accept_bi: {e}"))
            })
    }

    /// Accept a unidirectional stream (from client).
    pub async fn accept_uni(&self) -> std::io::Result<WtReadStream> {
        self.conn
            .accept_uni()
            .await
            .map(|recv| WtReadStream { recv })
            .map_err(|e| {
                std::io::Error::new(std::io::ErrorKind::Other, format!("wt accept_uni: {e}"))
            })
    }

    /// Receive a datagram.
    pub async fn recv_dgram(&self) -> std::io::Result<bytes::Bytes> {
        let datagram = self.conn.receive_datagram().await.map_err(|e| {
            std::io::Error::new(std::io::ErrorKind::Other, format!("wt recv_dgram: {e}"))
        })?;
        Ok(bytes::Bytes::from(datagram.to_vec()))
    }

    /// Open a server->client unidirectional stream.
    pub async fn open_uni(&self) -> std::io::Result<WtWriteStream> {
        let opening = self.conn.open_uni().await.map_err(|e| {
            std::io::Error::new(std::io::ErrorKind::Other, format!("wt open_uni: {e}"))
        })?;
        opening
            .await
            .map(|send| WtWriteStream { send })
            .map_err(|e| {
                std::io::Error::new(
                    std::io::ErrorKind::Other,
                    format!("wt open_uni (send stream): {e}"),
                )
            })
    }

    /// Send a datagram.
    pub fn send_dgram(&self, bytes: &bytes::Bytes) -> std::io::Result<()> {
        self.conn.send_datagram(bytes).map_err(|e| {
            std::io::Error::new(std::io::ErrorKind::Other, format!("wt send_dgram: {e}"))
        })
    }
}

#[cfg(feature = "net-wt-server")]
#[async_trait::async_trait(?Send)]
pub trait WtService: Send {
    async fn call<W: WtSession>(&mut self, session: &mut W) -> std::io::Result<()>;
}