Reimplement the accept APIs

crates/xwebtransport-core/src/lib.rs

@@ -12,9 +12,9 @@ pub use traits::*;
 
 pub mod prelude {
     pub use crate::traits::{
-        AcceptBiStream as _, AcceptUniStream as _, Connecting as _, Connection as _,
-        EndpointAccept as _, EndpointConnect as _, OpenBiStream as _, OpenUniStream as _,
-        OpeningBiStream as _, OpeningUniStream as _,
+        AcceptBiStream as _, AcceptUniStream as _, Accepting as _, Connecting as _,
+        Connection as _, EndpointAccept as _, EndpointConnect as _, OpenBiStream as _,
+        OpenUniStream as _, OpeningBiStream as _, OpeningUniStream as _, Request as _,
     };
 
     pub use crate::trait_utils::*;

crates/xwebtransport-core/src/trait_utils.rs

@@ -3,8 +3,14 @@ use crate::traits;
 pub type EndpointConnectConnectionFor<T> =
     <<T as traits::EndpointConnect>::Connecting as traits::Connecting>::Connection;
 
-pub type EndpointAcceptConnectionFor<T> =
-    <<T as traits::EndpointAccept>::Connecting as traits::Connecting>::Connection;
+pub type EndpointAcceptConnectionFor<T> = RequestConnectionFor<EndpointAcceptRequestFor<T>>;
+
+pub type EndpointAcceptRequestFor<T> =
+    <<T as traits::EndpointAccept>::Accepting as traits::Accepting>::Request;
+
+pub type RequestConnectionFor<T> = <T as traits::Request>::Connection;
+
+pub type AcceptingConnectionFor<T> = RequestConnectionFor<<T as traits::Accepting>::Request>;
 
 pub type BiStreamOpeningErrorFor<T> =
     <<T as traits::OpenBiStream>::Opening as traits::OpeningBiStream>::Error;

crates/xwebtransport-core/src/traits.rs

@@ -61,15 +61,6 @@ pub trait AcceptUniStream: Streams {
     async fn accept_uni(&self) -> Result<Self::RecvStream, Self::Error>;
 }
 
-#[cfg_attr(not(target_family = "wasm"), async_trait)]
-#[cfg_attr(target_family = "wasm", async_trait(?Send))]
-pub trait Connecting: maybe::Send {
-    type Connection: maybe::Send;
-    type Error: std::error::Error + maybe::Send + maybe::Sync + 'static;
-
-    async fn wait(self) -> Result<Self::Connection, Self::Error>;
-}
-
 #[cfg_attr(not(target_family = "wasm"), async_trait)]
 #[cfg_attr(target_family = "wasm", async_trait(?Send))]
 pub trait EndpointConnect: Sized + maybe::Send {
@@ -84,13 +75,42 @@ pub trait EndpointConnect: Sized + maybe::Send {
     ) -> Result<Self::Connecting, Self::Error>;
 }
 
+#[cfg_attr(not(target_family = "wasm"), async_trait)]
+#[cfg_attr(target_family = "wasm", async_trait(?Send))]
+pub trait Connecting: maybe::Send {
+    type Connection: maybe::Send;
+    type Error: std::error::Error + maybe::Send + maybe::Sync + 'static;
+
+    async fn wait(self) -> Result<Self::Connection, Self::Error>;
+}
+
 #[cfg_attr(not(target_family = "wasm"), async_trait)]
 #[cfg_attr(target_family = "wasm", async_trait(?Send))]
 pub trait EndpointAccept: Sized + maybe::Send {
-    type Connecting: Connecting;
+    type Accepting: Accepting;
     type Error: std::error::Error + maybe::Send + maybe::Sync + 'static;
 
-    async fn accept(&self) -> Result<Self::Connecting, Self::Error>;
+    async fn accept(&self) -> Result<Option<Self::Accepting>, Self::Error>;
+}
+
+#[cfg_attr(not(target_family = "wasm"), async_trait)]
+#[cfg_attr(target_family = "wasm", async_trait(?Send))]
+pub trait Accepting: maybe::Send {
+    type Request: Request;
+    type Error: std::error::Error + maybe::Send + maybe::Sync + 'static;
+
+    async fn wait(self) -> Result<Self::Request, Self::Error>;
+}
+
+#[cfg_attr(not(target_family = "wasm"), async_trait)]
+#[cfg_attr(target_family = "wasm", async_trait(?Send))]
+pub trait Request: maybe::Send {
+    type Connection: maybe::Send;
+    type OkError: std::error::Error + maybe::Send + maybe::Sync + 'static;
+    type CloseError: std::error::Error + maybe::Send + maybe::Sync + 'static;
+
+    async fn ok(self) -> Result<Self::Connection, Self::OkError>;
+    async fn close(self, status: u16) -> Result<(), Self::CloseError>;
 }
 
 pub trait Connection:

crates/xwebtransport-error/src/impls/debug.rs

@@ -21,7 +21,8 @@ where
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         match self {
             Accept::Accept(inner) => f.debug_tuple("Accept::Accept").field(inner).finish(),
-            Accept::Connecting(inner) => f.debug_tuple("Accept::Connecting").field(inner).finish(),
+            Accept::Accepting(inner) => f.debug_tuple("Accept::Accepting").field(inner).finish(),
+            Accept::RequestOk(inner) => f.debug_tuple("Accept::RequestOk").field(inner).finish(),
         }
     }
 }

crates/xwebtransport-error/src/impls/display.rs

@@ -19,7 +19,8 @@ where
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         match self {
             Accept::Accept(inner) => write!(f, "accept: {inner}"),
-            Accept::Connecting(inner) => write!(f, "connecting: {inner}"),
+            Accept::Accepting(inner) => write!(f, "accepting: {inner}"),
+            Accept::RequestOk(inner) => write!(f, "oking request: {inner}"),
         }
     }
 }

crates/xwebtransport-error/src/lib.rs

@@ -15,7 +15,8 @@ where
     Endpoint: traits::EndpointAccept,
 {
     Accept(Endpoint::Error),
-    Connecting(<Endpoint::Connecting as traits::Connecting>::Error),
+    Accepting(<Endpoint::Accepting as traits::Accepting>::Error),
+    RequestOk(<EndpointAcceptRequestFor<Endpoint> as traits::Request>::OkError),
 }
 
 pub enum OpenBi<Connection>

crates/xwebtransport-tests/src/utils.rs

@@ -23,21 +23,30 @@ where
 
 pub async fn accept<Endpoint>(
     endpoint: Endpoint,
-) -> Result<EndpointAcceptConnectionFor<Endpoint>, xwebtransport_error::Accept<Endpoint>>
+) -> Result<Option<EndpointAcceptConnectionFor<Endpoint>>, xwebtransport_error::Accept<Endpoint>>
 where
     Endpoint: xwebtransport_core::EndpointAccept,
     EndpointAcceptConnectionFor<Endpoint>: xwebtransport_core::Connection,
 {
-    let connecting = endpoint
+    let maybe_accepting = endpoint
         .accept()
         .await
         .map_err(xwebtransport_error::Accept::Accept)?;
-    let connection = connecting
+    let Some(accepting) = maybe_accepting else {
+        return Ok(None);
+    };
+
+    let request = accepting
         .wait()
         .await
-        .map_err(xwebtransport_error::Accept::Connecting)?;
+        .map_err(xwebtransport_error::Accept::Accepting)?;
 
-    Ok(connection)
+    let connection = request
+        .ok()
+        .await
+        .map_err(xwebtransport_error::Accept::RequestOk)?;
+
+    Ok(Some(connection))
 }
 
 pub async fn open_bi<Connection>(

crates/xwebtransport-wtransport/src/lib.rs

@@ -24,28 +24,49 @@ impl xwebtransport_core::traits::EndpointConnect for Endpoint<wtransport::endpoi
 
 #[async_trait]
 impl xwebtransport_core::traits::EndpointAccept for Endpoint<wtransport::endpoint::Server> {
-    type Connecting = SessionRequest;
-    type Error = wtransport::error::ConnectionError;
+    type Accepting = IncomingSession;
+    type Error = std::convert::Infallible;
 
-    async fn accept(&self) -> Result<Self::Connecting, Self::Error> {
-        let incoming = self.0.accept().await;
-        incoming.await.map(SessionRequest)
+    async fn accept(&self) -> Result<Option<Self::Accepting>, Self::Error> {
+        let incoming_session = self.0.accept().await;
+        let incoming_session = IncomingSession(incoming_session);
+        Ok(Some(incoming_session))
     }
 }
 
-impl xwebtransport_core::traits::Streams for Connection {
-    type SendStream = wtransport::SendStream;
-    type RecvStream = wtransport::RecvStream;
+#[async_trait]
+impl xwebtransport_core::traits::Accepting for IncomingSession {
+    type Request = SessionRequest;
+    type Error = wtransport::error::ConnectionError;
+
+    async fn wait(self) -> Result<Self::Request, Self::Error> {
+        self.0.await.map(SessionRequest)
+    }
 }
 
 #[async_trait]
-impl xwebtransport_core::traits::Connecting for SessionRequest {
+impl xwebtransport_core::traits::Request for SessionRequest {
     type Connection = Connection;
-    type Error = wtransport::error::ConnectionError;
+    type OkError = wtransport::error::ConnectionError;
+    type CloseError = std::convert::Infallible;
 
-    async fn wait(self) -> Result<Self::Connection, Self::Error> {
+    async fn ok(self) -> Result<Self::Connection, Self::OkError> {
         self.0.accept().await.map(Connection)
     }
+
+    async fn close(self, status: u16) -> Result<(), Self::CloseError> {
+        debug_assert!(
+            status == 404,
+            "wtransport driver only supports closing requests with 404 status code"
+        );
+        self.0.not_found().await;
+        Ok(())
+    }
+}
+
+impl xwebtransport_core::traits::Streams for Connection {
+    type SendStream = wtransport::SendStream;
+    type RecvStream = wtransport::RecvStream;
 }
 
 #[async_trait]

crates/xwebtransport-wtransport/src/types.rs

@@ -21,6 +21,7 @@ macro_rules! newtype {
 
 newtype!(Endpoint<Side> => wtransport::Endpoint<Side>);
 newtype!(Connection => wtransport::Connection);
+newtype!(IncomingSession => wtransport::endpoint::IncomingSession);
 newtype!(SessionRequest => wtransport::endpoint::SessionRequest);
 newtype!(OpeningBiStream => wtransport::stream::OpeningBiStream);
 newtype!(OpeningUniStream => wtransport::stream::OpeningUniStream);