Skip to main content

Server

trillium_grpc::server::dispatch

Trait Server 

Source 
pub trait Server: Sized + 'static {
    // Provided methods
    async fn unary<Req, Resp>(
        conn: Conn,
        f: impl AsyncFnOnce(&mut GrpcServerConn<Self>, Req) -> Result<Resp, Status>,
    ) -> Conn
       where Self: Codec<Req> + Codec<Resp>,
             Req: Send + 'static,
             Resp: Send + 'static { ... }
    async fn client_streaming<Resp>(
        conn: Conn,
        f: impl AsyncFnOnce(&mut GrpcServerConn<Self>) -> Result<Resp, Status>,
    ) -> Conn
       where Self: Codec<Resp>,
             Resp: Send + 'static { ... }
    async fn server_streaming<Req, Resp, S>(
        conn: Conn,
        f: impl AsyncFnOnce(&mut GrpcServerConn<Self>, Req) -> Result<S, Status>,
    ) -> Conn
       where Self: Codec<Req> + Codec<Resp>,
             Req: Send + 'static,
             Resp: Send + 'static,
             S: Stream<Item = Result<Resp, Status>> + Send + 'static { ... }
    async fn bidi<Req, Resp, R>(
        conn: Conn,
        prologue: impl AsyncFnOnce(&mut GrpcServerConn<Self>) -> Result<R, Status>,
    ) -> Conn
       where Self: Codec<Req> + Codec<Resp>,
             Req: Send + 'static,
             Resp: Send + 'static,
             R: BidiResponder<Req, Resp> { ... }
}
Available on crate feature server only.
Expand description

Server-side dispatch methods, available on any codec type via a blanket impl. Generated code calls these as Prost::unary(conn, ...) etc.

The three half-duplex methods take the Conn by value and return the finished Conn; the user closure is handed a GrpcServerConn control surface (and, for unary / server-streaming, the decoded request). bidi still takes a trillium::Upgrade — it is driven from Handler::upgrade after the head is flushed.

Provided Methods§

Source

async fn unary<Req, Resp>( conn: Conn, f: impl AsyncFnOnce(&mut GrpcServerConn<Self>, Req) -> Result<Resp, Status>, ) -> Conn
where Self: Codec<Req> + Codec<Resp>, Req: Send + 'static, Resp: Send + 'static,

Unary RPC: read exactly one request, await the user function, emit one response frame followed by grpc-status trailers.

Source

async fn client_streaming<Resp>( conn: Conn, f: impl AsyncFnOnce(&mut GrpcServerConn<Self>) -> Result<Resp, Status>, ) -> Conn
where Self: Codec<Resp>, Resp: Send + 'static,

Client-streaming RPC: hand the user a GrpcServerConn from which they read the request stream (conn.requests::<Req>()); emit the single response frame and grpc-status trailers.

Source

async fn server_streaming<Req, Resp, S>( conn: Conn, f: impl AsyncFnOnce(&mut GrpcServerConn<Self>, Req) -> Result<S, Status>, ) -> Conn
where Self: Codec<Req> + Codec<Resp>, Req: Send + 'static, Resp: Send + 'static, S: Stream<Item = Result<Resp, Status>> + Send + 'static,

Server-streaming RPC: read one request, await the user function for a response Stream, then frame each item lazily into the response body with grpc-status trailers derived from how the stream ended.

Source

async fn bidi<Req, Resp, R>( conn: Conn, prologue: impl AsyncFnOnce(&mut GrpcServerConn<Self>) -> Result<R, Status>, ) -> Conn
where Self: Codec<Req> + Codec<Resp>, Req: Send + 'static, Resp: Send + 'static, R: BidiResponder<Req, Resp>,

Bidirectional-streaming RPC — the run-phase prologue. Hand the user a GrpcServerConn from which they may read early request messages (to decide response headers) and set initial metadata, then return a BidiResponder that drives the read-while-write loop after the head is flushed. Returning Err(Status) rejects before the flush (trailers-only, no upgrade). See crate::server::bidi for the seam mechanics.

Dyn Compatibility§

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety".

Implementors§

Source§

impl<T: Sized + 'static> Server for T