Struct GrpcTimeout 

pub struct GrpcTimeout<S> { /* private fields */ }

A Service that bounds how long the inner service has to answer a gRPC request.

A gRPC client states its deadline in the grpc-timeout request header. Enforcing it server-side means a request the caller has already given up on stops consuming resources, rather than running to completion so its response can be discarded.

A request without the header, or with a header that doesn’t parse, is passed through with no deadline. Silently ignoring a malformed value is what the gRPC specification calls for: a deadline the server can’t read is not grounds for rejecting the request.

An expired deadline is answered with DEADLINE_EXCEEDED, which is the code the specification assigns to it. Note that tonic’s own timeout middleware answers with CANCELLED instead, an artifact of how it routes the expiry through its generic error handling.

Missing

There is no server-side maximum to bound a client that asks for an unreasonably long deadline, because nothing here needs one yet. Adding it means taking the shorter of the two durations.

Trait Implementations

impl<S: Clone> Clone for GrpcTimeout<S>

fn clone(&self) -> GrpcTimeout<S>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<S: Debug> Debug for GrpcTimeout<S>

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

Formats the value using the given formatter.

impl<S, ReqBody, ResBody> Service<Request<ReqBody>> for GrpcTimeout<S>

where S: Service<Request<ReqBody>, Response = Response<ResBody>, Error = Infallible>, ResBody: Default,

type Response = Response<ResBody>

Responses given by the service.

type Error = Infallible

Errors produced by the service.

type Future = GrpcTimeoutFuture<<S as Service<Request<ReqBody>>>::Future>

The future response value.

fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>>

Returns Poll::Ready(Ok(())) when the service is able to process requests.

fn call(&mut self, req: Request<ReqBody>) -> Self::Future

Process the request and return the response asynchronously.

impl<S: Copy> Copy for GrpcTimeout<S>