fixup! ACME: certificate issue and renewal implementation.

Author: bavshin-f5

src/acme.rs

@@ -1,5 +1,4 @@
 use core::cell::RefCell;
-use core::error::Error as StdError;
 use core::ptr::NonNull;
 use core::time::Duration;
 use std::collections::VecDeque;
@@ -9,8 +8,6 @@ use std::string::{String, ToString};
 use anyhow::{anyhow, Result};
 use bytes::Bytes;
 use http::Uri;
-use http_body::Body;
-use http_body_util::{BodyExt, Empty, Full};
 use ngx::allocator::{Allocator, Box};
 use ngx::async_::sleep;
 use ngx::collections::Vec;
@@ -85,14 +82,6 @@ fn try_get_header<K: http::header::AsHeaderName>(
     headers.get(key).and_then(|x| x.to_str().ok())
 }
 
-pub async fn collect_body<T>(body: T) -> Result<Bytes, T::Error>
-where
-    T: Body,
-    T::Error: StdError + Send + Sync + 'static,
-{
-    Ok(body.collect().await?.to_bytes())
-}
-
 impl<'a, Http> AcmeClient<'a, Http>
 where
     Http: HttpClient,
@@ -129,8 +118,7 @@ where
 
     async fn get_directory(&mut self) -> Result<types::Directory> {
         let res = self.get(&self.issuer.uri).await?;
-        let bytes = collect_body(res).await?;
-        let directory = serde_json::from_slice(&bytes)?;
+        let directory = serde_json::from_slice(res.body())?;
 
         Ok(directory)
     }
@@ -163,8 +151,7 @@ where
                 .and_then(parse_retry_after)
                 .unwrap_or(DEFAULT_RETRY_INTERVAL);
 
-            let bytes = collect_body(res).await?;
-            let result = serde_json::from_slice(&bytes)?;
+            let result = serde_json::from_slice(res.body())?;
 
             if predicate(&result) {
                 return Ok(result);
@@ -185,24 +172,23 @@ where
         payload: P,
     ) -> Result<T> {
         let res = self.post(url, payload).await?;
-        let bytes = collect_body(res).await?;
-        Ok(serde_json::from_slice(&bytes)?)
+        Ok(serde_json::from_slice(res.body())?)
     }
 
-    pub async fn get(&self, url: &Uri) -> Result<http::Response<Http::Body>> {
+    pub async fn get(&self, url: &Uri) -> Result<http::Response<Bytes>> {
         let req = http::Request::builder()
             .uri(url)
             .method(http::Method::GET)
             .header(http::header::CONTENT_LENGTH, 0)
-            .body(Empty::<Bytes>::new())?;
+            .body(String::new())?;
         Ok(self.http.request(req).await?)
     }
 
     pub async fn post<P: AsRef<[u8]>>(
         &self,
         url: &Uri,
         payload: P,
-    ) -> Result<http::Response<Http::Body>> {
+    ) -> Result<http::Response<Bytes>> {
         let mut fails = 0;
 
         let mut nonce = if let Some(nonce) = self.nonce.get() {
@@ -220,7 +206,6 @@ where
                 &nonce,
                 payload.as_ref(),
             )?;
-            let body = Bytes::from(body);
             let req = http::Request::builder()
                 .uri(url)
                 .method(http::Method::POST)
@@ -229,7 +214,7 @@ where
                     http::header::CONTENT_TYPE,
                     http::HeaderValue::from_static("application/jose+json"),
                 )
-                .body(Full::new(body))?;
+                .body(body)?;
 
             let res = match self.http.request(req).await {
                 Ok(res) => res,
@@ -259,8 +244,7 @@ where
                 .and_then(parse_retry_after)
                 .unwrap_or(DEFAULT_RETRY_INTERVAL);
 
-            let bytes = collect_body(res).await?;
-            let err: types::Problem = serde_json::from_slice(&bytes)?;
+            let err: types::Problem = serde_json::from_slice(res.body())?;
 
             let retriable = matches!(
                 err.kind,
@@ -312,8 +296,7 @@ where
         self.account = Some(key_id);
         self.nonce.add_from_response(&res);
 
-        let bytes = collect_body(res).await?;
-        Ok(serde_json::from_slice(&bytes)?)
+        Ok(serde_json::from_slice(res.body())?)
     }
 
     pub fn is_ready(&self) -> bool {
@@ -352,8 +335,7 @@ where
             .ok_or(anyhow!("no order URL"))?;
 
         let order_url = Uri::try_from(order_url)?;
-        let bytes = collect_body(res).await?;
-        let order: types::Order = serde_json::from_slice(&bytes)?;
+        let order: types::Order = serde_json::from_slice(res.body())?;
 
         let mut authorizations: Vec<(http::Uri, types::Authorization)> = Vec::new();
         for auth_url in order.authorizations {
@@ -397,7 +379,7 @@ where
             self.do_authorization(&order, url, authorization).await?;
         }
 
-        let mut bytes = collect_body(self.post(&order_url, &[]).await?).await?;
+        let mut bytes = self.post(&order_url, &[]).await?.into_body();
         let mut order: types::Order = serde_json::from_slice(&bytes)?;
 
         if order.status != OrderStatus::Ready {
@@ -410,7 +392,7 @@ where
         match self.post(&order.finalize, payload).await {
             Ok(res) => {
                 drop(order);
-                bytes = collect_body(res).await?;
+                bytes = res.into_body();
                 order = serde_json::from_slice(&bytes)?;
             }
             Err(err) => {
@@ -433,18 +415,13 @@ where
                 .and_then(parse_retry_after)
                 .unwrap_or(DEFAULT_RETRY_INTERVAL);
             drop(order);
-            bytes = collect_body(res).await?;
+            bytes = res.into_body();
             order = serde_json::from_slice(&bytes)?;
         }
 
         let certificate = order.certificate.ok_or(anyhow!("certifcate not ready"))?;
 
-        let chain = self
-            .post(&certificate, &[])
-            .await?
-            .collect()
-            .await?
-            .to_bytes();
+        let chain = self.post(&certificate, &[]).await?.into_body();
 
         // FIXME: avoid reallocation from std::vec::Vec.
         let x509 = Vec::from_iter(X509::stack_from_pem(&chain)?);