rama-ttrpc 0.4.0

ttRPC (gRPC for low-memory environments) support for rama
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

use rama_core::extensions::ExtensionsRef;
use rama_core::{Service, io::Io};
use rama_net::client::{ConnectionError, ConnectorService, EstablishedClientConnection};

use crate::Client;

/// A rama connector that establishes a transport connection through an inner connector and
/// wraps it in a ttRPC [`Client`], so a client stack yields a ready to use `Client` instead
/// of a raw stream.
#[derive(Debug, Clone, Default)]
pub struct TtrpcConnector<C> {
    inner: C,
}

impl<C> TtrpcConnector<C> {
    /// Wrap an inner (transport) connector so it yields a ttRPC [`Client`].
    pub const fn new(inner: C) -> Self {
        Self { inner }
    }
}

impl<C, Input> Service<Input> for TtrpcConnector<C>
where
    C: ConnectorService<Input, Connection: Io>,
    Input: Send + 'static,
{
    type Output = EstablishedClientConnection<Client, Input>;
    type Error = ConnectionError;

    async fn serve(&self, input: Input) -> Result<Self::Output, Self::Error> {
        let EstablishedClientConnection { input, conn } = self.inner.connect(input).await?;

        let extensions = conn.extensions().clone();
        let client = Client::new_with_extensions(conn, extensions);
        Ok(EstablishedClientConnection {
            input,
            conn: client,
        })
    }
}