Prepare for wasm32-unknown-unknown adoption

Cargo.toml

@@ -11,33 +11,38 @@ website = ["https://discord.com/invite/m3FpcapGDD"]
 
 
 [features]
-default = ["client"]
-backend = ["poem", "sqlx"]
+default = ["client", "rt-multi-thread"]
+backend = ["dep:poem", "dep:sqlx"]
+rt-multi-thread = ["tokio/rt-multi-thread"]
+rt = ["tokio/rt"]
 client = []
 
 [dependencies]
-tokio = { version = "1.29.1", features = ["macros"] }
+tokio = { version = "1.34.0", features = ["macros", "sync"] }
 serde = { version = "1.0.188", features = ["derive", "rc"] }
 serde_json = { version = "1.0.105", features = ["raw_value"] }
 serde-aux = "4.2.0"
 serde_with = "3.3.0"
 serde_repr = "0.1.16"
-reqwest = { version = "0.11.20", features = ["multipart", "json"] }
+reqwest = { git = "https://github.com/bitfl0wer/reqwest.git", branch = "wasm-headers", features = [
+    "multipart",
+    "json",
+] }
 url = "2.4.0"
 chrono = { version = "0.4.26", features = ["serde"] }
 regex = "1.9.4"
 custom_error = "1.9.2"
-tokio-tungstenite = { version = "0.20.1", features = [
-    "rustls-tls-native-roots",
-    "rustls-native-certs",
-] }
 futures-util = "0.3.28"
 http = "0.2.9"
 base64 = "0.21.3"
-hostname = "0.3.1"
 bitflags = { version = "2.4.0", features = ["serde"] }
 lazy_static = "1.4.0"
 poem = { version = "1.3.57", optional = true }
+thiserror = "1.0.47"
+jsonwebtoken = "8.3.0"
+log = "0.4.20"
+async-trait = "0.1.73"
+chorus-macros = "0.2.0"
 sqlx = { version = "0.7.1", features = [
     "mysql",
     "sqlite",
@@ -47,16 +52,28 @@ sqlx = { version = "0.7.1", features = [
     "runtime-tokio-native-tls",
     "any",
 ], optional = true }
-thiserror = "1.0.47"
-jsonwebtoken = "8.3.0"
-log = "0.4.20"
-async-trait = "0.1.73"
-chorus-macros = "0.2.0"
+safina-timer = "0.1.11"
+rand = "0.8.5"
+# TODO: Remove the below 2 imports for production!
+ws_stream_wasm = "0.7.4"
+pharos = "0.5.3"
+
+[target.'cfg(not(target_arch = "wasm32"))'.dependencies]
 rustls = "0.21.8"
 rustls-native-certs = "0.6.3"
-rand = "0.8.5"
+tokio-tungstenite = { version = "0.20.1", features = [
+    "rustls-tls-native-roots",
+    "rustls-native-certs",
+] }
+native-tls = "0.2.11"
+hostname = "0.3.1"
+
+[target.'cfg(target_arch = "wasm32")'.dependencies]
+getrandom = { version = "0.2.11", features = ["js"] }
+tokio-tungstenite = { version = "0.20.1", default-features = false }
+ws_stream_wasm = "0.7.4"
+pharos = "0.5.3"
+
 
 [dev-dependencies]
-tokio = { version = "1.32.0", features = ["full"] }
 lazy_static = "1.4.0"
-rusty-hook = "0.11.2"

examples/gateway_observers.rs

@@ -1,7 +1,8 @@
 use async_trait::async_trait;
+use chorus::gateway::Gateway;
 use chorus::{
     self,
-    gateway::{Gateway, Observer},
+    gateway::Observer,
     types::{GatewayIdentifyPayload, GatewayReady},
 };
 use std::{sync::Arc, time::Duration};
@@ -24,13 +25,13 @@ impl Observer<GatewayReady> for ExampleObserver {
     }
 }
 
-#[tokio::main]
+#[tokio::main(flavor = "current_thread")]
 async fn main() {
     // Find the gateway websocket url of the server we want to connect to
     let websocket_url_spacebar = "wss://gateway.old.server.spacebar.chat/".to_string();
 
     // Initiate the gateway connection
-    let gateway = Gateway::new(websocket_url_spacebar).await.unwrap();
+    let gateway = Gateway::spawn(websocket_url_spacebar).await.unwrap();
 
     // Create an instance of our observer
     let observer = ExampleObserver {};

examples/gateway_simple.rs

@@ -1,16 +1,17 @@
 use std::time::Duration;
 
-use chorus::{self, gateway::Gateway, types::GatewayIdentifyPayload};
+use chorus::gateway::Gateway;
+use chorus::{self, types::GatewayIdentifyPayload};
 use tokio::time::sleep;
 
 /// This example creates a simple gateway connection and a session with an Identify event
-#[tokio::main]
+#[tokio::main(flavor = "current_thread")]
 async fn main() {
     // Find the gateway websocket url of the server we want to connect to
     let websocket_url_spacebar = "wss://gateway.old.server.spacebar.chat/".to_string();
 
     // Initiate the gateway connection, starting a listener in one thread and a heartbeat handler in another
-    let gateway = Gateway::new(websocket_url_spacebar).await.unwrap();
+    let gateway = Gateway::spawn(websocket_url_spacebar).await.unwrap();
 
     // At this point, we are connected to the server and are sending heartbeats, however we still haven't authenticated
 

examples/instance.rs

@@ -1,7 +1,7 @@
 use chorus::instance::Instance;
 use chorus::UrlBundle;
 
-#[tokio::main]
+#[tokio::main(flavor = "current_thread")]
 async fn main() {
     let bundle = UrlBundle::new(
         "https://example.com/api".to_string(),

examples/login.rs

@@ -2,7 +2,7 @@ use chorus::instance::Instance;
 use chorus::types::LoginSchema;
 use chorus::UrlBundle;
 
-#[tokio::main]
+#[tokio::main(flavor = "current_thread")]
 async fn main() {
     let bundle = UrlBundle::new(
         "https://example.com/api".to_string(),

src/api/auth/login.rs

@@ -36,7 +36,7 @@ impl Instance {
             self.limits_information.as_mut().unwrap().ratelimits = shell.limits.clone().unwrap();
         }
         let mut identify = GatewayIdentifyPayload::common();
-        let gateway = Gateway::new(self.urls.wss.clone()).await.unwrap();
+        let gateway = Gateway::spawn(self.urls.wss.clone()).await.unwrap();
         identify.token = login_result.token.clone();
         gateway.send_identify(identify).await;
         let user = ChorusUser::new(

src/api/auth/mod.rs

@@ -3,9 +3,9 @@ use std::sync::{Arc, RwLock};
 pub use login::*;
 pub use register::*;
 
+use crate::gateway::Gateway;
 use crate::{
     errors::ChorusResult,
-    gateway::Gateway,
     instance::{ChorusUser, Instance},
     types::{GatewayIdentifyPayload, User},
 };
@@ -25,7 +25,7 @@ impl Instance {
             .await
             .unwrap();
         let mut identify = GatewayIdentifyPayload::common();
-        let gateway = Gateway::new(self.urls.wss.clone()).await.unwrap();
+        let gateway = Gateway::spawn(self.urls.wss.clone()).await.unwrap();
         identify.token = token.clone();
         gateway.send_identify(identify).await;
         let user = ChorusUser::new(

src/api/auth/register.rs

@@ -3,7 +3,7 @@ use std::sync::{Arc, RwLock};
 use reqwest::Client;
 use serde_json::to_string;
 
-use crate::gateway::Gateway;
+use crate::gateway::{Gateway, GatewayHandle};
 use crate::types::GatewayIdentifyPayload;
 use crate::{
     errors::ChorusResult,
@@ -45,7 +45,7 @@ impl Instance {
         let user_object = self.get_user(token.clone(), None).await.unwrap();
         let settings = ChorusUser::get_settings(&token, &self.urls.api.clone(), &mut self).await?;
         let mut identify = GatewayIdentifyPayload::common();
-        let gateway = Gateway::new(self.urls.wss.clone()).await.unwrap();
+        let gateway: GatewayHandle = Gateway::spawn(self.urls.wss.clone()).await.unwrap();
         identify.token = token.clone();
         gateway.send_identify(identify).await;
         let user = ChorusUser::new(

src/gateway/backend_tungstenite.rs

@@ -0,0 +1,65 @@
+use futures_util::{
+    stream::{SplitSink, SplitStream},
+    StreamExt,
+};
+use tokio::net::TcpStream;
+use tokio_tungstenite::{
+    connect_async_tls_with_config, tungstenite, Connector, MaybeTlsStream, WebSocketStream,
+};
+
+use super::GatewayMessage;
+use crate::errors::GatewayError;
+
+#[derive(Debug, Clone)]
+pub struct WebSocketBackend;
+
+// These could be made into inherent associated types when that's stabilized
+pub type WsSink = SplitSink<WebSocketStream<MaybeTlsStream<TcpStream>>, tungstenite::Message>;
+pub type WsStream = SplitStream<WebSocketStream<MaybeTlsStream<TcpStream>>>;
+
+impl WebSocketBackend {
+    pub async fn connect(
+        websocket_url: &str,
+    ) -> Result<(WsSink, WsStream), crate::errors::GatewayError> {
+        let mut roots = rustls::RootCertStore::empty();
+        for cert in rustls_native_certs::load_native_certs().expect("could not load platform certs")
+        {
+            roots.add(&rustls::Certificate(cert.0)).unwrap();
+        }
+        let (websocket_stream, _) = match connect_async_tls_with_config(
+            websocket_url,
+            None,
+            false,
+            Some(Connector::Rustls(
+                rustls::ClientConfig::builder()
+                    .with_safe_defaults()
+                    .with_root_certificates(roots)
+                    .with_no_client_auth()
+                    .into(),
+            )),
+        )
+        .await
+        {
+            Ok(websocket_stream) => websocket_stream,
+            Err(e) => {
+                return Err(GatewayError::CannotConnect {
+                    error: e.to_string(),
+                })
+            }
+        };
+
+        Ok(websocket_stream.split())
+    }
+}
+
+impl From<GatewayMessage> for tungstenite::Message {
+    fn from(message: GatewayMessage) -> Self {
+        Self::Text(message.0)
+    }
+}
+
+impl From<tungstenite::Message> for GatewayMessage {
+    fn from(value: tungstenite::Message) -> Self {
+        Self(value.to_string())
+    }
+}