Avoid http-body-util in public API

Author: djc

Cargo.toml

@@ -74,7 +74,6 @@ allowed_external_types = [
     "bytes::*",
     "http::*",
     "http_body::*",
-    "http_body_util::*",
     "hyper::*",
     "rustls_pki_types::*",
     "serde::*",

src/account.rs

@@ -6,24 +6,22 @@ use base64::prelude::{BASE64_URL_SAFE_NO_PAD, Engine};
 use http::header::LOCATION;
 #[cfg(feature = "time")]
 use http::{Method, Request};
-#[cfg(feature = "time")]
-use http_body_util::Full;
 use rustls_pki_types::{PrivateKeyDer, PrivatePkcs8KeyDer};
 use serde::de::DeserializeOwned;
 use serde::{Deserialize, Serialize};
 
 #[cfg(feature = "hyper-rustls")]
 use crate::DefaultClient;
 use crate::order::Order;
-#[cfg(feature = "time")]
-use crate::retry_after;
 use crate::types::{
     AccountCredentials, AuthorizationStatus, Empty, Header, JoseJson, Jwk, KeyOrKeyId, NewAccount,
     NewAccountPayload, NewOrder, OrderState, Problem, ProfileMeta, RevocationRequest, Signer,
     SigningAlgorithm,
 };
 #[cfg(feature = "time")]
 use crate::types::{CertificateIdentifier, RenewalInfo};
+#[cfg(feature = "time")]
+use crate::{BodyWrapper, retry_after};
 use crate::{BytesResponse, Client, Error, HttpClient, crypto, nonce_from_response};
 
 /// An ACME account as described in RFC 8555 (section 7.1.2)
@@ -169,10 +167,9 @@ impl Account {
         let request = Request::builder()
             .method(Method::GET)
             .uri(format!("{renewal_info_url}/{certificate_id}"))
-            .body(Full::default())?;
+            .body(BodyWrapper::default())?;
 
         let rsp = self.inner.client.http.request(request).await?;
-
         let Some(retry_after) = retry_after(&rsp) else {
             return Err(Error::Str("missing Retry-After header"));
         };

src/lib.rs

@@ -4,18 +4,21 @@
 #![warn(missing_docs)]
 #![cfg_attr(docsrs, feature(doc_cfg, doc_auto_cfg))]
 
+use std::convert::Infallible;
 use std::error::Error as StdError;
 use std::fmt;
 use std::future::Future;
 use std::pin::Pin;
 use std::str::FromStr;
+use std::task::{Context, Poll};
 use std::time::{Duration, SystemTime};
 
 use async_trait::async_trait;
-use bytes::Bytes;
+use bytes::{Buf, Bytes};
 use http::header::{CONTENT_TYPE, RETRY_AFTER};
 use http::{Method, Request, Response, StatusCode};
-use http_body_util::{BodyExt, Full};
+use http_body::{Frame, SizeHint};
+use http_body_util::BodyExt;
 use httpdate::HttpDate;
 #[cfg(feature = "hyper-rustls")]
 use hyper::body::Incoming;
@@ -56,7 +59,7 @@ impl Client {
     async fn new(directory_url: String, http: Box<dyn HttpClient>) -> Result<Self, Error> {
         let req = Request::builder()
             .uri(&directory_url)
-            .body(Full::default())
+            .body(BodyWrapper::default())
             .expect("infallible error should not occur");
         let rsp = http.request(req).await?;
         let body = rsp.body().await.map_err(Error::Other)?;
@@ -117,7 +120,7 @@ impl Client {
             .method(Method::POST)
             .uri(url)
             .header(CONTENT_TYPE, JOSE_JSON)
-            .body(Full::from(serde_json::to_vec(&body)?))?;
+            .body(BodyWrapper::from(serde_json::to_vec(&body)?))?;
 
         self.http.request(request).await
     }
@@ -130,7 +133,7 @@ impl Client {
         let request = Request::builder()
             .method(Method::HEAD)
             .uri(&self.directory.new_nonce)
-            .body(Full::default())
+            .body(BodyWrapper::default())
             .expect("infallible error should not occur");
 
         let rsp = self.http.request(request).await?;
@@ -187,7 +190,7 @@ fn retry_after(rsp: &BytesResponse) -> Option<SystemTime> {
 }
 
 #[cfg(feature = "hyper-rustls")]
-struct DefaultClient(HyperClient<hyper_rustls::HttpsConnector<HttpConnector>, Full<Bytes>>);
+struct DefaultClient(HyperClient<hyper_rustls::HttpsConnector<HttpConnector>, BodyWrapper<Bytes>>);
 
 #[cfg(feature = "hyper-rustls")]
 impl DefaultClient {
@@ -210,7 +213,7 @@ impl DefaultClient {
 impl HttpClient for DefaultClient {
     fn request(
         &self,
-        req: Request<Full<Bytes>>,
+        req: Request<BodyWrapper<Bytes>>,
     ) -> Pin<Box<dyn Future<Output = Result<BytesResponse, Error>> + Send>> {
         let fut = self.0.request(req);
         Box::pin(async move { BytesResponse::try_from(fut.await) })
@@ -222,15 +225,15 @@ pub trait HttpClient: Send + Sync + 'static {
     /// Send the given request and return the response
     fn request(
         &self,
-        req: Request<Full<Bytes>>,
+        req: Request<BodyWrapper<Bytes>>,
     ) -> Pin<Box<dyn Future<Output = Result<BytesResponse, Error>> + Send>>;
 }
 
 #[cfg(feature = "hyper-rustls")]
-impl<C: Connect + Clone + Send + Sync + 'static> HttpClient for HyperClient<C, Full<Bytes>> {
+impl<C: Connect + Clone + Send + Sync + 'static> HttpClient for HyperClient<C, BodyWrapper<Bytes>> {
     fn request(
         &self,
-        req: Request<Full<Bytes>>,
+        req: Request<BodyWrapper<Bytes>>,
     ) -> Pin<Box<dyn Future<Output = Result<BytesResponse, Error>> + Send>> {
         let fut = self.request(req);
         Box::pin(async move { BytesResponse::try_from(fut.await) })
@@ -276,7 +279,9 @@ where
     }
 }
 
-struct BodyWrapper<B> {
+/// A simple HTTP body wrapper type
+#[derive(Default)]
+pub struct BodyWrapper<B> {
     inner: Option<B>,
 }
 
@@ -299,6 +304,37 @@ where
     }
 }
 
+impl http_body::Body for BodyWrapper<Bytes> {
+    type Data = Bytes;
+    type Error = Infallible;
+
+    fn poll_frame(
+        mut self: Pin<&mut Self>,
+        _cx: &mut Context<'_>,
+    ) -> Poll<Option<Result<Frame<Self::Data>, Self::Error>>> {
+        Poll::Ready(self.inner.take().map(|d| Ok(Frame::data(d))))
+    }
+
+    fn is_end_stream(&self) -> bool {
+        self.inner.is_none()
+    }
+
+    fn size_hint(&self) -> SizeHint {
+        match self.inner.as_ref() {
+            Some(data) => SizeHint::with_exact(u64::try_from(data.remaining()).unwrap()),
+            None => SizeHint::with_exact(0),
+        }
+    }
+}
+
+impl From<Vec<u8>> for BodyWrapper<Bytes> {
+    fn from(data: Vec<u8>) -> Self {
+        BodyWrapper {
+            inner: Some(Bytes::from(data)),
+        }
+    }
+}
+
 #[async_trait]
 impl BytesBody for Bytes {
     async fn into_bytes(&mut self) -> Result<Bytes, Box<dyn StdError + Send + Sync + 'static>> {

tests/pebble.rs

@@ -19,13 +19,14 @@ use base64::prelude::BASE64_URL_SAFE_NO_PAD;
 use bytes::{Buf, Bytes};
 use http::header::CONTENT_TYPE;
 use http::{Method, Request};
-use http_body_util::{BodyExt, Full};
+use http_body_util::BodyExt;
 use hyper_util::client::legacy::Client as HyperClient;
 use hyper_util::client::legacy::connect::HttpConnector;
 use hyper_util::rt::TokioExecutor;
 use instant_acme::{
-    Account, AuthorizationStatus, ChallengeHandle, ChallengeType, Error, ExternalAccountKey,
-    Identifier, Key, KeyAuthorization, NewAccount, NewOrder, Order, OrderStatus, RetryPolicy,
+    Account, AuthorizationStatus, BodyWrapper, ChallengeHandle, ChallengeType, Error,
+    ExternalAccountKey, Identifier, Key, KeyAuthorization, NewAccount, NewOrder, Order,
+    OrderStatus, RetryPolicy,
 };
 #[cfg(all(feature = "time", feature = "x509-parser"))]
 use instant_acme::{CertificateIdentifier, RevocationRequest};
@@ -469,7 +470,7 @@ struct Environment {
     pebble: Subprocess,
     #[allow(dead_code)] // Held for the lifetime of the environment.
     challtestsrv: Subprocess,
-    client: HyperClient<hyper_rustls::HttpsConnector<HttpConnector>, Full<Bytes>>,
+    client: HyperClient<hyper_rustls::HttpsConnector<HttpConnector>, BodyWrapper<Bytes>>,
 }
 
 impl Environment {
@@ -681,7 +682,7 @@ impl Environment {
                 &self.config.pebble.management_listen_address
             ))
             .header(CONTENT_TYPE, "application/json")
-            .body(Full::default())?;
+            .body(BodyWrapper::default())?;
 
         let resp = self.client.request(req).await?;
         if resp.status() != 200 {
@@ -712,7 +713,7 @@ impl Environment {
                     .method(Method::POST)
                     .uri(url)
                     .header(CONTENT_TYPE, "application/json")
-                    .body(Full::from(body))?,
+                    .body(BodyWrapper::from(body))?,
             )
             .await?;
         Ok(())