Struct tonic::transport::server::Router[−][src]

pub struct Router<A, B> { /* fields omitted */ }
This is supported on crate feature transport only.

A stack based Service router.

Implementations

impl<A, B> Router<A, B> where
    A: Service<Request<Body>, Response = Response<BoxBody>> + Clone + Send + 'static,
    A::Future: Send + 'static,
    A::Error: Into<Box<dyn Error + Send + Sync>> + Send,
    B: Service<Request<Body>, Response = Response<BoxBody>> + Clone + Send + 'static,
    B::Future: Send + 'static,
    B::Error: Into<Box<dyn Error + Send + Sync>> + Send, [src]

pub fn add_service<S>(self, svc: S) -> Router<S, Or<A, B, Request<Body>>> where
    S: Service<Request<Body>, Response = Response<BoxBody>> + NamedService + Clone + Send + 'static,
    S::Future: Send + 'static,
    S::Error: Into<Box<dyn Error + Send + Sync>> + Send, [src]

Add a new service to this router.

pub fn add_optional_service<S>(
    self,
    svc: Option<S>
) -> Router<Either<S, Unimplemented>, Or<A, B, Request<Body>>> where
    S: Service<Request<Body>, Response = Response<BoxBody>> + NamedService + Clone + Send + 'static,
    S::Future: Send + 'static,
    S::Error: Into<Box<dyn Error + Send + Sync>> + Send, [src]

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 async fn serve(self, addr: SocketAddr) -> Result<(), Error>[src]

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 = ()>>(
    self,
    addr: SocketAddr,
    signal: F
) -> Result<(), Error>[src]

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>(
    self,
    incoming: I
) -> Result<(), Error> where
    I: Stream<Item = Result<IO, IE>>,
    IO: AsyncRead + AsyncWrite + Connected + Unpin + Send + 'static,
    IE: Into<Box<dyn Error + Send + Sync>>, [src]

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

pub async fn serve_with_incoming_shutdown<I, IO, IE, F>(
    self,
    incoming: I,
    signal: F
) -> Result<(), Error> where
    I: Stream<Item = Result<IO, IE>>,
    IO: AsyncRead + AsyncWrite + Connected + Unpin + Send + 'static,
    IE: Into<Box<dyn Error + Send + Sync>>,
    F: Future<Output = ()>, [src]

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.

pub fn into_service(self) -> RouterService<A, B>[src]

Create a tower service out of a router.

Trait Implementations

impl<A: Debug, B: Debug> Debug for Router<A, B>[src]

Auto Trait Implementations

impl<A, B> !RefUnwindSafe for Router<A, B>

impl<A, B> Send for Router<A, B> where
    A: Send,
    B: Send, 

impl<A, B> Sync for Router<A, B> where
    A: Sync,
    B: Sync, 

impl<A, B> Unpin for Router<A, B> where
    A: Unpin,
    B: Unpin, 

impl<A, B> !UnwindSafe for Router<A, B>

Blanket Implementations

impl<T> Any for T where
    T: 'static + ?Sized, [src]

impl<T> Borrow<T> for T where
    T: ?Sized, [src]

impl<T> BorrowMut<T> for T where
    T: ?Sized, [src]

impl<T> From<T> for T[src]

impl<T> Instrument for T[src]

impl<T> Instrument for T[src]

impl<T, U> Into<U> for T where
    U: From<T>, [src]

impl<T, U> TryFrom<U> for T where
    U: Into<T>, [src]

type Error = Infallible

The type returned in the event of a conversion error.

impl<T, U> TryInto<U> for T where
    U: TryFrom<T>, [src]

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.

impl<V, T> VZip<V> for T where
    V: MultiLane<T>, 

impl<T> WithSubscriber for T[src]