use std::{
convert::TryFrom,
error::Error as StdError,
fmt,
io::Read,
net::SocketAddr,
pin::Pin,
task::{Context, Poll},
time::Duration,
};
use bytes::Bytes;
use futures_io::AsyncRead;
use futures_util::{AsyncReadExt as _, AsyncWriteExt as _};
use http::{Extensions, HeaderMap, HeaderName, HeaderValue, Method, StatusCode, Uri, Version};
use http_body::{Body as _, Frame, SizeHint};
use serde::{Serialize, de::DeserializeOwned};
use crate::{
Error, Event, Executor, Limits, Multipart, Request, Result, Timeouts, auth::Authentication,
proxy, redirect, retry,
};
#[derive(Clone)]
pub struct Client {
inner: crate::Client,
}
pub struct ClientBuilder {
inner: crate::ClientBuilder,
}
pub struct RequestBuilder<'client> {
inner: crate::RequestBuilder<'client>,
}
pub struct Response {
inner: http::Response<Body>,
url: Uri,
content_length: Option<u64>,
remote_addr: Option<SocketAddr>,
limits: Limits,
info: crate::ResponseInfo,
}
pub struct Body {
inner: crate::Body,
data: Bytes,
offset: usize,
finished: bool,
}
pub struct Upgraded {
inner: crate::Upgraded,
}
pub struct EventStream {
inner: crate::EventStream,
}
pub struct JsonStream<T> {
inner: crate::JsonStream<T>,
}
impl Client {
pub fn new() -> Result<Self> {
Self::builder().build()
}
#[must_use]
pub fn builder() -> ClientBuilder {
ClientBuilder {
inner: crate::Client::builder(),
}
}
#[must_use]
pub fn request(&self, method: Method, target: impl AsRef<str>) -> RequestBuilder<'_> {
RequestBuilder {
inner: self.inner.request(method, target),
}
}
#[must_use]
pub fn get(&self, target: impl AsRef<str>) -> RequestBuilder<'_> {
self.request(Method::GET, target)
}
#[must_use]
pub fn post(&self, target: impl AsRef<str>) -> RequestBuilder<'_> {
self.request(Method::POST, target)
}
#[must_use]
pub fn put(&self, target: impl AsRef<str>) -> RequestBuilder<'_> {
self.request(Method::PUT, target)
}
#[must_use]
pub fn patch(&self, target: impl AsRef<str>) -> RequestBuilder<'_> {
self.request(Method::PATCH, target)
}
#[must_use]
pub fn delete(&self, target: impl AsRef<str>) -> RequestBuilder<'_> {
self.request(Method::DELETE, target)
}
#[must_use]
pub fn head(&self, target: impl AsRef<str>) -> RequestBuilder<'_> {
self.request(Method::HEAD, target)
}
#[must_use]
pub fn options(&self, target: impl AsRef<str>) -> RequestBuilder<'_> {
self.request(Method::OPTIONS, target)
}
#[must_use]
pub fn trace(&self, target: impl AsRef<str>) -> RequestBuilder<'_> {
self.request(Method::TRACE, target)
}
#[must_use]
pub fn connect(&self, target: impl AsRef<str>) -> RequestBuilder<'_> {
self.request(Method::CONNECT, target)
}
pub fn send(&self, request: Request) -> Result<Response> {
futures_lite::future::block_on(self.inner.send(request)).map(Response::from_async)
}
}
impl ClientBuilder {
#[must_use]
pub fn base_url(mut self, value: impl AsRef<str>) -> Self {
self.inner = self.inner.base_url(value);
self
}
#[must_use]
pub fn default_header<K, V>(mut self, name: K, value: V) -> Self
where
HeaderName: TryFrom<K>,
HeaderValue: TryFrom<V>,
{
self.inner = self.inner.default_header(name, value);
self
}
#[must_use]
pub fn default_headers(mut self, headers: HeaderMap) -> Self {
self.inner = self.inner.default_headers(headers);
self
}
#[must_use]
pub fn auth(mut self, authentication: impl Authentication + 'static) -> Self {
self.inner = self.inner.auth(authentication);
self
}
#[must_use]
pub fn user_agent(mut self, value: impl AsRef<str>) -> Self {
self.inner = self.inner.user_agent(value);
self
}
#[must_use]
pub fn no_user_agent(mut self) -> Self {
self.inner = self.inner.no_user_agent();
self
}
#[must_use]
pub fn timeout(mut self, timeout: impl Into<Option<Duration>>) -> Self {
self.inner = self.inner.timeout(timeout);
self
}
#[must_use]
pub fn timeouts(mut self, timeouts: Timeouts) -> Self {
self.inner = self.inner.timeouts(timeouts);
self
}
#[must_use]
pub fn limits(mut self, limits: Limits) -> Self {
self.inner = self.inner.limits(limits);
self
}
#[must_use]
pub fn resolver(mut self, resolver: impl crate::dns::Resolver + 'static) -> Self {
self.inner = self.inner.resolver(resolver);
self
}
#[must_use]
pub fn connection(mut self, settings: crate::connection::Settings) -> Self {
self.inner = self.inner.connection(settings);
self
}
#[must_use]
pub fn redirects(mut self, policy: redirect::Policy) -> Self {
self.inner = self.inner.redirects(policy);
self
}
#[must_use]
pub fn retry(mut self, policy: retry::Policy) -> Self {
self.inner = self.inner.retry(policy);
self
}
#[must_use]
pub fn proxy(mut self, policy: proxy::Policy) -> Self {
self.inner = self.inner.proxy(policy);
self
}
#[must_use]
pub fn executor(mut self, executor: Executor) -> Self {
self.inner = self.inner.executor(executor);
self
}
#[must_use]
pub fn runtime(mut self, runtime: crate::runtime::Runtime) -> Self {
self.inner = self.inner.runtime(runtime);
self
}
#[must_use]
pub fn disable_compression(mut self) -> Self {
self.inner = self.inner.disable_compression();
self
}
#[cfg(feature = "cookies")]
#[must_use]
pub fn cookies(mut self) -> Self {
self.inner = self.inner.cookies();
self
}
#[cfg(feature = "cookies")]
#[must_use]
pub fn cookie_jar(mut self, jar: std::sync::Arc<crate::CookieJar>) -> Self {
self.inner = self.inner.cookie_jar(jar);
self
}
#[must_use]
pub fn trust_pem(mut self, bundle: impl AsRef<[u8]>) -> Self {
self.inner = self.inner.trust_pem(bundle);
self
}
#[must_use]
pub fn add_root_pem(mut self, bundle: impl AsRef<[u8]>) -> Self {
self.inner = self.inner.add_root_pem(bundle);
self
}
#[must_use]
pub fn identity_pem(mut self, identity: impl AsRef<[u8]>) -> Self {
self.inner = self.inner.identity_pem(identity);
self
}
#[must_use]
pub fn minimum_tls_version(mut self, version: crate::tls::Version) -> Self {
self.inner = self.inner.minimum_tls_version(version);
self
}
#[must_use]
pub fn maximum_tls_version(mut self, version: crate::tls::Version) -> Self {
self.inner = self.inner.maximum_tls_version(version);
self
}
#[must_use]
pub fn https_only(mut self) -> Self {
self.inner = self.inner.https_only();
self
}
pub fn build(self) -> Result<Client> {
self.inner.build().map(|inner| Client { inner })
}
}
impl RequestBuilder<'_> {
#[must_use]
pub fn header<K, V>(mut self, name: K, value: V) -> Self
where
HeaderName: TryFrom<K>,
HeaderValue: TryFrom<V>,
{
self.inner = self.inner.header(name, value);
self
}
#[must_use]
pub fn append_header<K, V>(mut self, name: K, value: V) -> Self
where
HeaderName: TryFrom<K>,
HeaderValue: TryFrom<V>,
{
self.inner = self.inner.append_header(name, value);
self
}
#[must_use]
pub fn headers(mut self, headers: HeaderMap) -> Self {
self.inner = self.inner.headers(headers);
self
}
#[must_use]
pub fn auth(mut self, authentication: impl Authentication + 'static) -> Self {
self.inner = self.inner.auth(authentication);
self
}
#[must_use]
pub fn query<T>(mut self, query_params: &T) -> Self
where
T: Serialize + ?Sized,
{
self.inner = self.inner.query(query_params);
self
}
#[must_use]
pub fn timeout(mut self, timeout: impl Into<Option<Duration>>) -> Self {
self.inner = self.inner.timeout(timeout);
self
}
#[must_use]
pub fn version(mut self, version: Version) -> Self {
self.inner = self.inner.version(version);
self
}
#[must_use]
pub fn extension<T>(mut self, value: T) -> Self
where
T: Clone + Send + Sync + 'static,
{
self.inner = self.inner.extension(value);
self
}
#[must_use]
pub fn body(mut self, body: impl Into<crate::Body>) -> Self {
self.inner = self.inner.body(body);
self
}
#[must_use]
pub fn reader<R>(mut self, reader: R) -> Self
where
R: Read + Send + 'static,
{
self.inner = self
.inner
.body(crate::Body::wrap(Upload::new(reader, None)));
self
}
#[must_use]
pub fn reader_with_length<R>(mut self, reader: R, length: u64) -> Self
where
R: Read + Send + 'static,
{
self.inner = self.inner.body(crate::Body::wrap(Upload::new(
reader.take(length),
Some(length),
)));
self
}
#[must_use]
pub fn text(mut self, text: impl Into<String>) -> Self {
self.inner = self.inner.text(text);
self
}
#[must_use]
pub fn html(mut self, html: impl Into<String>) -> Self {
self.inner = self.inner.html(html);
self
}
#[must_use]
pub fn json<T>(mut self, value: &T) -> Self
where
T: Serialize + ?Sized,
{
self.inner = self.inner.json(value);
self
}
#[must_use]
pub fn form<T>(mut self, value: &T) -> Self
where
T: Serialize + ?Sized,
{
self.inner = self.inner.form(value);
self
}
#[must_use]
pub fn ndjson<I, T, E>(mut self, records: I) -> Self
where
I: IntoIterator<Item = std::result::Result<T, E>>,
I::IntoIter: Send + 'static,
T: Serialize,
E: StdError + Send + Sync + 'static,
{
self.inner = self.inner.ndjson(futures_util::stream::iter(records));
self
}
#[must_use]
pub fn json_array<I, T, E>(mut self, values: I) -> Self
where
I: IntoIterator<Item = std::result::Result<T, E>>,
I::IntoIter: Send + 'static,
T: Serialize,
E: StdError + Send + Sync + 'static,
{
self.inner = self.inner.json_array(futures_util::stream::iter(values));
self
}
#[must_use]
pub fn sse<I, E>(mut self, events: I) -> Self
where
I: IntoIterator<Item = std::result::Result<Event, E>>,
I::IntoIter: Send + 'static,
E: StdError + Send + Sync + 'static,
{
self.inner = self.inner.sse(futures_util::stream::iter(events));
self
}
#[must_use]
pub fn multipart(mut self, multipart: Multipart) -> Self {
self.inner = self.inner.multipart(multipart);
self
}
pub fn build(self) -> Result<Request> {
self.inner.build()
}
pub fn send(self) -> Result<Response> {
futures_lite::future::block_on(self.inner.send()).map(Response::from_async)
}
}
impl Response {
fn from_async(response: crate::Response) -> Self {
let (inner, url, content_length, remote_addr, limits, info) = response.into_parts();
let (parts, body) = inner.into_parts();
Self {
inner: http::Response::from_parts(parts, Body::new(body)),
url,
content_length,
remote_addr,
limits,
info,
}
}
#[must_use]
pub fn status(&self) -> StatusCode {
self.inner.status()
}
#[must_use]
pub fn version(&self) -> Version {
self.inner.version()
}
#[must_use]
pub fn headers(&self) -> &HeaderMap {
self.inner.headers()
}
#[must_use]
pub fn headers_mut(&mut self) -> &mut HeaderMap {
self.inner.headers_mut()
}
#[must_use]
pub fn extensions(&self) -> &Extensions {
self.inner.extensions()
}
#[must_use]
pub fn extensions_mut(&mut self) -> &mut Extensions {
self.inner.extensions_mut()
}
#[must_use]
pub fn url(&self) -> &Uri {
&self.url
}
#[must_use]
pub const fn content_length(&self) -> Option<u64> {
self.content_length
}
#[must_use]
pub const fn remote_addr(&self) -> Option<SocketAddr> {
self.remote_addr
}
#[must_use]
pub const fn info(&self) -> crate::ResponseInfo {
self.info
}
pub fn error_for_status(self) -> Result<Self> {
self.error_for_status_ref()?;
Ok(self)
}
pub fn error_for_status_ref(&self) -> Result<&Self> {
if self.status().is_client_error() || self.status().is_server_error() {
return Err(Error::status_error(self.status()));
}
Ok(self)
}
#[must_use]
pub fn body(&self) -> &Body {
self.inner.body()
}
#[must_use]
pub fn body_mut(&mut self) -> &mut Body {
self.inner.body_mut()
}
#[must_use]
pub fn into_body(self) -> Body {
self.inner.into_body()
}
#[must_use]
pub fn ndjson<T>(self) -> JsonStream<T>
where
T: DeserializeOwned,
{
JsonStream {
inner: self.into_response_stream().ndjson(),
}
}
#[must_use]
pub fn sse(self) -> EventStream {
EventStream {
inner: self.into_response_stream().sse(),
}
}
pub fn upgrade(mut self) -> Result<Upgraded> {
let upgrade = self
.extensions_mut()
.remove::<crate::Upgrade>()
.unwrap_or_else(crate::Upgrade::unavailable);
futures_lite::future::block_on(upgrade).map(|inner| Upgraded { inner })
}
pub fn bytes(self) -> Result<Bytes> {
let limit = self.limits.response_body_bytes();
collect(self.into_body(), limit)
}
pub fn bytes_with_limit(self, limit: usize) -> Result<Bytes> {
if limit == 0 {
return Err(Error::request(
"response body limit must be greater than zero",
));
}
collect(self.into_body(), limit)
}
pub fn text(self) -> Result<String> {
let content_type = self
.headers()
.get(http::header::CONTENT_TYPE)
.and_then(|value| value.to_str().ok())
.map(ToOwned::to_owned);
crate::response::decode_text(&self.bytes()?, content_type.as_deref())
}
pub fn text_with_limit(self, limit: usize) -> Result<String> {
let content_type = self
.headers()
.get(http::header::CONTENT_TYPE)
.and_then(|value| value.to_str().ok())
.map(ToOwned::to_owned);
crate::response::decode_text(&self.bytes_with_limit(limit)?, content_type.as_deref())
}
pub fn json<T>(self) -> Result<T>
where
T: DeserializeOwned,
{
crate::content::decode_json(&self.bytes()?, "response JSON could not be decoded")
}
pub fn json_with_limit<T>(self, limit: usize) -> Result<T>
where
T: DeserializeOwned,
{
crate::content::decode_json(
&self.bytes_with_limit(limit)?,
"response JSON could not be decoded",
)
}
pub fn form<T>(self) -> Result<T>
where
T: DeserializeOwned,
{
crate::content::decode_form(&self.bytes()?, "response form could not be decoded")
}
pub fn form_with_limit<T>(self, limit: usize) -> Result<T>
where
T: DeserializeOwned,
{
crate::content::decode_form(
&self.bytes_with_limit(limit)?,
"response form could not be decoded",
)
}
pub fn discard(mut self) -> Result<()> {
std::io::copy(&mut self.inner.body_mut(), &mut std::io::sink())
.map(|_| ())
.map_err(body_io_error)
}
pub fn copy_to(mut self, writer: &mut impl std::io::Write) -> Result<u64> {
std::io::copy(self.inner.body_mut(), writer).map_err(body_io_error)
}
fn into_response_stream(self) -> crate::ResponseStream {
let item_limit = self.limits.stream_item_bytes();
crate::ResponseStream::new(self.inner.into_body().into_async(), item_limit)
}
}
impl Body {
fn new(inner: crate::Body) -> Self {
let finished = inner.is_end_stream();
Self {
inner,
data: Bytes::new(),
offset: 0,
finished,
}
}
fn into_async(self) -> crate::Body {
let prefix = (self.offset < self.data.len()).then(|| self.data.slice(self.offset..));
if prefix.is_none() {
return self.inner;
}
crate::Body::from_http_body(
PrefixedBody {
prefix,
inner: self.inner,
},
|error| error,
)
}
}
impl EventStream {
#[must_use]
pub fn json<T>(self) -> JsonStream<T>
where
T: DeserializeOwned,
{
JsonStream {
inner: self.inner.json(),
}
}
#[must_use]
pub fn json_until_done<T>(self) -> JsonStream<T>
where
T: DeserializeOwned,
{
JsonStream {
inner: self.inner.json_until_done(),
}
}
}
impl Iterator for EventStream {
type Item = Result<Event>;
fn next(&mut self) -> Option<Self::Item> {
futures_lite::future::block_on(self.inner.next()).transpose()
}
}
impl<T> Iterator for JsonStream<T> {
type Item = Result<T>;
fn next(&mut self) -> Option<Self::Item> {
futures_lite::future::block_on(self.inner.next()).transpose()
}
}
impl fmt::Debug for EventStream {
fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
formatter
.debug_struct("blocking::EventStream")
.finish_non_exhaustive()
}
}
impl<T> fmt::Debug for JsonStream<T> {
fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
formatter
.debug_struct("blocking::JsonStream")
.finish_non_exhaustive()
}
}
impl Read for Body {
fn read(&mut self, output: &mut [u8]) -> std::io::Result<usize> {
loop {
if self.offset < self.data.len() {
let length = (self.data.len() - self.offset).min(output.len());
output[..length].copy_from_slice(&self.data[self.offset..self.offset + length]);
self.offset += length;
return Ok(length);
}
if self.finished {
return Ok(0);
}
let frame = futures_lite::future::block_on(std::future::poll_fn(|context| {
Pin::new(&mut self.inner).poll_frame(context)
}));
match frame {
Some(Ok(frame)) => {
if let Ok(data) = frame.into_data() {
self.data = data;
self.offset = 0;
}
}
Some(Err(error)) => {
let kind = if error.is_timeout() {
std::io::ErrorKind::TimedOut
} else {
std::io::ErrorKind::Other
};
return Err(std::io::Error::new(kind, error));
}
None => self.finished = true,
}
}
}
}
impl Read for Upgraded {
fn read(&mut self, output: &mut [u8]) -> std::io::Result<usize> {
futures_lite::future::block_on(self.inner.read(output))
}
}
fn body_io_error(error: std::io::Error) -> Error {
error
.get_ref()
.and_then(|error| error.downcast_ref::<Error>())
.cloned()
.unwrap_or_else(Error::body)
}
impl std::io::Write for Upgraded {
fn write(&mut self, bytes: &[u8]) -> std::io::Result<usize> {
futures_lite::future::block_on(self.inner.write(bytes))
}
fn flush(&mut self) -> std::io::Result<()> {
futures_lite::future::block_on(self.inner.flush())
}
}
impl fmt::Debug for Client {
fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
formatter
.debug_tuple("blocking::Client")
.field(&self.inner)
.finish()
}
}
impl fmt::Debug for ClientBuilder {
fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
formatter
.debug_tuple("blocking::ClientBuilder")
.field(&self.inner)
.finish()
}
}
impl fmt::Debug for Response {
fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
formatter
.debug_struct("blocking::Response")
.field("status", &self.status())
.field("version", &self.version())
.field("header_count", &self.headers().len())
.field("content_length", &self.content_length)
.field("remote_addr", &self.remote_addr)
.field("info", &self.info)
.finish_non_exhaustive()
}
}
impl fmt::Debug for Body {
fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
formatter
.debug_struct("blocking::Body")
.finish_non_exhaustive()
}
}
impl fmt::Debug for Upgraded {
fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
formatter
.debug_struct("blocking::Upgraded")
.finish_non_exhaustive()
}
}
struct Upload<R> {
reader: ::blocking::Unblock<R>,
buffer: Vec<u8>,
remaining: Option<u64>,
finished: bool,
}
struct PrefixedBody {
prefix: Option<Bytes>,
inner: crate::Body,
}
impl http_body::Body for PrefixedBody {
type Data = Bytes;
type Error = Error;
fn poll_frame(
self: Pin<&mut Self>,
context: &mut Context<'_>,
) -> Poll<Option<std::result::Result<Frame<Self::Data>, Self::Error>>> {
let this = self.get_mut();
if let Some(prefix) = this.prefix.take() {
return Poll::Ready(Some(Ok(Frame::data(prefix))));
}
Pin::new(&mut this.inner).poll_frame(context)
}
fn is_end_stream(&self) -> bool {
self.prefix.is_none() && self.inner.is_end_stream()
}
fn size_hint(&self) -> SizeHint {
let prefix = self.prefix.as_ref().map_or(0, |bytes| bytes.len() as u64);
let inner = self.inner.size_hint();
let mut hint = SizeHint::new();
hint.set_lower(prefix.saturating_add(inner.lower()));
if let Some(upper) = inner.upper().and_then(|upper| prefix.checked_add(upper)) {
hint.set_upper(upper);
}
hint
}
}
impl<R> Upload<R> {
fn new(reader: R, remaining: Option<u64>) -> Self {
Self {
reader: ::blocking::Unblock::new(reader),
buffer: vec![0; 16 * 1024],
remaining,
finished: false,
}
}
}
impl<R> http_body::Body for Upload<R>
where
R: Read + Send + 'static,
{
type Data = Bytes;
type Error = std::io::Error;
fn poll_frame(
self: Pin<&mut Self>,
context: &mut Context<'_>,
) -> Poll<Option<std::result::Result<Frame<Self::Data>, Self::Error>>> {
let this = self.get_mut();
if this.finished {
return Poll::Ready(None);
}
let limit = this
.remaining
.and_then(|remaining| usize::try_from(remaining).ok())
.map_or(this.buffer.len(), |remaining| {
remaining.min(this.buffer.len())
});
if limit == 0 {
this.finished = true;
return Poll::Ready(None);
}
match Pin::new(&mut this.reader).poll_read(context, &mut this.buffer[..limit]) {
Poll::Ready(Ok(0)) if this.remaining.is_some() => {
this.finished = true;
Poll::Ready(Some(Err(std::io::Error::new(
std::io::ErrorKind::UnexpectedEof,
"blocking request body ended before its declared length",
))))
}
Poll::Ready(Ok(0)) => {
this.finished = true;
Poll::Ready(None)
}
Poll::Ready(Ok(read)) => {
if let Some(remaining) = &mut this.remaining {
*remaining = remaining.saturating_sub(read as u64);
}
Poll::Ready(Some(Ok(Frame::data(Bytes::copy_from_slice(
&this.buffer[..read],
)))))
}
Poll::Ready(Err(error)) => {
this.finished = true;
Poll::Ready(Some(Err(error)))
}
Poll::Pending => Poll::Pending,
}
}
fn is_end_stream(&self) -> bool {
self.finished || self.remaining == Some(0)
}
fn size_hint(&self) -> SizeHint {
self.remaining
.map_or_else(SizeHint::default, SizeHint::with_exact)
}
}
fn collect(body: Body, limit: usize) -> Result<Bytes> {
if body.finished {
let data = body.data.slice(body.offset..);
if data.len() > limit {
return Err(Error::body_too_large());
}
return Ok(data);
}
futures_lite::future::block_on(collect_async(body, limit))
}
async fn collect_async(body: Body, limit: usize) -> Result<Bytes> {
let Body {
mut inner,
data,
offset,
finished: _,
} = body;
let buffered = data.len().saturating_sub(offset) as u64;
if inner.size_hint().lower().saturating_add(buffered) > limit as u64 {
return Err(Error::body_too_large());
}
let capacity = inner
.size_hint()
.exact()
.and_then(|length| usize::try_from(length).ok())
.and_then(|length| length.checked_add(data.len().saturating_sub(offset)))
.filter(|length| *length <= limit);
let mut first = (offset < data.len()).then(|| data.slice(offset..));
if first.as_ref().is_some_and(|data| data.len() > limit) {
return Err(Error::body_too_large());
}
let mut bytes = None;
while let Some(frame) =
std::future::poll_fn(|context| Pin::new(&mut inner).poll_frame(context)).await
{
let frame = frame?;
if let Ok(data) = frame.into_data() {
let length = bytes
.as_ref()
.map_or_else(|| first.as_ref().map_or(0, Bytes::len), Vec::len)
.checked_add(data.len())
.ok_or_else(Error::body_too_large)?;
if length > limit {
return Err(Error::body_too_large());
}
if let Some(bytes) = &mut bytes {
bytes.extend_from_slice(&data);
} else if let Some(previous) = first.take() {
let mut collected = Vec::with_capacity(capacity.unwrap_or(length).max(length));
collected.extend_from_slice(&previous);
collected.extend_from_slice(&data);
bytes = Some(collected);
} else {
first = Some(data);
}
}
}
Ok(bytes.map(Bytes::from).or(first).unwrap_or_default())
}
#[cfg(test)]
mod tests {
use std::io;
use std::sync::{
Arc,
atomic::{AtomicUsize, Ordering},
};
use http_body_util::BodyExt as _;
use super::*;
struct CountingReader {
data: io::Cursor<Vec<u8>>,
consumed: Arc<AtomicUsize>,
}
impl Read for CountingReader {
fn read(&mut self, output: &mut [u8]) -> io::Result<usize> {
let read = self.data.read(output)?;
self.consumed.fetch_add(read, Ordering::Relaxed);
Ok(read)
}
}
struct NeverPoll;
impl http_body::Body for NeverPoll {
type Data = Bytes;
type Error = io::Error;
fn poll_frame(
self: Pin<&mut Self>,
_: &mut Context<'_>,
) -> Poll<Option<std::result::Result<Frame<Self::Data>, Self::Error>>> {
panic!("an oversized declared body must be rejected before polling")
}
fn size_hint(&self) -> SizeHint {
SizeHint::with_exact(8)
}
}
#[test]
fn exact_blocking_uploads_leave_trailing_reader_bytes_unread() {
let consumed = Arc::new(AtomicUsize::new(0));
let reader = CountingReader {
data: io::Cursor::new(b"onetwo".to_vec()),
consumed: Arc::clone(&consumed),
};
let mut upload = Upload::new(reader.take(3), Some(3));
let frame = futures_lite::future::block_on(upload.frame())
.expect("frame")
.expect("read");
assert_eq!(frame.into_data().expect("data"), "one");
assert!(futures_lite::future::block_on(upload.frame()).is_none());
assert_eq!(consumed.load(Ordering::Relaxed), 3);
}
#[test]
fn blocking_collection_rejects_an_oversized_hint_before_reading() {
let body = Body::new(crate::Body::wrap(NeverPoll));
assert!(collect(body, 4).unwrap_err().is_body_too_large());
}
}