Enum StreamingBody 

pub enum StreamingBody<B> {
    Buffered {
        data: Option<Bytes>,
    },
    Streaming {
        inner: B,
    },
    File {
        reader: File,
        buffer: BytesMut,
        done: bool,
        size: u64,
        check: Option<Box<FileCheck>>,
    },
}

Available on crate feature streaming only.

A body type that can represent either buffered data from cache or streaming body from upstream.

This enum allows the HTTP cache middleware to efficiently handle:

• Cached responses (buffered data)
• Cache misses (streaming from upstream)
• Disk-cached responses (streaming from file)

Variants

• Buffered: Contains cached response data that can be sent immediately
• Streaming: Wraps an upstream body for streaming responses
• File: Streams from a tokio::fs::File in 64KB chunks (only with streaming feature)

Variants

Buffered

Fields

data: Option<Bytes>

Streaming

Fields

inner: B

File

Fields

reader: File

buffer: BytesMut

done: bool

size: u64

check: Option<Box<FileCheck>>

Implementations

impl<B> StreamingBody<B>

pub fn buffered(data: Bytes) -> StreamingBody<B>

Create a new buffered body from bytes.

The bytes are consumed on the first poll and sent as a single frame.

pub fn streaming(body: B) -> StreamingBody<B>

Create a new streaming body from an upstream body.

The upstream body is passed through without additional buffering.

pub fn from_file_with_size(file: File, size: u64) -> StreamingBody<B>

Create a new file-streaming body from a tokio::fs::File with known size.

This allows streaming large cached responses from disk without loading the entire body into memory. Data is read in 64KB chunks.

Cursor contract

The caller must position file at the start of the body bytes before calling this function. Exactly size bytes are streamed from the current cursor position; trailing file content is ignored and a file shorter than size yields a stream error.

size is used to provide accurate size hints to downstream consumers.

pub fn from_file_verified( file: File, size: u64, checksum: [u8; 32], on_corrupt: impl FnOnce() + Send + 'static, ) -> StreamingBody<B>

Like from_file_with_size, but hashes the streamed bytes and compares against checksum when the stream completes. On mismatch the final frame is replaced with an error and on_corrupt is invoked once.

impl<B> StreamingBody<B>

where B: Body + Unpin + Send, <B as Body>::Error: Into<StreamingError>, <B as Body>::Data: Into<Bytes>,

pub fn into_bytes_stream( self, ) -> impl Stream<Item = Result<Bytes, Box<dyn Error + Send + Sync>>> + Send

Convert this streaming body into a stream of Bytes.

This method allows for streaming without collecting the entire body into memory first.

Trait Implementations

impl<B> Body for StreamingBody<B>

where B: Body + Unpin, <B as Body>::Error: Into<StreamingError>, <B as Body>::Data: Into<Bytes>,

type Data = Bytes

Values yielded by the Body.

type Error = StreamingError

The error type this Body might generate.

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

Attempt to pull out the next frame of this stream.

fn is_end_stream(&self) -> bool

A hint that may return true when the end of stream has been reached.

fn size_hint(&self) -> SizeHint

A hint that returns the bounds on the remaining length of the stream.

impl<B> Debug for StreamingBody<B>

where B: Debug,

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

Formats the value using the given formatter.

impl<B> From<Bytes> for StreamingBody<B>

fn from(bytes: Bytes) -> StreamingBody<B>

Converts to this type from the input type.

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

where <PinnedFieldsOfHelperStruct<__Origin<'__pin, B>> as PinnedFieldsOfHelperTrait>::Actual: Unpin,