fix: Body's reader is now optional; may be checked for emptiness

SUMMARY:

Fixes the integration issue with isahc, whereby a `isahc::Body` created from
`isahc::Body::reader`has a length of `None`, which signals to `isahc::Client`
to send a body with an unknown length. A length of `None` is interpreted as
being unknown, and therefore a body is sent with every request. This causes a
501 error on servers which do not permit a body in the request, such as GET
requests to Cloudflare CDNs.

CHANGES:

* Changed `http_client::Body`'s `reader` field to being optional
* Added a `http_client::Body::is_empty` method to check for emptiness
* On creating a new request for `isahc::Client`:
  - Create a `isahc::Body::empty` if `http_client::Body` is empty
  - Create a `isahc::Body::reader` if otherwise not empty

Author: mmstick

src/isahc.rs

@@ -42,10 +42,16 @@ impl HttpClient for IsahcClient {
         let client = self.client.clone();
         Box::pin(async move {
             let (parts, body) = req.into_parts();
-            let body = match body.len {
-                Some(len) => isahc::Body::reader_sized(body, len),
-                None => isahc::Body::reader(body),
+
+            let body = if body.is_empty() {
+                isahc::Body::empty()
+            } else {
+                match body.len {
+                    Some(len) => isahc::Body::reader_sized(body, len),
+                    None => isahc::Body::reader(body),
+                }
             };
+
             let req: http::Request<isahc::Body> = http::Request::from_parts(parts, body);
 
             let res = client.send_async(req).await?;

src/lib.rs

@@ -69,7 +69,7 @@ pub trait HttpClient: Debug + Unpin + Send + Sync + Clone + 'static {
 /// Both `Body` and `Bytes` values can be easily created from standard owned byte buffer types
 /// like `Vec<u8>` or `String`, using the `From` trait.
 pub struct Body {
-    reader: Box<dyn AsyncRead + Unpin + Send + 'static>,
+    reader: Option<Box<dyn AsyncRead + Unpin + Send + 'static>>,
     /// Intentionally use `u64` over `usize` here.
     /// `usize` won't work if you try to send 10GB file from 32bit host.
     #[allow(dead_code)] // not all backends make use of this
@@ -80,18 +80,23 @@ impl Body {
     /// Create a new empty body.
     pub fn empty() -> Self {
         Self {
-            reader: Box::new(futures::io::empty()),
+            reader: None,
             len: Some(0),
         }
     }
 
     /// Create a new instance from a reader.
     pub fn from_reader(reader: impl AsyncRead + Unpin + Send + 'static) -> Self {
         Self {
-            reader: Box::new(reader),
+            reader: Some(Box::new(reader)),
             len: None,
         }
     }
+
+    /// Validate that the body was created with `Body::empty()`.
+    pub fn is_empty(&self) -> bool {
+        self.reader.is_none()
+    }
 }
 
 impl AsyncRead for Body {
@@ -101,7 +106,10 @@ impl AsyncRead for Body {
         cx: &mut Context<'_>,
         buf: &mut [u8],
     ) -> Poll<io::Result<usize>> {
-        Pin::new(&mut self.reader).poll_read(cx, buf)
+        match self.reader.as_mut() {
+            Some(reader) => Pin::new(reader).poll_read(cx, buf),
+            None => Poll::Ready(Ok(0)),
+        }
     }
 }
 
@@ -118,7 +126,7 @@ impl From<Vec<u8>> for Body {
     fn from(vec: Vec<u8>) -> Body {
         let len = vec.len() as u64;
         Self {
-            reader: Box::new(Cursor::new(vec)),
+            reader: Some(Box::new(Cursor::new(vec))),
             len: Some(len),
         }
     }
@@ -128,6 +136,9 @@ impl<R: AsyncRead + Unpin + Send + 'static> From<Box<R>> for Body {
     /// Converts an `AsyncRead` into a Body.
     #[allow(missing_doc_code_examples)]
     fn from(reader: Box<R>) -> Self {
-        Self { reader, len: None }
+        Self {
+            reader: Some(reader),
+            len: None,
+        }
     }
 }