chore(deps): update rust crate tokio-tungstenite to 0.26 (v2) (#2210)

Co-authored-by: renovate[bot] <29139614+renovate[bot]@users.noreply.github.com>
Co-authored-by: FabianLars <fabianlars@fabianlars.de>

plugins/websocket/src/lib.rs

@@ -66,13 +66,21 @@ struct ConnectionManager(Mutex<HashMap<Id, WebSocketWriter>>);
 #[cfg(any(feature = "rustls-tls", feature = "native-tls"))]
 struct TlsConnector(Mutex<Option<Connector>>);
 
+#[derive(Deserialize)]
+#[serde(untagged, rename_all = "camelCase")]
+enum Max {
+    None,
+    Number(usize),
+}
+
 #[derive(Deserialize)]
 #[serde(rename_all = "camelCase")]
-pub struct ConnectionConfig {
+pub(crate) struct ConnectionConfig {
+    pub read_buffer_size: Option<usize>,
     pub write_buffer_size: Option<usize>,
     pub max_write_buffer_size: Option<usize>,
-    pub max_message_size: Option<usize>,
-    pub max_frame_size: Option<usize>,
+    pub max_message_size: Option<Max>,
+    pub max_frame_size: Option<Max>,
     #[serde(default)]
     pub accept_unmasked_frames: bool,
     pub headers: Option<Vec<(String, String)>>,
@@ -80,18 +88,38 @@ pub struct ConnectionConfig {
 
 impl From<ConnectionConfig> for WebSocketConfig {
     fn from(config: ConnectionConfig) -> Self {
-        // Disabling the warning on max_send_queue which we don't use anymore since it was deprecated.
-        #[allow(deprecated)]
-        Self {
-            max_send_queue: None,
-            write_buffer_size: config.write_buffer_size.unwrap_or(128 * 1024),
-            max_write_buffer_size: config.max_write_buffer_size.unwrap_or(usize::MAX),
-            // This may be harmful since if it's not provided from js we're overwriting the default value with None, meaning no size limit.
-            max_message_size: config.max_message_size,
-            // This may be harmful since if it's not provided from js we're overwriting the default value with None, meaning no size limit.
-            max_frame_size: config.max_frame_size,
-            accept_unmasked_frames: config.accept_unmasked_frames,
+        let mut builder =
+            WebSocketConfig::default().accept_unmasked_frames(config.accept_unmasked_frames);
+
+        if let Some(read_buffer_size) = config.read_buffer_size {
+            builder = builder.read_buffer_size(read_buffer_size)
         }
+
+        if let Some(write_buffer_size) = config.write_buffer_size {
+            builder = builder.write_buffer_size(write_buffer_size)
+        }
+
+        if let Some(max_write_buffer_size) = config.max_write_buffer_size {
+            builder = builder.max_write_buffer_size(max_write_buffer_size)
+        }
+
+        if let Some(max_message_size) = config.max_message_size {
+            let max_size = match max_message_size {
+                Max::None => Option::None,
+                Max::Number(n) => Some(n),
+            };
+            builder = builder.max_message_size(max_size);
+        }
+
+        if let Some(max_frame_size) = config.max_frame_size {
+            let max_size = match max_frame_size {
+                Max::None => Option::None,
+                Max::Number(n) => Some(n),
+            };
+            builder = builder.max_frame_size(max_size);
+        }
+
+        builder
     }
 }
 
@@ -157,21 +185,21 @@ async fn connect<R: Runtime>(
 
                 let response = match message {
                     Ok(Message::Text(t)) => {
-                        serde_json::to_value(WebSocketMessage::Text(t)).unwrap()
+                        serde_json::to_value(WebSocketMessage::Text(t.to_string())).unwrap()
                     }
                     Ok(Message::Binary(t)) => {
-                        serde_json::to_value(WebSocketMessage::Binary(t)).unwrap()
+                        serde_json::to_value(WebSocketMessage::Binary(t.to_vec())).unwrap()
                     }
                     Ok(Message::Ping(t)) => {
-                        serde_json::to_value(WebSocketMessage::Ping(t)).unwrap()
+                        serde_json::to_value(WebSocketMessage::Ping(t.to_vec())).unwrap()
                     }
                     Ok(Message::Pong(t)) => {
-                        serde_json::to_value(WebSocketMessage::Pong(t)).unwrap()
+                        serde_json::to_value(WebSocketMessage::Pong(t.to_vec())).unwrap()
                     }
                     Ok(Message::Close(t)) => {
                         serde_json::to_value(WebSocketMessage::Close(t.map(|v| CloseFrame {
                             code: v.code.into(),
-                            reason: v.reason.into_owned(),
+                            reason: v.reason.to_string(),
                         })))
                         .unwrap()
                     }
@@ -197,13 +225,13 @@ async fn send(
     if let Some(write) = manager.0.lock().await.get_mut(&id) {
         write
             .send(match message {
-                WebSocketMessage::Text(t) => Message::Text(t),
-                WebSocketMessage::Binary(t) => Message::Binary(t),
-                WebSocketMessage::Ping(t) => Message::Ping(t),
-                WebSocketMessage::Pong(t) => Message::Pong(t),
+                WebSocketMessage::Text(t) => Message::Text(t.into()),
+                WebSocketMessage::Binary(t) => Message::Binary(t.into()),
+                WebSocketMessage::Ping(t) => Message::Ping(t.into()),
+                WebSocketMessage::Pong(t) => Message::Pong(t.into()),
                 WebSocketMessage::Close(t) => Message::Close(t.map(|v| ProtocolCloseFrame {
                     code: v.code.into(),
-                    reason: std::borrow::Cow::Owned(v.reason),
+                    reason: v.reason.into(),
                 })),
             })
             .await?;