Merge pull request #103 from http-rs/fix-trailers

Make recv_trailers return a concrete type

Author: yoshuawuyts

src/request.rs

@@ -10,7 +10,7 @@ use crate::headers::{
     self, HeaderName, HeaderValue, Headers, Names, ToHeaderValues, Values, CONTENT_TYPE,
 };
 use crate::mime::Mime;
-use crate::trailers::{Trailers, TrailersSender};
+use crate::trailers::{self, Trailers};
 use crate::Cookie;
 use crate::{Body, Method, TypeMap, Url, Version};
 
@@ -31,8 +31,8 @@ pin_project_lite::pin_project! {
         url: Url,
         headers: Headers,
         version: Option<Version>,
-        sender: Option<sync::Sender<crate::Result<Trailers>>>,
-        receiver: sync::Receiver<crate::Result<Trailers>>,
+        sender: Option<sync::Sender<Trailers>>,
+        receiver: Option<sync::Receiver<Trailers>>,
         #[pin]
         body: Body,
         local: TypeMap,
@@ -50,7 +50,7 @@ impl Request {
             version: None,
             body: Body::empty(),
             sender: Some(sender),
-            receiver,
+            receiver: Some(receiver),
             local: TypeMap::new(),
         }
     }
@@ -431,17 +431,21 @@ impl Request {
     }
 
     /// Sends trailers to the a receiver.
-    pub fn send_trailers(&mut self) -> TrailersSender {
+    pub fn send_trailers(&mut self) -> trailers::Sender {
         let sender = self
             .sender
             .take()
             .expect("Trailers sender can only be constructed once");
-        TrailersSender::new(sender)
+        trailers::Sender::new(sender)
     }
 
     /// Receive trailers from a sender.
-    pub async fn recv_trailers(&self) -> Option<crate::Result<Trailers>> {
-        self.receiver.recv().await
+    pub async fn recv_trailers(&mut self) -> trailers::Receiver {
+        let receiver = self
+            .receiver
+            .take()
+            .expect("Trailers receiver can only be constructed once");
+        trailers::Receiver::new(receiver)
     }
 
     /// An iterator visiting all header pairs in arbitrary order.

src/response.rs

@@ -10,7 +10,7 @@ use crate::headers::{
     self, HeaderName, HeaderValue, Headers, Names, ToHeaderValues, Values, CONTENT_TYPE,
 };
 use crate::mime::Mime;
-use crate::trailers::{Trailers, TrailersSender};
+use crate::trailers::{self, Trailers};
 use crate::{Body, Cookie, StatusCode, TypeMap, Version};
 
 pin_project_lite::pin_project! {
@@ -33,8 +33,8 @@ pin_project_lite::pin_project! {
         status: StatusCode,
         headers: Headers,
         version: Option<Version>,
-        sender: Option<sync::Sender<crate::Result<Trailers>>>,
-        receiver: sync::Receiver<crate::Result<Trailers>>,
+        sender: Option<sync::Sender<Trailers>>,
+        receiver: Option<sync::Receiver<Trailers>>,
         #[pin]
         body: Body,
         local: TypeMap,
@@ -51,7 +51,7 @@ impl Response {
             version: None,
             body: Body::empty(),
             sender: Some(sender),
-            receiver,
+            receiver: Some(receiver),
             local: TypeMap::new(),
         }
     }
@@ -396,17 +396,21 @@ impl Response {
     }
 
     /// Sends trailers to the a receiver.
-    pub fn send_trailers(&mut self) -> TrailersSender {
+    pub fn send_trailers(&mut self) -> trailers::Sender {
         let sender = self
             .sender
             .take()
             .expect("Trailers sender can only be constructed once");
-        TrailersSender::new(sender)
+        trailers::Sender::new(sender)
     }
 
     /// Receive trailers from a sender.
-    pub async fn recv_trailers(&self) -> Option<crate::Result<Trailers>> {
-        self.receiver.recv().await
+    pub async fn recv_trailers(&mut self) -> trailers::Receiver {
+        let receiver = self
+            .receiver
+            .take()
+            .expect("Trailers receiver can only be constructed once");
+        trailers::Receiver::new(receiver)
     }
 
     /// An iterator visiting all header pairs in arbitrary order.

src/trailers.rs

@@ -34,10 +34,11 @@
 //! trailers.insert("Content-Type", "text/plain")?;
 //!
 //! task::spawn(async move {
-//!     let _trailers = req.recv_trailers().await;
+//!     let trailers = req.recv_trailers().await;
+//!     # drop(trailers)
 //! });
 //!
-//! sender.send(Ok(trailers)).await;
+//! sender.send(trailers).await;
 //! #
 //! # Ok(()) })}
 //! ```
@@ -49,10 +50,14 @@
 use crate::headers::{
     HeaderName, HeaderValue, Headers, Iter, IterMut, Names, ToHeaderValues, Values,
 };
-use async_std::sync::Sender;
+use async_std::prelude::*;
+use async_std::sync;
 
 use std::convert::TryInto;
+use std::future::Future;
 use std::ops::{Deref, DerefMut};
+use std::pin::Pin;
+use std::task::{Context, Poll};
 
 /// A collection of trailing HTTP headers.
 #[derive(Debug)]
@@ -182,21 +187,47 @@ impl DerefMut for Trailers {
 /// called once, and cannot be cloned. That's because only a single instance of
 /// `Trailers` should be created.
 #[derive(Debug)]
-pub struct TrailersSender {
-    sender: Sender<crate::Result<Trailers>>,
+pub struct Sender {
+    sender: sync::Sender<Trailers>,
 }
 
-impl TrailersSender {
-    /// Create a new instance of `TrailersSender`.
+impl Sender {
+    /// Create a new instance of `Sender`.
     #[doc(hidden)]
-    pub fn new(sender: Sender<crate::Result<Trailers>>) -> Self {
+    pub fn new(sender: sync::Sender<Trailers>) -> Self {
         Self { sender }
     }
 
     /// Send a `Trailer`.
     ///
     /// The channel will be consumed after having sent trailers.
-    pub async fn send(self, trailers: crate::Result<Trailers>) {
+    pub async fn send(self, trailers: Trailers) {
         self.sender.send(trailers).await
     }
 }
+
+/// The receiving half of a channel to send trailers.
+///
+/// Unlike `async_std::sync::channel` the `send` method on this type can only be
+/// called once, and cannot be cloned. That's because only a single instance of
+/// `Trailers` should be created.
+#[must_use = "Futures do nothing unless polled or .awaited"]
+#[derive(Debug)]
+pub struct Receiver {
+    receiver: sync::Receiver<Trailers>,
+}
+
+impl Receiver {
+    /// Create a new instance of `Receiver`.
+    pub(crate) fn new(receiver: sync::Receiver<Trailers>) -> Self {
+        Self { receiver }
+    }
+}
+
+impl Future for Receiver {
+    type Output = Option<Trailers>;
+
+    fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
+        Pin::new(&mut self.receiver).poll_next(cx)
+    }
+}