diff options
Diffstat (limited to '')
| -rw-r--r-- | third_party/rust/http-body/.cargo-checksum.json | 1 | ||||
| -rw-r--r-- | third_party/rust/http-body/CHANGELOG.md | 62 | ||||
| -rw-r--r-- | third_party/rust/http-body/Cargo.toml | 45 | ||||
| -rw-r--r-- | third_party/rust/http-body/LICENSE | 25 | ||||
| -rw-r--r-- | third_party/rust/http-body/README.md | 27 | ||||
| -rw-r--r-- | third_party/rust/http-body/src/combinators/box_body.rs | 134 | ||||
| -rw-r--r-- | third_party/rust/http-body/src/combinators/map_data.rs | 94 | ||||
| -rw-r--r-- | third_party/rust/http-body/src/combinators/map_err.rs | 97 | ||||
| -rw-r--r-- | third_party/rust/http-body/src/combinators/mod.rs | 11 | ||||
| -rw-r--r-- | third_party/rust/http-body/src/empty.rs | 75 | ||||
| -rw-r--r-- | third_party/rust/http-body/src/full.rs | 151 | ||||
| -rw-r--r-- | third_party/rust/http-body/src/lib.rs | 324 | ||||
| -rw-r--r-- | third_party/rust/http-body/src/limited.rs | 299 | ||||
| -rw-r--r-- | third_party/rust/http-body/src/next.rs | 31 | ||||
| -rw-r--r-- | third_party/rust/http-body/src/size_hint.rs | 86 | ||||
| -rw-r--r-- | third_party/rust/http-body/tests/is_end_stream.rs | 79 |
16 files changed, 1541 insertions, 0 deletions
diff --git a/third_party/rust/http-body/.cargo-checksum.json b/third_party/rust/http-body/.cargo-checksum.json new file mode 100644 index 0000000000..dd8581af9b --- /dev/null +++ b/third_party/rust/http-body/.cargo-checksum.json @@ -0,0 +1 @@ +{"files":{"CHANGELOG.md":"b225eb6c706ab729255efa55603551151216b9e5f96dd722469ff5f28d843338","Cargo.toml":"037a31b6a59c860c5fe9860ba07b91f0141311453af66275b6d1336db2b1b1fb","LICENSE":"0345e2b98685e3807fd802a2478085dcae35023e3da59b5a00f712504314d83a","README.md":"0f90f61ee419eefd4104005ef6900445fafce9a710dd1989463f3cebaf0fafe8","src/combinators/box_body.rs":"d27dfa9f289c9c8d1fe714415fb5df5bdaafafb80a5cff66fbbe720841e806bf","src/combinators/map_data.rs":"3063f44d1318feeec639eff6544e7fb91ad9abf9a295770af4cc69b48a691796","src/combinators/map_err.rs":"9db485a5904579147673ac7f9f347e322d283d95a421daaf5541d048045eec7e","src/combinators/mod.rs":"c9e32f64ab2f4866d14256fff4256ba61d4c1bcfaf2748754c561de3abe1eccd","src/empty.rs":"3e44cee68410101cb8bf88c0de504885075c084357e83bcd3a6761ba5c7c58d2","src/full.rs":"efcbf6831d32271170e2ed86c328bfb887aec0c93689f1218ab5a18c319b0fa8","src/lib.rs":"140ff217ecf7e361b9f083dc664f1d65be176b235a71fdb1e8031eafda989a38","src/limited.rs":"485fc1c58bba29d2c7afdb4a032cd0e3c3578979ccd71f7459ddcd67e0f16077","src/next.rs":"d6863067b20c4bb42dced5c17bd954816b1338ce53e8d34ab81dbe240a1601cf","src/size_hint.rs":"017ed58c59b446b93aa4922e35b596490bf8f03af37c631610cc6576f1c21439","tests/is_end_stream.rs":"3a66d80d064f8a447bfa9fd212c2f91855604b1b41f554da3a029bc4a5be3a7e"},"package":"d5f38f16d184e36f2408a55281cd658ecbd3ca05cce6d6510a176eca393e26d1"}
\ No newline at end of file diff --git a/third_party/rust/http-body/CHANGELOG.md b/third_party/rust/http-body/CHANGELOG.md new file mode 100644 index 0000000000..4708a20075 --- /dev/null +++ b/third_party/rust/http-body/CHANGELOG.md @@ -0,0 +1,62 @@ +# Unreleased + +None. + +# 0.4.5 (May 20, 2022) + +- Add `String` impl for `Body`. +- Add `Limited` body implementation. + +# 0.4.4 (October 22, 2021) + +- Add `UnsyncBoxBody` and `Body::boxed_unsync`. + +# 0.4.3 (August 8, 2021) + +- Implement `Default` for `BoxBody`. + +# 0.4.2 (May 8, 2021) + +- Correctly override `Body::size_hint` and `Body::is_end_stream` for `Empty`. +- Add `Full` which is a body that consists of a single chunk. + +# 0.4.1 (March 18, 2021) + +- Add combinators to `Body`: + - `map_data`: Change the `Data` chunks produced by the body. + - `map_err`: Change the `Error`s produced by the body. + - `boxed`: Convert the `Body` into a boxed trait object. +- Add `Empty`. + +# 0.4.0 (December 23, 2020) + +- Update `bytes` to v1.0. + +# 0.3.1 (December 13, 2019) + +- Implement `Body` for `http::Request<impl Body>` and `http::Response<impl Body>`. + +# 0.3.0 (December 4, 2019) + +- Rename `next` combinator to `data`. + +# 0.2.0 (December 3, 2019) + +- Update `http` to v0.2. +- Update `bytes` to v0.5. + +# 0.2.0-alpha.3 (October 1, 2019) + +- Fix `Body` to be object-safe. + +# 0.2.0-alpha.2 (October 1, 2019) + +- Add `next` and `trailers` combinator methods. + +# 0.2.0-alpha.1 (August 20, 2019) + +- Update to use `Pin` in `poll_data` and `poll_trailers`. + +# 0.1.0 (May 7, 2019) + +- Initial release diff --git a/third_party/rust/http-body/Cargo.toml b/third_party/rust/http-body/Cargo.toml new file mode 100644 index 0000000000..202ce7de84 --- /dev/null +++ b/third_party/rust/http-body/Cargo.toml @@ -0,0 +1,45 @@ +# THIS FILE IS AUTOMATICALLY GENERATED BY CARGO +# +# When uploading crates to the registry Cargo will automatically +# "normalize" Cargo.toml files for maximal compatibility +# with all versions of Cargo and also rewrite `path` dependencies +# to registry (e.g., crates.io) dependencies. +# +# If you are reading this file be aware that the original Cargo.toml +# will likely look very different (and much more reasonable). +# See Cargo.toml.orig for the original contents. + +[package] +edition = "2018" +name = "http-body" +version = "0.4.5" +authors = [ + "Carl Lerche <me@carllerche.com>", + "Lucio Franco <luciofranco14@gmail.com>", + "Sean McArthur <sean@seanmonstar.com>", +] +description = """ +Trait representing an asynchronous, streaming, HTTP request or response body. +""" +documentation = "https://docs.rs/http-body" +readme = "README.md" +keywords = ["http"] +categories = ["web-programming"] +license = "MIT" +repository = "https://github.com/hyperium/http-body" + +[dependencies.bytes] +version = "1" + +[dependencies.http] +version = "0.2" + +[dependencies.pin-project-lite] +version = "0.2" + +[dev-dependencies.tokio] +version = "1" +features = [ + "macros", + "rt", +] diff --git a/third_party/rust/http-body/LICENSE b/third_party/rust/http-body/LICENSE new file mode 100644 index 0000000000..27b08f2874 --- /dev/null +++ b/third_party/rust/http-body/LICENSE @@ -0,0 +1,25 @@ +Copyright (c) 2019 Hyper Contributors + +Permission is hereby granted, free of charge, to any +person obtaining a copy of this software and associated +documentation files (the "Software"), to deal in the +Software without restriction, including without +limitation the rights to use, copy, modify, merge, +publish, distribute, sublicense, and/or sell copies of +the Software, and to permit persons to whom the Software +is furnished to do so, subject to the following +conditions: + +The above copyright notice and this permission notice +shall be included in all copies or substantial portions +of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF +ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED +TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A +PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT +SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY +CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION +OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR +IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER +DEALINGS IN THE SOFTWARE. diff --git a/third_party/rust/http-body/README.md b/third_party/rust/http-body/README.md new file mode 100644 index 0000000000..c82ba29056 --- /dev/null +++ b/third_party/rust/http-body/README.md @@ -0,0 +1,27 @@ +# HTTP Body + +A trait representing asynchronous operations on an HTTP body. + +[![crates.io][crates-badge]][crates-url] +[![documentation][docs-badge]][docs-url] +[![MIT License][mit-badge]][mit-url] +[![CI Status][ci-badge]][ci-url] + +[crates-badge]: https://img.shields.io/crates/v/http-body.svg +[crates-url]: https://crates.io/crates/http-body +[docs-badge]: https://docs.rs/http-body/badge.svg +[docs-url]: https://docs.rs/http-body +[mit-badge]: https://img.shields.io/badge/license-MIT-blue.svg +[mit-url]: LICENSE +[ci-badge]: https://github.com/hyperium/http-body/workflows/CI/badge.svg +[ci-url]: https://github.com/hyperium/http-body/actions?query=workflow%3ACI + +## License + +This project is licensed under the [MIT license](LICENSE). + +### Contribution + +Unless you explicitly state otherwise, any contribution intentionally submitted +for inclusion in `http-body` by you, shall be licensed as MIT, without any additional +terms or conditions. diff --git a/third_party/rust/http-body/src/combinators/box_body.rs b/third_party/rust/http-body/src/combinators/box_body.rs new file mode 100644 index 0000000000..97c8313fd7 --- /dev/null +++ b/third_party/rust/http-body/src/combinators/box_body.rs @@ -0,0 +1,134 @@ +use crate::Body; +use bytes::Buf; +use std::{ + fmt, + pin::Pin, + task::{Context, Poll}, +}; + +/// A boxed [`Body`] trait object. +pub struct BoxBody<D, E> { + inner: Pin<Box<dyn Body<Data = D, Error = E> + Send + Sync + 'static>>, +} + +/// A boxed [`Body`] trait object that is !Sync. +pub struct UnsyncBoxBody<D, E> { + inner: Pin<Box<dyn Body<Data = D, Error = E> + Send + 'static>>, +} + +impl<D, E> BoxBody<D, E> { + /// Create a new `BoxBody`. + pub fn new<B>(body: B) -> Self + where + B: Body<Data = D, Error = E> + Send + Sync + 'static, + D: Buf, + { + Self { + inner: Box::pin(body), + } + } +} + +impl<D, E> fmt::Debug for BoxBody<D, E> { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + f.debug_struct("BoxBody").finish() + } +} + +impl<D, E> Body for BoxBody<D, E> +where + D: Buf, +{ + type Data = D; + type Error = E; + + fn poll_data( + mut self: Pin<&mut Self>, + cx: &mut Context<'_>, + ) -> Poll<Option<Result<Self::Data, Self::Error>>> { + self.inner.as_mut().poll_data(cx) + } + + fn poll_trailers( + mut self: Pin<&mut Self>, + cx: &mut Context<'_>, + ) -> Poll<Result<Option<http::HeaderMap>, Self::Error>> { + self.inner.as_mut().poll_trailers(cx) + } + + fn is_end_stream(&self) -> bool { + self.inner.is_end_stream() + } + + fn size_hint(&self) -> crate::SizeHint { + self.inner.size_hint() + } +} + +impl<D, E> Default for BoxBody<D, E> +where + D: Buf + 'static, +{ + fn default() -> Self { + BoxBody::new(crate::Empty::new().map_err(|err| match err {})) + } +} + +// === UnsyncBoxBody === +impl<D, E> UnsyncBoxBody<D, E> { + /// Create a new `BoxBody`. + pub fn new<B>(body: B) -> Self + where + B: Body<Data = D, Error = E> + Send + 'static, + D: Buf, + { + Self { + inner: Box::pin(body), + } + } +} + +impl<D, E> fmt::Debug for UnsyncBoxBody<D, E> { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + f.debug_struct("UnsyncBoxBody").finish() + } +} + +impl<D, E> Body for UnsyncBoxBody<D, E> +where + D: Buf, +{ + type Data = D; + type Error = E; + + fn poll_data( + mut self: Pin<&mut Self>, + cx: &mut Context<'_>, + ) -> Poll<Option<Result<Self::Data, Self::Error>>> { + self.inner.as_mut().poll_data(cx) + } + + fn poll_trailers( + mut self: Pin<&mut Self>, + cx: &mut Context<'_>, + ) -> Poll<Result<Option<http::HeaderMap>, Self::Error>> { + self.inner.as_mut().poll_trailers(cx) + } + + fn is_end_stream(&self) -> bool { + self.inner.is_end_stream() + } + + fn size_hint(&self) -> crate::SizeHint { + self.inner.size_hint() + } +} + +impl<D, E> Default for UnsyncBoxBody<D, E> +where + D: Buf + 'static, +{ + fn default() -> Self { + UnsyncBoxBody::new(crate::Empty::new().map_err(|err| match err {})) + } +} diff --git a/third_party/rust/http-body/src/combinators/map_data.rs b/third_party/rust/http-body/src/combinators/map_data.rs new file mode 100644 index 0000000000..6d9c5a8964 --- /dev/null +++ b/third_party/rust/http-body/src/combinators/map_data.rs @@ -0,0 +1,94 @@ +use crate::Body; +use bytes::Buf; +use pin_project_lite::pin_project; +use std::{ + any::type_name, + fmt, + pin::Pin, + task::{Context, Poll}, +}; + +pin_project! { + /// Body returned by the [`map_data`] combinator. + /// + /// [`map_data`]: crate::util::BodyExt::map_data + #[derive(Clone, Copy)] + pub struct MapData<B, F> { + #[pin] + inner: B, + f: F + } +} + +impl<B, F> MapData<B, F> { + #[inline] + pub(crate) fn new(body: B, f: F) -> Self { + Self { inner: body, f } + } + + /// Get a reference to the inner body + pub fn get_ref(&self) -> &B { + &self.inner + } + + /// Get a mutable reference to the inner body + pub fn get_mut(&mut self) -> &mut B { + &mut self.inner + } + + /// Get a pinned mutable reference to the inner body + pub fn get_pin_mut(self: Pin<&mut Self>) -> Pin<&mut B> { + self.project().inner + } + + /// Consume `self`, returning the inner body + pub fn into_inner(self) -> B { + self.inner + } +} + +impl<B, F, B2> Body for MapData<B, F> +where + B: Body, + F: FnMut(B::Data) -> B2, + B2: Buf, +{ + type Data = B2; + type Error = B::Error; + + fn poll_data( + self: Pin<&mut Self>, + cx: &mut Context<'_>, + ) -> Poll<Option<Result<Self::Data, Self::Error>>> { + let this = self.project(); + match this.inner.poll_data(cx) { + Poll::Pending => Poll::Pending, + Poll::Ready(None) => Poll::Ready(None), + Poll::Ready(Some(Ok(data))) => Poll::Ready(Some(Ok((this.f)(data)))), + Poll::Ready(Some(Err(err))) => Poll::Ready(Some(Err(err))), + } + } + + fn poll_trailers( + self: Pin<&mut Self>, + cx: &mut Context<'_>, + ) -> Poll<Result<Option<http::HeaderMap>, Self::Error>> { + self.project().inner.poll_trailers(cx) + } + + fn is_end_stream(&self) -> bool { + self.inner.is_end_stream() + } +} + +impl<B, F> fmt::Debug for MapData<B, F> +where + B: fmt::Debug, +{ + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + f.debug_struct("MapData") + .field("inner", &self.inner) + .field("f", &type_name::<F>()) + .finish() + } +} diff --git a/third_party/rust/http-body/src/combinators/map_err.rs b/third_party/rust/http-body/src/combinators/map_err.rs new file mode 100644 index 0000000000..c77168deb5 --- /dev/null +++ b/third_party/rust/http-body/src/combinators/map_err.rs @@ -0,0 +1,97 @@ +use crate::Body; +use pin_project_lite::pin_project; +use std::{ + any::type_name, + fmt, + pin::Pin, + task::{Context, Poll}, +}; + +pin_project! { + /// Body returned by the [`map_err`] combinator. + /// + /// [`map_err`]: crate::util::BodyExt::map_err + #[derive(Clone, Copy)] + pub struct MapErr<B, F> { + #[pin] + inner: B, + f: F + } +} + +impl<B, F> MapErr<B, F> { + #[inline] + pub(crate) fn new(body: B, f: F) -> Self { + Self { inner: body, f } + } + + /// Get a reference to the inner body + pub fn get_ref(&self) -> &B { + &self.inner + } + + /// Get a mutable reference to the inner body + pub fn get_mut(&mut self) -> &mut B { + &mut self.inner + } + + /// Get a pinned mutable reference to the inner body + pub fn get_pin_mut(self: Pin<&mut Self>) -> Pin<&mut B> { + self.project().inner + } + + /// Consume `self`, returning the inner body + pub fn into_inner(self) -> B { + self.inner + } +} + +impl<B, F, E> Body for MapErr<B, F> +where + B: Body, + F: FnMut(B::Error) -> E, +{ + type Data = B::Data; + type Error = E; + + fn poll_data( + self: Pin<&mut Self>, + cx: &mut Context<'_>, + ) -> Poll<Option<Result<Self::Data, Self::Error>>> { + let this = self.project(); + match this.inner.poll_data(cx) { + Poll::Pending => Poll::Pending, + Poll::Ready(None) => Poll::Ready(None), + Poll::Ready(Some(Ok(data))) => Poll::Ready(Some(Ok(data))), + Poll::Ready(Some(Err(err))) => Poll::Ready(Some(Err((this.f)(err)))), + } + } + + fn poll_trailers( + self: Pin<&mut Self>, + cx: &mut Context<'_>, + ) -> Poll<Result<Option<http::HeaderMap>, Self::Error>> { + let this = self.project(); + this.inner.poll_trailers(cx).map_err(this.f) + } + + fn is_end_stream(&self) -> bool { + self.inner.is_end_stream() + } + + fn size_hint(&self) -> crate::SizeHint { + self.inner.size_hint() + } +} + +impl<B, F> fmt::Debug for MapErr<B, F> +where + B: fmt::Debug, +{ + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + f.debug_struct("MapErr") + .field("inner", &self.inner) + .field("f", &type_name::<F>()) + .finish() + } +} diff --git a/third_party/rust/http-body/src/combinators/mod.rs b/third_party/rust/http-body/src/combinators/mod.rs new file mode 100644 index 0000000000..c52f367554 --- /dev/null +++ b/third_party/rust/http-body/src/combinators/mod.rs @@ -0,0 +1,11 @@ +//! Combinators for the `Body` trait. + +mod box_body; +mod map_data; +mod map_err; + +pub use self::{ + box_body::{BoxBody, UnsyncBoxBody}, + map_data::MapData, + map_err::MapErr, +}; diff --git a/third_party/rust/http-body/src/empty.rs b/third_party/rust/http-body/src/empty.rs new file mode 100644 index 0000000000..7d63ceb054 --- /dev/null +++ b/third_party/rust/http-body/src/empty.rs @@ -0,0 +1,75 @@ +use super::{Body, SizeHint}; +use bytes::Buf; +use http::HeaderMap; +use std::{ + convert::Infallible, + fmt, + marker::PhantomData, + pin::Pin, + task::{Context, Poll}, +}; + +/// A body that is always empty. +pub struct Empty<D> { + _marker: PhantomData<fn() -> D>, +} + +impl<D> Empty<D> { + /// Create a new `Empty`. + pub fn new() -> Self { + Self::default() + } +} + +impl<D: Buf> Body for Empty<D> { + type Data = D; + type Error = Infallible; + + #[inline] + fn poll_data( + self: Pin<&mut Self>, + _cx: &mut Context<'_>, + ) -> Poll<Option<Result<Self::Data, Self::Error>>> { + Poll::Ready(None) + } + + #[inline] + fn poll_trailers( + self: Pin<&mut Self>, + _cx: &mut Context<'_>, + ) -> Poll<Result<Option<HeaderMap>, Self::Error>> { + Poll::Ready(Ok(None)) + } + + fn is_end_stream(&self) -> bool { + true + } + + fn size_hint(&self) -> SizeHint { + SizeHint::with_exact(0) + } +} + +impl<D> fmt::Debug for Empty<D> { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + f.debug_struct("Empty").finish() + } +} + +impl<D> Default for Empty<D> { + fn default() -> Self { + Self { + _marker: PhantomData, + } + } +} + +impl<D> Clone for Empty<D> { + fn clone(&self) -> Self { + Self { + _marker: PhantomData, + } + } +} + +impl<D> Copy for Empty<D> {} diff --git a/third_party/rust/http-body/src/full.rs b/third_party/rust/http-body/src/full.rs new file mode 100644 index 0000000000..f1d063b0ae --- /dev/null +++ b/third_party/rust/http-body/src/full.rs @@ -0,0 +1,151 @@ +use crate::{Body, SizeHint}; +use bytes::{Buf, Bytes}; +use http::HeaderMap; +use pin_project_lite::pin_project; +use std::borrow::Cow; +use std::convert::{Infallible, TryFrom}; +use std::pin::Pin; +use std::task::{Context, Poll}; + +pin_project! { + /// A body that consists of a single chunk. + #[derive(Clone, Copy, Debug)] + pub struct Full<D> { + data: Option<D>, + } +} + +impl<D> Full<D> +where + D: Buf, +{ + /// Create a new `Full`. + pub fn new(data: D) -> Self { + let data = if data.has_remaining() { + Some(data) + } else { + None + }; + Full { data } + } +} + +impl<D> Body for Full<D> +where + D: Buf, +{ + type Data = D; + type Error = Infallible; + + fn poll_data( + mut self: Pin<&mut Self>, + _cx: &mut Context<'_>, + ) -> Poll<Option<Result<D, Self::Error>>> { + Poll::Ready(self.data.take().map(Ok)) + } + + fn poll_trailers( + self: Pin<&mut Self>, + _cx: &mut Context<'_>, + ) -> Poll<Result<Option<HeaderMap>, Self::Error>> { + Poll::Ready(Ok(None)) + } + + fn is_end_stream(&self) -> bool { + self.data.is_none() + } + + fn size_hint(&self) -> SizeHint { + self.data + .as_ref() + .map(|data| SizeHint::with_exact(u64::try_from(data.remaining()).unwrap())) + .unwrap_or_else(|| SizeHint::with_exact(0)) + } +} + +impl<D> Default for Full<D> +where + D: Buf, +{ + /// Create an empty `Full`. + fn default() -> Self { + Full { data: None } + } +} + +impl<D> From<Bytes> for Full<D> +where + D: Buf + From<Bytes>, +{ + fn from(bytes: Bytes) -> Self { + Full::new(D::from(bytes)) + } +} + +impl<D> From<Vec<u8>> for Full<D> +where + D: Buf + From<Vec<u8>>, +{ + fn from(vec: Vec<u8>) -> Self { + Full::new(D::from(vec)) + } +} + +impl<D> From<&'static [u8]> for Full<D> +where + D: Buf + From<&'static [u8]>, +{ + fn from(slice: &'static [u8]) -> Self { + Full::new(D::from(slice)) + } +} + +impl<D, B> From<Cow<'static, B>> for Full<D> +where + D: Buf + From<&'static B> + From<B::Owned>, + B: ToOwned + ?Sized, +{ + fn from(cow: Cow<'static, B>) -> Self { + match cow { + Cow::Borrowed(b) => Full::new(D::from(b)), + Cow::Owned(o) => Full::new(D::from(o)), + } + } +} + +impl<D> From<String> for Full<D> +where + D: Buf + From<String>, +{ + fn from(s: String) -> Self { + Full::new(D::from(s)) + } +} + +impl<D> From<&'static str> for Full<D> +where + D: Buf + From<&'static str>, +{ + fn from(slice: &'static str) -> Self { + Full::new(D::from(slice)) + } +} + +#[cfg(test)] +mod tests { + use super::*; + + #[tokio::test] + async fn full_returns_some() { + let mut full = Full::new(&b"hello"[..]); + assert_eq!(full.size_hint().exact(), Some(b"hello".len() as u64)); + assert_eq!(full.data().await, Some(Ok(&b"hello"[..]))); + assert!(full.data().await.is_none()); + } + + #[tokio::test] + async fn empty_full_returns_none() { + assert!(Full::<&[u8]>::default().data().await.is_none()); + assert!(Full::new(&b""[..]).data().await.is_none()); + } +} diff --git a/third_party/rust/http-body/src/lib.rs b/third_party/rust/http-body/src/lib.rs new file mode 100644 index 0000000000..84efd9169f --- /dev/null +++ b/third_party/rust/http-body/src/lib.rs @@ -0,0 +1,324 @@ +#![doc(html_root_url = "https://docs.rs/http-body/0.4.5")] +#![deny( + missing_debug_implementations, + missing_docs, + unreachable_pub, + broken_intra_doc_links +)] +#![cfg_attr(test, deny(warnings))] + +//! Asynchronous HTTP request or response body. +//! +//! See [`Body`] for more details. +//! +//! [`Body`]: trait.Body.html + +mod empty; +mod full; +mod limited; +mod next; +mod size_hint; + +pub mod combinators; + +pub use self::empty::Empty; +pub use self::full::Full; +pub use self::limited::{LengthLimitError, Limited}; +pub use self::next::{Data, Trailers}; +pub use self::size_hint::SizeHint; + +use self::combinators::{BoxBody, MapData, MapErr, UnsyncBoxBody}; +use bytes::{Buf, Bytes}; +use http::HeaderMap; +use std::convert::Infallible; +use std::ops; +use std::pin::Pin; +use std::task::{Context, Poll}; + +/// Trait representing a streaming body of a Request or Response. +/// +/// Data is streamed via the `poll_data` function, which asynchronously yields `T: Buf` values. The +/// `size_hint` function provides insight into the total number of bytes that will be streamed. +/// +/// The `poll_trailers` function returns an optional set of trailers used to finalize the request / +/// response exchange. This is mostly used when using the HTTP/2.0 protocol. +/// +pub trait Body { + /// Values yielded by the `Body`. + type Data: Buf; + + /// The error type this `Body` might generate. + type Error; + + /// Attempt to pull out the next data buffer of this stream. + fn poll_data( + self: Pin<&mut Self>, + cx: &mut Context<'_>, + ) -> Poll<Option<Result<Self::Data, Self::Error>>>; + + /// Poll for an optional **single** `HeaderMap` of trailers. + /// + /// This function should only be called once `poll_data` returns `None`. + fn poll_trailers( + self: Pin<&mut Self>, + cx: &mut Context<'_>, + ) -> Poll<Result<Option<HeaderMap>, Self::Error>>; + + /// Returns `true` when the end of stream has been reached. + /// + /// An end of stream means that both `poll_data` and `poll_trailers` will + /// return `None`. + /// + /// A return value of `false` **does not** guarantee that a value will be + /// returned from `poll_stream` or `poll_trailers`. + fn is_end_stream(&self) -> bool { + false + } + + /// Returns the bounds on the remaining length of the stream. + /// + /// When the **exact** remaining length of the stream is known, the upper bound will be set and + /// will equal the lower bound. + fn size_hint(&self) -> SizeHint { + SizeHint::default() + } + + /// Returns future that resolves to next data chunk, if any. + fn data(&mut self) -> Data<'_, Self> + where + Self: Unpin + Sized, + { + Data(self) + } + + /// Returns future that resolves to trailers, if any. + fn trailers(&mut self) -> Trailers<'_, Self> + where + Self: Unpin + Sized, + { + Trailers(self) + } + + /// Maps this body's data value to a different value. + fn map_data<F, B>(self, f: F) -> MapData<Self, F> + where + Self: Sized, + F: FnMut(Self::Data) -> B, + B: Buf, + { + MapData::new(self, f) + } + + /// Maps this body's error value to a different value. + fn map_err<F, E>(self, f: F) -> MapErr<Self, F> + where + Self: Sized, + F: FnMut(Self::Error) -> E, + { + MapErr::new(self, f) + } + + /// Turn this body into a boxed trait object. + fn boxed(self) -> BoxBody<Self::Data, Self::Error> + where + Self: Sized + Send + Sync + 'static, + { + BoxBody::new(self) + } + + /// Turn this body into a boxed trait object that is !Sync. + fn boxed_unsync(self) -> UnsyncBoxBody<Self::Data, Self::Error> + where + Self: Sized + Send + 'static, + { + UnsyncBoxBody::new(self) + } +} + +impl<T: Body + Unpin + ?Sized> Body for &mut T { + type Data = T::Data; + type Error = T::Error; + + fn poll_data( + mut self: Pin<&mut Self>, + cx: &mut Context<'_>, + ) -> Poll<Option<Result<Self::Data, Self::Error>>> { + Pin::new(&mut **self).poll_data(cx) + } + + fn poll_trailers( + mut self: Pin<&mut Self>, + cx: &mut Context<'_>, + ) -> Poll<Result<Option<HeaderMap>, Self::Error>> { + Pin::new(&mut **self).poll_trailers(cx) + } + + fn is_end_stream(&self) -> bool { + Pin::new(&**self).is_end_stream() + } + + fn size_hint(&self) -> SizeHint { + Pin::new(&**self).size_hint() + } +} + +impl<P> Body for Pin<P> +where + P: Unpin + ops::DerefMut, + P::Target: Body, +{ + type Data = <<P as ops::Deref>::Target as Body>::Data; + type Error = <<P as ops::Deref>::Target as Body>::Error; + + fn poll_data( + self: Pin<&mut Self>, + cx: &mut Context<'_>, + ) -> Poll<Option<Result<Self::Data, Self::Error>>> { + Pin::get_mut(self).as_mut().poll_data(cx) + } + + fn poll_trailers( + self: Pin<&mut Self>, + cx: &mut Context<'_>, + ) -> Poll<Result<Option<HeaderMap>, Self::Error>> { + Pin::get_mut(self).as_mut().poll_trailers(cx) + } + + fn is_end_stream(&self) -> bool { + self.as_ref().is_end_stream() + } + + fn size_hint(&self) -> SizeHint { + self.as_ref().size_hint() + } +} + +impl<T: Body + Unpin + ?Sized> Body for Box<T> { + type Data = T::Data; + type Error = T::Error; + + fn poll_data( + mut self: Pin<&mut Self>, + cx: &mut Context<'_>, + ) -> Poll<Option<Result<Self::Data, Self::Error>>> { + Pin::new(&mut **self).poll_data(cx) + } + + fn poll_trailers( + mut self: Pin<&mut Self>, + cx: &mut Context<'_>, + ) -> Poll<Result<Option<HeaderMap>, Self::Error>> { + Pin::new(&mut **self).poll_trailers(cx) + } + + fn is_end_stream(&self) -> bool { + self.as_ref().is_end_stream() + } + + fn size_hint(&self) -> SizeHint { + self.as_ref().size_hint() + } +} + +impl<B: Body> Body for http::Request<B> { + type Data = B::Data; + type Error = B::Error; + + fn poll_data( + self: Pin<&mut Self>, + cx: &mut Context<'_>, + ) -> Poll<Option<Result<Self::Data, Self::Error>>> { + unsafe { + self.map_unchecked_mut(http::Request::body_mut) + .poll_data(cx) + } + } + + fn poll_trailers( + self: Pin<&mut Self>, + cx: &mut Context<'_>, + ) -> Poll<Result<Option<HeaderMap>, Self::Error>> { + unsafe { + self.map_unchecked_mut(http::Request::body_mut) + .poll_trailers(cx) + } + } + + fn is_end_stream(&self) -> bool { + self.body().is_end_stream() + } + + fn size_hint(&self) -> SizeHint { + self.body().size_hint() + } +} + +impl<B: Body> Body for http::Response<B> { + type Data = B::Data; + type Error = B::Error; + + fn poll_data( + self: Pin<&mut Self>, + cx: &mut Context<'_>, + ) -> Poll<Option<Result<Self::Data, Self::Error>>> { + unsafe { + self.map_unchecked_mut(http::Response::body_mut) + .poll_data(cx) + } + } + + fn poll_trailers( + self: Pin<&mut Self>, + cx: &mut Context<'_>, + ) -> Poll<Result<Option<HeaderMap>, Self::Error>> { + unsafe { + self.map_unchecked_mut(http::Response::body_mut) + .poll_trailers(cx) + } + } + + fn is_end_stream(&self) -> bool { + self.body().is_end_stream() + } + + fn size_hint(&self) -> SizeHint { + self.body().size_hint() + } +} + +impl Body for String { + type Data = Bytes; + type Error = Infallible; + + fn poll_data( + mut self: Pin<&mut Self>, + _cx: &mut Context<'_>, + ) -> Poll<Option<Result<Self::Data, Self::Error>>> { + if !self.is_empty() { + let s = std::mem::take(&mut *self); + Poll::Ready(Some(Ok(s.into_bytes().into()))) + } else { + Poll::Ready(None) + } + } + + fn poll_trailers( + self: Pin<&mut Self>, + _cx: &mut Context<'_>, + ) -> Poll<Result<Option<HeaderMap>, Self::Error>> { + Poll::Ready(Ok(None)) + } + + fn is_end_stream(&self) -> bool { + self.is_empty() + } + + fn size_hint(&self) -> SizeHint { + SizeHint::with_exact(self.len() as u64) + } +} + +#[cfg(test)] +fn _assert_bounds() { + fn can_be_trait_object(_: &dyn Body<Data = std::io::Cursor<Vec<u8>>, Error = std::io::Error>) {} +} diff --git a/third_party/rust/http-body/src/limited.rs b/third_party/rust/http-body/src/limited.rs new file mode 100644 index 0000000000..a40add91f9 --- /dev/null +++ b/third_party/rust/http-body/src/limited.rs @@ -0,0 +1,299 @@ +use crate::{Body, SizeHint}; +use bytes::Buf; +use http::HeaderMap; +use pin_project_lite::pin_project; +use std::error::Error; +use std::fmt; +use std::pin::Pin; +use std::task::{Context, Poll}; + +pin_project! { + /// A length limited body. + /// + /// This body will return an error if more than the configured number + /// of bytes are returned on polling the wrapped body. + #[derive(Clone, Copy, Debug)] + pub struct Limited<B> { + remaining: usize, + #[pin] + inner: B, + } +} + +impl<B> Limited<B> { + /// Create a new `Limited`. + pub fn new(inner: B, limit: usize) -> Self { + Self { + remaining: limit, + inner, + } + } +} + +impl<B> Body for Limited<B> +where + B: Body, + B::Error: Into<Box<dyn Error + Send + Sync>>, +{ + type Data = B::Data; + type Error = Box<dyn Error + Send + Sync>; + + fn poll_data( + self: Pin<&mut Self>, + cx: &mut Context<'_>, + ) -> Poll<Option<Result<Self::Data, Self::Error>>> { + let this = self.project(); + let res = match this.inner.poll_data(cx) { + Poll::Pending => return Poll::Pending, + Poll::Ready(None) => None, + Poll::Ready(Some(Ok(data))) => { + if data.remaining() > *this.remaining { + *this.remaining = 0; + Some(Err(LengthLimitError.into())) + } else { + *this.remaining -= data.remaining(); + Some(Ok(data)) + } + } + Poll::Ready(Some(Err(err))) => Some(Err(err.into())), + }; + + Poll::Ready(res) + } + + fn poll_trailers( + self: Pin<&mut Self>, + cx: &mut Context<'_>, + ) -> Poll<Result<Option<HeaderMap>, Self::Error>> { + let this = self.project(); + let res = match this.inner.poll_trailers(cx) { + Poll::Pending => return Poll::Pending, + Poll::Ready(Ok(data)) => Ok(data), + Poll::Ready(Err(err)) => Err(err.into()), + }; + + Poll::Ready(res) + } + + fn is_end_stream(&self) -> bool { + self.inner.is_end_stream() + } + + fn size_hint(&self) -> SizeHint { + use std::convert::TryFrom; + match u64::try_from(self.remaining) { + Ok(n) => { + let mut hint = self.inner.size_hint(); + if hint.lower() >= n { + hint.set_exact(n) + } else if let Some(max) = hint.upper() { + hint.set_upper(n.min(max)) + } else { + hint.set_upper(n) + } + hint + } + Err(_) => self.inner.size_hint(), + } + } +} + +/// An error returned when body length exceeds the configured limit. +#[derive(Debug)] +#[non_exhaustive] +pub struct LengthLimitError; + +impl fmt::Display for LengthLimitError { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + f.write_str("length limit exceeded") + } +} + +impl Error for LengthLimitError {} + +#[cfg(test)] +mod tests { + use super::*; + use crate::Full; + use bytes::Bytes; + use std::convert::Infallible; + + #[tokio::test] + async fn read_for_body_under_limit_returns_data() { + const DATA: &[u8] = b"testing"; + let inner = Full::new(Bytes::from(DATA)); + let body = &mut Limited::new(inner, 8); + + let mut hint = SizeHint::new(); + hint.set_upper(7); + assert_eq!(body.size_hint().upper(), hint.upper()); + + let data = body.data().await.unwrap().unwrap(); + assert_eq!(data, DATA); + hint.set_upper(0); + assert_eq!(body.size_hint().upper(), hint.upper()); + + assert!(matches!(body.data().await, None)); + } + + #[tokio::test] + async fn read_for_body_over_limit_returns_error() { + const DATA: &[u8] = b"testing a string that is too long"; + let inner = Full::new(Bytes::from(DATA)); + let body = &mut Limited::new(inner, 8); + + let mut hint = SizeHint::new(); + hint.set_upper(8); + assert_eq!(body.size_hint().upper(), hint.upper()); + + let error = body.data().await.unwrap().unwrap_err(); + assert!(matches!(error.downcast_ref(), Some(LengthLimitError))); + } + + struct Chunky(&'static [&'static [u8]]); + + impl Body for Chunky { + type Data = &'static [u8]; + type Error = Infallible; + + fn poll_data( + self: Pin<&mut Self>, + _cx: &mut Context<'_>, + ) -> Poll<Option<Result<Self::Data, Self::Error>>> { + let mut this = self; + match this.0.split_first().map(|(&head, tail)| (Ok(head), tail)) { + Some((data, new_tail)) => { + this.0 = new_tail; + + Poll::Ready(Some(data)) + } + None => Poll::Ready(None), + } + } + + fn poll_trailers( + self: Pin<&mut Self>, + _cx: &mut Context<'_>, + ) -> Poll<Result<Option<HeaderMap>, Self::Error>> { + Poll::Ready(Ok(Some(HeaderMap::new()))) + } + } + + #[tokio::test] + async fn read_for_chunked_body_around_limit_returns_first_chunk_but_returns_error_on_over_limit_chunk( + ) { + const DATA: &[&[u8]] = &[b"testing ", b"a string that is too long"]; + let inner = Chunky(DATA); + let body = &mut Limited::new(inner, 8); + + let mut hint = SizeHint::new(); + hint.set_upper(8); + assert_eq!(body.size_hint().upper(), hint.upper()); + + let data = body.data().await.unwrap().unwrap(); + assert_eq!(data, DATA[0]); + hint.set_upper(0); + assert_eq!(body.size_hint().upper(), hint.upper()); + + let error = body.data().await.unwrap().unwrap_err(); + assert!(matches!(error.downcast_ref(), Some(LengthLimitError))); + } + + #[tokio::test] + async fn read_for_chunked_body_over_limit_on_first_chunk_returns_error() { + const DATA: &[&[u8]] = &[b"testing a string", b" that is too long"]; + let inner = Chunky(DATA); + let body = &mut Limited::new(inner, 8); + + let mut hint = SizeHint::new(); + hint.set_upper(8); + assert_eq!(body.size_hint().upper(), hint.upper()); + + let error = body.data().await.unwrap().unwrap_err(); + assert!(matches!(error.downcast_ref(), Some(LengthLimitError))); + } + + #[tokio::test] + async fn read_for_chunked_body_under_limit_is_okay() { + const DATA: &[&[u8]] = &[b"test", b"ing!"]; + let inner = Chunky(DATA); + let body = &mut Limited::new(inner, 8); + + let mut hint = SizeHint::new(); + hint.set_upper(8); + assert_eq!(body.size_hint().upper(), hint.upper()); + + let data = body.data().await.unwrap().unwrap(); + assert_eq!(data, DATA[0]); + hint.set_upper(4); + assert_eq!(body.size_hint().upper(), hint.upper()); + + let data = body.data().await.unwrap().unwrap(); + assert_eq!(data, DATA[1]); + hint.set_upper(0); + assert_eq!(body.size_hint().upper(), hint.upper()); + + assert!(matches!(body.data().await, None)); + } + + #[tokio::test] + async fn read_for_trailers_propagates_inner_trailers() { + const DATA: &[&[u8]] = &[b"test", b"ing!"]; + let inner = Chunky(DATA); + let body = &mut Limited::new(inner, 8); + let trailers = body.trailers().await.unwrap(); + assert_eq!(trailers, Some(HeaderMap::new())) + } + + #[derive(Debug)] + enum ErrorBodyError { + Data, + Trailers, + } + + impl fmt::Display for ErrorBodyError { + fn fmt(&self, _f: &mut fmt::Formatter) -> fmt::Result { + Ok(()) + } + } + + impl Error for ErrorBodyError {} + + struct ErrorBody; + + impl Body for ErrorBody { + type Data = &'static [u8]; + type Error = ErrorBodyError; + + fn poll_data( + self: Pin<&mut Self>, + _cx: &mut Context<'_>, + ) -> Poll<Option<Result<Self::Data, Self::Error>>> { + Poll::Ready(Some(Err(ErrorBodyError::Data))) + } + + fn poll_trailers( + self: Pin<&mut Self>, + _cx: &mut Context<'_>, + ) -> Poll<Result<Option<HeaderMap>, Self::Error>> { + Poll::Ready(Err(ErrorBodyError::Trailers)) + } + } + + #[tokio::test] + async fn read_for_body_returning_error_propagates_error() { + let body = &mut Limited::new(ErrorBody, 8); + let error = body.data().await.unwrap().unwrap_err(); + assert!(matches!(error.downcast_ref(), Some(ErrorBodyError::Data))); + } + + #[tokio::test] + async fn trailers_for_body_returning_error_propagates_error() { + let body = &mut Limited::new(ErrorBody, 8); + let error = body.trailers().await.unwrap_err(); + assert!(matches!( + error.downcast_ref(), + Some(ErrorBodyError::Trailers) + )); + } +} diff --git a/third_party/rust/http-body/src/next.rs b/third_party/rust/http-body/src/next.rs new file mode 100644 index 0000000000..fc87ffcf01 --- /dev/null +++ b/third_party/rust/http-body/src/next.rs @@ -0,0 +1,31 @@ +use crate::Body; + +use core::future::Future; +use core::pin::Pin; +use core::task; + +#[must_use = "futures don't do anything unless polled"] +#[derive(Debug)] +/// Future that resolves to the next data chunk from `Body` +pub struct Data<'a, T: ?Sized>(pub(crate) &'a mut T); + +impl<'a, T: Body + Unpin + ?Sized> Future for Data<'a, T> { + type Output = Option<Result<T::Data, T::Error>>; + + fn poll(mut self: Pin<&mut Self>, ctx: &mut task::Context<'_>) -> task::Poll<Self::Output> { + Pin::new(&mut self.0).poll_data(ctx) + } +} + +#[must_use = "futures don't do anything unless polled"] +#[derive(Debug)] +/// Future that resolves to the optional trailers from `Body` +pub struct Trailers<'a, T: ?Sized>(pub(crate) &'a mut T); + +impl<'a, T: Body + Unpin + ?Sized> Future for Trailers<'a, T> { + type Output = Result<Option<http::HeaderMap>, T::Error>; + + fn poll(mut self: Pin<&mut Self>, ctx: &mut task::Context<'_>) -> task::Poll<Self::Output> { + Pin::new(&mut self.0).poll_trailers(ctx) + } +} diff --git a/third_party/rust/http-body/src/size_hint.rs b/third_party/rust/http-body/src/size_hint.rs new file mode 100644 index 0000000000..00a8f19177 --- /dev/null +++ b/third_party/rust/http-body/src/size_hint.rs @@ -0,0 +1,86 @@ +use std::u64; + +/// A `Body` size hint +/// +/// The default implementation returns: +/// +/// * 0 for `lower` +/// * `None` for `upper`. +#[derive(Debug, Default, Clone)] +pub struct SizeHint { + lower: u64, + upper: Option<u64>, +} + +impl SizeHint { + /// Returns a new `SizeHint` with default values + #[inline] + pub fn new() -> SizeHint { + SizeHint::default() + } + + /// Returns a new `SizeHint` with both upper and lower bounds set to the + /// given value. + #[inline] + pub fn with_exact(value: u64) -> SizeHint { + SizeHint { + lower: value, + upper: Some(value), + } + } + + /// Returns the lower bound of data that the `Body` will yield before + /// completing. + #[inline] + pub fn lower(&self) -> u64 { + self.lower + } + + /// Set the value of the `lower` hint. + /// + /// # Panics + /// + /// The function panics if `value` is greater than `upper`. + #[inline] + pub fn set_lower(&mut self, value: u64) { + assert!(value <= self.upper.unwrap_or(u64::MAX)); + self.lower = value; + } + + /// Returns the upper bound of data the `Body` will yield before + /// completing, or `None` if the value is unknown. + #[inline] + pub fn upper(&self) -> Option<u64> { + self.upper + } + + /// Set the value of the `upper` hint value. + /// + /// # Panics + /// + /// This function panics if `value` is less than `lower`. + #[inline] + pub fn set_upper(&mut self, value: u64) { + assert!(value >= self.lower, "`value` is less than than `lower`"); + + self.upper = Some(value); + } + + /// Returns the exact size of data that will be yielded **if** the + /// `lower` and `upper` bounds are equal. + #[inline] + pub fn exact(&self) -> Option<u64> { + if Some(self.lower) == self.upper { + self.upper + } else { + None + } + } + + /// Set the value of the `lower` and `upper` bounds to exactly the same. + #[inline] + pub fn set_exact(&mut self, value: u64) { + self.lower = value; + self.upper = Some(value); + } +} diff --git a/third_party/rust/http-body/tests/is_end_stream.rs b/third_party/rust/http-body/tests/is_end_stream.rs new file mode 100644 index 0000000000..beaeb0b1a0 --- /dev/null +++ b/third_party/rust/http-body/tests/is_end_stream.rs @@ -0,0 +1,79 @@ +use http::HeaderMap; +use http_body::{Body, SizeHint}; +use std::pin::Pin; +use std::task::{Context, Poll}; + +struct Mock { + size_hint: SizeHint, +} + +impl Body for Mock { + type Data = ::std::io::Cursor<Vec<u8>>; + type Error = (); + + fn poll_data( + self: Pin<&mut Self>, + _cx: &mut Context<'_>, + ) -> Poll<Option<Result<Self::Data, Self::Error>>> { + Poll::Ready(None) + } + + fn poll_trailers( + self: Pin<&mut Self>, + _cx: &mut Context<'_>, + ) -> Poll<Result<Option<HeaderMap>, Self::Error>> { + Poll::Ready(Ok(None)) + } + + fn size_hint(&self) -> SizeHint { + self.size_hint.clone() + } +} + +#[test] +fn is_end_stream_true() { + let combos = [ + (None, None, false), + (Some(123), None, false), + (Some(0), Some(123), false), + (Some(123), Some(123), false), + (Some(0), Some(0), false), + ]; + + for &(lower, upper, is_end_stream) in &combos { + let mut size_hint = SizeHint::new(); + assert_eq!(0, size_hint.lower()); + assert!(size_hint.upper().is_none()); + + if let Some(lower) = lower { + size_hint.set_lower(lower); + } + + if let Some(upper) = upper { + size_hint.set_upper(upper); + } + + let mut mock = Mock { size_hint }; + + assert_eq!( + is_end_stream, + Pin::new(&mut mock).is_end_stream(), + "size_hint = {:?}", + mock.size_hint.clone() + ); + } +} + +#[test] +fn is_end_stream_default_false() { + let mut mock = Mock { + size_hint: SizeHint::default(), + }; + + assert_eq!( + false, + Pin::new(&mut mock).is_end_stream(), + "size_hint = {:?}", + mock.size_hint.clone() + ); +} |