Struct tonic::transport::server::Router

pub struct Router<L = Identity> { /* private fields */ }

A stack based Service router.

Implementations

impl<L> Router<L>

pub fn add_service<S>(self, svc: S) -> Self

where S: Service<Request<BoxBody>, Response = Response<BoxBody>, Error = Infallible> + NamedService + Clone + Send + 'static, S::Future: Send + 'static,

Add a new service to this router.

pub fn add_optional_service<S>(self, svc: Option<S>) -> Self

where S: Service<Request<BoxBody>, Response = Response<BoxBody>, Error = Infallible> + NamedService + Clone + Send + 'static, S::Future: Send + 'static,

Add a new optional service to this router.

Note

Even when the argument given is None this will capture all requests to this service name. As a result, one cannot use this to toggle between two identically named implementations.

pub fn into_router(self) -> Router

👎Deprecated since 0.12.2: Use Routes::into_axum_router instead.

Convert this tonic Router into an axum Router consuming the tonic one.

pub async fn serve<ResBody>(self, addr: SocketAddr) -> Result<(), Error>

where L: Layer<Routes> + Clone, L::Service: Service<Request<BoxBody>, Response = Response<ResBody>> + Clone + Send + 'static, <<L as Layer<Routes>>::Service as Service<Request<BoxBody>>>::Future: Send + 'static, <<L as Layer<Routes>>::Service as Service<Request<BoxBody>>>::Error: Into<Box<dyn Error + Send + Sync>> + Send, ResBody: Body<Data = Bytes> + Send + 'static, ResBody::Error: Into<Box<dyn Error + Send + Sync>>,

Consume this Server creating a future that will execute the server on tokio’s default executor.

pub async fn serve_with_shutdown<F: Future<Output = ()>, ResBody>( self, addr: SocketAddr, signal: F, ) -> Result<(), Error>

where L: Layer<Routes>, L::Service: Service<Request<BoxBody>, Response = Response<ResBody>> + Clone + Send + 'static, <<L as Layer<Routes>>::Service as Service<Request<BoxBody>>>::Future: Send + 'static, <<L as Layer<Routes>>::Service as Service<Request<BoxBody>>>::Error: Into<Box<dyn Error + Send + Sync>> + Send, ResBody: Body<Data = Bytes> + Send + 'static, ResBody::Error: Into<Box<dyn Error + Send + Sync>>,

Consume this Server creating a future that will execute the server on tokio’s default executor. And shutdown when the provided signal is received.

pub async fn serve_with_incoming<I, IO, IE, ResBody>( self, incoming: I, ) -> Result<(), Error>

where I: Stream<Item = Result<IO, IE>>, IO: AsyncRead + AsyncWrite + Connected + Unpin + Send + 'static, IO::ConnectInfo: Clone + Send + Sync + 'static, IE: Into<Box<dyn Error + Send + Sync>>, L: Layer<Routes>, L::Service: Service<Request<BoxBody>, Response = Response<ResBody>> + Clone + Send + 'static, <<L as Layer<Routes>>::Service as Service<Request<BoxBody>>>::Future: Send + 'static, <<L as Layer<Routes>>::Service as Service<Request<BoxBody>>>::Error: Into<Box<dyn Error + Send + Sync>> + Send, ResBody: Body<Data = Bytes> + Send + 'static, ResBody::Error: Into<Box<dyn Error + Send + Sync>>,

Consume this Server creating a future that will execute the server on the provided incoming stream of AsyncRead + AsyncWrite.

This method discards any provided Server TCP configuration.

pub async fn serve_with_incoming_shutdown<I, IO, IE, F, ResBody>( self, incoming: I, signal: F, ) -> Result<(), Error>

where I: Stream<Item = Result<IO, IE>>, IO: AsyncRead + AsyncWrite + Connected + Unpin + Send + 'static, IO::ConnectInfo: Clone + Send + Sync + 'static, IE: Into<Box<dyn Error + Send + Sync>>, F: Future<Output = ()>, L: Layer<Routes>, L::Service: Service<Request<BoxBody>, Response = Response<ResBody>> + Clone + Send + 'static, <<L as Layer<Routes>>::Service as Service<Request<BoxBody>>>::Future: Send + 'static, <<L as Layer<Routes>>::Service as Service<Request<BoxBody>>>::Error: Into<Box<dyn Error + Send + Sync>> + Send, ResBody: Body<Data = Bytes> + Send + 'static, ResBody::Error: Into<Box<dyn Error + Send + Sync>>,

Consume this Server creating a future that will execute the server on the provided incoming stream of AsyncRead + AsyncWrite. Similar to serve_with_shutdown this method will also take a signal future to gracefully shutdown the server.

This method discards any provided Server TCP configuration.

pub fn into_service<ResBody>(self) -> L::Service

where L: Layer<Routes>, L::Service: Service<Request<BoxBody>, Response = Response<ResBody>> + Clone + Send + 'static, <<L as Layer<Routes>>::Service as Service<Request<BoxBody>>>::Future: Send + 'static, <<L as Layer<Routes>>::Service as Service<Request<BoxBody>>>::Error: Into<Box<dyn Error + Send + Sync>> + Send, ResBody: Body<Data = Bytes> + Send + 'static, ResBody::Error: Into<Box<dyn Error + Send + Sync>>,

Create a tower service out of a router.

Trait Implementations

impl<L: Debug> Debug for Router<L>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.