add some comments

Author: jbr

src/read_notifier.rs

@@ -6,18 +6,23 @@ use async_std::io::{self, BufRead, Read};
 use async_std::sync::Sender;
 
 pin_project_lite::pin_project! {
-    pub(crate) struct ReadNotifier<B>{
+    /// ReadNotifier forwards [`async_std::io::Read`] and
+    /// [`async_std::io::BufRead`] to an inner reader. When the
+    /// ReadNotifier is read from (using `Read`, `ReadExt`, or
+    /// `BufRead` methods), it sends a single message containing `()`
+    /// on the channel.
+    pub(crate) struct ReadNotifier<B> {
         #[pin]
         reader: B,
         sender: Sender<()>,
-        read: bool
+        has_been_read: bool
     }
 }
 
 impl<B> fmt::Debug for ReadNotifier<B> {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         f.debug_struct("ReadNotifier")
-            .field("read", &self.read)
+            .field("read", &self.has_been_read)
             .finish()
     }
 }
@@ -27,7 +32,7 @@ impl<B: BufRead> ReadNotifier<B> {
         Self {
             reader,
             sender,
-            read: false,
+            has_been_read: false,
         }
     }
 }
@@ -50,9 +55,9 @@ impl<B: Read> Read for ReadNotifier<B> {
     ) -> Poll<io::Result<usize>> {
         let this = self.project();
 
-        if !*this.read {
+        if !*this.has_been_read {
             if let Ok(()) = this.sender.try_send(()) {
-                *this.read = true;
+                *this.has_been_read = true;
             };
         }
 

src/server/decode.rs

@@ -88,22 +88,32 @@ where
         "Unexpected Content-Length header"
     );
 
-    let (sender, receiver) = sync::channel(1);
+    // Establish a channel to wait for the body to be read. This
+    // allows us to avoid sending 100-continue in situations that
+    // respond without reading the body, saving clients from uploading
+    // their body.
+    let (body_read_sender, body_read_receiver) = sync::channel(1);
 
-    if let Some(CONTINUE_HEADER_VALUE) = req.header(EXPECT).map(|h| h.as_str()) {
+    if Some(CONTINUE_HEADER_VALUE) == req.header(EXPECT).map(|h| h.as_str()) {
         task::spawn(async move {
-            if let Ok(()) = receiver.recv().await {
+            // If the client expects a 100-continue header, spawn a
+            // task to wait for the first read attempt on the body.
+            if let Ok(()) = body_read_receiver.recv().await {
                 io.write_all(CONTINUE_RESPONSE).await.ok();
             };
+            // Since the sender is moved into the Body, this task will
+            // finish when the client disconnects, whether or not
+            // 100-continue was sent.
         });
     }
 
     // Check for Transfer-Encoding
     if let Some(encoding) = transfer_encoding {
         if encoding.last().as_str() == "chunked" {
             let trailer_sender = req.send_trailers();
-            let reader = BufReader::new(ChunkedDecoder::new(reader, trailer_sender));
-            let reader = ReadNotifier::new(reader, sender);
+            let reader = ChunkedDecoder::new(reader, trailer_sender);
+            let reader = BufReader::new(reader);
+            let reader = ReadNotifier::new(reader, body_read_sender);
             req.set_body(Body::from_reader(reader, None));
             return Ok(Some(req));
         }
@@ -113,7 +123,7 @@ where
     // Check for Content-Length.
     if let Some(len) = content_length {
         let len = len.last().as_str().parse::<usize>()?;
-        let reader = ReadNotifier::new(reader.take(len as u64), sender);
+        let reader = ReadNotifier::new(reader.take(len as u64), body_read_sender);
         req.set_body(Body::from_reader(reader, Some(len)));
     }