Struct DeadlineBody 

pub struct DeadlineBody<B> { /* private fields */ }

Available on crate feature timeout only.

Wrapper around a Body that enforces a hard deadline on the entire body transfer.

Unlike TimeoutBody, which resets its deadline each time a frame is received, DeadlineBody starts a single timer at construction and returns a TimeoutError if the body is not fully consumed before the deadline.

The deadline is wall-clock time from construction, not cumulative poll time. The timer continues to count even if the consumer is not actively polling the body. If you poll some frames, pause to do other work, and then resume, the elapsed pause time counts toward the deadline.

When to use this

This is primarily useful as middleware on public-facing endpoints where you want to bound the total wall-clock time a single request can hold resources (task slots, memory for buffering, etc.), regardless of how frequently data trickles in. A slow client sending one byte per second will never trip TimeoutBody’s idle timeout, but will correctly trip DeadlineBody.

If you only need to detect stalled connections where no data flows for a period, use TimeoutBody instead. The two can be stacked if you want both an idle timeout and a hard deadline.

Example

use http::{Request, Response};
use bytes::Bytes;
use http_body_util::Full;
use std::time::Duration;
use tower::ServiceBuilder;
use tower_http::timeout::RequestBodyDeadlineLayer;

async fn handle(_: Request<Full<Bytes>>) -> Result<Response<Full<Bytes>>, std::convert::Infallible> {
    // ...
}

let svc = ServiceBuilder::new()
    // Timeout bodies after 30 seconds total
    .layer(RequestBodyDeadlineLayer::new(Duration::from_secs(30)))
    .service_fn(handle);

Implementations

impl<B> DeadlineBody<B>

pub fn new(timeout: Duration, body: B) -> Self

Creates a new DeadlineBody.

The timeout starts immediately. If the body is not fully consumed within timeout, subsequent poll_frame calls will return a TimeoutError.

Trait Implementations

impl<B> Body for DeadlineBody<B>

where B: Body, B::Error: Into<BoxError>,

type Data = <B as Body>::Data

Values yielded by the Body.

type Error = Box<dyn Error + Send + Sync>

The error type this Body might generate.

fn poll_frame( self: Pin<&mut Self>, cx: &mut Context<'_>, ) -> Poll<Option<Result<Frame<Self::Data>, Self::Error>>>

Attempt to pull out the next data buffer of this stream.

fn is_end_stream(&self) -> bool

Returns true when the end of stream has been reached.

fn size_hint(&self) -> SizeHint

Returns the bounds on the remaining length of the stream.

impl<'__pin, B> Unpin for DeadlineBody<B>

where PinnedFieldsOf<__Origin<'__pin, B>>: Unpin,