feat(socketioxide/v4): implement SocketIO V4 (closes #51)

e2e/src/socketioxide.rs

@@ -26,8 +26,9 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
     let ns = Namespace::builder()
         .add("/", |socket| async move {
             info!("Socket.IO connected: {:?} {:?}", socket.ns(), socket.sid);
-            let data: Value = socket.handshake.data().unwrap();
-            socket.emit("auth", data).ok();
+            if let Some(data) = socket.handshake.data::<Value>() {
+                socket.emit("auth", data.unwrap()).ok();
+            }
 
             socket.on("message", |socket, data: Value, bin, _| async move {
                 info!("Received event: {:?} {:?}", data, bin);
@@ -41,8 +42,9 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
         })
         .add("/custom", |socket| async move {
             info!("Socket.IO connected on: {:?} {:?}", socket.ns(), socket.sid);
-            let data: Value = socket.handshake.data().unwrap();
-            socket.emit("auth", data).ok();
+            if let Some(data) = socket.handshake.data::<Value>() {
+                socket.emit("auth", data.unwrap()).ok();
+            }
         })
         .build();
 

examples/src/chat/handlers.rs

@@ -14,7 +14,7 @@ struct Auth {
 
 pub async fn handler(socket: Arc<Socket<LocalAdapter>>) {
     info!("Socket connected on / with id: {}", socket.sid);
-    if let Ok(data) = socket.handshake.data::<Auth>() {
+    if let Some(Ok(data)) = socket.handshake.data::<Auth>() {
         info!("Nickname: {:?}", data.nickname);
         socket.extensions.insert(data.nickname);
         socket.emit("message", "Welcome to the chat!").ok();

examples/src/socketio-echo/axum_echo.rs

@@ -12,7 +12,7 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
     let ns = Namespace::builder()
         .add("/", |socket| async move {
             info!("Socket.IO connected: {:?} {:?}", socket.ns(), socket.sid);
-            let data: Value = socket.handshake.data().unwrap();
+            let data: Value = socket.handshake.data().unwrap().unwrap();
             socket.emit("auth", data).ok();
 
             socket.on("message", |socket, data: Value, bin, _| async move {
@@ -27,7 +27,7 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
         })
         .add("/custom", |socket| async move {
             info!("Socket.IO connected on: {:?} {:?}", socket.ns(), socket.sid);
-            let data: Value = socket.handshake.data().unwrap();
+            let data: Value = socket.handshake.data().unwrap().unwrap();
             socket.emit("auth", data).ok();
         })
         .build();

examples/src/socketio-echo/hyper_echo.rs

@@ -11,7 +11,7 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
     let ns = Namespace::builder()
         .add("/", |socket| async move {
             info!("Socket.IO connected: {:?} {:?}", socket.ns(), socket.sid);
-            let data: Value = socket.handshake.data().unwrap();
+            let data: Value = socket.handshake.data().unwrap().unwrap();
             socket.emit("auth", data).ok();
 
             socket.on("message", |socket, data: Value, bin, _| async move {
@@ -26,7 +26,7 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
         })
         .add("/custom", |socket| async move {
             info!("Socket.IO connected on: {:?} {:?}", socket.ns(), socket.sid);
-            let data: Value = socket.handshake.data().unwrap();
+            let data: Value = socket.handshake.data().unwrap().unwrap();
             socket.emit("auth", data).ok();
         })
         .build();

examples/src/socketio-echo/warp_echo.rs

@@ -12,7 +12,7 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
     let ns = Namespace::builder()
         .add("/", |socket| async move {
             info!("Socket.IO connected: {:?} {:?}", socket.ns(), socket.sid);
-            let data: Value = socket.handshake.data().unwrap();
+            let data: Value = socket.handshake.data().unwrap().unwrap();
             socket.emit("auth", data).ok();
 
             socket.on("message", |socket, data: Value, bin, _| async move {
@@ -27,7 +27,7 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
         })
         .add("/custom", |socket| async move {
             info!("Socket.IO connected on: {:?} {:?}", socket.ns(), socket.sid);
-            let data: Value = socket.handshake.data().unwrap();
+            let data: Value = socket.handshake.data().unwrap().unwrap();
             socket.emit("auth", data).ok();
         })
         .build();

socketioxide/Cargo.toml

@@ -18,7 +18,7 @@ license = "MIT"
 readme = "../Readme.md"
 
 [dependencies]
-engineioxide = { path = "../engineioxide", version = "0.3.0" }
+engineioxide = { path = "../engineioxide", version = "0.3.0", default-features = false }
 futures = "0.3.27"
 tokio = "1.26.0"
 serde = { version = "1.0.155", features = ["derive"] }
@@ -35,3 +35,8 @@ dashmap = "5.4.0"
 [dev-dependencies]
 axum = "0.6.18"
 tracing-subscriber = "0.3.17"
+
+[features]
+default = ["v5"]
+v5 = ["engineioxide/v4"]
+v4 = ["engineioxide/v3"]

socketioxide/src/client.rs

@@ -59,16 +59,17 @@ impl<A: Adapter> Client<A> {
     /// Called when a socket connects to a new namespace
     fn sock_connect(
         &self,
-        auth: Value,
+        auth: Option<Value>,
         ns_path: String,
         socket: &EIoSocket<Self>,
     ) -> Result<(), SendError> {
         debug!("auth: {:?}", auth);
         let handshake = Handshake::new(auth, socket.req_data.clone());
         let sid = socket.sid;
         if let Some(ns) = self.get_ns(&ns_path) {
+            let protocol = socket.protocol;
             let socket = ns.connect(sid, socket.tx.clone(), handshake, self.config.clone());
-            socket.send(Packet::connect(ns_path.clone(), sid))?;
+            socket.send(Packet::connect(ns_path.clone(), sid, protocol))?;
             Ok(())
         } else {
             socket
@@ -117,6 +118,15 @@ impl<A: Adapter> EngineIoHandler for Client<A> {
 
     fn on_connect(&self, socket: &EIoSocket<Self>) {
         debug!("eio socket connect {}", socket.sid);
+
+        // Connecting the client to the default namespace is mandatory if the SocketIO protocol is v4.
+        #[cfg(feature = "v4")]
+        {
+            if socket.protocol == engineioxide::service::ProtocolVersion::V3 {
+                debug!("Connecting to default namespace");
+                self.sock_connect(None, "/".into(), socket).unwrap();
+            }
+        }
     }
     fn on_disconnect(&self, socket: &EIoSocket<Self>) {
         debug!("eio socket disconnect {}", socket.sid);

socketioxide/src/handshake.rs

@@ -8,13 +8,13 @@ use crate::errors::Error;
 /// Handshake informations bound to a socket
 #[derive(Debug)]
 pub struct Handshake {
-    pub(crate) auth: serde_json::Value,
+    pub(crate) auth: Option<serde_json::Value>,
     pub issued: SystemTime,
     pub req: Arc<SocketReq>,
 }
 
 impl Handshake {
-    pub(crate) fn new(auth: serde_json::Value, req: Arc<SocketReq>) -> Self {
+    pub(crate) fn new(auth: Option<serde_json::Value>, req: Arc<SocketReq>) -> Self {
         Self {
             auth,
             req,
@@ -24,16 +24,20 @@ impl Handshake {
     /// Extract the data from the handshake.
     ///
     /// It is cloned and deserialized from a json::Value to the given type.
-    pub fn data<T: DeserializeOwned>(&self) -> Result<T, Error> {
-        Ok(serde_json::from_value(self.auth.clone())?)
+    pub fn data<T: DeserializeOwned>(&self) -> Option<Result<T, Error>> {
+        if let Some(auth) = &self.auth {
+            Some(serde_json::from_value(auth.clone()).map_err(Error::from))
+        } else {
+            None
+        }
     }
 }
 
 #[cfg(test)]
 impl Handshake {
     pub fn new_dummy() -> Self {
         Self {
-            auth: serde_json::json!({}),
+            auth: Some(serde_json::json!({})),
             issued: SystemTime::now(),
             req: Arc::new(SocketReq {
                 headers: Default::default(),

socketioxide/src/lib.rs

@@ -60,6 +60,9 @@
 //! }
 //! ```
 
+#[cfg(not(any(feature = "v4", feature = "v5")))]
+compile_error!("At least one protocol version must be enabled");
+
 pub mod adapter;
 pub mod retryer;
 

socketioxide/src/packet.rs

@@ -1,3 +1,4 @@
+use engineioxide::service::ProtocolVersion;
 use itertools::{Itertools, PeekingNext};
 use serde::{de::DeserializeOwned, Deserialize, Serialize};
 use serde_json::{json, Value};
@@ -16,16 +17,49 @@ pub struct Packet {
 }
 
 impl Packet {
-    pub fn connect(ns: String, sid: Sid) -> Self {
+    #[cfg(all(feature = "v5", feature = "v4"))]
+    pub fn connect(ns: String, sid: Sid, protocol: ProtocolVersion) -> Self {
+        // Decide which SocketIO packet format to use based on the current EngineIO protocol version.
+        match protocol {
+            ProtocolVersion::V3 => Self::connect_v4(ns),
+            ProtocolVersion::V4 => Self::connect_v5(ns, sid),
+        }
+    }
+
+    #[cfg(feature = "v5")]
+    #[cfg(not(feature = "v4"))]
+    pub fn connect(ns: String, sid: Sid, _: ProtocolVersion) -> Self {
+        Self::connect_v5(ns, sid)
+    }
+
+    #[cfg(feature = "v4")]
+    #[cfg(not(feature = "v5"))]
+    pub fn connect(ns: String, _: Sid, _: ProtocolVersion) -> Self {
+        Self::connect_v4(ns)
+    }
+
+    /// Sends a connect packet without payload.
+    #[cfg(feature = "v4")]
+    fn connect_v4(ns: String) -> Self {
+        Self {
+            inner: PacketData::Connect(None),
+            ns,
+        }
+    }
+
+    /// Sends a connect packet with payload.
+    #[cfg(feature = "v5")]
+    fn connect_v5(ns: String, sid: Sid) -> Self {
         let val = serde_json::to_value(ConnectPacket {
             sid: sid.to_string(),
         })
         .unwrap();
         Self {
-            inner: PacketData::Connect(val),
+            inner: PacketData::Connect(Some(val)),
             ns,
         }
     }
+
     pub fn disconnect(ns: String) -> Self {
         Self {
             inner: PacketData::Disconnect,
@@ -88,7 +122,7 @@ impl Packet {
 /// | BINARY_ACK    | 6   | Used to [acknowledge](#acknowledgement) an event (the response includes binary data). |
 #[derive(Debug, Clone, PartialEq)]
 pub enum PacketData {
-    Connect(Value),
+    Connect(Option<Value>),
     Disconnect,
     Event(String, Value, Option<i64>),
     EventAck(Value, i64),
@@ -196,7 +230,11 @@ impl TryInto<String> for Packet {
         }
 
         match self.inner {
-            PacketData::Connect(data) => res.push_str(&serde_json::to_string(&data)?),
+            PacketData::Connect(data) => {
+                if let Some(payload) = data {
+                    res.push_str(&serde_json::to_string(&payload)?);
+                }
+            }
             PacketData::Disconnect => (),
             PacketData::Event(event, data, ack) => {
                 if let Some(ack) = ack {
@@ -338,7 +376,7 @@ impl TryFrom<String> for Packet {
 
         let data = chars.as_str();
         let inner = match index {
-            '0' => PacketData::Connect(deserialize_packet(data)?.unwrap_or_else(|| json!({}))),
+            '0' => PacketData::Connect(deserialize_packet(data)?.unwrap_or_default()),
             '1' => PacketData::Disconnect,
             '2' => {
                 let (event, payload) = deserialize_event_packet(data)?;
@@ -404,7 +442,7 @@ mod test {
         assert_eq!(
             Packet {
                 ns: "/".to_string(),
-                inner: PacketData::Connect(json!({ "token": "123"}))
+                inner: PacketData::Connect(Some(json!({ "token": "123"})))
             },
             packet.unwrap()
         );
@@ -417,7 +455,7 @@ mod test {
         assert_eq!(
             Packet {
                 ns: "/admin™".to_owned(),
-                inner: PacketData::Connect(json!({ "token™": "123" }))
+                inner: PacketData::Connect(Some(json!({ "token™": "123" })))
             },
             packet.unwrap()
         );