Commonized networking (#3310)

* Fix not being able to connect to local friends socket

* Start basic work on tunneling protocol and move some code into a common crate

* Commonize message serialization logic

* Serialize Base62Ids as u64 when human-readability is not required

* Move ActiveSockets tuple into struct

* Make CI run when rust-common is updated

CI is currently broken for labrinth, however

* Fix theseus-release.yml to reference itself correctly

* Implement Labrinth side of tunneling

* Implement non-friend part of theseus tunneling

* Implement client-side except for socket loop

* Implement the socket loop

Doesn't work though. Debugging time!

* Fix config.rs

* Fix deadlock in labrinth socket handling

* Update dockerfile

* switch to workspace prepare at root level

* Wait for connection before tunneling in playground

* Move rust-common into labrinth

* Remove rust-common references from Actions

* Revert "Update dockerfile"

This reverts commit 3caad59bb474ce425d0b8928d7cee7ae1a5011bd.

* Fix Docker build

* Rebuild Theseus if common code changes

* Allow multiple connections from the same user

* Fix test building

* Move FriendSocketListening and FriendSocketStoppedListening to non-panicking TODO for now

* Make message_serialization macro take varargs for binary messages

* Improve syntax of message_serialization macro

* Remove the ability to connect to a virtual socket, and disable the ability to listen on one

* Allow the app to compile without running labrinth

* Clippy fix

* Update Rust and Clippy fix again

---------

Co-authored-by: Jai A <jaiagr+gpg@pm.me>

apps/labrinth/src/common/networking/message.rs

@@ -0,0 +1,65 @@
+use crate::common::ids::UserId;
+use crate::common::users::UserStatus;
+use serde::{Deserialize, Serialize};
+use uuid::Uuid;
+
+#[derive(Debug, Serialize, Deserialize)]
+#[serde(tag = "type", rename_all = "snake_case")]
+pub enum ClientToServerMessage {
+    StatusUpdate {
+        profile_name: Option<String>,
+    },
+
+    SocketListen {
+        socket: Uuid,
+    },
+    SocketClose {
+        socket: Uuid,
+    },
+    SocketSend {
+        socket: Uuid,
+        #[serde(with = "serde_bytes")]
+        data: Vec<u8>,
+    },
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+#[serde(tag = "type", rename_all = "snake_case")]
+pub enum ServerToClientMessage {
+    StatusUpdate {
+        status: UserStatus,
+    },
+    UserOffline {
+        id: UserId,
+    },
+    FriendStatuses {
+        statuses: Vec<UserStatus>,
+    },
+    FriendRequest {
+        from: UserId,
+    },
+    FriendRequestRejected {
+        from: UserId,
+    },
+
+    FriendSocketListening {
+        user: UserId,
+        socket: Uuid,
+    },
+    FriendSocketStoppedListening {
+        user: UserId,
+    },
+
+    SocketConnected {
+        to_socket: Uuid,
+        new_socket: Uuid,
+    },
+    SocketClosed {
+        socket: Uuid,
+    },
+    SocketData {
+        socket: Uuid,
+        #[serde(with = "serde_bytes")]
+        data: Vec<u8>,
+    },
+}

apps/labrinth/src/common/networking/mod.rs

@@ -0,0 +1,2 @@
+pub mod message;
+pub mod serialization;

apps/labrinth/src/common/networking/serialization.rs

@@ -0,0 +1,56 @@
+use super::message::{ClientToServerMessage, ServerToClientMessage};
+use either::Either;
+use thiserror::Error;
+
+#[derive(Debug, Error)]
+pub enum SerializationError {
+    #[error("Failed to (de)serialize message: {0}")]
+    SerializationFailed(#[from] serde_json::Error),
+
+    #[error("Failed to (de)serialize binary message: {0}")]
+    BinarySerializationFailed(#[from] serde_cbor::Error),
+}
+
+macro_rules! message_serialization {
+    ($message_enum:ty $(,$binary_pattern:pat_param)* $(,)?) => {
+        impl $message_enum {
+            pub fn is_binary(&self) -> bool {
+                match self {
+                    $(
+                        $binary_pattern => true,
+                    )*
+                    _ => false,
+                }
+            }
+
+            pub fn serialize(
+                &self,
+            ) -> Result<Either<String, Vec<u8>>, SerializationError> {
+                Ok(match self {
+                    $(
+                        $binary_pattern => Either::Right(serde_cbor::to_vec(self)?),
+                    )*
+                    _ => Either::Left(serde_json::to_string(self)?),
+                })
+            }
+
+            pub fn deserialize(
+                msg: Either<&str, &[u8]>,
+            ) -> Result<Self, SerializationError> {
+                Ok(match msg {
+                    Either::Left(text) => serde_json::from_str(&text)?,
+                    Either::Right(bytes) => serde_cbor::from_slice(&bytes)?,
+                })
+            }
+        }
+    };
+}
+
+message_serialization!(
+    ClientToServerMessage,
+    ClientToServerMessage::SocketSend { .. },
+);
+message_serialization!(
+    ServerToClientMessage,
+    ServerToClientMessage::SocketData { .. },
+);