Struct Streaming 

pub struct Streaming { /* private fields */ }

A response whose headers have arrived and whose body is still being read.

The size limit still applies to the decoded total, so a body that outgrows it fails partway through rather than being buffered first.

let mut response = client.get("http://files.onion/big.iso")?.send_streaming().await?;
println!("{} {:?}", response.status(), response.header("content-length"));

let mut written = 0usize;
while let Some(chunk) = response.chunk().await? {
    written += chunk.len();
}

Timeouts

The client’s request timeout covers the connection, the request and the response headers. Once this value is handed back the deadline no longer applies — a download that takes an hour is a legitimate thing to want, and hypertor will not cut it off. Impose your own deadline around the read loop if you need one.

Implementations

impl Streaming

pub fn from_response<B>(response: Response<B>, limit: usize) -> Result<Self>

where B: Body<Data = Bytes> + Send + 'static, B::Error: Error + Send + Sync + 'static,

Wrap a hyper response, decoding its Content-Encoding and bounding the decoded body at limit bytes.

This is what the client uses internally. It is public because the limit-enforcing decoder is useful on its own — over an onion stream you speak yourself, say — and because a size guarantee you cannot test is not a guarantee.

Use from_head_response for the answer to a HEAD request: the metadata there describes a body that is not actually being sent.

pub fn from_head_response<B>( response: Response<B>, limit: usize, ) -> Result<Self>

where B: Body<Data = Bytes> + Send + 'static, B::Error: Error + Send + Sync + 'static,

Wrap the response to a HEAD request.

RFC 9110 §9.3.2 says a HEAD response carries the header fields the equivalent GET would have sent — including Content-Length and Content-Encoding — while carrying no body at all. Treating those as describing real bytes would reject HEAD on any resource larger than the size limit, and would hand an empty stream to a decompressor that then reports a truncated member. Neither has anything to do with what is actually on the wire, which is nothing.

pub fn status(&self) -> StatusCode

The status code.

pub fn version(&self) -> Version

The HTTP version the response was received over.

pub fn headers(&self) -> &HeaderMap

The response headers.

pub fn header(&self, name: &str) -> Option<&str>

A single header value, if present and valid ASCII.

pub fn content_type(&self) -> Option<&str>

The Content-Type header.

pub fn is_success(&self) -> bool

Whether the status is 2xx.

pub fn error_for_status(self) -> Result<Self>

Return an error if the status is not 2xx.

pub async fn chunk(&mut self) -> Result<Option<Bytes>>

The next decoded chunk, or None once the body has ended.

pub fn bytes_stream(self) -> impl Stream<Item = Result<Bytes>> + Send

The body as a Stream of decoded chunks.

pub async fn buffered(self) -> Result<Response>

Read the rest of the body into memory and return a buffered Response.

Trait Implementations

impl Debug for Streaming

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

Formats the value using the given formatter.