work

src/bin/client/net.rs

@@ -1,6 +1,8 @@
 use crate::ClientEvent;
+use dashmap::DashMap;
 use openworm::net::{
-    ClientMsg, RecvHandler, SERVER_NAME, ServerMsg, SkipServerVerification, recv_uni, send_uni,
+    AccountCreated, ClientMsg, ClientMsgInst, CreateAccount, RecvHandler, RequestId, SERVER_NAME,
+    ServerMsg, ServerRespMsg, SkipServerVerification, recv_uni, send_uni,
 };
 use quinn::{
     ClientConfig, Connection, Endpoint, IdleTimeout, TransportConfig,
@@ -38,25 +40,53 @@ impl AppHandle {
 
 type NetResult<T> = Result<T, String>;
 
+pub trait ClientRequest {}
+
 pub enum NetCtrlMsg {
-    Exchange(ClientMsg, oneshot::Sender<>),
     Send(ClientMsg),
+    Request(ClientMsg, oneshot::Sender<ServerMsg>),
     Exit,
 }
 
-impl From<ClientMsg> for NetCtrlMsg {
-    fn from(value: ClientMsg) -> Self {
-        Self::Send(value)
-    }
-}
-
 impl NetHandle {
-    pub fn send(&self, msg: impl Into<NetCtrlMsg>) {
-        self.send.send(msg.into());
+    fn send_(&self, msg: NetCtrlMsg) {
+        let _ = self.send.send(msg);
+    }
+
+    pub fn send(&self, msg: impl Into<ClientMsg>) {
+        self.send_(NetCtrlMsg::Send(msg.into()));
+    }
+
+    pub async fn request<R: RequestMsg>(&self, msg: R) -> Result<R::Result, ()> {
+        let (send, recv) = oneshot::channel();
+        self.send_(NetCtrlMsg::Request(msg.into(), send));
+        let Ok(recv) = recv.await else { todo!() };
+        if let Some(res) = R::result(recv) {
+            Ok(res)
+        } else {
+            todo!()
+        }
     }
 
     pub fn exit(self) {
-        self.send(NetCtrlMsg::Exit);
+        self.send_(NetCtrlMsg::Exit);
+    }
+}
+
+pub trait RequestMsg: Into<ClientMsg> {
+    type Result;
+    fn result(msg: ServerMsg) -> Option<Self::Result>;
+}
+
+impl RequestMsg for CreateAccount {
+    type Result = AccountCreated;
+
+    fn result(msg: ServerMsg) -> Option<Self::Result> {
+        if let ServerMsg::AccountCreated(res) = msg {
+            Some(res)
+        } else {
+            None
+        }
     }
 }
 
@@ -129,12 +159,25 @@ pub async fn connect(msg: impl MsgHandler, info: ConnectInfo) -> Result<NetHandl
     let (endpoint, conn) = connection_no_cert(addr).await?;
     let conn_ = conn.clone();
 
-    let recv = ServerRecv { msg };
-    tokio::spawn(recv_uni(conn_, recv.into()));
+    let mut req_id = RequestId::first();
+    let recv = Arc::new(ServerRecv {
+        msg,
+        requests: DashMap::default(),
+    });
+    tokio::spawn(recv_uni(conn_, recv.clone()));
     tokio::spawn(async move {
         while let Some(msg) = ui_recv.recv().await {
             match msg {
                 NetCtrlMsg::Send(msg) => {
+                    let msg = ClientMsgInst::from(msg);
+                    if send_uni(&conn, msg).await.is_err() {
+                        println!("disconnected from server");
+                        break;
+                    }
+                }
+                NetCtrlMsg::Request(msg, send) => {
+                    let msg = ClientMsgInst::from(msg);
+                    recv.requests.insert(req_id.next(), send);
                     if send_uni(&conn, msg).await.is_err() {
                         println!("disconnected from server");
                         break;
@@ -155,18 +198,29 @@ pub async fn connect(msg: impl MsgHandler, info: ConnectInfo) -> Result<NetHandl
 pub trait MsgHandler: Sync + Send + 'static {
     fn run(&self, msg: ServerMsg) -> impl Future<Output = ()> + Send;
 }
-impl<F: AsyncFn(ServerMsg) + Sync + Send + 'static> MsgHandler for F {
+impl<F: AsyncFn(ServerMsg) + Sync + Send + 'static> MsgHandler for F
+where
+    for<'a> F::CallRefFuture<'a>: Send,
+{
     async fn run(&self, msg: ServerMsg) {
-        self(msg);
+        self(msg).await;
     }
 }
 
 struct ServerRecv<F: MsgHandler> {
+    requests: DashMap<RequestId, oneshot::Sender<ServerMsg>>,
     msg: F,
 }
 
-impl<F: MsgHandler> RecvHandler<ServerMsg> for ServerRecv<F> {
-    async fn msg(&self, msg: ServerMsg) {
-        self.msg.run(msg).await;
+impl<F: MsgHandler> RecvHandler<ServerRespMsg> for ServerRecv<F> {
+    async fn msg(&self, resp: ServerRespMsg) {
+        let msg = resp.msg.into();
+        if let Some(id) = resp.request_id
+            && let Some((_, send)) = self.requests.remove(&id)
+        {
+            send.send(msg);
+        } else {
+            self.msg.run(msg).await;
+        }
     }
 }