volo 0.12.3

Volo is a high-performance and strong-extensibility Rust RPC framework that helps developers build microservices.
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

use futures::Future;
use tokio::io::{self, Interest, Ready};

use super::conn::{OwnedReadHalf, OwnedWriteHalf};
use crate::net::conn::{Conn, ConnStream};

/// Asynchronous extension functions.
pub trait AsyncExt {
    /// Checks for IO readiness.
    ///
    /// See [`tokio::net::TcpStream::ready`] for details.
    fn ready(&self, interest: Interest) -> impl Future<Output = io::Result<Ready>> + Send;

    /// Get helper of ShmIPC.
    #[cfg(feature = "shmipc")]
    fn shmipc_helper(&self) -> super::shmipc::ShmipcHelper {
        super::shmipc::ShmipcHelper::none()
    }
}

impl AsyncExt for Conn {
    async fn ready(&self, interest: Interest) -> io::Result<Ready> {
        match &self.stream {
            ConnStream::Tcp(stream) => stream.ready(interest).await,
            #[cfg(target_family = "unix")]
            ConnStream::Unix(stream) => stream.ready(interest).await,
            #[cfg(feature = "__tls")]
            ConnStream::Tls(_) => Err(io::Error::new(
                io::ErrorKind::Unsupported,
                "AsyncExt is not supported for TLS connection",
            )),
            #[cfg(feature = "shmipc")]
            ConnStream::Shmipc(_) => Err(io::Error::new(
                io::ErrorKind::Unsupported,
                "AsyncExt is not supported for ShmIPC connection",
            )),
        }
    }

    #[cfg(feature = "shmipc")]
    fn shmipc_helper(&self) -> super::shmipc::ShmipcHelper {
        match &self.stream {
            ConnStream::Shmipc(stream) => stream.helper(),
            _ => Default::default(),
        }
    }
}

impl AsyncExt for OwnedReadHalf {
    async fn ready(&self, interest: Interest) -> io::Result<Ready> {
        match self {
            OwnedReadHalf::Tcp(half) => half.ready(interest).await,
            #[cfg(target_family = "unix")]
            OwnedReadHalf::Unix(half) => half.ready(interest).await,
            #[cfg(feature = "__tls")]
            OwnedReadHalf::Tls(_) => Err(io::Error::new(
                io::ErrorKind::Unsupported,
                "AsyncExt is not supported for TLS connection",
            )),
            #[cfg(feature = "shmipc")]
            OwnedReadHalf::Shmipc(_) => Err(io::Error::new(
                io::ErrorKind::Unsupported,
                "AsyncExt is not supported for ShmIPC connection",
            )),
        }
    }

    #[cfg(feature = "shmipc")]
    fn shmipc_helper(&self) -> super::shmipc::ShmipcHelper {
        match self {
            OwnedReadHalf::Shmipc(rh) => rh.helper(),
            _ => Default::default(),
        }
    }
}

impl AsyncExt for OwnedWriteHalf {
    async fn ready(&self, interest: Interest) -> io::Result<Ready> {
        match self {
            OwnedWriteHalf::Tcp(half) => half.ready(interest).await,
            #[cfg(target_family = "unix")]
            OwnedWriteHalf::Unix(half) => half.ready(interest).await,
            #[cfg(feature = "__tls")]
            OwnedWriteHalf::Tls(_) => Err(io::Error::new(
                io::ErrorKind::Unsupported,
                "AsyncExt is not supported for TLS connection",
            )),
            #[cfg(feature = "shmipc")]
            OwnedWriteHalf::Shmipc(_) => Err(io::Error::new(
                io::ErrorKind::Unsupported,
                "AsyncExt is not supported for ShmIPC connection",
            )),
        }
    }

    #[cfg(feature = "shmipc")]
    fn shmipc_helper(&self) -> super::shmipc::ShmipcHelper {
        match self {
            OwnedWriteHalf::Shmipc(wh) => wh.helper(),
            _ => Default::default(),
        }
    }
}