Change web-transport-trait::Session::closed() to return a Result (#110)

Author: kixelated

web-transport-quinn/src/session.rs

@@ -558,8 +558,11 @@ impl web_transport_trait::Session for Session {
         Self::close(self, code, reason.as_bytes());
     }
 
-    async fn closed(&self) -> Self::Error {
-        Self::closed(self).await
+    async fn closed(&self) -> Result<(), Self::Error> {
+        match Self::closed(self).await {
+            SessionError::ConnectionError(quinn::ConnectionError::LocallyClosed) => Ok(()),
+            err => Err(err),
+        }
     }
 
     fn send_datagram(&self, data: Bytes) -> Result<(), Self::Error> {

web-transport-trait/src/lib.rs

@@ -60,7 +60,7 @@ pub trait Session: Clone + MaybeSend + MaybeSync + 'static {
     fn close(&self, code: u32, reason: &str);
 
     /// Block until the connection is closed.
-    fn closed(&self) -> impl Future<Output = Self::Error> + MaybeSend;
+    fn closed(&self) -> impl Future<Output = Result<(), Self::Error>> + MaybeSend;
 }
 
 /// An outgoing stream of bytes to the peer.

web-transport-wasm/src/session.rs

@@ -162,8 +162,8 @@ impl web_transport_trait::Session for Session {
         Self::close(self, code, reason);
     }
 
-    async fn closed(&self) -> Self::Error {
-        Self::closed(self).await
+    async fn closed(&self) -> Result<(), Self::Error> {
+        self.closed_inner().await
     }
 
     fn send_datagram(&self, _data: Bytes) -> Result<(), Self::Error> {

web-transport-ws/examples/server.rs

@@ -65,7 +65,9 @@ async fn run(stream: tokio::net::TcpStream) -> anyhow::Result<()> {
 
                 println!("Bidirectional stream closed");
             }
-            err = session.closed() => return Err(err.into()),
+            result = session.closed() => {
+                return result.map_err(|e| e.into());
+            }
         }
     }
 }

web-transport-ws/src/session.rs

@@ -458,13 +458,15 @@ impl generic::Session for Session {
             .ok();
     }
 
-    async fn closed(&self) -> Self::Error {
+    async fn closed(&self) -> Result<(), Self::Error> {
         let mut closed = self.closed.subscribe();
-        closed
+        let err = closed
             .wait_for(|err| err.is_some())
             .await
             .map(|e| e.clone().unwrap_or(Error::Closed))
-            .unwrap_or(Error::Closed)
+            .unwrap_or(Error::Closed);
+
+        Err(err)
     }
 
     fn send_datagram(&self, _payload: Bytes) -> Result<(), Self::Error> {