Simple session

Cargo.lock

@@ -276,6 +276,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "9a8e94ea7f378bd32cbbd37198a4a91436180c5bb472411e48b5ec2e2124ae9e"
 dependencies = [
  "serde_core",
+ "serde_derive",
 ]
 
 [[package]]

Cargo.toml

@@ -6,7 +6,7 @@ edition = "2024"
 [dependencies]
 base64 = "0.22.1"
 rand = "0.10.0"
-serde = "1.0.228"
+serde = { version = "1.0.228", features = ["serde_derive"] }
 serde_json = "1.0.149"
 sha1 = "0.10.6"
 tokio = { version = "1.49.0", features = ["io-util", "macros", "net", "rt", "sync", "time"] }

src/session.rs

@@ -0,0 +1,90 @@
+use std::{marker::PhantomData, sync::Arc};
+
+use serde::{Deserialize, Serialize};
+use tokio::sync::Mutex;
+
+use crate::ws::WebSocket;
+
+#[derive(Debug, Serialize, Deserialize)]
+pub enum SessionMessageKind {
+    Request,
+    Response,
+    Notification,
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+pub struct SessionMessage<T: Serialize> {
+    id: u32,
+    kind: SessionMessageKind,
+    data: T,
+}
+
+pub struct Session<
+    Req: Serialize + for<'a> Deserialize<'a>,
+    Res: Serialize + for<'a> Deserialize<'a>,
+    PeerReq: Serialize + for<'a> Deserialize<'a>,
+    PeerRes: Serialize + for<'a> Deserialize<'a>,
+    Notification: Serialize + for<'a> Deserialize<'a>,
+> {
+    _pd: (
+        PhantomData<Req>,
+        PhantomData<Res>,
+        PhantomData<PeerReq>,
+        PhantomData<PeerRes>,
+        PhantomData<Notification>,
+    ),
+    pub ws: WebSocket,
+    id: Arc<Mutex<u32>>,
+}
+
+impl<
+    Req: Serialize + for<'a> Deserialize<'a>,
+    Res: Serialize + for<'a> Deserialize<'a>,
+    PeerReq: Serialize + for<'a> Deserialize<'a>,
+    PeerRes: Serialize + for<'a> Deserialize<'a>,
+    Notification: Serialize + for<'a> Deserialize<'a>,
+> Session<Req, Res, PeerReq, PeerRes, Notification>
+{
+    pub async fn send_id<T: Serialize>(
+        &self,
+        id: u32,
+        kind: SessionMessageKind,
+        data: &T,
+    ) -> crate::Result<()> {
+        self.ws
+            .send_text_payload(&serde_json::to_vec(&SessionMessage { id, kind, data })?)
+            .await?;
+
+        Ok(())
+    }
+
+    pub async fn send<T: Serialize>(
+        &self,
+        kind: SessionMessageKind,
+        data: &T,
+    ) -> crate::Result<()> {
+        self.send_id(
+            {
+                let mut i = self.id.lock().await;
+                *i += 1;
+                *i
+            },
+            kind,
+            data,
+        )
+        .await
+    }
+
+    pub async fn request(&self, data: &Req) -> crate::Result<()> {
+        self.send(SessionMessageKind::Request, data).await
+    }
+
+    pub async fn respond(&self, to_req: &SessionMessage<PeerReq>, data: &Res) -> crate::Result<()> {
+        self.send_id(to_req.id, SessionMessageKind::Response, data)
+            .await
+    }
+
+    pub async fn notify(&self, data: &Res) -> crate::Result<()> {
+        self.send(SessionMessageKind::Notification, data).await
+    }
+}

src/ws/mod.rs

@@ -99,6 +99,10 @@ impl WebSocket {
         self.send_frame(0x1, msg.as_bytes()).await
     }
 
+    pub async fn send_text_payload(&self, payload: &[u8]) -> Result<()> {
+        self.send_frame(0x1, payload).await
+    }
+
     pub async fn send_bin(&self, payload: &[u8]) -> Result<()> {
         self.send_frame(0x2, payload).await
     }