Struct ReqwestStreamBody 

pub struct ReqwestStreamBody { /* private fields */ }

Available on crate features arrow or csv or json or protobuf only.

A request body that streams a sequence of items.

Convert it into a reqwest::Body with .into(), or hand it to StreamBodyRequest::stream_body, which also sets the Content-Type.

HTTP caveats

Streaming a request body is much less universally supported than streaming a response. None of the following stops it working, but each will surprise you if it is not expected.

1. The body cannot be replayed. RequestBuilder::try_clone returns None for a streaming body, so retry middleware — reqwest-retry and anything like it — cannot retry the request.
2. A redirect silently sends an empty body. reqwest follows redirects through a middleware that substitutes a default body when the original cannot be cloned, and for reqwest that default is an empty body. A 307 or 308 on a streaming upload therefore arrives at the new location with nothing in it, and no error is reported. Use redirect::Policy::none for streaming uploads and handle redirects yourself.
3. Transfer-Encoding is chunked. No Content-Length can be computed, so HTTP/1.1 uses chunked encoding. Some API gateways reject chunked request bodies. HTTP/2 is unaffected.
4. Expect: 100-continue is not supported. hyper neither sends it nor waits for it, so setting the header by hand does not get you the behaviour: you may upload a great many bytes before learning the request was rejected. When the server does answer early, the body is dropped and the outcome is reported as aborted.
5. Buffering reverse proxies defeat streaming. nginx buffers request bodies by default (proxy_request_buffering on), as do many CDNs and API gateways; the server then sees one complete body rather than a stream. Set proxy_request_buffering off;.
6. Timeouts cover the whole exchange. RequestBuilder::timeout spans connect through response body, so a slow source stream can trip it.

Implementations

impl ReqwestStreamBody

pub fn new<S, T, FMT>(format: FMT, stream: S) -> Self

where FMT: StreamFormatEncode<T> + StreamFormat, FMT::Encoder: Send + 'static, S: Stream<Item = T> + Send + 'static, T: Send + 'static,

A body encoding stream with format.

pub fn try_new<S, T, FMT, E>(format: FMT, stream: S) -> Self

where FMT: StreamFormatEncode<T> + StreamFormat, FMT::Encoder: Send + 'static, S: Stream<Item = Result<T, E>> + Send + 'static, T: Send + 'static, E: Into<Box<dyn Error + Send + Sync>> + Send + 'static,

A body encoding a fallible stream with format.

Errors from your source stream are forwarded into the body stream, where they abort the request. Use ReqwestStreamBodyOptions::on_error to observe them.

pub fn with_options<S, T, FMT>( format: FMT, stream: S, options: ReqwestStreamBodyOptions, ) -> Self

where FMT: StreamFormatEncode<T> + StreamFormat, FMT::Encoder: Send + 'static, S: Stream<Item = T> + Send + 'static, T: Send + 'static,

A body encoding stream with format, with options.

pub fn try_with_options<S, T, FMT, E>( format: FMT, stream: S, options: ReqwestStreamBodyOptions, ) -> Self

where FMT: StreamFormatEncode<T> + StreamFormat, FMT::Encoder: Send + 'static, S: Stream<Item = Result<T, E>> + Send + 'static, T: Send + 'static, E: Into<Box<dyn Error + Send + Sync>> + Send + 'static,

A body encoding a fallible stream with format, with options.

pub fn content_type(&self) -> &HeaderValue

The Content-Type this body should be sent with.

StreamBodyRequest::stream_body and the per-format methods set it for you; this is for callers building a request by hand.

pub fn into_stream(self) -> BoxStream<'static, StreamBodyResult<Bytes>>

The encoded bytes, for callers who are not sending an HTTP request.

Public on purpose: it makes the body testable without a server, and lets you write the same encoding to a file, a socket, or an object-store SDK.

Trait Implementations

impl Debug for ReqwestStreamBody

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

Formats the value using the given formatter.

impl From<ReqwestStreamBody> for Body

fn from(body: ReqwestStreamBody) -> Self

Converts to this type from the input type.