diff --git a/README.md b/README.md index f1fbc0a..82ac173 100644 --- a/README.md +++ b/README.md @@ -30,7 +30,7 @@ -## Roadmap +## Progress Tracker/Roadmap: ### Core Functionality - [x] Rate Limiter (hint: couldn't be fully tested due to [an Issue with the Spacebar Server](https://github.com/spacebarchat/server/issues/1022)) - [x] [Login (the conventional way)](https://github.com/polyphony-chat/chorus/issues/1) diff --git a/examples/gateway_observers.rs b/examples/gateway_observers.rs index 0920d61..166b84a 100644 --- a/examples/gateway_observers.rs +++ b/examples/gateway_observers.rs @@ -17,7 +17,7 @@ pub struct ExampleObserver {} // One struct can be an observer of multiple websocketevents, if needed impl Observer for ExampleObserver { // After we subscribe to an event this function is called every time we receive it - fn update(&self, _data: &GatewayReady) { + fn update(&mut self, _data: &GatewayReady) { println!("Observed Ready!"); } } diff --git a/examples/gateway_simple.rs b/examples/gateway_simple.rs index 19de9bb..c346839 100644 --- a/examples/gateway_simple.rs +++ b/examples/gateway_simple.rs @@ -1,5 +1,4 @@ use chorus::{self, gateway::Gateway, types::GatewayIdentifyPayload}; -use tokio; /// This example creates a simple gateway connection and a session with an Identify event #[tokio::main] diff --git a/src/api/auth/login.rs b/src/api/auth/login.rs index 55d7799..aeafec2 100644 --- a/src/api/auth/login.rs +++ b/src/api/auth/login.rs @@ -1,72 +1,70 @@ -pub mod login { - use std::cell::RefCell; - use std::rc::Rc; +use std::cell::RefCell; +use std::rc::Rc; - use reqwest::Client; - use serde_json::{from_str, json}; +use reqwest::Client; +use serde_json::{from_str, json}; - use crate::api::limits::LimitType; - use crate::errors::ChorusLibError; - use crate::instance::{Instance, UserMeta}; - use crate::limit::LimitedRequester; - use crate::types::{ErrorResponse, LoginResult, LoginSchema}; +use crate::api::limits::LimitType; +use crate::errors::ChorusLibError; +use crate::instance::{Instance, UserMeta}; +use crate::limit::LimitedRequester; +use crate::types::{ErrorResponse, LoginResult, LoginSchema}; - impl Instance { - pub async fn login_account( - &mut self, - login_schema: &LoginSchema, - ) -> Result { - let mut requester = LimitedRequester::new().await; - let json_schema = json!(login_schema); - let client = Client::new(); - let endpoint_url = self.urls.get_api().to_string() + "/auth/login"; - let request_builder = client.post(endpoint_url).body(json_schema.to_string()); - // We do not have a user yet, and the UserRateLimits will not be affected by a login - // request (since login is an instance wide limit), which is why we are just cloning the - // instances' limits to pass them on as user_rate_limits later. - let mut cloned_limits = self.limits.clone(); - let response = requester - .send_request( - request_builder, - LimitType::AuthRegister, - &mut self.limits, - &mut cloned_limits, - ) - .await; - if response.is_err() { - return Err(ChorusLibError::NoResponse); - } - - let response_unwrap = response.unwrap(); - let status = response_unwrap.status(); - let response_text_string = response_unwrap.text().await.unwrap(); - if status.is_client_error() { - let json: ErrorResponse = serde_json::from_str(&response_text_string).unwrap(); - let error_type = json.errors.errors.iter().next().unwrap().0.to_owned(); - let mut error = "".to_string(); - for (_, value) in json.errors.errors.iter() { - for error_item in value._errors.iter() { - error += &(error_item.message.to_string() + " (" + &error_item.code + ")"); - } - } - return Err(ChorusLibError::InvalidFormBodyError { error_type, error }); - } - - let cloned_limits = self.limits.clone(); - let login_result: LoginResult = from_str(&response_text_string).unwrap(); - let object = self - .get_user(login_result.token.clone(), None) - .await - .unwrap(); - let user = UserMeta::new( - Rc::new(RefCell::new(self.clone())), - login_result.token, - cloned_limits, - login_result.settings, - object, - ); - - Ok(user) +impl Instance { + pub async fn login_account( + &mut self, + login_schema: &LoginSchema, + ) -> Result { + let mut requester = LimitedRequester::new().await; + let json_schema = json!(login_schema); + let client = Client::new(); + let endpoint_url = self.urls.get_api().to_string() + "/auth/login"; + let request_builder = client.post(endpoint_url).body(json_schema.to_string()); + // We do not have a user yet, and the UserRateLimits will not be affected by a login + // request (since login is an instance wide limit), which is why we are just cloning the + // instances' limits to pass them on as user_rate_limits later. + let mut cloned_limits = self.limits.clone(); + let response = requester + .send_request( + request_builder, + LimitType::AuthRegister, + &mut self.limits, + &mut cloned_limits, + ) + .await; + if response.is_err() { + return Err(ChorusLibError::NoResponse); } + + let response_unwrap = response.unwrap(); + let status = response_unwrap.status(); + let response_text_string = response_unwrap.text().await.unwrap(); + if status.is_client_error() { + let json: ErrorResponse = serde_json::from_str(&response_text_string).unwrap(); + let error_type = json.errors.errors.iter().next().unwrap().0.to_owned(); + let mut error = "".to_string(); + for (_, value) in json.errors.errors.iter() { + for error_item in value._errors.iter() { + error += &(error_item.message.to_string() + " (" + &error_item.code + ")"); + } + } + return Err(ChorusLibError::InvalidFormBodyError { error_type, error }); + } + + let cloned_limits = self.limits.clone(); + let login_result: LoginResult = from_str(&response_text_string).unwrap(); + let object = self + .get_user(login_result.token.clone(), None) + .await + .unwrap(); + let user = UserMeta::new( + Rc::new(RefCell::new(self.clone())), + login_result.token, + cloned_limits, + login_result.settings, + object, + ); + + Ok(user) } } diff --git a/src/api/auth/mod.rs b/src/api/auth/mod.rs index 3093e74..663bf5e 100644 --- a/src/api/auth/mod.rs +++ b/src/api/auth/mod.rs @@ -1,5 +1,5 @@ -pub mod login; -pub mod register; - pub use login::*; pub use register::*; + +pub mod login; +pub mod register; diff --git a/src/api/auth/register.rs b/src/api/auth/register.rs index d961fbf..d8c4847 100644 --- a/src/api/auth/register.rs +++ b/src/api/auth/register.rs @@ -1,79 +1,77 @@ -pub mod register { - use std::{cell::RefCell, rc::Rc}; +use std::{cell::RefCell, rc::Rc}; - use reqwest::Client; - use serde_json::{from_str, json}; +use reqwest::Client; +use serde_json::{from_str, json}; - use crate::{ - api::limits::LimitType, - errors::ChorusLibError, - instance::{Instance, Token, UserMeta}, - limit::LimitedRequester, - types::{ErrorResponse, RegisterSchema}, - }; +use crate::{ + api::limits::LimitType, + errors::ChorusLibError, + instance::{Instance, Token, UserMeta}, + limit::LimitedRequester, + types::{ErrorResponse, RegisterSchema}, +}; - impl Instance { - /** - Registers a new user on the Spacebar server. - # Arguments - * `register_schema` - The [`RegisterSchema`] that contains all the information that is needed to register a new user. - # Errors - * [`ChorusLibError`] - If the server does not respond. - */ - pub async fn register_account( - &mut self, - register_schema: &RegisterSchema, - ) -> Result { - let json_schema = json!(register_schema); - let mut limited_requester = LimitedRequester::new().await; - let client = Client::new(); - let endpoint_url = self.urls.get_api().to_string() + "/auth/register"; - let request_builder = client.post(endpoint_url).body(json_schema.to_string()); - // We do not have a user yet, and the UserRateLimits will not be affected by a login - // request (since register is an instance wide limit), which is why we are just cloning - // the instances' limits to pass them on as user_rate_limits later. - let mut cloned_limits = self.limits.clone(); - let response = limited_requester - .send_request( - request_builder, - LimitType::AuthRegister, - &mut self.limits, - &mut cloned_limits, - ) - .await; - if response.is_err() { - return Err(ChorusLibError::NoResponse); - } - - let response_unwrap = response.unwrap(); - let status = response_unwrap.status(); - let response_unwrap_text = response_unwrap.text().await.unwrap(); - let token = from_str::(&response_unwrap_text).unwrap(); - let token = token.token; - if status.is_client_error() { - let json: ErrorResponse = serde_json::from_str(&token).unwrap(); - let error_type = json.errors.errors.iter().next().unwrap().0.to_owned(); - let mut error = "".to_string(); - for (_, value) in json.errors.errors.iter() { - for error_item in value._errors.iter() { - error += &(error_item.message.to_string() + " (" + &error_item.code + ")"); - } - } - return Err(ChorusLibError::InvalidFormBodyError { error_type, error }); - } - let user_object = self.get_user(token.clone(), None).await.unwrap(); - let settings = - UserMeta::get_settings(&token, &self.urls.get_api().to_string(), &mut self.limits) - .await - .unwrap(); - let user: UserMeta = UserMeta::new( - Rc::new(RefCell::new(self.clone())), - token.clone(), - cloned_limits, - settings, - user_object, - ); - Ok(user) +impl Instance { + /** + Registers a new user on the Spacebar server. + # Arguments + * `register_schema` - The [`RegisterSchema`] that contains all the information that is needed to register a new user. + # Errors + * [`ChorusLibError`] - If the server does not respond. + */ + pub async fn register_account( + &mut self, + register_schema: &RegisterSchema, + ) -> Result { + let json_schema = json!(register_schema); + let mut limited_requester = LimitedRequester::new().await; + let client = Client::new(); + let endpoint_url = self.urls.get_api().to_string() + "/auth/register"; + let request_builder = client.post(endpoint_url).body(json_schema.to_string()); + // We do not have a user yet, and the UserRateLimits will not be affected by a login + // request (since register is an instance wide limit), which is why we are just cloning + // the instances' limits to pass them on as user_rate_limits later. + let mut cloned_limits = self.limits.clone(); + let response = limited_requester + .send_request( + request_builder, + LimitType::AuthRegister, + &mut self.limits, + &mut cloned_limits, + ) + .await; + if response.is_err() { + return Err(ChorusLibError::NoResponse); } + + let response_unwrap = response.unwrap(); + let status = response_unwrap.status(); + let response_unwrap_text = response_unwrap.text().await.unwrap(); + let token = from_str::(&response_unwrap_text).unwrap(); + let token = token.token; + if status.is_client_error() { + let json: ErrorResponse = serde_json::from_str(&token).unwrap(); + let error_type = json.errors.errors.iter().next().unwrap().0.to_owned(); + let mut error = "".to_string(); + for (_, value) in json.errors.errors.iter() { + for error_item in value._errors.iter() { + error += &(error_item.message.to_string() + " (" + &error_item.code + ")"); + } + } + return Err(ChorusLibError::InvalidFormBodyError { error_type, error }); + } + let user_object = self.get_user(token.clone(), None).await.unwrap(); + let settings = + UserMeta::get_settings(&token, &self.urls.get_api().to_string(), &mut self.limits) + .await + .unwrap(); + let user: UserMeta = UserMeta::new( + Rc::new(RefCell::new(self.clone())), + token.clone(), + cloned_limits, + settings, + user_object, + ); + Ok(user) } } diff --git a/src/api/channels/mod.rs b/src/api/channels/mod.rs index 94b42b6..b72861e 100644 --- a/src/api/channels/mod.rs +++ b/src/api/channels/mod.rs @@ -1,9 +1,9 @@ -pub mod channels; -pub mod messages; -pub mod permissions; -pub mod reactions; - pub use channels::*; pub use messages::*; pub use permissions::*; pub use reactions::*; + +pub mod channels; +pub mod messages; +pub mod permissions; +pub mod reactions; diff --git a/src/api/channels/reactions.rs b/src/api/channels/reactions.rs index 9bd7adc..e46adba 100644 --- a/src/api/channels/reactions.rs +++ b/src/api/channels/reactions.rs @@ -28,7 +28,7 @@ impl ReactionMeta { # Reference See [https://discord.com/developers/docs/resources/channel#delete-all-reactions](https://discord.com/developers/docs/resources/channel#delete-all-reactions) - */ + */ pub async fn delete_all( &self, user: &mut UserMeta, @@ -66,7 +66,7 @@ impl ReactionMeta { # Reference See [https://discord.com/developers/docs/resources/channel#get-reactions](https://discord.com/developers/docs/resources/channel#get-reactions) - */ + */ pub async fn get( &self, emoji: &str, @@ -108,7 +108,7 @@ impl ReactionMeta { # Reference See [https://discord.com/developers/docs/resources/channel#delete-all-reactions-for-emoji](https://discord.com/developers/docs/resources/channel#delete-all-reactions-for-emoji) - */ + */ pub async fn delete_emoji( &self, emoji: &str, @@ -154,7 +154,7 @@ impl ReactionMeta { # Reference See [https://discord.com/developers/docs/resources/channel#create-reaction](https://discord.com/developers/docs/resources/channel#create-reaction) - */ + */ pub async fn create( &self, emoji: &str, @@ -241,7 +241,7 @@ impl ReactionMeta { # Reference See [https://discord.com/developers/docs/resources/channel#delete-own-reaction](https://discord.com/developers/docs/resources/channel#delete-own-reaction) - */ + */ pub async fn delete_user( &self, user_id: &str, diff --git a/src/api/guilds/guilds.rs b/src/api/guilds/guilds.rs index 56912e7..c94d327 100644 --- a/src/api/guilds/guilds.rs +++ b/src/api/guilds/guilds.rs @@ -173,7 +173,7 @@ impl Guild { Err(e) => { return Err(ChorusLibError::InvalidResponseError { error: e.to_string(), - }) + }); } }; let _: Vec = match from_str(&stringed_response) { @@ -181,7 +181,7 @@ impl Guild { Err(e) => { return Err(ChorusLibError::InvalidResponseError { error: e.to_string(), - }) + }); } }; } diff --git a/src/api/guilds/member.rs b/src/api/guilds/member.rs index a6ec7d7..7b0f5d5 100644 --- a/src/api/guilds/member.rs +++ b/src/api/guilds/member.rs @@ -43,7 +43,7 @@ impl types::GuildMember { Err(e) => { return Err(ChorusLibError::InvalidResponseError { error: e.to_string(), - }) + }); } }; let member = from_str::(&response_text); diff --git a/src/api/guilds/mod.rs b/src/api/guilds/mod.rs index 1138a50..7577479 100644 --- a/src/api/guilds/mod.rs +++ b/src/api/guilds/mod.rs @@ -1,7 +1,7 @@ -pub mod guilds; -pub mod member; -pub mod roles; - pub use guilds::*; pub use roles::*; pub use roles::*; + +pub mod guilds; +pub mod member; +pub mod roles; diff --git a/src/api/guilds/roles.rs b/src/api/guilds/roles.rs index b2e9b31..f8b3be4 100644 --- a/src/api/guilds/roles.rs +++ b/src/api/guilds/roles.rs @@ -48,7 +48,7 @@ impl types::RoleObject { Err(e) => { return Err(ChorusLibError::InvalidResponseError { error: e.to_string(), - }) + }); } }; @@ -105,7 +105,7 @@ impl types::RoleObject { Err(e) => { return Err(ChorusLibError::InvalidResponseError { error: e.to_string(), - }) + }); } }; @@ -139,7 +139,7 @@ impl types::RoleObject { Err(e) => { return Err(ChorusLibError::FormCreationError { error: e.to_string(), - }) + }); } }; let request = Client::new().post(url).bearer_auth(user.token()).body(body); @@ -161,7 +161,7 @@ impl types::RoleObject { Err(e) => { return Err(ChorusLibError::InvalidResponseError { error: e.to_string(), - }) + }); } }; Ok(role) @@ -194,7 +194,7 @@ impl types::RoleObject { Err(e) => { return Err(ChorusLibError::FormCreationError { error: e.to_string(), - }) + }); } }; let request = Client::new() @@ -216,7 +216,7 @@ impl types::RoleObject { Err(e) => { return Err(ChorusLibError::InvalidResponseError { error: e.to_string(), - }) + }); } }; Ok(role) @@ -256,7 +256,7 @@ impl types::RoleObject { Err(e) => { return Err(ChorusLibError::FormCreationError { error: e.to_string(), - }) + }); } }; let request = Client::new() @@ -281,7 +281,7 @@ impl types::RoleObject { Err(e) => { return Err(ChorusLibError::InvalidResponseError { error: e.to_string(), - }) + }); } }; Ok(role) diff --git a/src/api/policies/instance/instance.rs b/src/api/policies/instance/instance.rs index 055568f..c775195 100644 --- a/src/api/policies/instance/instance.rs +++ b/src/api/policies/instance/instance.rs @@ -10,7 +10,7 @@ impl Instance { Gets the instance policies schema. # Errors [`ChorusLibError`] - If the request fails. - */ + */ pub async fn general_configuration_schema( &self, ) -> Result { diff --git a/src/api/policies/instance/limits.rs b/src/api/policies/instance/limits.rs index 1c96883..98e0fc8 100644 --- a/src/api/policies/instance/limits.rs +++ b/src/api/policies/instance/limits.rs @@ -47,7 +47,6 @@ pub mod limits { #[derive(Debug, Deserialize, Serialize)] #[allow(non_snake_case)] - pub struct Guild { pub maxRoles: u64, pub maxEmojis: u64, @@ -58,7 +57,6 @@ pub mod limits { #[derive(Debug, Deserialize, Serialize)] #[allow(non_snake_case)] - pub struct Message { pub maxCharacters: u64, pub maxTTSCharacters: u64, @@ -70,7 +68,6 @@ pub mod limits { #[derive(Debug, Deserialize, Serialize)] #[allow(non_snake_case)] - pub struct Channel { pub maxPins: u64, pub maxTopic: u64, @@ -102,7 +99,6 @@ pub mod limits { #[derive(Debug, Deserialize, Serialize)] #[allow(non_snake_case)] - pub struct AuthRoutes { pub login: Window, pub register: Window, @@ -110,7 +106,6 @@ pub mod limits { #[derive(Debug, Deserialize, Serialize)] #[allow(non_snake_case)] - pub struct AbsoluteRate { pub register: AbsoluteWindow, pub sendMessage: AbsoluteWindow, @@ -125,7 +120,6 @@ pub mod limits { #[derive(Debug, Deserialize, Serialize)] #[allow(non_snake_case)] - pub struct Config { pub user: User, pub guild: Guild, diff --git a/src/api/policies/instance/mod.rs b/src/api/policies/instance/mod.rs index b05078e..7be9605 100644 --- a/src/api/policies/instance/mod.rs +++ b/src/api/policies/instance/mod.rs @@ -1,5 +1,5 @@ -pub mod instance; -pub mod limits; - pub use instance::*; pub use limits::*; + +pub mod instance; +pub mod limits; diff --git a/src/api/policies/mod.rs b/src/api/policies/mod.rs index 6b4a5bc..3e25d8c 100644 --- a/src/api/policies/mod.rs +++ b/src/api/policies/mod.rs @@ -1,3 +1,3 @@ -pub mod instance; - pub use instance::limits::*; + +pub mod instance; diff --git a/src/api/users/mod.rs b/src/api/users/mod.rs index 3bad41b..058be4c 100644 --- a/src/api/users/mod.rs +++ b/src/api/users/mod.rs @@ -1,3 +1,3 @@ -pub mod users; - pub use users::*; + +pub mod users; diff --git a/src/errors.rs b/src/errors.rs index e0789e3..0f65669 100644 --- a/src/errors.rs +++ b/src/errors.rs @@ -32,3 +32,35 @@ custom_error! { pub ObserverError AlreadySubscribedError = "Each event can only be subscribed to once." } + +custom_error! { + /// For errors we receive from the gateway, see https://discord-userdoccers.vercel.app/topics/opcodes-and-status-codes#gateway-close-event-codes; + /// + /// Supposed to be sent as numbers, though they are sent as string most of the time? + /// + /// Also includes errors when initiating a connection and unexpected opcodes + #[derive(PartialEq, Eq)] + pub GatewayError + // Errors we have received from the gateway + UnknownError = "We're not sure what went wrong. Try reconnecting?", + UnknownOpcodeError = "You sent an invalid Gateway opcode or an invalid payload for an opcode", + DecodeError = "Gateway server couldn't decode payload", + NotAuthenticatedError = "You sent a payload prior to identifying", + AuthenticationFailedError = "The account token sent with your identify payload is invalid", + AlreadyAuthenticatedError = "You've already identified, no need to reauthenticate", + InvalidSequenceNumberError = "The sequence number sent when resuming the session was invalid. Reconnect and start a new session", + RateLimitedError = "You are being rate limited!", + SessionTimedOutError = "Your session timed out. Reconnect and start a new one", + InvalidShardError = "You sent us an invalid shard when identifying", + ShardingRequiredError = "The session would have handled too many guilds - you are required to shard your connection in order to connect", + InvalidAPIVersionError = "You sent an invalid Gateway version", + InvalidIntentsError = "You sent an invalid intent", + DisallowedIntentsError = "You sent a disallowed intent. You may have tried to specify an intent that you have not enabled or are not approved for", + + // Errors when initiating a gateway connection + CannotConnectError{error: String} = "Cannot connect due to a tungstenite error: {error}", + NonHelloOnInitiateError{opcode: u8} = "Received non hello on initial gateway connection ({opcode}), something is definitely wrong", + + // Other misc errors + UnexpectedOpcodeReceivedError{opcode: u8} = "Received an opcode we weren't expecting to receive: {opcode}", +} diff --git a/src/gateway.rs b/src/gateway.rs index 85c3515..a765702 100644 --- a/src/gateway.rs +++ b/src/gateway.rs @@ -1,13 +1,16 @@ +use crate::errors::GatewayError; use crate::errors::ObserverError; use crate::gateway::events::Events; use crate::types; +use crate::types::WebSocketEvent; +use std::sync::Arc; + use futures_util::stream::SplitSink; +use futures_util::stream::SplitStream; use futures_util::SinkExt; use futures_util::StreamExt; use native_tls::TlsConnector; -use std::sync::Arc; use tokio::net::TcpStream; -use tokio::sync::mpsc; use tokio::sync::mpsc::error::TryRecvError; use tokio::sync::mpsc::Sender; use tokio::sync::Mutex; @@ -66,13 +69,116 @@ const GATEWAY_CALL_SYNC: u8 = 13; /// See [types::LazyRequest] const GATEWAY_LAZY_REQUEST: u8 = 14; +/// The amount of time we wait for a heartbeat ack before resending our heartbeat in ms +const HEARTBEAT_ACK_TIMEOUT: u128 = 2000; + +#[derive(Clone, Debug)] +/** +Represents a messsage received from the gateway. This will be either a [GatewayReceivePayload], containing events, or a [GatewayError]. +This struct is used internally when handling messages. +*/ +pub struct GatewayMessage { + /// The message we received from the server + message: tokio_tungstenite::tungstenite::Message, +} + +impl GatewayMessage { + /// Creates self from a tungstenite message + pub fn from_tungstenite_message(message: tokio_tungstenite::tungstenite::Message) -> Self { + Self { message } + } + + /// Parses the message as an error; + /// Returns the error if succesfully parsed, None if the message isn't an error + pub fn error(&self) -> Option { + let content = self.message.to_string(); + + // Some error strings have dots on the end, which we don't care about + let processed_content = content.clone().to_lowercase().replace(".", ""); + + match processed_content.as_str() { + "unknown error" | "4000" => { + return Some(GatewayError::UnknownError); + } + "unknown opcode" | "4001" => { + return Some(GatewayError::UnknownOpcodeError); + } + "decode error" | "error while decoding payload" | "4002" => { + return Some(GatewayError::DecodeError); + } + "not authenticated" | "4003" => { + return Some(GatewayError::NotAuthenticatedError); + } + "authentication failed" | "4004" => { + return Some(GatewayError::AuthenticationFailedError); + } + "already authenticated" | "4005" => { + return Some(GatewayError::AlreadyAuthenticatedError); + } + "invalid seq" | "4007" => { + return Some(GatewayError::InvalidSequenceNumberError); + } + "rate limited" | "4008" => { + return Some(GatewayError::RateLimitedError); + } + "session timed out" | "4009" => { + return Some(GatewayError::SessionTimedOutError); + } + "invalid shard" | "4010" => { + return Some(GatewayError::InvalidShardError); + } + "sharding required" | "4011" => { + return Some(GatewayError::ShardingRequiredError); + } + "invalid api version" | "4012" => { + return Some(GatewayError::InvalidAPIVersionError); + } + "invalid intent(s)" | "invalid intent" | "4013" => { + return Some(GatewayError::InvalidIntentsError); + } + "disallowed intent(s)" | "disallowed intents" | "4014" => { + return Some(GatewayError::DisallowedIntentsError); + } + _ => { + return None; + } + } + } + + /// Returns whether or not the message is an error + pub fn is_error(&self) -> bool { + return self.error().is_some(); + } + + /// Parses the message as a payload; + /// Returns a result of deserializing + pub fn payload(&self) -> Result { + return serde_json::from_str(self.message.to_text().unwrap()); + } + + /// Returns whether or not the message is a payload + pub fn is_payload(&self) -> bool { + // close messages are never payloads, payloads are only text messages + if self.message.is_close() | !self.message.is_text() { + return false; + } + + return self.payload().is_ok(); + } + + /// Returns whether or not the message is empty + pub fn is_empty(&self) -> bool { + return self.message.is_empty(); + } +} + #[derive(Debug)] /** Represents a handle to a Gateway connection. A Gateway connection will create observable [`GatewayEvents`](GatewayEvent), which you can subscribe to. Gateway events include all currently implemented [Types] with the trait [`WebSocketEvent`] Using this handle you can also send Gateway Events directly. -*/ + */ pub struct GatewayHandle { pub url: String, pub events: Arc>, @@ -85,6 +191,8 @@ pub struct GatewayHandle { >, >, pub handle: JoinHandle<()>, + /// Tells gateway tasks to close + kill_send: tokio::sync::broadcast::Sender<()>, } impl GatewayHandle { @@ -127,10 +235,10 @@ impl GatewayHandle { } /// Sends an update presence event to the gateway - pub async fn send_update_presence(&self, to_send: types::PresenceUpdate) { + pub async fn send_update_presence(&self, to_send: types::UpdatePresence) { let to_send_value = serde_json::to_value(&to_send).unwrap(); - println!("GW: Sending Presence Update.."); + println!("GW: Sending Update Presence.."); self.send_json_event(GATEWAY_UPDATE_PRESENCE, to_send_value) .await; @@ -174,11 +282,19 @@ impl GatewayHandle { self.send_json_event(GATEWAY_LAZY_REQUEST, to_send_value) .await; } + + /// Closes the websocket connection and stops all gateway tasks; + /// + /// Esentially pulls the plug on the gateway, leaving it possible to resume; + pub async fn close(&self) { + self.kill_send.send(()).unwrap(); + self.websocket_send.lock().await.close().await.unwrap(); + } } pub struct Gateway { pub events: Arc>, - heartbeat_handler: Option, + heartbeat_handler: HeartbeatHandler, pub websocket_send: Arc< Mutex< SplitSink< @@ -187,12 +303,12 @@ pub struct Gateway { >, >, >, + pub websocket_receive: SplitStream>>, + kill_send: tokio::sync::broadcast::Sender<()>, } impl Gateway { - pub async fn new( - websocket_url: String, - ) -> Result { + pub async fn new(websocket_url: String) -> Result { let (websocket_stream, _) = match connect_async_tls_with_config( &websocket_url, None, @@ -204,72 +320,141 @@ impl Gateway { .await { Ok(websocket_stream) => websocket_stream, - Err(e) => return Err(e), + Err(e) => { + return Err(GatewayError::CannotConnectError { + error: e.to_string(), + }) + } }; - let (gateway_send, mut gateway_receive) = websocket_stream.split(); + let (websocket_send, mut websocket_receive) = websocket_stream.split(); - let shared_gateway_send = Arc::new(Mutex::new(gateway_send)); + let shared_websocket_send = Arc::new(Mutex::new(websocket_send)); - let mut gateway = Gateway { - events: Arc::new(Mutex::new(Events::default())), - heartbeat_handler: None, - websocket_send: shared_gateway_send.clone(), - }; - - let shared_events = gateway.events.clone(); + // Create a shared broadcast channel for killing all gateway tasks + let (kill_send, mut _kill_receive) = tokio::sync::broadcast::channel::<()>(16); // Wait for the first hello and then spawn both tasks so we avoid nested tasks // This automatically spawns the heartbeat task, but from the main thread - let msg = gateway_receive.next().await.unwrap().unwrap(); + let msg = websocket_receive.next().await.unwrap().unwrap(); let gateway_payload: types::GatewayReceivePayload = serde_json::from_str(msg.to_text().unwrap()).unwrap(); if gateway_payload.op_code != GATEWAY_HELLO { - println!("Received non hello on gateway init, what is happening?"); - return Err(tokio_tungstenite::tungstenite::Error::Protocol( - tokio_tungstenite::tungstenite::error::ProtocolError::InvalidOpcode( - gateway_payload.op_code, - ), - )); + return Err(GatewayError::NonHelloOnInitiateError { + opcode: gateway_payload.op_code, + }); } println!("GW: Received Hello"); let gateway_hello: types::HelloData = serde_json::from_str(gateway_payload.event_data.unwrap().get()).unwrap(); - gateway.heartbeat_handler = Some(HeartbeatHandler::new( - gateway_hello.heartbeat_interval, - shared_gateway_send.clone(), - )); + + let events = Events::default(); + let shared_events = Arc::new(Mutex::new(events)); + + let mut gateway = Gateway { + events: shared_events.clone(), + heartbeat_handler: HeartbeatHandler::new( + gateway_hello.heartbeat_interval, + shared_websocket_send.clone(), + kill_send.subscribe(), + ), + websocket_send: shared_websocket_send.clone(), + websocket_receive, + kill_send: kill_send.clone(), + }; // Now we can continuously check for messages in a different task, since we aren't going to receive another hello let handle: JoinHandle<()> = task::spawn(async move { - loop { - let msg = gateway_receive.next().await; - if msg.as_ref().is_some() { - let msg_unwrapped = msg.unwrap().unwrap(); - gateway.handle_event(msg_unwrapped).await; - }; - } + gateway.gateway_listen_task().await; }); return Ok(GatewayHandle { url: websocket_url.clone(), events: shared_events, - websocket_send: shared_gateway_send.clone(), + websocket_send: shared_websocket_send.clone(), handle, + kill_send: kill_send.clone(), }); } + /// The main gateway listener task; + /// + /// Can only be stopped by closing the websocket, cannot be made to listen for kill + pub async fn gateway_listen_task(&mut self) { + loop { + let msg = self.websocket_receive.next().await; + + // This if chain can be much better but if let is unstable on stable rust + if msg.as_ref().is_some() { + if msg.as_ref().unwrap().is_ok() { + let msg_unwrapped = msg.unwrap().unwrap(); + self.handle_message(GatewayMessage::from_tungstenite_message(msg_unwrapped)) + .await; + + continue; + } + } + + // We couldn't receive the next message or it was an error, something is wrong with the websocket, close + println!("GW: Websocket is broken, stopping gateway"); + break; + } + } + + /// Closes the websocket connection and stops all tasks + async fn close(&mut self) { + self.kill_send.send(()).unwrap(); + self.websocket_send.lock().await.close().await.unwrap(); + } + + /// Deserializes and updates a dispatched event, when we already know its type; + /// (Called for every event in handle_message) + async fn handle_event<'a, T: WebSocketEvent + serde::Deserialize<'a>>( + data: &'a str, + event: &mut GatewayEvent, + ) -> Result<(), serde_json::Error> { + let data_deserialize_result: Result = serde_json::from_str(data); + + if data_deserialize_result.is_err() { + return Err(data_deserialize_result.err().unwrap()); + } + + event.update_data(data_deserialize_result.unwrap()).await; + return Ok(()); + } + /// This handles a message as a websocket event and updates its events along with the events' observers - pub async fn handle_event(&mut self, msg: tokio_tungstenite::tungstenite::Message) { - if msg.to_string() == String::new() { + pub async fn handle_message(&mut self, msg: GatewayMessage) { + if msg.is_empty() { return; } - let gateway_payload: types::GatewayReceivePayload = - serde_json::from_str(msg.to_text().unwrap()).unwrap(); + if !msg.is_error() && !msg.is_payload() { + println!( + "Message unrecognised: {:?}, please open an issue on the chorus github", + msg.message.to_string() + ); + return; + } + + // To:do: handle errors in a good way, maybe observers like events? + if msg.is_error() { + println!("GW: Received error, connection will close.."); + + let error = msg.error(); + + match error { + _ => {} + } + + self.close().await; + return; + } + + let gateway_payload = msg.payload().unwrap(); // See https://discord.com/developers/docs/topics/opcodes-and-status-codes#gateway-gateway-opcodes match gateway_payload.op_code { @@ -285,858 +470,1012 @@ impl Gateway { // "Some" of these are undocumented match gateway_payload_t.as_str() { "READY" => { - let new_data: types::GatewayReady = - serde_json::from_str(gateway_payload.event_data.unwrap().get()) - .unwrap(); - self.events - .lock() - .await - .session - .ready - .update_data(new_data) - .await; + let event = &mut self.events.lock().await.session.ready; + + let result = + Gateway::handle_event(gateway_payload.event_data.unwrap().get(), event) + .await; + + if result.is_err() { + println!( + "Failed to parse gateway event {} ({})", + gateway_payload_t, + result.err().unwrap() + ); + return; + } } "READY_SUPPLEMENTAL" => { - let new_data: types::GatewayReadySupplemental = - serde_json::from_str(gateway_payload.event_data.unwrap().get()) - .unwrap(); - self.events - .lock() - .await - .session - .ready_supplemental - .update_data(new_data) - .await; + let event = &mut self.events.lock().await.session.ready_supplemental; + + let result = + Gateway::handle_event(gateway_payload.event_data.unwrap().get(), event) + .await; + + if result.is_err() { + println!( + "Failed to parse gateway event {} ({})", + gateway_payload_t, + result.err().unwrap() + ); + return; + } } "RESUMED" => {} "APPLICATION_COMMAND_PERMISSIONS_UPDATE" => { - let new_data: types::ApplicationCommandPermissionsUpdate = - serde_json::from_str(gateway_payload.event_data.unwrap().get()) - .unwrap(); - self.events + let event = &mut self + .events .lock() .await .application - .command_permissions_update - .update_data(new_data) - .await; + .command_permissions_update; + + let result = + Gateway::handle_event(gateway_payload.event_data.unwrap().get(), event) + .await; + + if result.is_err() { + println!( + "Failed to parse gateway event {} ({})", + gateway_payload_t, + result.err().unwrap() + ); + return; + } } "AUTO_MODERATION_RULE_CREATE" => { - let new_data: types::AutoModerationRuleCreate = - serde_json::from_str(gateway_payload.event_data.unwrap().get()) - .unwrap(); - self.events - .lock() - .await - .auto_moderation - .rule_create - .update_data(new_data) - .await; + let event = &mut self.events.lock().await.auto_moderation.rule_create; + let result = + Gateway::handle_event(gateway_payload.event_data.unwrap().get(), event) + .await; + if result.is_err() { + println!( + "Failed to parse gateway event {} ({})", + gateway_payload_t, + result.err().unwrap() + ); + return; + } } "AUTO_MODERATION_RULE_UPDATE" => { - let new_data: types::AutoModerationRuleUpdate = - serde_json::from_str(gateway_payload.event_data.unwrap().get()) - .unwrap(); - self.events - .lock() - .await - .auto_moderation - .rule_update - .update_data(new_data) - .await; + let event = &mut self.events.lock().await.auto_moderation.rule_update; + let result = + Gateway::handle_event(gateway_payload.event_data.unwrap().get(), event) + .await; + if result.is_err() { + println!( + "Failed to parse gateway event {} ({})", + gateway_payload_t, + result.err().unwrap() + ); + return; + } } "AUTO_MODERATION_RULE_DELETE" => { - let new_data: types::AutoModerationRuleDelete = - serde_json::from_str(gateway_payload.event_data.unwrap().get()) - .unwrap(); - self.events - .lock() - .await - .auto_moderation - .rule_delete - .update_data(new_data) - .await; + let event = &mut self.events.lock().await.auto_moderation.rule_delete; + let result = + Gateway::handle_event(gateway_payload.event_data.unwrap().get(), event) + .await; + if result.is_err() { + println!( + "Failed to parse gateway event {} ({})", + gateway_payload_t, + result.err().unwrap() + ); + return; + } } "AUTO_MODERATION_ACTION_EXECUTION" => { - let new_data: types::AutoModerationActionExecution = - serde_json::from_str(gateway_payload.event_data.unwrap().get()) - .unwrap(); - self.events - .lock() - .await - .auto_moderation - .action_execution - .update_data(new_data) - .await; + let event = &mut self.events.lock().await.auto_moderation.action_execution; + let result = + Gateway::handle_event(gateway_payload.event_data.unwrap().get(), event) + .await; + if result.is_err() { + println!( + "Failed to parse gateway event {} ({})", + gateway_payload_t, + result.err().unwrap() + ); + return; + } } "CHANNEL_CREATE" => { - let new_data: types::ChannelCreate = - serde_json::from_str(gateway_payload.event_data.unwrap().get()) - .unwrap(); - self.events - .lock() - .await - .channel - .create - .update_data(new_data) - .await; + let event = &mut self.events.lock().await.channel.create; + let result = + Gateway::handle_event(gateway_payload.event_data.unwrap().get(), event) + .await; + if result.is_err() { + println!( + "Failed to parse gateway event {} ({})", + gateway_payload_t, + result.err().unwrap() + ); + return; + } } "CHANNEL_UPDATE" => { - let new_data: types::ChannelUpdate = - serde_json::from_str(gateway_payload.event_data.unwrap().get()) - .unwrap(); - self.events - .lock() - .await - .channel - .update - .update_data(new_data) - .await; + let event = &mut self.events.lock().await.channel.update; + let result = + Gateway::handle_event(gateway_payload.event_data.unwrap().get(), event) + .await; + if result.is_err() { + println!( + "Failed to parse gateway event {} ({})", + gateway_payload_t, + result.err().unwrap() + ); + return; + } } "CHANNEL_UNREAD_UPDATE" => { - let new_data: types::ChannelUnreadUpdate = - serde_json::from_str(gateway_payload.event_data.unwrap().get()) - .unwrap(); - self.events - .lock() - .await - .channel - .unread_update - .update_data(new_data) - .await; + let event = &mut self.events.lock().await.channel.unread_update; + let result = + Gateway::handle_event(gateway_payload.event_data.unwrap().get(), event) + .await; + if result.is_err() { + println!( + "Failed to parse gateway event {} ({})", + gateway_payload_t, + result.err().unwrap() + ); + return; + } } "CHANNEL_DELETE" => { - let new_data: types::ChannelDelete = - serde_json::from_str(gateway_payload.event_data.unwrap().get()) - .unwrap(); - self.events - .lock() - .await - .channel - .delete - .update_data(new_data) - .await; + let event = &mut self.events.lock().await.channel.delete; + let result = + Gateway::handle_event(gateway_payload.event_data.unwrap().get(), event) + .await; + if result.is_err() { + println!( + "Failed to parse gateway event {} ({})", + gateway_payload_t, + result.err().unwrap() + ); + return; + } } "CHANNEL_PINS_UPDATE" => { - let new_data: types::ChannelPinsUpdate = - serde_json::from_str(gateway_payload.event_data.unwrap().get()) - .unwrap(); - self.events - .lock() - .await - .channel - .pins_update - .update_data(new_data) - .await; + let event = &mut self.events.lock().await.channel.pins_update; + let result = + Gateway::handle_event(gateway_payload.event_data.unwrap().get(), event) + .await; + if result.is_err() { + println!( + "Failed to parse gateway event {} ({})", + gateway_payload_t, + result.err().unwrap() + ); + return; + } } "CALL_CREATE" => { - let new_data: types::CallCreate = - serde_json::from_str(gateway_payload.event_data.unwrap().get()) - .unwrap(); - self.events - .lock() - .await - .call - .create - .update_data(new_data) - .await; + let event = &mut self.events.lock().await.call.create; + let result = + Gateway::handle_event(gateway_payload.event_data.unwrap().get(), event) + .await; + if result.is_err() { + println!( + "Failed to parse gateway event {} ({})", + gateway_payload_t, + result.err().unwrap() + ); + return; + } } "CALL_UPDATE" => { - let new_data: types::CallUpdate = - serde_json::from_str(gateway_payload.event_data.unwrap().get()) - .unwrap(); - self.events - .lock() - .await - .call - .update - .update_data(new_data) - .await; + let event = &mut self.events.lock().await.call.update; + let result = + Gateway::handle_event(gateway_payload.event_data.unwrap().get(), event) + .await; + if result.is_err() { + println!( + "Failed to parse gateway event {} ({})", + gateway_payload_t, + result.err().unwrap() + ); + return; + } } "CALL_DELETE" => { - let new_data: types::CallDelete = - serde_json::from_str(gateway_payload.event_data.unwrap().get()) - .unwrap(); - self.events - .lock() - .await - .call - .delete - .update_data(new_data) - .await; + let event = &mut self.events.lock().await.call.delete; + let result = + Gateway::handle_event(gateway_payload.event_data.unwrap().get(), event) + .await; + if result.is_err() { + println!( + "Failed to parse gateway event {} ({})", + gateway_payload_t, + result.err().unwrap() + ); + return; + } } "THREAD_CREATE" => { - let new_data: types::ThreadCreate = - serde_json::from_str(gateway_payload.event_data.unwrap().get()) - .unwrap(); - self.events - .lock() - .await - .thread - .create - .update_data(new_data) - .await; + let event = &mut self.events.lock().await.thread.create; + let result = + Gateway::handle_event(gateway_payload.event_data.unwrap().get(), event) + .await; + if result.is_err() { + println!( + "Failed to parse gateway event {} ({})", + gateway_payload_t, + result.err().unwrap() + ); + return; + } } "THREAD_UPDATE" => { - let new_data: types::ThreadUpdate = - serde_json::from_str(gateway_payload.event_data.unwrap().get()) - .unwrap(); - self.events - .lock() - .await - .thread - .update - .update_data(new_data) - .await; + let event = &mut self.events.lock().await.thread.update; + let result = + Gateway::handle_event(gateway_payload.event_data.unwrap().get(), event) + .await; + if result.is_err() { + println!( + "Failed to parse gateway event {} ({})", + gateway_payload_t, + result.err().unwrap() + ); + return; + } } "THREAD_DELETE" => { - let new_data: types::ThreadDelete = - serde_json::from_str(gateway_payload.event_data.unwrap().get()) - .unwrap(); - self.events - .lock() - .await - .thread - .delete - .update_data(new_data) - .await; + let event = &mut self.events.lock().await.thread.delete; + let result = + Gateway::handle_event(gateway_payload.event_data.unwrap().get(), event) + .await; + if result.is_err() { + println!( + "Failed to parse gateway event {} ({})", + gateway_payload_t, + result.err().unwrap() + ); + return; + } } "THREAD_LIST_SYNC" => { - let new_data: types::ThreadListSync = - serde_json::from_str(gateway_payload.event_data.unwrap().get()) - .unwrap(); - self.events - .lock() - .await - .thread - .list_sync - .update_data(new_data) - .await; + let event = &mut self.events.lock().await.thread.list_sync; + let result = + Gateway::handle_event(gateway_payload.event_data.unwrap().get(), event) + .await; + if result.is_err() { + println!( + "Failed to parse gateway event {} ({})", + gateway_payload_t, + result.err().unwrap() + ); + return; + } } "THREAD_MEMBER_UPDATE" => { - let new_data: types::ThreadMemberUpdate = - serde_json::from_str(gateway_payload.event_data.unwrap().get()) - .unwrap(); - self.events - .lock() - .await - .thread - .member_update - .update_data(new_data) - .await; + let event = &mut self.events.lock().await.thread.member_update; + let result = + Gateway::handle_event(gateway_payload.event_data.unwrap().get(), event) + .await; + if result.is_err() { + println!( + "Failed to parse gateway event {} ({})", + gateway_payload_t, + result.err().unwrap() + ); + return; + } } "THREAD_MEMBERS_UPDATE" => { - let new_data: types::ThreadMembersUpdate = - serde_json::from_str(gateway_payload.event_data.unwrap().get()) - .unwrap(); - self.events - .lock() - .await - .thread - .members_update - .update_data(new_data) - .await; + let event = &mut self.events.lock().await.thread.members_update; + let result = + Gateway::handle_event(gateway_payload.event_data.unwrap().get(), event) + .await; + if result.is_err() { + println!( + "Failed to parse gateway event {} ({})", + gateway_payload_t, + result.err().unwrap() + ); + return; + } } "GUILD_CREATE" => { - let new_data: types::GuildCreate = - serde_json::from_str(gateway_payload.event_data.unwrap().get()) - .unwrap(); - self.events - .lock() - .await - .guild - .create - .update_data(new_data) - .await; + let event = &mut self.events.lock().await.guild.create; + let result = + Gateway::handle_event(gateway_payload.event_data.unwrap().get(), event) + .await; + if result.is_err() { + println!( + "Failed to parse gateway event {} ({})", + gateway_payload_t, + result.err().unwrap() + ); + return; + } } "GUILD_UPDATE" => { - let new_data: types::GuildUpdate = - serde_json::from_str(gateway_payload.event_data.unwrap().get()) - .unwrap(); - self.events - .lock() - .await - .guild - .update - .update_data(new_data) - .await; + let event = &mut self.events.lock().await.guild.update; + let result = + Gateway::handle_event(gateway_payload.event_data.unwrap().get(), event) + .await; + if result.is_err() { + println!( + "Failed to parse gateway event {} ({})", + gateway_payload_t, + result.err().unwrap() + ); + return; + } } "GUILD_DELETE" => { - let new_data: types::GuildDelete = - serde_json::from_str(gateway_payload.event_data.unwrap().get()) - .unwrap(); - self.events - .lock() - .await - .guild - .delete - .update_data(new_data) - .await; + let event = &mut self.events.lock().await.guild.delete; + let result = + Gateway::handle_event(gateway_payload.event_data.unwrap().get(), event) + .await; + if result.is_err() { + println!( + "Failed to parse gateway event {} ({})", + gateway_payload_t, + result.err().unwrap() + ); + return; + } } "GUILD_AUDIT_LOG_ENTRY_CREATE" => { - let new_data: types::GuildAuditLogEntryCreate = - serde_json::from_str(gateway_payload.event_data.unwrap().get()) - .unwrap(); - self.events - .lock() - .await - .guild - .audit_log_entry_create - .update_data(new_data) - .await; + let event = &mut self.events.lock().await.guild.audit_log_entry_create; + let result = + Gateway::handle_event(gateway_payload.event_data.unwrap().get(), event) + .await; + if result.is_err() { + println!( + "Failed to parse gateway event {} ({})", + gateway_payload_t, + result.err().unwrap() + ); + return; + } } "GUILD_BAN_ADD" => { - let new_data: types::GuildBanAdd = - serde_json::from_str(gateway_payload.event_data.unwrap().get()) - .unwrap(); - self.events - .lock() - .await - .guild - .ban_add - .update_data(new_data) - .await; + let event = &mut self.events.lock().await.guild.ban_add; + let result = + Gateway::handle_event(gateway_payload.event_data.unwrap().get(), event) + .await; + if result.is_err() { + println!( + "Failed to parse gateway event {} ({})", + gateway_payload_t, + result.err().unwrap() + ); + return; + } } "GUILD_BAN_REMOVE" => { - let new_data: types::GuildBanRemove = - serde_json::from_str(gateway_payload.event_data.unwrap().get()) - .unwrap(); - self.events - .lock() - .await - .guild - .ban_remove - .update_data(new_data) - .await; + let event = &mut self.events.lock().await.guild.ban_remove; + let result = + Gateway::handle_event(gateway_payload.event_data.unwrap().get(), event) + .await; + if result.is_err() { + println!( + "Failed to parse gateway event {} ({})", + gateway_payload_t, + result.err().unwrap() + ); + return; + } } "GUILD_EMOJIS_UPDATE" => { - let new_data: types::GuildEmojisUpdate = - serde_json::from_str(gateway_payload.event_data.unwrap().get()) - .unwrap(); - self.events - .lock() - .await - .guild - .emojis_update - .update_data(new_data) - .await; + let event = &mut self.events.lock().await.guild.emojis_update; + let result = + Gateway::handle_event(gateway_payload.event_data.unwrap().get(), event) + .await; + if result.is_err() { + println!( + "Failed to parse gateway event {} ({})", + gateway_payload_t, + result.err().unwrap() + ); + return; + } } "GUILD_STICKERS_UPDATE" => { - let new_data: types::GuildStickersUpdate = - serde_json::from_str(gateway_payload.event_data.unwrap().get()) - .unwrap(); - self.events - .lock() - .await - .guild - .stickers_update - .update_data(new_data) - .await; + let event = &mut self.events.lock().await.guild.stickers_update; + let result = + Gateway::handle_event(gateway_payload.event_data.unwrap().get(), event) + .await; + if result.is_err() { + println!( + "Failed to parse gateway event {} ({})", + gateway_payload_t, + result.err().unwrap() + ); + return; + } } "GUILD_INTEGRATIONS_UPDATE" => { - let new_data: types::GuildIntegrationsUpdate = - serde_json::from_str(gateway_payload.event_data.unwrap().get()) - .unwrap(); - self.events - .lock() - .await - .guild - .integrations_update - .update_data(new_data) - .await; + let event = &mut self.events.lock().await.guild.integrations_update; + let result = + Gateway::handle_event(gateway_payload.event_data.unwrap().get(), event) + .await; + if result.is_err() { + println!( + "Failed to parse gateway event {} ({})", + gateway_payload_t, + result.err().unwrap() + ); + return; + } } "GUILD_MEMBER_ADD" => { - let new_data: types::GuildMemberAdd = - serde_json::from_str(gateway_payload.event_data.unwrap().get()) - .unwrap(); - self.events - .lock() - .await - .guild - .member_add - .update_data(new_data) - .await; + let event = &mut self.events.lock().await.guild.member_add; + let result = + Gateway::handle_event(gateway_payload.event_data.unwrap().get(), event) + .await; + if result.is_err() { + println!( + "Failed to parse gateway event {} ({})", + gateway_payload_t, + result.err().unwrap() + ); + return; + } } "GUILD_MEMBER_REMOVE" => { - let new_data: types::GuildMemberRemove = - serde_json::from_str(gateway_payload.event_data.unwrap().get()) - .unwrap(); - self.events - .lock() - .await - .guild - .member_remove - .update_data(new_data) - .await; + let event = &mut self.events.lock().await.guild.member_remove; + let result = + Gateway::handle_event(gateway_payload.event_data.unwrap().get(), event) + .await; + if result.is_err() { + println!( + "Failed to parse gateway event {} ({})", + gateway_payload_t, + result.err().unwrap() + ); + return; + } } "GUILD_MEMBER_UPDATE" => { - let new_data: types::GuildMemberUpdate = - serde_json::from_str(gateway_payload.event_data.unwrap().get()) - .unwrap(); - self.events - .lock() - .await - .guild - .member_update - .update_data(new_data) - .await; + let event = &mut self.events.lock().await.guild.member_update; + let result = + Gateway::handle_event(gateway_payload.event_data.unwrap().get(), event) + .await; + if result.is_err() { + println!( + "Failed to parse gateway event {} ({})", + gateway_payload_t, + result.err().unwrap() + ); + return; + } } "GUILD_MEMBERS_CHUNK" => { - let new_data: types::GuildMembersChunk = - serde_json::from_str(gateway_payload.event_data.unwrap().get()) - .unwrap(); - self.events - .lock() - .await - .guild - .members_chunk - .update_data(new_data) - .await; + let event = &mut self.events.lock().await.guild.members_chunk; + let result = + Gateway::handle_event(gateway_payload.event_data.unwrap().get(), event) + .await; + if result.is_err() { + println!( + "Failed to parse gateway event {} ({})", + gateway_payload_t, + result.err().unwrap() + ); + return; + } } "GUILD_ROLE_CREATE" => { - let new_data: types::GuildRoleCreate = - serde_json::from_str(gateway_payload.event_data.unwrap().get()) - .unwrap(); - self.events - .lock() - .await - .guild - .role_create - .update_data(new_data) - .await; + let event = &mut self.events.lock().await.guild.role_create; + let result = + Gateway::handle_event(gateway_payload.event_data.unwrap().get(), event) + .await; + if result.is_err() { + println!( + "Failed to parse gateway event {} ({})", + gateway_payload_t, + result.err().unwrap() + ); + return; + } } "GUILD_ROLE_UPDATE" => { - let new_data: types::GuildRoleUpdate = - serde_json::from_str(gateway_payload.event_data.unwrap().get()) - .unwrap(); - self.events - .lock() - .await - .guild - .role_update - .update_data(new_data) - .await; + let event = &mut self.events.lock().await.guild.role_update; + let result = + Gateway::handle_event(gateway_payload.event_data.unwrap().get(), event) + .await; + if result.is_err() { + println!( + "Failed to parse gateway event {} ({})", + gateway_payload_t, + result.err().unwrap() + ); + return; + } } "GUILD_ROLE_DELETE" => { - let new_data: types::GuildRoleDelete = - serde_json::from_str(gateway_payload.event_data.unwrap().get()) - .unwrap(); - self.events - .lock() - .await - .guild - .role_delete - .update_data(new_data) - .await; + let event = &mut self.events.lock().await.guild.role_delete; + let result = + Gateway::handle_event(gateway_payload.event_data.unwrap().get(), event) + .await; + if result.is_err() { + println!( + "Failed to parse gateway event {} ({})", + gateway_payload_t, + result.err().unwrap() + ); + return; + } } "GUILD_SCHEDULED_EVENT_CREATE" => { - let new_data: types::GuildScheduledEventCreate = - serde_json::from_str(gateway_payload.event_data.unwrap().get()) - .unwrap(); - self.events - .lock() - .await - .guild - .role_scheduled_event_create - .update_data(new_data) - .await; + let event = &mut self.events.lock().await.guild.role_scheduled_event_create; + let result = + Gateway::handle_event(gateway_payload.event_data.unwrap().get(), event) + .await; + if result.is_err() { + println!( + "Failed to parse gateway event {} ({})", + gateway_payload_t, + result.err().unwrap() + ); + return; + } } "GUILD_SCHEDULED_EVENT_UPDATE" => { - let new_data: types::GuildScheduledEventUpdate = - serde_json::from_str(gateway_payload.event_data.unwrap().get()) - .unwrap(); - self.events - .lock() - .await - .guild - .role_scheduled_event_update - .update_data(new_data) - .await; + let event = &mut self.events.lock().await.guild.role_scheduled_event_update; + let result = + Gateway::handle_event(gateway_payload.event_data.unwrap().get(), event) + .await; + if result.is_err() { + println!( + "Failed to parse gateway event {} ({})", + gateway_payload_t, + result.err().unwrap() + ); + return; + } } "GUILD_SCHEDULED_EVENT_DELETE" => { - let new_data: types::GuildScheduledEventDelete = - serde_json::from_str(gateway_payload.event_data.unwrap().get()) - .unwrap(); - self.events - .lock() - .await - .guild - .role_scheduled_event_delete - .update_data(new_data) - .await; + let event = &mut self.events.lock().await.guild.role_scheduled_event_delete; + let result = + Gateway::handle_event(gateway_payload.event_data.unwrap().get(), event) + .await; + if result.is_err() { + println!( + "Failed to parse gateway event {} ({})", + gateway_payload_t, + result.err().unwrap() + ); + return; + } } "GUILD_SCHEDULED_EVENT_USER_ADD" => { - let new_data: types::GuildScheduledEventUserAdd = - serde_json::from_str(gateway_payload.event_data.unwrap().get()) - .unwrap(); - self.events - .lock() - .await - .guild - .role_scheduled_event_user_add - .update_data(new_data) - .await; + let event = + &mut self.events.lock().await.guild.role_scheduled_event_user_add; + let result = + Gateway::handle_event(gateway_payload.event_data.unwrap().get(), event) + .await; + if result.is_err() { + println!( + "Failed to parse gateway event {} ({})", + gateway_payload_t, + result.err().unwrap() + ); + return; + } } "GUILD_SCHEDULED_EVENT_USER_REMOVE" => { - let new_data: types::GuildScheduledEventUserRemove = - serde_json::from_str(gateway_payload.event_data.unwrap().get()) - .unwrap(); - self.events + let event = &mut self + .events .lock() .await .guild - .role_scheduled_event_user_remove - .update_data(new_data) - .await; + .role_scheduled_event_user_remove; + let result = + Gateway::handle_event(gateway_payload.event_data.unwrap().get(), event) + .await; + if result.is_err() { + println!( + "Failed to parse gateway event {} ({})", + gateway_payload_t, + result.err().unwrap() + ); + return; + } } "PASSIVE_UPDATE_V1" => { - let new_data: types::PassiveUpdateV1 = - serde_json::from_str(gateway_payload.event_data.unwrap().get()) - .unwrap(); - self.events - .lock() - .await - .guild - .passive_update_v1 - .update_data(new_data) - .await; + let event = &mut self.events.lock().await.guild.passive_update_v1; + let result = + Gateway::handle_event(gateway_payload.event_data.unwrap().get(), event) + .await; + if result.is_err() { + println!( + "Failed to parse gateway event {} ({})", + gateway_payload_t, + result.err().unwrap() + ); + return; + } } "INTEGRATION_CREATE" => { - let new_data: types::IntegrationCreate = - serde_json::from_str(gateway_payload.event_data.unwrap().get()) - .unwrap(); - self.events - .lock() - .await - .integration - .create - .update_data(new_data) - .await; + let event = &mut self.events.lock().await.integration.create; + let result = + Gateway::handle_event(gateway_payload.event_data.unwrap().get(), event) + .await; + if result.is_err() { + println!( + "Failed to parse gateway event {} ({})", + gateway_payload_t, + result.err().unwrap() + ); + return; + } } "INTEGRATION_UPDATE" => { - let new_data: types::IntegrationUpdate = - serde_json::from_str(gateway_payload.event_data.unwrap().get()) - .unwrap(); - self.events - .lock() - .await - .integration - .update - .update_data(new_data) - .await; + let event = &mut self.events.lock().await.integration.update; + let result = + Gateway::handle_event(gateway_payload.event_data.unwrap().get(), event) + .await; + if result.is_err() { + println!( + "Failed to parse gateway event {} ({})", + gateway_payload_t, + result.err().unwrap() + ); + return; + } } "INTEGRATION_DELETE" => { - let new_data: types::IntegrationDelete = - serde_json::from_str(gateway_payload.event_data.unwrap().get()) - .unwrap(); - self.events - .lock() - .await - .integration - .delete - .update_data(new_data) - .await; + let event = &mut self.events.lock().await.integration.delete; + let result = + Gateway::handle_event(gateway_payload.event_data.unwrap().get(), event) + .await; + if result.is_err() { + println!( + "Failed to parse gateway event {} ({})", + gateway_payload_t, + result.err().unwrap() + ); + return; + } } "INTERACTION_CREATE" => { - let new_data: types::InteractionCreate = - serde_json::from_str(gateway_payload.event_data.unwrap().get()) - .unwrap(); - self.events - .lock() - .await - .interaction - .create - .update_data(new_data) - .await; + let event = &mut self.events.lock().await.interaction.create; + let result = + Gateway::handle_event(gateway_payload.event_data.unwrap().get(), event) + .await; + if result.is_err() { + println!( + "Failed to parse gateway event {} ({})", + gateway_payload_t, + result.err().unwrap() + ); + return; + } } "INVITE_CREATE" => { - let new_data: types::InviteCreate = - serde_json::from_str(gateway_payload.event_data.unwrap().get()) - .unwrap(); - self.events - .lock() - .await - .invite - .create - .update_data(new_data) - .await; + let event = &mut self.events.lock().await.invite.create; + let result = + Gateway::handle_event(gateway_payload.event_data.unwrap().get(), event) + .await; + if result.is_err() { + println!( + "Failed to parse gateway event {} ({})", + gateway_payload_t, + result.err().unwrap() + ); + return; + } } "INVITE_DELETE" => { - let new_data: types::InviteDelete = - serde_json::from_str(gateway_payload.event_data.unwrap().get()) - .unwrap(); - self.events - .lock() - .await - .invite - .delete - .update_data(new_data) - .await; + let event = &mut self.events.lock().await.invite.delete; + let result = + Gateway::handle_event(gateway_payload.event_data.unwrap().get(), event) + .await; + if result.is_err() { + println!( + "Failed to parse gateway event {} ({})", + gateway_payload_t, + result.err().unwrap() + ); + return; + } } "MESSAGE_CREATE" => { - let new_data: types::MessageCreate = - serde_json::from_str(gateway_payload.event_data.unwrap().get()) - .unwrap(); - self.events - .lock() - .await - .message - .create - .update_data(new_data) - .await; + let event = &mut self.events.lock().await.message.create; + let result = + Gateway::handle_event(gateway_payload.event_data.unwrap().get(), event) + .await; + if result.is_err() { + println!( + "Failed to parse gateway event {} ({})", + gateway_payload_t, + result.err().unwrap() + ); + return; + } } "MESSAGE_UPDATE" => { - let new_data: types::MessageUpdate = - serde_json::from_str(gateway_payload.event_data.unwrap().get()) - .unwrap(); - self.events - .lock() - .await - .message - .update - .update_data(new_data) - .await; + let event = &mut self.events.lock().await.message.update; + let result = + Gateway::handle_event(gateway_payload.event_data.unwrap().get(), event) + .await; + if result.is_err() { + println!( + "Failed to parse gateway event {} ({})", + gateway_payload_t, + result.err().unwrap() + ); + return; + } } "MESSAGE_DELETE" => { - let new_data: types::MessageDelete = - serde_json::from_str(gateway_payload.event_data.unwrap().get()) - .unwrap(); - self.events - .lock() - .await - .message - .delete - .update_data(new_data) - .await; + let event = &mut self.events.lock().await.message.delete; + let result = + Gateway::handle_event(gateway_payload.event_data.unwrap().get(), event) + .await; + if result.is_err() { + println!( + "Failed to parse gateway event {} ({})", + gateway_payload_t, + result.err().unwrap() + ); + return; + } } "MESSAGE_DELETE_BULK" => { - let new_data: types::MessageDeleteBulk = - serde_json::from_str(gateway_payload.event_data.unwrap().get()) - .unwrap(); - self.events - .lock() - .await - .message - .delete_bulk - .update_data(new_data) - .await; + let event = &mut self.events.lock().await.message.delete_bulk; + let result = + Gateway::handle_event(gateway_payload.event_data.unwrap().get(), event) + .await; + if result.is_err() { + println!( + "Failed to parse gateway event {} ({})", + gateway_payload_t, + result.err().unwrap() + ); + return; + } } "MESSAGE_REACTION_ADD" => { - let new_data: types::MessageReactionAdd = - serde_json::from_str(gateway_payload.event_data.unwrap().get()) - .unwrap(); - self.events - .lock() - .await - .message - .reaction_add - .update_data(new_data) - .await; + let event = &mut self.events.lock().await.message.reaction_add; + let result = + Gateway::handle_event(gateway_payload.event_data.unwrap().get(), event) + .await; + if result.is_err() { + println!( + "Failed to parse gateway event {} ({})", + gateway_payload_t, + result.err().unwrap() + ); + return; + } } "MESSAGE_REACTION_REMOVE" => { - let new_data: types::MessageReactionRemove = - serde_json::from_str(gateway_payload.event_data.unwrap().get()) - .unwrap(); - self.events - .lock() - .await - .message - .reaction_remove - .update_data(new_data) - .await; + let event = &mut self.events.lock().await.message.reaction_remove; + let result = + Gateway::handle_event(gateway_payload.event_data.unwrap().get(), event) + .await; + if result.is_err() { + println!( + "Failed to parse gateway event {} ({})", + gateway_payload_t, + result.err().unwrap() + ); + return; + } } "MESSAGE_REACTION_REMOVE_ALL" => { - let new_data: types::MessageReactionRemoveAll = - serde_json::from_str(gateway_payload.event_data.unwrap().get()) - .unwrap(); - self.events - .lock() - .await - .message - .reaction_remove_all - .update_data(new_data) - .await; + let event = &mut self.events.lock().await.message.reaction_remove_all; + let result = + Gateway::handle_event(gateway_payload.event_data.unwrap().get(), event) + .await; + if result.is_err() { + println!( + "Failed to parse gateway event {} ({})", + gateway_payload_t, + result.err().unwrap() + ); + return; + } } "MESSAGE_REACTION_REMOVE_EMOJI" => { - let new_data: types::MessageReactionRemoveEmoji = - serde_json::from_str(gateway_payload.event_data.unwrap().get()) - .unwrap(); - self.events - .lock() - .await - .message - .reaction_remove_emoji - .update_data(new_data) - .await; + let event = &mut self.events.lock().await.message.reaction_remove_emoji; + let result = + Gateway::handle_event(gateway_payload.event_data.unwrap().get(), event) + .await; + if result.is_err() { + println!( + "Failed to parse gateway event {} ({})", + gateway_payload_t, + result.err().unwrap() + ); + return; + } } "MESSAGE_ACK" => { - let new_data: types::MessageACK = - serde_json::from_str(gateway_payload.event_data.unwrap().get()) - .unwrap(); - self.events - .lock() - .await - .message - .ack - .update_data(new_data) - .await; + let event = &mut self.events.lock().await.message.ack; + let result = + Gateway::handle_event(gateway_payload.event_data.unwrap().get(), event) + .await; + if result.is_err() { + println!( + "Failed to parse gateway event {} ({})", + gateway_payload_t, + result.err().unwrap() + ); + return; + } } "PRESENCE_UPDATE" => { - let new_data: types::PresenceUpdate = - serde_json::from_str(gateway_payload.event_data.unwrap().get()) - .unwrap(); - self.events - .lock() - .await - .user - .presence_update - .update_data(new_data) - .await; + let event = &mut self.events.lock().await.user.presence_update; + let result = + Gateway::handle_event(gateway_payload.event_data.unwrap().get(), event) + .await; + if result.is_err() { + println!( + "Failed to parse gateway event {} ({})", + gateway_payload_t, + result.err().unwrap() + ); + return; + } } "RELATIONSHIP_ADD" => { - let new_data: types::RelationshipAdd = - serde_json::from_str(gateway_payload.event_data.unwrap().get()) - .unwrap(); - self.events - .lock() - .await - .relationship - .add - .update_data(new_data) - .await; + let event = &mut self.events.lock().await.relationship.add; + let result = + Gateway::handle_event(gateway_payload.event_data.unwrap().get(), event) + .await; + if result.is_err() { + println!( + "Failed to parse gateway event {} ({})", + gateway_payload_t, + result.err().unwrap() + ); + return; + } } "RELATIONSHIP_REMOVE" => { - let new_data: types::RelationshipRemove = - serde_json::from_str(gateway_payload.event_data.unwrap().get()) - .unwrap(); - self.events - .lock() - .await - .relationship - .remove - .update_data(new_data) - .await; + let event = &mut self.events.lock().await.relationship.remove; + let result = + Gateway::handle_event(gateway_payload.event_data.unwrap().get(), event) + .await; + if result.is_err() { + println!( + "Failed to parse gateway event {} ({})", + gateway_payload_t, + result.err().unwrap() + ); + return; + } } "STAGE_INSTANCE_CREATE" => { - let new_data: types::StageInstanceCreate = - serde_json::from_str(gateway_payload.event_data.unwrap().get()) - .unwrap(); - self.events - .lock() - .await - .stage_instance - .create - .update_data(new_data) - .await; + let event = &mut self.events.lock().await.stage_instance.create; + let result = + Gateway::handle_event(gateway_payload.event_data.unwrap().get(), event) + .await; + if result.is_err() { + println!( + "Failed to parse gateway event {} ({})", + gateway_payload_t, + result.err().unwrap() + ); + return; + } } "STAGE_INSTANCE_UPDATE" => { - let new_data: types::StageInstanceUpdate = - serde_json::from_str(gateway_payload.event_data.unwrap().get()) - .unwrap(); - self.events - .lock() - .await - .stage_instance - .update - .update_data(new_data) - .await; + let event = &mut self.events.lock().await.stage_instance.update; + let result = + Gateway::handle_event(gateway_payload.event_data.unwrap().get(), event) + .await; + if result.is_err() { + println!( + "Failed to parse gateway event {} ({})", + gateway_payload_t, + result.err().unwrap() + ); + return; + } } "STAGE_INSTANCE_DELETE" => { - let new_data: types::StageInstanceDelete = - serde_json::from_str(gateway_payload.event_data.unwrap().get()) - .unwrap(); - self.events - .lock() - .await - .stage_instance - .delete - .update_data(new_data) - .await; + let event = &mut self.events.lock().await.stage_instance.delete; + let result = + Gateway::handle_event(gateway_payload.event_data.unwrap().get(), event) + .await; + if result.is_err() { + println!( + "Failed to parse gateway event {} ({})", + gateway_payload_t, + result.err().unwrap() + ); + return; + } } "SESSIONS_REPLACE" => { - let sessions: Vec = - serde_json::from_str(gateway_payload.event_data.unwrap().get()) - .unwrap(); - let new_data = types::SessionsReplace { sessions }; + let result: Result, serde_json::Error> = + serde_json::from_str(gateway_payload.event_data.unwrap().get()); + if result.is_err() { + println!( + "Failed to parse gateway event {} ({})", + gateway_payload_t, + result.err().unwrap() + ); + return; + } + + let data = types::SessionsReplace { + sessions: result.unwrap(), + }; + self.events .lock() .await .session .replace - .update_data(new_data) - .await; - } - "TYPING_START" => { - let new_data: types::TypingStartEvent = - serde_json::from_str(gateway_payload.event_data.unwrap().get()) - .unwrap(); - self.events - .lock() - .await - .user - .typing_start_event - .update_data(new_data) + .update_data(data) .await; } "USER_UPDATE" => { - let new_data: types::UserUpdate = - serde_json::from_str(gateway_payload.event_data.unwrap().get()) - .unwrap(); - self.events - .lock() - .await - .user - .update - .update_data(new_data) - .await; + let event = &mut self.events.lock().await.user.update; + let result = + Gateway::handle_event(gateway_payload.event_data.unwrap().get(), event) + .await; + if result.is_err() { + println!( + "Failed to parse gateway event {} ({})", + gateway_payload_t, + result.err().unwrap() + ); + return; + } } "USER_GUILD_SETTINGS_UPDATE" => { - let new_data: types::UserGuildSettingsUpdate = - serde_json::from_str(gateway_payload.event_data.unwrap().get()) - .unwrap(); - self.events - .lock() - .await - .user - .guild_settings_update - .update_data(new_data) - .await; + let event = &mut self.events.lock().await.user.guild_settings_update; + let result = + Gateway::handle_event(gateway_payload.event_data.unwrap().get(), event) + .await; + if result.is_err() { + println!( + "Failed to parse gateway event {} ({})", + gateway_payload_t, + result.err().unwrap() + ); + return; + } } "VOICE_STATE_UPDATE" => { - let new_data: types::VoiceStateUpdate = - serde_json::from_str(gateway_payload.event_data.unwrap().get()) - .unwrap(); - self.events - .lock() - .await - .voice - .state_update - .update_data(new_data) - .await; + let event = &mut self.events.lock().await.voice.state_update; + let result = + Gateway::handle_event(gateway_payload.event_data.unwrap().get(), event) + .await; + if result.is_err() { + println!( + "Failed to parse gateway event {} ({})", + gateway_payload_t, + result.err().unwrap() + ); + return; + } } "VOICE_SERVER_UPDATE" => { - let new_data: types::VoiceServerUpdate = - serde_json::from_str(gateway_payload.event_data.unwrap().get()) - .unwrap(); - self.events - .lock() - .await - .voice - .server_update - .update_data(new_data) - .await; + let event = &mut self.events.lock().await.voice.server_update; + let result = + Gateway::handle_event(gateway_payload.event_data.unwrap().get(), event) + .await; + if result.is_err() { + println!( + "Failed to parse gateway event {} ({})", + gateway_payload_t, + result.err().unwrap() + ); + return; + } } "WEBHOOKS_UPDATE" => { - let new_data: types::WebhooksUpdate = - serde_json::from_str(gateway_payload.event_data.unwrap().get()) - .unwrap(); - self.events - .lock() - .await - .webhooks - .update - .update_data(new_data) - .await; + let event = &mut self.events.lock().await.webhooks.update; + let result = + Gateway::handle_event(gateway_payload.event_data.unwrap().get(), event) + .await; + if result.is_err() { + println!( + "Failed to parse gateway event {} ({})", + gateway_payload_t, + result.err().unwrap() + ); + return; + } } _ => { println!("Received unrecognized gateway event ({})! Please open an issue on the chorus github so we can implement it", &gateway_payload_t); @@ -1144,7 +1483,23 @@ impl Gateway { } } // We received a heartbeat from the server - GATEWAY_HEARTBEAT => {} + // "Discord may send the app a Heartbeat (opcode 1) event, in which case the app should send a Heartbeat event immediately." + GATEWAY_HEARTBEAT => { + println!("GW: Received Heartbeat // Heartbeat Request"); + + // Tell the heartbeat handler it should send a heartbeat right away + + let heartbeat_communication = HeartbeatThreadCommunication { + sequence_number: gateway_payload.sequence_number, + op_code: Some(GATEWAY_HEARTBEAT), + }; + + self.heartbeat_handler + .send + .send(heartbeat_communication) + .await + .unwrap(); + } GATEWAY_RECONNECT => { todo!() } @@ -1158,6 +1513,19 @@ impl Gateway { } GATEWAY_HEARTBEAT_ACK => { println!("GW: Received Heartbeat ACK"); + + // Tell the heartbeat handler we received an ack + + let heartbeat_communication = HeartbeatThreadCommunication { + sequence_number: gateway_payload.sequence_number, + op_code: Some(GATEWAY_HEARTBEAT_ACK), + }; + + self.heartbeat_handler + .send + .send(heartbeat_communication) + .await + .unwrap(); } GATEWAY_IDENTIFY | GATEWAY_UPDATE_PRESENCE @@ -1166,39 +1534,36 @@ impl Gateway { | GATEWAY_REQUEST_GUILD_MEMBERS | GATEWAY_CALL_SYNC | GATEWAY_LAZY_REQUEST => { - panic!( - "Received gateway op code that's meant to be sent, not received ({})", - gateway_payload.op_code - ) + let error = GatewayError::UnexpectedOpcodeReceivedError { + opcode: gateway_payload.op_code, + }; + Err::<(), GatewayError>(error).unwrap(); } _ => { println!("Received unrecognized gateway op code ({})! Please open an issue on the chorus github so we can implement it", gateway_payload.op_code); } } - // If we have an active heartbeat thread and we received a seq number we should let it know + // If we we received a seq number we should let it know if gateway_payload.sequence_number.is_some() { - if self.heartbeat_handler.is_some() { - let heartbeat_communication = HeartbeatThreadCommunication { - op_code: gateway_payload.op_code, - sequence_number: gateway_payload.sequence_number.unwrap(), - }; + let heartbeat_communication = HeartbeatThreadCommunication { + sequence_number: Some(gateway_payload.sequence_number.unwrap()), + // Op code is irrelevant here + op_code: None, + }; - self.heartbeat_handler - .as_mut() - .unwrap() - .send - .send(heartbeat_communication) - .await - .unwrap(); - } + self.heartbeat_handler + .send + .send(heartbeat_communication) + .await + .unwrap(); } } } /** Handles sending heartbeats to the gateway in another thread -*/ + */ struct HeartbeatHandler { /// The heartbeat interval in milliseconds pub heartbeat_interval: u128, @@ -1219,41 +1584,19 @@ impl HeartbeatHandler { >, >, >, + kill_rc: tokio::sync::broadcast::Receiver<()>, ) -> HeartbeatHandler { - let (send, mut receive) = mpsc::channel(32); + let (send, receive) = tokio::sync::mpsc::channel(32); + let kill_receive = kill_rc.resubscribe(); let handle: JoinHandle<()> = task::spawn(async move { - let mut last_heartbeat_timestamp: Instant = time::Instant::now(); - let mut last_seq_number: Option = None; - - loop { - // If we received a seq number update, use that as the last seq number - let received_communication: Result = - receive.try_recv(); - if received_communication.is_ok() { - last_seq_number = Some(received_communication.unwrap().sequence_number); - } - - let should_send = - last_heartbeat_timestamp.elapsed().as_millis() >= heartbeat_interval; - - if should_send { - println!("GW: Sending Heartbeat.."); - - let heartbeat = types::GatewayHeartbeat { - op: GATEWAY_HEARTBEAT, - d: last_seq_number, - }; - - let heartbeat_json = serde_json::to_string(&heartbeat).unwrap(); - - let msg = tokio_tungstenite::tungstenite::Message::text(heartbeat_json); - - websocket_tx.lock().await.send(msg).await.unwrap(); - - last_heartbeat_timestamp = time::Instant::now(); - } - } + HeartbeatHandler::heartbeat_task( + websocket_tx, + heartbeat_interval, + receive, + kill_receive, + ) + .await; }); Self { @@ -1262,18 +1605,109 @@ impl HeartbeatHandler { handle, } } + + /// The main heartbeat task; + /// + /// Can be killed by the kill broadcast; + /// If the websocket is closed, will die out next time it tries to send a heartbeat; + pub async fn heartbeat_task( + websocket_tx: Arc< + Mutex< + SplitSink< + WebSocketStream>, + tokio_tungstenite::tungstenite::Message, + >, + >, + >, + heartbeat_interval: u128, + mut receive: tokio::sync::mpsc::Receiver, + mut kill_receive: tokio::sync::broadcast::Receiver<()>, + ) { + let mut last_heartbeat_timestamp: Instant = time::Instant::now(); + let mut last_heartbeat_acknowledged = true; + let mut last_seq_number: Option = None; + + loop { + let should_shutdown = kill_receive.try_recv().is_ok(); + if should_shutdown { + break; + } + + let mut should_send; + + let time_to_send = last_heartbeat_timestamp.elapsed().as_millis() >= heartbeat_interval; + + should_send = time_to_send; + + let received_communication: Result = + receive.try_recv(); + if received_communication.is_ok() { + let communication = received_communication.unwrap(); + + // If we received a seq number update, use that as the last seq number + if communication.sequence_number.is_some() { + last_seq_number = Some(communication.sequence_number.unwrap()); + } + + if communication.op_code.is_some() { + match communication.op_code.unwrap() { + GATEWAY_HEARTBEAT => { + // As per the api docs, if the server sends us a Heartbeat, that means we need to respond with a heartbeat immediately + should_send = true; + } + GATEWAY_HEARTBEAT_ACK => { + // The server received our heartbeat + last_heartbeat_acknowledged = true; + } + _ => {} + } + } + } + + // If the server hasn't acknowledged our heartbeat we should resend it + if !last_heartbeat_acknowledged + && last_heartbeat_timestamp.elapsed().as_millis() > HEARTBEAT_ACK_TIMEOUT + { + should_send = true; + println!("GW: Timed out waiting for a heartbeat ack, resending"); + } + + if should_send { + println!("GW: Sending Heartbeat.."); + + let heartbeat = types::GatewayHeartbeat { + op: GATEWAY_HEARTBEAT, + d: last_seq_number, + }; + + let heartbeat_json = serde_json::to_string(&heartbeat).unwrap(); + + let msg = tokio_tungstenite::tungstenite::Message::text(heartbeat_json); + + let send_result = websocket_tx.lock().await.send(msg).await; + if send_result.is_err() { + // We couldn't send, the websocket is broken + println!("GW: Couldnt send heartbeat, websocket seems broken"); + break; + } + + last_heartbeat_timestamp = time::Instant::now(); + last_heartbeat_acknowledged = false; + } + } + } } /** -Used to communicate with the main thread. -Either signifies a sequence number update or a received heartbeat ack +Used for communications between the heartbeat and gateway thread. +Either signifies a sequence number update, a heartbeat ACK or a Heartbeat request by the server */ #[derive(Clone, Copy, Debug)] struct HeartbeatThreadCommunication { - /// The opcode for the communication we received - op_code: u8, - /// The sequence number we got from discord - sequence_number: u64, + /// The opcode for the communication we received, if relevant + op_code: Option, + /// The sequence number we got from discord, if any + sequence_number: Option, } /** @@ -1282,13 +1716,12 @@ an Observable. The Observer is notified when the Observable's data changes. In this case, the Observable is a [`GatewayEvent`], which is a wrapper around a WebSocketEvent. */ pub trait Observer: std::fmt::Debug { - fn update(&self, data: &T); + fn update(&mut self, data: &T); } /** GatewayEvent is a wrapper around a WebSocketEvent. It is used to notify the observers of a change in the WebSocketEvent. GatewayEvents are observable. -*/ - + */ #[derive(Default, Debug)] pub struct GatewayEvent { observers: Vec + Sync + Send>>>, @@ -1307,7 +1740,7 @@ impl GatewayEvent { /** Returns true if the GatewayEvent is observed by at least one Observer. - */ + */ pub fn is_observed(&self) -> bool { self.is_observed } @@ -1318,7 +1751,7 @@ impl GatewayEvent { # Errors Returns an error if the GatewayEvent is already observed. Error type: [`ObserverError::AlreadySubscribedError`] - */ + */ pub fn subscribe( &mut self, observable: Arc + Sync + Send>>, @@ -1333,7 +1766,7 @@ impl GatewayEvent { /** Unsubscribes an Observer from the GatewayEvent. - */ + */ pub fn unsubscribe(&mut self, observable: Arc + Sync + Send>>) { // .retain()'s closure retains only those elements of the vector, which have a different // pointer value than observable. @@ -1346,7 +1779,7 @@ impl GatewayEvent { /** Updates the GatewayEvent's data and notifies the observers. - */ + */ async fn update_data(&mut self, new_event_data: T) { self.event_data = new_event_data; self.notify().await; @@ -1354,16 +1787,19 @@ impl GatewayEvent { /** Notifies the observers of the GatewayEvent. - */ + */ async fn notify(&self) { for observer in &self.observers { - observer.lock().await.update(&self.event_data); + let mut observer_lock = observer.lock().await; + observer_lock.update(&self.event_data); + drop(observer_lock); } } } mod events { use super::*; + #[derive(Default, Debug)] pub struct Events { pub application: Application, @@ -1528,8 +1964,9 @@ mod example { #[derive(Debug)] struct Consumer; + impl Observer for Consumer { - fn update(&self, data: &types::GatewayResume) { + fn update(&mut self, data: &types::GatewayResume) { println!("{}", data.token) } } @@ -1551,7 +1988,7 @@ mod example { let consumer = Consumer; let arc_mut_consumer = Arc::new(Mutex::new(consumer)); - event.subscribe(arc_mut_consumer.clone()); + event.subscribe(arc_mut_consumer.clone()).unwrap(); event.notify().await; @@ -1569,11 +2006,4 @@ mod example { event.subscribe(arc_mut_second_consumer.clone()).unwrap(); } - - #[tokio::test] - async fn test_gateway_establish() { - let _gateway = Gateway::new("ws://localhost:3001/".to_string()) - .await - .unwrap(); - } } diff --git a/src/instance.rs b/src/instance.rs index 524735b..42b7298 100644 --- a/src/instance.rs +++ b/src/instance.rs @@ -1,3 +1,7 @@ +use std::cell::RefCell; +use std::fmt; +use std::rc::Rc; + use serde::{Deserialize, Serialize}; use crate::api::limits::Limits; @@ -5,10 +9,6 @@ use crate::errors::{ChorusLibError, FieldFormatError}; use crate::types::{GeneralConfiguration, User, UserSettings}; use crate::URLBundle; -use std::cell::RefCell; -use std::fmt; -use std::rc::Rc; - #[derive(Debug, Clone)] /** The [`Instance`] what you will be using to perform all sorts of actions on the Spacebar server. @@ -47,7 +47,7 @@ impl Instance { Err(e) => { return Err(ChorusLibError::CantGetInfoError { error: e.to_string(), - }) + }); } }; Ok(instance) diff --git a/src/lib.rs b/src/lib.rs index a849188..2e25d3d 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -1,3 +1,5 @@ +use url::{ParseError, Url}; + #[cfg(feature = "client")] pub mod api; pub mod errors; @@ -11,9 +13,7 @@ pub mod types; #[cfg(feature = "client")] pub mod voice; -use url::{ParseError, Url}; #[derive(Clone, Default, Debug, PartialEq, Eq)] - /// A URLBundle is a struct which bundles together the API-, Gateway- and CDN-URLs of a Spacebar /// instance. pub struct URLBundle { diff --git a/src/limit.rs b/src/limit.rs index 70f5c06..ce0ba4e 100644 --- a/src/limit.rs +++ b/src/limit.rs @@ -1,11 +1,12 @@ +use std::collections::VecDeque; + +use reqwest::{Client, RequestBuilder, Response}; + use crate::{ api::limits::{Limit, LimitType, Limits, LimitsMutRef}, errors::ChorusLibError, }; -use reqwest::{Client, RequestBuilder, Response}; -use std::collections::VecDeque; - // Note: There seem to be some overlapping request limiters. We need to make sure that sending a // request checks for all the request limiters that apply, and blocks if any of the limiters are 0 @@ -64,7 +65,7 @@ impl LimitedRequester { - There has been an error with processing (unwrapping) the [`Response`](`reqwest::Response`) - The call to [`update_limits`](`crate::limits::update_limits`) yielded errors. Read the methods' Errors section for more information. - */ + */ pub async fn send_request( &mut self, request: RequestBuilder, @@ -79,7 +80,7 @@ impl LimitedRequester { return Err(ChorusLibError::RequestErrorError { url: "".to_string(), error: e.to_string(), - }) + }); } }; let result = self.http.execute(built_request).await; @@ -88,7 +89,7 @@ impl LimitedRequester { Err(e) => { return Err(ChorusLibError::ReceivedErrorCodeError { error_code: e.to_string(), - }) + }); } }; self.update_limits( @@ -104,7 +105,7 @@ impl LimitedRequester { _ => { return Err(ChorusLibError::ReceivedErrorCodeError { error_code: response.status().as_str().to_string(), - }) + }); } } } else { @@ -281,10 +282,11 @@ impl LimitedRequester { mod rate_limit { use serde_json::from_str; - use super::*; use crate::{api::limits::Config, URLBundle}; - #[tokio::test] + use super::*; + + #[tokio::test] async fn create_limited_requester() { let _urls = URLBundle::new( String::from("http://localhost:3001/api/"), diff --git a/src/types/config/types/guild_configuration.rs b/src/types/config/types/guild_configuration.rs index 2dc4d5b..4fedf51 100644 --- a/src/types/config/types/guild_configuration.rs +++ b/src/types/config/types/guild_configuration.rs @@ -1,3 +1,8 @@ +use std::fmt::{Display, Formatter}; +use std::io::Write; +use std::ops::{Deref, DerefMut}; +use std::str::FromStr; + use serde::{Deserialize, Serialize}; #[cfg(feature = "sqlx")] use sqlx::{ @@ -6,10 +11,6 @@ use sqlx::{ error::BoxDynError, Decode, Encode, MySql, }; -use std::fmt::{Display, Formatter}; -use std::io::Write; -use std::ops::{Deref, DerefMut}; -use std::str::FromStr; use crate::types::config::types::subconfigs::guild::{ autojoin::AutoJoinConfiguration, discovery::DiscoverConfiguration, diff --git a/src/types/config/types/subconfigs/register/email.rs b/src/types/config/types/subconfigs/register/email.rs index ac99bfc..8688cd2 100644 --- a/src/types/config/types/subconfigs/register/email.rs +++ b/src/types/config/types/subconfigs/register/email.rs @@ -9,6 +9,7 @@ pub struct RegistrationEmailConfiguration { #[serde(default)] pub domains: Vec, } + impl Default for RegistrationEmailConfiguration { fn default() -> Self { Self { diff --git a/src/types/config/types/subconfigs/register/mod.rs b/src/types/config/types/subconfigs/register/mod.rs index ad92571..a2d714e 100644 --- a/src/types/config/types/subconfigs/register/mod.rs +++ b/src/types/config/types/subconfigs/register/mod.rs @@ -1,7 +1,7 @@ -mod date_of_birth; -mod email; -mod password; - pub use date_of_birth::DateOfBirthConfiguration; pub use email::RegistrationEmailConfiguration; pub use password::PasswordConfiguration; + +mod date_of_birth; +mod email; +mod password; diff --git a/src/types/config/types/subconfigs/security/mod.rs b/src/types/config/types/subconfigs/security/mod.rs index ceeb0d3..8455000 100644 --- a/src/types/config/types/subconfigs/security/mod.rs +++ b/src/types/config/types/subconfigs/security/mod.rs @@ -1,5 +1,5 @@ -mod captcha; -mod twofactor; - pub use captcha::{CaptchaConfiguration, CaptchaService}; pub use twofactor::TwoFactorConfiguration; + +mod captcha; +mod twofactor; diff --git a/src/types/entities/application.rs b/src/types/entities/application.rs index 56b16ae..e5c4a01 100644 --- a/src/types/entities/application.rs +++ b/src/types/entities/application.rs @@ -1,10 +1,11 @@ -use crate::types::utils::Snowflake; -use crate::types::{Team, User}; use bitflags::{bitflags, Flags}; use serde::{Deserialize, Serialize}; use serde_json::Value; use serde_repr::{Deserialize_repr, Serialize_repr}; +use crate::types::utils::Snowflake; +use crate::types::{Team, User}; + #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)] #[cfg_attr(feature = "sqlx", derive(sqlx::FromRow))] pub struct Application { diff --git a/src/types/entities/attachment.rs b/src/types/entities/attachment.rs index 5bdfede..423bac6 100644 --- a/src/types/entities/attachment.rs +++ b/src/types/entities/attachment.rs @@ -23,7 +23,6 @@ pub struct Attachment { } #[derive(Debug, Serialize, Deserialize, Clone)] - pub struct PartialDiscordFileAttachment { pub id: Option, pub filename: String, diff --git a/src/types/entities/guild.rs b/src/types/entities/guild.rs index f9fa2e2..5e513d9 100644 --- a/src/types/entities/guild.rs +++ b/src/types/entities/guild.rs @@ -34,7 +34,7 @@ pub struct Guild { pub emojis: Vec, pub explicit_content_filter: Option, //#[cfg_attr(feature = "sqlx", sqlx(try_from = "String"))] - pub features: GuildFeaturesList, + pub features: Option, pub icon: Option, #[cfg_attr(feature = "sqlx", sqlx(skip))] pub icon_hash: Option, diff --git a/src/types/entities/message.rs b/src/types/entities/message.rs index f864014..a64ea0d 100644 --- a/src/types/entities/message.rs +++ b/src/types/entities/message.rs @@ -170,7 +170,6 @@ pub struct EmbedAuthor { } #[derive(Debug, PartialEq, Clone, Serialize, Deserialize)] - pub struct EmbedField { name: String, value: String, diff --git a/src/types/entities/mod.rs b/src/types/entities/mod.rs index d27c76e..b63bb9a 100644 --- a/src/types/entities/mod.rs +++ b/src/types/entities/mod.rs @@ -1,26 +1,3 @@ -mod application; -mod attachment; -mod audit_log; -mod auto_moderation; -mod channel; -mod config; -mod emoji; -mod guild; -mod guild_member; -mod integration; -mod message; -mod relationship; -mod role; -mod security_key; -mod stage_instance; -mod sticker; -mod team; -mod template; -mod user; -mod user_settings; -mod voice_state; -mod webhook; - pub use application::*; pub use attachment::*; pub use audit_log::*; @@ -43,3 +20,26 @@ pub use user::*; pub use user_settings::*; pub use voice_state::*; pub use webhook::*; + +mod application; +mod attachment; +mod audit_log; +mod auto_moderation; +mod channel; +mod config; +mod emoji; +mod guild; +mod guild_member; +mod integration; +mod message; +mod relationship; +mod role; +mod security_key; +mod stage_instance; +mod sticker; +mod team; +mod template; +mod user; +mod user_settings; +mod voice_state; +mod webhook; diff --git a/src/types/entities/role.rs b/src/types/entities/role.rs index 3cbf0ea..7f527be 100644 --- a/src/types/entities/role.rs +++ b/src/types/entities/role.rs @@ -1,6 +1,6 @@ use bitflags::bitflags; use serde::{Deserialize, Serialize}; -use serde_aux::prelude::deserialize_option_number_from_string; +use serde_aux::prelude::{deserialize_option_number_from_string, deserialize_string_from_number}; use crate::types::utils::Snowflake; @@ -16,6 +16,7 @@ pub struct RoleObject { pub unicode_emoji: Option, pub position: u16, #[serde(default)] + #[serde(deserialize_with = "deserialize_string_from_number")] pub permissions: String, pub managed: bool, pub mentionable: bool, diff --git a/src/types/entities/template.rs b/src/types/entities/template.rs index aa87251..c2a2aca 100644 --- a/src/types/entities/template.rs +++ b/src/types/entities/template.rs @@ -21,7 +21,8 @@ pub struct GuildTemplate { pub updated_at: DateTime, pub source_guild_id: String, #[cfg_attr(feature = "sqlx", sqlx(skip))] - pub source_guild: Vec, // Unsure how a {recursive: Guild} looks like, might be a Vec? + pub source_guild: Vec, + // Unsure how a {recursive: Guild} looks like, might be a Vec? #[cfg_attr(feature = "sqlx", sqlx(skip))] pub serialized_source_guild: Vec, } diff --git a/src/types/entities/user_settings.rs b/src/types/entities/user_settings.rs index 7b9541f..40b936a 100644 --- a/src/types/entities/user_settings.rs +++ b/src/types/entities/user_settings.rs @@ -13,6 +13,12 @@ pub enum UserStatus { Invisible, } +impl std::fmt::Display for UserStatus { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(f, "{}", serde_json::to_string(self).unwrap()) + } +} + #[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, Default)] #[cfg_attr(feature = "sqlx", derive(sqlx::Type))] #[serde(rename_all = "lowercase")] diff --git a/src/types/events/application.rs b/src/types/events/application.rs index aca2b29..8afb374 100644 --- a/src/types/events/application.rs +++ b/src/types/events/application.rs @@ -2,7 +2,7 @@ use serde::{Deserialize, Serialize}; use crate::types::{GuildApplicationCommandPermissions, WebSocketEvent}; -#[derive(Debug, Deserialize, Serialize, Default)] +#[derive(Debug, Deserialize, Serialize, Default, Clone)] /// See https://discord.com/developers/docs/topics/gateway-events#application-command-permissions-update pub struct ApplicationCommandPermissionsUpdate { #[serde(flatten)] diff --git a/src/types/events/auto_moderation.rs b/src/types/events/auto_moderation.rs index 2fa8fc5..d82aa02 100644 --- a/src/types/events/auto_moderation.rs +++ b/src/types/events/auto_moderation.rs @@ -5,7 +5,7 @@ use crate::types::{ WebSocketEvent, }; -#[derive(Debug, Deserialize, Serialize, Default)] +#[derive(Debug, Deserialize, Serialize, Default, Clone)] /// See https://discord.com/developers/docs/topics/gateway-events#auto-moderation-rule-create pub struct AutoModerationRuleCreate { #[serde(flatten)] @@ -14,7 +14,7 @@ pub struct AutoModerationRuleCreate { impl WebSocketEvent for AutoModerationRuleCreate {} -#[derive(Debug, Deserialize, Serialize, Default)] +#[derive(Debug, Deserialize, Serialize, Default, Clone)] /// See https://discord.com/developers/docs/topics/gateway-events#auto-moderation-rule-update pub struct AutoModerationRuleUpdate { #[serde(flatten)] @@ -23,7 +23,7 @@ pub struct AutoModerationRuleUpdate { impl WebSocketEvent for AutoModerationRuleUpdate {} -#[derive(Debug, Deserialize, Serialize, Default)] +#[derive(Debug, Deserialize, Serialize, Default, Clone)] /// See https://discord.com/developers/docs/topics/gateway-events#auto-moderation-rule-delete pub struct AutoModerationRuleDelete { #[serde(flatten)] @@ -32,7 +32,7 @@ pub struct AutoModerationRuleDelete { impl WebSocketEvent for AutoModerationRuleDelete {} -#[derive(Debug, Deserialize, Serialize, Default)] +#[derive(Debug, Deserialize, Serialize, Default, Clone)] /// See https://discord.com/developers/docs/topics/gateway-events#auto-moderation-action-execution pub struct AutoModerationActionExecution { pub guild_id: Snowflake, diff --git a/src/types/events/call.rs b/src/types/events/call.rs index 3c58635..1f7401a 100644 --- a/src/types/events/call.rs +++ b/src/types/events/call.rs @@ -2,50 +2,59 @@ use serde::{Deserialize, Serialize}; use crate::types::{VoiceState, WebSocketEvent}; -#[derive(Debug, Deserialize, Serialize, Default)] -/// Officially Undocumented -/// Is sent to a client by the server to signify a new being created -/// {"t":"CALL_CREATE","s":2,"op":0,"d":{"voice_states":[],"ringing":[],"region":"milan","message_id":"1107187514906775613","embedded_activities":[],"channel_id":"837609115475771392"}} +#[derive(Debug, Deserialize, Serialize, Default, Clone)] +/// Officially Undocumented; +/// Is sent to a client by the server to signify a new call being created; +/// +/// Ex: {"t":"CALL_CREATE","s":2,"op":0,"d":{"voice_states":[],"ringing":[],"region":"milan","message_id":"1107187514906775613","embedded_activities":[],"channel_id":"837609115475771392"}} pub struct CallCreate { pub voice_states: Vec, /// Seems like a vec of channel ids pub ringing: Vec, - pub region: String, // milan + pub region: String, + // milan pub message_id: String, /// What is this? pub embedded_activities: Vec, pub channel_id: String, } + impl WebSocketEvent for CallCreate {} -#[derive(Debug, Deserialize, Serialize, Default)] -/// Officially Undocumented -/// Updates the status of calls -/// {"t":"CALL_UPDATE","s":5,"op":0,"d":{"ringing":["837606544539254834"],"region":"milan","message_id":"1107191540234846308","guild_id":null,"channel_id":"837609115475771392"}} +#[derive(Debug, Deserialize, Serialize, Default, Clone)] +/// Officially Undocumented; +/// Updates the client on which calls are ringing, along with a specific call?; +/// +/// Ex: {"t":"CALL_UPDATE","s":5,"op":0,"d":{"ringing":["837606544539254834"],"region":"milan","message_id":"1107191540234846308","guild_id":null,"channel_id":"837609115475771392"}} pub struct CallUpdate { /// Seems like a vec of channel ids pub ringing: Vec, - pub region: String, // milan + pub region: String, + // milan pub message_id: String, pub guild_id: Option, pub channel_id: String, } + impl WebSocketEvent for CallUpdate {} -#[derive(Debug, Deserialize, Serialize, Default)] -/// Officially Undocumented -/// Deletes a ringing call -/// {"t":"CALL_DELETE","s":8,"op":0,"d":{"channel_id":"837609115475771392"}} +#[derive(Debug, Deserialize, Serialize, Default, Clone)] +/// Officially Undocumented; +/// Deletes a ringing call; +/// Ex: {"t":"CALL_DELETE","s":8,"op":0,"d":{"channel_id":"837609115475771392"}} pub struct CallDelete { pub channel_id: String, } + impl WebSocketEvent for CallDelete {} -#[derive(Debug, Deserialize, Serialize, Default)] -/// Officially Undocumented -/// See https://unofficial-discord-docs.vercel.app/gateway/op13 -/// {"op":13,"d":{"channel_id":"837609115475771392"}} +#[derive(Debug, Deserialize, Serialize, Default, Clone)] +/// Officially Undocumented; +/// See https://unofficial-discord-docs.vercel.app/gateway/op13; +/// +/// Ex: {"op":13,"d":{"channel_id":"837609115475771392"}} pub struct CallSync { pub channel_id: String, } + impl WebSocketEvent for CallSync {} diff --git a/src/types/events/channel.rs b/src/types/events/channel.rs index adafa9f..43ffa96 100644 --- a/src/types/events/channel.rs +++ b/src/types/events/channel.rs @@ -13,7 +13,7 @@ pub struct ChannelPinsUpdate { impl WebSocketEvent for ChannelPinsUpdate {} -#[derive(Debug, Default, Deserialize, Serialize)] +#[derive(Debug, Default, Deserialize, Serialize, Clone)] /// See https://discord.com/developers/docs/topics/gateway-events#channel-create pub struct ChannelCreate { #[serde(flatten)] @@ -22,7 +22,7 @@ pub struct ChannelCreate { impl WebSocketEvent for ChannelCreate {} -#[derive(Debug, Default, Deserialize, Serialize)] +#[derive(Debug, Default, Deserialize, Serialize, Clone)] /// See https://discord.com/developers/docs/topics/gateway-events#channel-update pub struct ChannelUpdate { #[serde(flatten)] @@ -31,7 +31,7 @@ pub struct ChannelUpdate { impl WebSocketEvent for ChannelUpdate {} -#[derive(Debug, Default, Deserialize, Serialize)] +#[derive(Debug, Default, Deserialize, Serialize, Clone)] /// Officially undocumented. /// Sends updates to client about a new message with its id /// {"channel_unread_updates": [{"id": "816412869766938648", "last_message_id": "1085892012085104680"}} @@ -40,7 +40,7 @@ pub struct ChannelUnreadUpdate { pub guild_id: String, } -#[derive(Debug, Default, Deserialize, Serialize)] +#[derive(Debug, Default, Deserialize, Serialize, Clone)] /// Contains very few fields from [Channel] /// See also [ChannelUnreadUpdates] pub struct ChannelUnreadUpdateObject { @@ -51,7 +51,7 @@ pub struct ChannelUnreadUpdateObject { impl WebSocketEvent for ChannelUnreadUpdate {} -#[derive(Debug, Default, Deserialize, Serialize)] +#[derive(Debug, Default, Deserialize, Serialize, Clone)] /// See https://discord.com/developers/docs/topics/gateway-events#channel-delete pub struct ChannelDelete { #[serde(flatten)] diff --git a/src/types/events/guild.rs b/src/types/events/guild.rs index d1c8fe4..decc2e8 100644 --- a/src/types/events/guild.rs +++ b/src/types/events/guild.rs @@ -1,20 +1,22 @@ -use crate::types::entities::{Guild, PublicUser, UnavailableGuild}; -use crate::types::events::WebSocketEvent; -use crate::types::{AuditLogEntry, Emoji, GuildMember, GuildScheduledEvent, RoleObject, Sticker}; use chrono::{DateTime, Utc}; use serde::{Deserialize, Serialize}; +use crate::types::entities::{Guild, PublicUser, UnavailableGuild}; +use crate::types::events::WebSocketEvent; +use crate::types::{AuditLogEntry, Emoji, GuildMember, GuildScheduledEvent, RoleObject, Sticker}; + use super::PresenceUpdate; -#[derive(Debug, Deserialize, Serialize, Default)] -/// See https://discord.com/developers/docs/topics/gateway-events#guild-create -/// This one is particularly painful, it can be a Guild object with an extra field or an unavailable guild object +#[derive(Debug, Deserialize, Serialize, Default, Clone)] +/// See https://discord.com/developers/docs/topics/gateway-events#guild-create; +/// Received to give data about a guild; +// This one is particularly painful, it can be a Guild object with an extra field or an unavailable guild object pub struct GuildCreate { #[serde(flatten)] pub d: GuildCreateDataOption, } -#[derive(Debug, Deserialize, Serialize)] +#[derive(Debug, Deserialize, Serialize, Clone)] #[serde(untagged)] pub enum GuildCreateDataOption { UnavailableGuild(UnavailableGuild), @@ -26,10 +28,12 @@ impl Default for GuildCreateDataOption { GuildCreateDataOption::UnavailableGuild(UnavailableGuild::default()) } } + impl WebSocketEvent for GuildCreate {} -#[derive(Debug, Default, Deserialize, Serialize)] -/// See https://discord.com/developers/docs/topics/gateway-events#guild-ban-add-guild-ban-add-event-fields +#[derive(Debug, Default, Deserialize, Serialize, Clone)] +/// See https://discord.com/developers/docs/topics/gateway-events#guild-ban-add-guild-ban-add-event-fields; +/// Received to give info about a user being banned from a guild; pub struct GuildBanAdd { pub guild_id: String, pub user: PublicUser, @@ -37,8 +41,9 @@ pub struct GuildBanAdd { impl WebSocketEvent for GuildBanAdd {} -#[derive(Debug, Default, Deserialize, Serialize)] -/// See https://discord.com/developers/docs/topics/gateway-events#guild-ban-remove +#[derive(Debug, Default, Deserialize, Serialize, Clone)] +/// See https://discord.com/developers/docs/topics/gateway-events#guild-ban-remove; +/// Received to give info about a user being unbanned from a guild; pub struct GuildBanRemove { pub guild_id: String, pub user: PublicUser, @@ -46,8 +51,9 @@ pub struct GuildBanRemove { impl WebSocketEvent for GuildBanRemove {} -#[derive(Debug, Default, Deserialize, Serialize)] -/// See https://discord.com/developers/docs/topics/gateway-events#guild-update +#[derive(Debug, Default, Deserialize, Serialize, Clone)] +/// See https://discord.com/developers/docs/topics/gateway-events#guild-update; +/// Received to give info about a guild being updated; pub struct GuildUpdate { #[serde(flatten)] pub guild: Guild, @@ -55,8 +61,9 @@ pub struct GuildUpdate { impl WebSocketEvent for GuildUpdate {} -#[derive(Debug, Default, Deserialize, Serialize)] -/// See https://discord.com/developers/docs/topics/gateway-events#guild-delete +#[derive(Debug, Default, Deserialize, Serialize, Clone)] +/// See https://discord.com/developers/docs/topics/gateway-events#guild-delete; +/// Received to tell the client about a guild being deleted; pub struct GuildDelete { #[serde(flatten)] pub guild: UnavailableGuild, @@ -64,8 +71,9 @@ pub struct GuildDelete { impl WebSocketEvent for GuildDelete {} -#[derive(Debug, Default, Deserialize, Serialize)] -/// See https://discord.com/developers/docs/topics/gateway-events#guild-audit-log-entry-create +#[derive(Debug, Default, Deserialize, Serialize, Clone)] +/// See https://discord.com/developers/docs/topics/gateway-events#guild-audit-log-entry-create; +/// Received to the client about an audit log entry being added; pub struct GuildAuditLogEntryCreate { #[serde(flatten)] pub entry: AuditLogEntry, @@ -73,8 +81,9 @@ pub struct GuildAuditLogEntryCreate { impl WebSocketEvent for GuildAuditLogEntryCreate {} -#[derive(Debug, Default, Deserialize, Serialize)] -/// See https://discord.com/developers/docs/topics/gateway-events#guild-emojis-update +#[derive(Debug, Default, Deserialize, Serialize, Clone)] +/// See https://discord.com/developers/docs/topics/gateway-events#guild-emojis-update; +/// Received to tell the client about a change to a guild's emoji list; pub struct GuildEmojisUpdate { pub guild_id: String, pub emojis: Vec, @@ -82,8 +91,9 @@ pub struct GuildEmojisUpdate { impl WebSocketEvent for GuildEmojisUpdate {} -#[derive(Debug, Default, Deserialize, Serialize)] -/// See https://discord.com/developers/docs/topics/gateway-events#guild-stickers-update +#[derive(Debug, Default, Deserialize, Serialize, Clone)] +/// See https://discord.com/developers/docs/topics/gateway-events#guild-stickers-update; +/// Received to tell the client about a change to a guild's sticker list; pub struct GuildStickersUpdate { pub guild_id: String, pub stickers: Vec, @@ -91,7 +101,7 @@ pub struct GuildStickersUpdate { impl WebSocketEvent for GuildStickersUpdate {} -#[derive(Debug, Default, Deserialize, Serialize)] +#[derive(Debug, Default, Deserialize, Serialize, Clone)] /// See https://discord.com/developers/docs/topics/gateway-events#guild-integrations-update pub struct GuildIntegrationsUpdate { pub guild_id: String, @@ -99,8 +109,9 @@ pub struct GuildIntegrationsUpdate { impl WebSocketEvent for GuildIntegrationsUpdate {} -#[derive(Debug, Default, Deserialize, Serialize)] -/// See https://discord.com/developers/docs/topics/gateway-events#guild-member-add +#[derive(Debug, Default, Deserialize, Serialize, Clone)] +/// See https://discord.com/developers/docs/topics/gateway-events#guild-member-add; +/// Received to tell the client about a user joining a guild; pub struct GuildMemberAdd { #[serde(flatten)] pub member: GuildMember, @@ -109,8 +120,9 @@ pub struct GuildMemberAdd { impl WebSocketEvent for GuildMemberAdd {} -#[derive(Debug, Default, Deserialize, Serialize)] -/// See https://discord.com/developers/docs/topics/gateway-events#guild-member-remove +#[derive(Debug, Default, Deserialize, Serialize, Clone)] +/// See https://discord.com/developers/docs/topics/gateway-events#guild-member-remove; +/// Received to tell the client about a user leaving a guild; pub struct GuildMemberRemove { pub guild_id: String, pub user: PublicUser, @@ -118,7 +130,7 @@ pub struct GuildMemberRemove { impl WebSocketEvent for GuildMemberRemove {} -#[derive(Debug, Default, Deserialize, Serialize)] +#[derive(Debug, Default, Deserialize, Serialize, Clone)] /// See https://discord.com/developers/docs/topics/gateway-events#guild-member-update pub struct GuildMemberUpdate { pub guild_id: String, @@ -136,7 +148,7 @@ pub struct GuildMemberUpdate { impl WebSocketEvent for GuildMemberUpdate {} -#[derive(Debug, Default, Deserialize, Serialize)] +#[derive(Debug, Default, Deserialize, Serialize, Clone)] /// See https://discord.com/developers/docs/topics/gateway-events#guild-members-chunk pub struct GuildMembersChunk { pub guild_id: String, @@ -150,7 +162,7 @@ pub struct GuildMembersChunk { impl WebSocketEvent for GuildMembersChunk {} -#[derive(Debug, Default, Deserialize, Serialize)] +#[derive(Debug, Default, Deserialize, Serialize, Clone)] /// See https://discord.com/developers/docs/topics/gateway-events#guild-role-create pub struct GuildRoleCreate { pub guild_id: String, @@ -159,7 +171,7 @@ pub struct GuildRoleCreate { impl WebSocketEvent for GuildRoleCreate {} -#[derive(Debug, Default, Deserialize, Serialize)] +#[derive(Debug, Default, Deserialize, Serialize, Clone)] /// See https://discord.com/developers/docs/topics/gateway-events#guild-role-update pub struct GuildRoleUpdate { pub guild_id: String, @@ -168,7 +180,7 @@ pub struct GuildRoleUpdate { impl WebSocketEvent for GuildRoleUpdate {} -#[derive(Debug, Default, Deserialize, Serialize)] +#[derive(Debug, Default, Deserialize, Serialize, Clone)] /// See https://discord.com/developers/docs/topics/gateway-events#guild-role-delete pub struct GuildRoleDelete { pub guild_id: String, @@ -177,7 +189,7 @@ pub struct GuildRoleDelete { impl WebSocketEvent for GuildRoleDelete {} -#[derive(Debug, Default, Deserialize, Serialize)] +#[derive(Debug, Default, Deserialize, Serialize, Clone)] /// See https://discord.com/developers/docs/topics/gateway-events#guild-scheduled-event-create pub struct GuildScheduledEventCreate { #[serde(flatten)] @@ -186,7 +198,7 @@ pub struct GuildScheduledEventCreate { impl WebSocketEvent for GuildScheduledEventCreate {} -#[derive(Debug, Default, Deserialize, Serialize)] +#[derive(Debug, Default, Deserialize, Serialize, Clone)] /// See https://discord.com/developers/docs/topics/gateway-events#guild-scheduled-event-update pub struct GuildScheduledEventUpdate { #[serde(flatten)] @@ -195,7 +207,7 @@ pub struct GuildScheduledEventUpdate { impl WebSocketEvent for GuildScheduledEventUpdate {} -#[derive(Debug, Default, Deserialize, Serialize)] +#[derive(Debug, Default, Deserialize, Serialize, Clone)] /// See https://discord.com/developers/docs/topics/gateway-events#guild-scheduled-event-delete pub struct GuildScheduledEventDelete { #[serde(flatten)] @@ -204,7 +216,7 @@ pub struct GuildScheduledEventDelete { impl WebSocketEvent for GuildScheduledEventDelete {} -#[derive(Debug, Default, Deserialize, Serialize)] +#[derive(Debug, Default, Deserialize, Serialize, Clone)] /// See https://discord.com/developers/docs/topics/gateway-events#guild-scheduled-event-user-add pub struct GuildScheduledEventUserAdd { pub guild_scheduled_event_id: String, @@ -214,7 +226,7 @@ pub struct GuildScheduledEventUserAdd { impl WebSocketEvent for GuildScheduledEventUserAdd {} -#[derive(Debug, Default, Deserialize, Serialize)] +#[derive(Debug, Default, Deserialize, Serialize, Clone)] /// See https://discord.com/developers/docs/topics/gateway-events#guild-scheduled-event-user-remove pub struct GuildScheduledEventUserRemove { pub guild_scheduled_event_id: String, diff --git a/src/types/events/heartbeat.rs b/src/types/events/heartbeat.rs index be9e3f8..b402ff9 100644 --- a/src/types/events/heartbeat.rs +++ b/src/types/events/heartbeat.rs @@ -9,7 +9,7 @@ pub struct GatewayHeartbeat { impl WebSocketEvent for GatewayHeartbeat {} -#[derive(Debug, Default, Deserialize, Serialize)] +#[derive(Debug, Default, Deserialize, Serialize, Clone)] pub struct GatewayHeartbeatAck { pub op: i32, } diff --git a/src/types/events/hello.rs b/src/types/events/hello.rs index 214f211..e370f9c 100644 --- a/src/types/events/hello.rs +++ b/src/types/events/hello.rs @@ -1,6 +1,7 @@ -use crate::types::events::WebSocketEvent; +use crate::types::WebSocketEvent; use serde::{Deserialize, Serialize}; +/// Received on gateway init, tells the client how often to send heartbeats; #[derive(Debug, Default, Deserialize, Serialize)] pub struct GatewayHello { pub op: i32, @@ -9,8 +10,11 @@ pub struct GatewayHello { impl WebSocketEvent for GatewayHello {} -#[derive(Debug, Default, Deserialize, Serialize)] +#[derive(Debug, Default, Deserialize, Serialize, Clone)] +/// Contains info on how often the client should send heartbeats to the server; pub struct HelloData { + /// How often a client should send heartbeats, in milliseconds + // u128 because std used u128s for milliseconds pub heartbeat_interval: u128, } diff --git a/src/types/events/identify.rs b/src/types/events/identify.rs index c4b55f4..dcd3a8a 100644 --- a/src/types/events/identify.rs +++ b/src/types/events/identify.rs @@ -9,7 +9,8 @@ pub struct GatewayIdentifyPayload { #[serde(skip_serializing_if = "Option::is_none")] pub compress: Option, #[serde(skip_serializing_if = "Option::is_none")] - pub large_threshold: Option, //default: 50 + pub large_threshold: Option, + //default: 50 #[serde(skip_serializing_if = "Option::is_none")] pub shard: Option>, #[serde(skip_serializing_if = "Option::is_none")] @@ -65,7 +66,7 @@ impl GatewayIdentifyPayload { impl WebSocketEvent for GatewayIdentifyPayload {} -#[derive(Debug, Deserialize, Serialize)] +#[derive(Debug, Deserialize, Serialize, Clone)] #[serde_as] pub struct GatewayIdentifyConnectionProps { /// Almost always sent diff --git a/src/types/events/integration.rs b/src/types/events/integration.rs index 6569a72..9a38e83 100644 --- a/src/types/events/integration.rs +++ b/src/types/events/integration.rs @@ -2,7 +2,7 @@ use serde::{Deserialize, Serialize}; use crate::types::{Integration, WebSocketEvent}; -#[derive(Debug, Default, Deserialize, Serialize)] +#[derive(Debug, Default, Deserialize, Serialize, Clone)] /// See https://discord.com/developers/docs/topics/gateway-events#integration-create pub struct IntegrationCreate { #[serde(flatten)] @@ -12,7 +12,7 @@ pub struct IntegrationCreate { impl WebSocketEvent for IntegrationCreate {} -#[derive(Debug, Default, Deserialize, Serialize)] +#[derive(Debug, Default, Deserialize, Serialize, Clone)] /// See https://discord.com/developers/docs/topics/gateway-events#integration-update pub struct IntegrationUpdate { #[serde(flatten)] @@ -22,7 +22,7 @@ pub struct IntegrationUpdate { impl WebSocketEvent for IntegrationUpdate {} -#[derive(Debug, Default, Deserialize, Serialize)] +#[derive(Debug, Default, Deserialize, Serialize, Clone)] /// See https://discord.com/developers/docs/topics/gateway-events#integration-delete pub struct IntegrationDelete { pub id: String, diff --git a/src/types/events/interaction.rs b/src/types/events/interaction.rs index 51513a3..e77ee7c 100644 --- a/src/types/events/interaction.rs +++ b/src/types/events/interaction.rs @@ -2,7 +2,7 @@ use serde::{Deserialize, Serialize}; use crate::types::{Interaction, WebSocketEvent}; -#[derive(Debug, Default, Deserialize, Serialize)] +#[derive(Debug, Default, Deserialize, Serialize, Clone)] /// See https://discord.com/developers/docs/topics/gateway-events#interaction-create pub struct InteractionCreate { #[serde(flatten)] diff --git a/src/types/events/invite.rs b/src/types/events/invite.rs index 4eb31a7..fc6c80d 100644 --- a/src/types/events/invite.rs +++ b/src/types/events/invite.rs @@ -2,7 +2,7 @@ use serde::{Deserialize, Serialize}; use crate::types::{GuildInvite, WebSocketEvent}; -#[derive(Debug, Default, Deserialize, Serialize)] +#[derive(Debug, Default, Deserialize, Serialize, Clone)] /// See https://discord.com/developers/docs/topics/gateway-events#invite-create pub struct InviteCreate { #[serde(flatten)] @@ -11,7 +11,7 @@ pub struct InviteCreate { impl WebSocketEvent for InviteCreate {} -#[derive(Debug, Default, Deserialize, Serialize)] +#[derive(Debug, Default, Deserialize, Serialize, Clone)] /// See https://discord.com/developers/docs/topics/gateway-events#invite-delete pub struct InviteDelete { pub channel_id: String, diff --git a/src/types/events/lazy_request.rs b/src/types/events/lazy_request.rs index 2bf3038..0cbea8a 100644 --- a/src/types/events/lazy_request.rs +++ b/src/types/events/lazy_request.rs @@ -4,7 +4,7 @@ use serde::{Deserialize, Serialize}; use super::WebSocketEvent; -#[derive(Debug, Deserialize, Serialize, Default)] +#[derive(Debug, Deserialize, Serialize, Default, Clone)] /// Officially Undocumented /// /// Sent to the server to signify lazy loading of a guild; @@ -24,4 +24,5 @@ pub struct LazyRequest { #[serde(skip_serializing_if = "Option::is_none")] pub channels: Option>>>, } + impl WebSocketEvent for LazyRequest {} diff --git a/src/types/events/message.rs b/src/types/events/message.rs index ef3e900..f4f8115 100644 --- a/src/types/events/message.rs +++ b/src/types/events/message.rs @@ -4,7 +4,7 @@ use crate::types::entities::{Emoji, GuildMember, Message, PublicUser}; use super::WebSocketEvent; -#[derive(Debug, Deserialize, Serialize, Default)] +#[derive(Debug, Deserialize, Serialize, Default, Clone)] pub struct TypingStartEvent { pub channel_id: String, pub guild_id: Option, @@ -15,7 +15,7 @@ pub struct TypingStartEvent { impl WebSocketEvent for TypingStartEvent {} -#[derive(Debug, Serialize, Deserialize, Default)] +#[derive(Debug, Serialize, Deserialize, Default, Clone)] /// See https://discord.com/developers/docs/topics/gateway-events#message-create pub struct MessageCreate { #[serde(flatten)] @@ -25,7 +25,7 @@ pub struct MessageCreate { mentions: Option>, } -#[derive(Debug, Serialize, Deserialize, Default)] +#[derive(Debug, Serialize, Deserialize, Default, Clone)] /// See https://discord.com/developers/docs/topics/gateway-events#message-create-message-create-extra-fields pub struct MessageCreateUser { #[serde(flatten)] @@ -35,7 +35,7 @@ pub struct MessageCreateUser { impl WebSocketEvent for MessageCreate {} -#[derive(Debug, Serialize, Deserialize, Default)] +#[derive(Debug, Serialize, Deserialize, Default, Clone)] pub struct MessageUpdate { #[serde(flatten)] message: Message, @@ -46,7 +46,7 @@ pub struct MessageUpdate { impl WebSocketEvent for MessageUpdate {} -#[derive(Debug, Serialize, Deserialize, Default)] +#[derive(Debug, Serialize, Deserialize, Default, Clone)] pub struct MessageDelete { id: String, channel_id: String, @@ -55,7 +55,7 @@ pub struct MessageDelete { impl WebSocketEvent for MessageDelete {} -#[derive(Debug, Serialize, Deserialize, Default)] +#[derive(Debug, Serialize, Deserialize, Default, Clone)] pub struct MessageDeleteBulk { ids: Vec, channel_id: String, @@ -64,7 +64,7 @@ pub struct MessageDeleteBulk { impl WebSocketEvent for MessageDeleteBulk {} -#[derive(Debug, Serialize, Deserialize, Default)] +#[derive(Debug, Serialize, Deserialize, Default, Clone)] pub struct MessageReactionAdd { user_id: String, channel_id: String, @@ -76,7 +76,7 @@ pub struct MessageReactionAdd { impl WebSocketEvent for MessageReactionAdd {} -#[derive(Debug, Serialize, Deserialize, Default)] +#[derive(Debug, Serialize, Deserialize, Default, Clone)] pub struct MessageReactionRemove { user_id: String, channel_id: String, @@ -87,7 +87,7 @@ pub struct MessageReactionRemove { impl WebSocketEvent for MessageReactionRemove {} -#[derive(Debug, Serialize, Deserialize, Default)] +#[derive(Debug, Serialize, Deserialize, Default, Clone)] pub struct MessageReactionRemoveAll { channel_id: String, message_id: String, @@ -96,7 +96,7 @@ pub struct MessageReactionRemoveAll { impl WebSocketEvent for MessageReactionRemoveAll {} -#[derive(Debug, Serialize, Deserialize, Default)] +#[derive(Debug, Serialize, Deserialize, Default, Clone)] pub struct MessageReactionRemoveEmoji { channel_id: String, message_id: String, @@ -106,7 +106,7 @@ pub struct MessageReactionRemoveEmoji { impl WebSocketEvent for MessageReactionRemoveEmoji {} -#[derive(Debug, Deserialize, Serialize, Default)] +#[derive(Debug, Deserialize, Serialize, Default, Clone)] /// Officially Undocumented /// /// Not documented anywhere unofficially @@ -126,4 +126,5 @@ pub struct MessageACK { pub flags: Option, pub channel_id: String, } + impl WebSocketEvent for MessageACK {} diff --git a/src/types/events/mod.rs b/src/types/events/mod.rs index 2889e6d..6333544 100644 --- a/src/types/events/mod.rs +++ b/src/types/events/mod.rs @@ -1,31 +1,5 @@ use serde::{Deserialize, Serialize}; -mod application; -mod auto_moderation; -mod call; -mod channel; -mod guild; -mod heartbeat; -mod hello; -mod identify; -mod integration; -mod interaction; -mod invite; -mod lazy_request; -mod message; -mod passive_update; -mod presence; -mod ready; -mod relationship; -mod request_members; -mod resume; -mod session; -mod stage_instance; -mod thread; -mod user; -mod voice; -mod webhooks; - pub use application::*; pub use auto_moderation::*; pub use call::*; @@ -52,6 +26,32 @@ pub use user::*; pub use voice::*; pub use webhooks::*; +mod application; +mod auto_moderation; +mod call; +mod channel; +mod guild; +mod heartbeat; +mod hello; +mod identify; +mod integration; +mod interaction; +mod invite; +mod lazy_request; +mod message; +mod passive_update; +mod presence; +mod ready; +mod relationship; +mod request_members; +mod resume; +mod session; +mod stage_instance; +mod thread; +mod user; +mod voice; +mod webhooks; + pub trait WebSocketEvent {} #[derive(Debug, Default, Serialize, Clone)] @@ -79,7 +79,6 @@ impl WebSocketEvent for GatewaySendPayload {} /// /// Similar to [GatewaySendPayload], except we send a [Value] for d whilst we receive a [serde_json::value::RawValue] /// Also, we never need to sent the event name - pub struct GatewayReceivePayload<'a> { #[serde(rename = "op")] pub op_code: u8, diff --git a/src/types/events/presence.rs b/src/types/events/presence.rs index dd49fde..93afbf5 100644 --- a/src/types/events/presence.rs +++ b/src/types/events/presence.rs @@ -1,14 +1,27 @@ -use crate::types::events::WebSocketEvent; -use crate::types::interfaces::Activity; -use crate::types::PublicUser; +use crate::types::{events::WebSocketEvent, UserStatus}; +use crate::types::{Activity, PublicUser, Snowflake}; use serde::{Deserialize, Serialize}; #[derive(Debug, Deserialize, Serialize, Default, Clone)] +/// Sent by the client to update its status and presence; +/// See https://discord.com/developers/docs/topics/gateway-events#update-presence +pub struct UpdatePresence { + /// unix time of when the client went idle, or none if client is not idle + pub since: Option, + /// the client's status (online, invisible, offline, dnd, idle..) + pub status: UserStatus, + pub activities: Vec, + pub afk: bool, +} + +#[derive(Debug, Deserialize, Serialize, Default, Clone)] +/// Received to tell the client that a user updated their presence / status /// See https://discord.com/developers/docs/topics/gateway-events#presence-update-presence-update-event-fields pub struct PresenceUpdate { pub user: PublicUser, - pub guild_id: Option, - pub status: String, + #[serde(default)] + pub guild_id: Option, + pub status: UserStatus, pub activities: Vec, pub client_status: ClientStatusObject, } diff --git a/src/types/events/ready.rs b/src/types/events/ready.rs index c559f0b..9b6eab9 100644 --- a/src/types/events/ready.rs +++ b/src/types/events/ready.rs @@ -1,13 +1,14 @@ +use serde::{Deserialize, Serialize}; + use crate::types::entities::{Guild, User}; use crate::types::events::{Session, WebSocketEvent}; use crate::types::interfaces::ClientStatusObject; use crate::types::{Activity, GuildMember, PresenceUpdate, VoiceState}; -use serde::{Deserialize, Serialize}; -#[derive(Debug, Deserialize, Serialize, Default)] -/// Sort of documented, though most fields are left out -/// For a full example see https://gist.github.com/kozabrada123/a347002b1fb8825a5727e40746d4e199 -/// to:do add all undocumented fields +#[derive(Debug, Deserialize, Serialize, Default, Clone)] +/// 1/2 half documented; +/// Received after identifying, provides initial user info; +/// See https://discord.com/developers/docs/topics/gateway-events#ready; pub struct GatewayReady { pub analytics_token: Option, pub auth_session_id_hash: Option, @@ -27,10 +28,9 @@ pub struct GatewayReady { impl WebSocketEvent for GatewayReady {} -#[derive(Debug, Deserialize, Serialize, Default)] -/// Officially Undocumented -/// Sent after the READY event when a client is a user -/// {"t":"READY_SUPPLEMENTAL","s":2,"op":0,"d":{"merged_presences":{"guilds":[[{"user_id":"463640391196082177","status":"online","game":null,"client_status":{"web":"online"},"activities":[]}]],"friends":[{"user_id":"463640391196082177","status":"online","last_modified":1684053508443,"client_status":{"web":"online"},"activities":[]}]},"merged_members":[[{"user_id":"463640391196082177","roles":[],"premium_since":null,"pending":false,"nick":"pog","mute":false,"joined_at":"2021-05-30T15:24:08.763000+00:00","flags":0,"deaf":false,"communication_disabled_until":null,"avatar":null}]],"lazy_private_channels":[],"guilds":[{"voice_states":[],"id":"848582562217590824","embedded_activities":[]}],"disclose":["pomelo"]}} +#[derive(Debug, Deserialize, Serialize, Default, Clone)] +/// Officially Undocumented; +/// Sent after the READY event when a client is a user, seems to somehow add onto the ready event; pub struct GatewayReadySupplemental { pub merged_presences: MergedPresences, pub merged_members: Vec>, @@ -43,13 +43,13 @@ pub struct GatewayReadySupplemental { impl WebSocketEvent for GatewayReadySupplemental {} -#[derive(Debug, Deserialize, Serialize, Default)] +#[derive(Debug, Deserialize, Serialize, Default, Clone)] pub struct MergedPresences { pub guilds: Vec>, pub friends: Vec, } -#[derive(Debug, Deserialize, Serialize, Default)] +#[derive(Debug, Deserialize, Serialize, Default, Clone)] pub struct MergedPresenceFriend { pub user_id: String, pub status: String, @@ -59,7 +59,7 @@ pub struct MergedPresenceFriend { pub activities: Vec, } -#[derive(Debug, Deserialize, Serialize, Default)] +#[derive(Debug, Deserialize, Serialize, Default, Clone)] pub struct MergedPresenceGuild { pub user_id: String, pub status: String, @@ -69,7 +69,7 @@ pub struct MergedPresenceGuild { pub activities: Vec, } -#[derive(Debug, Deserialize, Serialize, Default)] +#[derive(Debug, Deserialize, Serialize, Default, Clone)] pub struct SupplementalGuild { pub voice_states: Option>, pub id: String, diff --git a/src/types/events/relationship.rs b/src/types/events/relationship.rs index c9b79c0..441c74a 100644 --- a/src/types/events/relationship.rs +++ b/src/types/events/relationship.rs @@ -11,7 +11,7 @@ pub struct RelationshipAdd { impl WebSocketEvent for RelationshipAdd {} -#[derive(Debug, Deserialize, Serialize, Default)] +#[derive(Debug, Deserialize, Serialize, Default, Clone)] /// See https://github.com/spacebarchat/server/issues/203 pub struct RelationshipRemove { pub id: Snowflake, diff --git a/src/types/events/session.rs b/src/types/events/session.rs index 26364d9..574c5fa 100644 --- a/src/types/events/session.rs +++ b/src/types/events/session.rs @@ -2,7 +2,7 @@ use serde::{Deserialize, Serialize}; use crate::types::{Activity, WebSocketEvent}; -#[derive(Debug, Deserialize, Serialize, Default)] +#[derive(Debug, Deserialize, Serialize, Default, Clone)] /// Officially Undocumented /// Seems like it sends active session info to users on connect /// [{"activities":[],"client_info":{"client":"web","os":"other","version":0},"session_id":"ab5941b50d818b1f8d93b4b1b581b192","status":"online"}] @@ -10,7 +10,7 @@ pub struct SessionsReplace { pub sessions: Vec, } -#[derive(Debug, Deserialize, Serialize, Default)] +#[derive(Debug, Deserialize, Serialize, Default, Clone)] /// Session info for the current user pub struct Session { pub activities: Vec, @@ -19,7 +19,7 @@ pub struct Session { pub status: String, } -#[derive(Debug, Deserialize, Serialize, Default)] +#[derive(Debug, Deserialize, Serialize, Default, Clone)] /// Another Client info object /// {"client":"web","os":"other","version":0} // Note: I don't think this one exists yet? Though I might've made a mistake and this might be a duplicate diff --git a/src/types/events/stage_instance.rs b/src/types/events/stage_instance.rs index ea215f9..0fe487b 100644 --- a/src/types/events/stage_instance.rs +++ b/src/types/events/stage_instance.rs @@ -2,7 +2,7 @@ use serde::{Deserialize, Serialize}; use crate::types::{StageInstance, WebSocketEvent}; -#[derive(Debug, Deserialize, Serialize, Default)] +#[derive(Debug, Deserialize, Serialize, Default, Clone)] /// See https://discord.com/developers/docs/topics/gateway-events#stage-instance-create pub struct StageInstanceCreate { #[serde(flatten)] @@ -11,7 +11,7 @@ pub struct StageInstanceCreate { impl WebSocketEvent for StageInstanceCreate {} -#[derive(Debug, Deserialize, Serialize, Default)] +#[derive(Debug, Deserialize, Serialize, Default, Clone)] /// See https://discord.com/developers/docs/topics/gateway-events#stage-instance-update pub struct StageInstanceUpdate { #[serde(flatten)] @@ -20,7 +20,7 @@ pub struct StageInstanceUpdate { impl WebSocketEvent for StageInstanceUpdate {} -#[derive(Debug, Deserialize, Serialize, Default)] +#[derive(Debug, Deserialize, Serialize, Default, Clone)] /// See https://discord.com/developers/docs/topics/gateway-events#stage-instance-delete pub struct StageInstanceDelete { #[serde(flatten)] diff --git a/src/types/events/thread.rs b/src/types/events/thread.rs index 0cc5f91..88684ac 100644 --- a/src/types/events/thread.rs +++ b/src/types/events/thread.rs @@ -1,8 +1,9 @@ -use crate::types::entities::{Channel, ThreadMember}; -use crate::types::events::WebSocketEvent; use serde::{Deserialize, Serialize}; -#[derive(Debug, Default, Deserialize, Serialize)] +use crate::types::entities::{Channel, ThreadMember}; +use crate::types::events::WebSocketEvent; + +#[derive(Debug, Default, Deserialize, Serialize, Clone)] /// See https://discord.com/developers/docs/topics/gateway-events#thread-create pub struct ThreadCreate { #[serde(flatten)] @@ -11,7 +12,7 @@ pub struct ThreadCreate { impl WebSocketEvent for ThreadCreate {} -#[derive(Debug, Default, Deserialize, Serialize)] +#[derive(Debug, Default, Deserialize, Serialize, Clone)] /// See https://discord.com/developers/docs/topics/gateway-events#thread-update pub struct ThreadUpdate { #[serde(flatten)] @@ -20,7 +21,7 @@ pub struct ThreadUpdate { impl WebSocketEvent for ThreadUpdate {} -#[derive(Debug, Default, Deserialize, Serialize)] +#[derive(Debug, Default, Deserialize, Serialize, Clone)] /// See https://discord.com/developers/docs/topics/gateway-events#thread-delete pub struct ThreadDelete { #[serde(flatten)] @@ -29,7 +30,7 @@ pub struct ThreadDelete { impl WebSocketEvent for ThreadDelete {} -#[derive(Debug, Default, Deserialize, Serialize)] +#[derive(Debug, Default, Deserialize, Serialize, Clone)] /// See https://discord.com/developers/docs/topics/gateway-events#thread-list-sync pub struct ThreadListSync { pub guild_id: String, @@ -40,7 +41,7 @@ pub struct ThreadListSync { impl WebSocketEvent for ThreadListSync {} -#[derive(Debug, Default, Deserialize, Serialize)] +#[derive(Debug, Default, Deserialize, Serialize, Clone)] /// See https://discord.com/developers/docs/topics/gateway-events#thread-member-update /// The inner payload is a thread member object with an extra field. pub struct ThreadMemberUpdate { @@ -51,7 +52,7 @@ pub struct ThreadMemberUpdate { impl WebSocketEvent for ThreadMemberUpdate {} -#[derive(Debug, Default, Deserialize, Serialize)] +#[derive(Debug, Default, Deserialize, Serialize, Clone)] /// See https://discord.com/developers/docs/topics/gateway-events#thread-members-update pub struct ThreadMembersUpdate { pub id: String, diff --git a/src/types/events/user.rs b/src/types/events/user.rs index cfdae5c..18c8511 100644 --- a/src/types/events/user.rs +++ b/src/types/events/user.rs @@ -1,10 +1,12 @@ +use serde::{Deserialize, Serialize}; + use crate::types::entities::PublicUser; use crate::types::events::WebSocketEvent; use crate::types::utils::Snowflake; -use serde::{Deserialize, Serialize}; -#[derive(Debug, Default, Deserialize, Serialize)] -/// See https://discord.com/developers/docs/topics/gateway-events#user-update +#[derive(Debug, Default, Deserialize, Serialize, Clone)] +/// See https://discord.com/developers/docs/topics/gateway-events#user-update; +/// Sent to indicate updates to a user object; (name changes, discriminator changes, etc); pub struct UserUpdate { #[serde(flatten)] pub user: PublicUser, @@ -12,12 +14,12 @@ pub struct UserUpdate { impl WebSocketEvent for UserUpdate {} -#[derive(Debug, Default, Deserialize, Serialize)] -/// Undocumented +#[derive(Debug, Default, Deserialize, Serialize, Clone)] +/// Undocumented; /// -/// Possibly an update for muted guild / channel settings for the current user +/// Possibly an update for muted guild / channel settings for the current user; /// -/// {"version":2,"suppress_roles":false,"suppress_everyone":false,"notify_highlights":0,"muted":false,"mute_scheduled_events":false,"mute_config":null,"mobile_push":true,"message_notifications":1,"hide_muted_channels":false,"guild_id":"848582562217590824","flags":0,"channel_overrides":[{"muted":false,"mute_config":null,"message_notifications":3,"flags":4096,"collapsed":false,"channel_id":"1042689182893604885"}]} +/// Ex: {"version":2,"suppress_roles":false,"suppress_everyone":false,"notify_highlights":0,"muted":false,"mute_scheduled_events":false,"mute_config":null,"mobile_push":true,"message_notifications":1,"hide_muted_channels":false,"guild_id":"848582562217590824","flags":0,"channel_overrides":[{"muted":false,"mute_config":null,"message_notifications":3,"flags":4096,"collapsed":false,"channel_id":"1042689182893604885"}]} pub struct UserGuildSettingsUpdate { pub version: u8, pub suppress_roles: bool, @@ -37,12 +39,12 @@ pub struct UserGuildSettingsUpdate { impl WebSocketEvent for UserGuildSettingsUpdate {} -#[derive(Debug, Default, Deserialize, Serialize)] -/// Undocumented +#[derive(Debug, Default, Deserialize, Serialize, Clone)] +/// Undocumented; /// -/// Received in [UserGuildSettingsUpdate] +/// Received in [UserGuildSettingsUpdate]; /// -/// {"muted":false,"mute_config":null,"message_notifications":3,"flags":4096,"collapsed":false,"channel_id":"1042689182893604885"} +/// Ex: {"muted":false,"mute_config":null,"message_notifications":3,"flags":4096,"collapsed":false,"channel_id":"1042689182893604885"} pub struct UserGuildSettingsChannelOverride { pub muted: bool, /// ?? diff --git a/src/types/events/voice.rs b/src/types/events/voice.rs index 8af9c66..e896393 100644 --- a/src/types/events/voice.rs +++ b/src/types/events/voice.rs @@ -2,11 +2,10 @@ use crate::types::{events::WebSocketEvent, VoiceState}; use serde::{Deserialize, Serialize}; #[derive(Debug, Deserialize, Serialize, Default)] -/// See https://discord.com/developers/docs/topics/gateway-events#update-voice-state /// -/// Sent to the server +/// Sent to the server to indicate an update of the voice state (leave voice channel, join voice channel, mute, deafen); /// -/// Not to be confused with [VoiceStateUpdate] +/// Not to be confused with [VoiceStateUpdate]; pub struct UpdateVoiceState { pub guild_id: Option, pub channel_id: Option, @@ -16,12 +15,12 @@ pub struct UpdateVoiceState { impl WebSocketEvent for UpdateVoiceState {} -#[derive(Debug, Deserialize, Serialize, Default)] -/// See https://discord.com/developers/docs/topics/gateway-events#voice-state-update +#[derive(Debug, Deserialize, Serialize, Default, Clone)] +/// See https://discord.com/developers/docs/topics/gateway-events#voice-state-update; /// -/// Received from the server +/// Received from the server to indicate an update in a user's voice state (leave voice channel, join voice channel, mute, deafen, etc); /// -/// Not to be confused with [UpdateVoiceState] +/// Not to be confused with [UpdateVoiceState]; pub struct VoiceStateUpdate { #[serde(flatten)] pub state: VoiceState, @@ -29,8 +28,10 @@ pub struct VoiceStateUpdate { impl WebSocketEvent for VoiceStateUpdate {} -#[derive(Debug, Deserialize, Serialize, Default)] -/// See https://discord.com/developers/docs/topics/gateway-events#voice-server-update +#[derive(Debug, Deserialize, Serialize, Default, Clone)] +/// See https://discord.com/developers/docs/topics/gateway-events#voice-server-update; +/// +/// Received to indicate which voice endpoint, token and guild_id to use; pub struct VoiceServerUpdate { pub token: String, pub guild_id: String, diff --git a/src/types/events/webhooks.rs b/src/types/events/webhooks.rs index b88e1ee..3a93c60 100644 --- a/src/types/events/webhooks.rs +++ b/src/types/events/webhooks.rs @@ -2,7 +2,7 @@ use serde::{Deserialize, Serialize}; use super::WebSocketEvent; -#[derive(Debug, Deserialize, Serialize, Default)] +#[derive(Debug, Deserialize, Serialize, Default, Clone)] /// See https://discord.com/developers/docs/topics/gateway-events#webhooks-update pub struct WebhooksUpdate { pub guild_id: String, diff --git a/src/types/interfaces/activity.rs b/src/types/interfaces/activity.rs index 42ecc43..94a7168 100644 --- a/src/types/interfaces/activity.rs +++ b/src/types/interfaces/activity.rs @@ -1,6 +1,7 @@ -use crate::types::entities::Emoji; use serde::{Deserialize, Serialize}; +use crate::types::entities::Emoji; + #[derive(Debug, Deserialize, Serialize, Clone)] pub struct Activity { name: String, diff --git a/src/types/interfaces/guild_welcome_screen.rs b/src/types/interfaces/guild_welcome_screen.rs index 0260ab3..4912a78 100644 --- a/src/types/interfaces/guild_welcome_screen.rs +++ b/src/types/interfaces/guild_welcome_screen.rs @@ -1,6 +1,7 @@ -use crate::types::utils::Snowflake; use serde::{Deserialize, Serialize}; +use crate::types::utils::Snowflake; + #[derive(Serialize, Deserialize, Debug, Default, Clone, PartialEq)] pub struct WelcomeScreenObject { pub enabled: bool, diff --git a/src/types/interfaces/interaction.rs b/src/types/interfaces/interaction.rs index 0827078..dd131c8 100644 --- a/src/types/interfaces/interaction.rs +++ b/src/types/interfaces/interaction.rs @@ -1,8 +1,9 @@ -use crate::types::entities::{AllowedMention, Embed}; -use crate::types::utils::Snowflake; use serde::{Deserialize, Serialize}; use serde_json::Value; +use crate::types::entities::{AllowedMention, Embed}; +use crate::types::utils::Snowflake; + #[derive(Debug, Default, Clone, PartialEq, Serialize, Deserialize)] pub struct Interaction { pub id: Snowflake, diff --git a/src/types/interfaces/mod.rs b/src/types/interfaces/mod.rs index 0f99ae2..946eb39 100644 --- a/src/types/interfaces/mod.rs +++ b/src/types/interfaces/mod.rs @@ -1,11 +1,11 @@ -mod activity; -mod connected_account; -mod guild_welcome_screen; -mod interaction; -mod status; - pub use activity::*; pub use connected_account::*; pub use guild_welcome_screen::*; pub use interaction::*; pub use status::*; + +mod activity; +mod connected_account; +mod guild_welcome_screen; +mod interaction; +mod status; diff --git a/src/types/schema/auth.rs b/src/types/schema/auth.rs index 68c4546..fc7a1ad 100644 --- a/src/types/schema/auth.rs +++ b/src/types/schema/auth.rs @@ -1,7 +1,8 @@ -use crate::errors::FieldFormatError; use regex::Regex; use serde::{Deserialize, Serialize}; +use crate::errors::FieldFormatError; + /** A struct that represents a well-formed email address. */ @@ -100,7 +101,6 @@ You will receive a [`FieldFormatError`], if: - The username is not between 2 and 32 characters. - The password is not between 1 and 72 characters. */ - #[derive(Debug, Serialize, Deserialize, PartialEq, Eq)] #[serde(rename_all = "snake_case")] pub struct RegisterSchema { diff --git a/src/types/schema/guild.rs b/src/types/schema/guild.rs index 835f6ad..cb0dac8 100644 --- a/src/types/schema/guild.rs +++ b/src/types/schema/guild.rs @@ -1,6 +1,7 @@ -use crate::types::entities::Channel; use serde::{Deserialize, Serialize}; +use crate::types::entities::Channel; + #[derive(Debug, Deserialize, Serialize)] #[serde(rename_all = "snake_case")] /// Represents the schema which needs to be sent to create a Guild. diff --git a/src/types/schema/message.rs b/src/types/schema/message.rs index 6121f5f..7ff27f1 100644 --- a/src/types/schema/message.rs +++ b/src/types/schema/message.rs @@ -1,7 +1,8 @@ +use serde::{Deserialize, Serialize}; + use crate::types::entities::{ AllowedMention, Component, Embed, MessageReference, PartialDiscordFileAttachment, }; -use serde::{Deserialize, Serialize}; #[derive(Debug, Deserialize, Serialize)] #[serde(rename_all = "snake_case")] diff --git a/src/types/schema/mod.rs b/src/types/schema/mod.rs index 2e5c4f0..53795ec 100644 --- a/src/types/schema/mod.rs +++ b/src/types/schema/mod.rs @@ -1,11 +1,3 @@ -mod apierror; -mod auth; -mod channel; -mod guild; -mod message; -mod role; -mod user; - pub use apierror::*; pub use auth::*; pub use channel::*; @@ -14,11 +6,20 @@ pub use message::*; pub use role::*; pub use user::*; +mod apierror; +mod auth; +mod channel; +mod guild; +mod message; +mod role; +mod user; + #[cfg(test)] mod schemas_tests { - use super::*; use crate::errors::FieldFormatError; + use super::*; + #[test] fn password_too_short() { assert_eq!( diff --git a/src/types/schema/role.rs b/src/types/schema/role.rs index 65faa39..4ae300d 100644 --- a/src/types/schema/role.rs +++ b/src/types/schema/role.rs @@ -1,4 +1,3 @@ -use crate::types::Snowflake; use serde::{Deserialize, Serialize}; #[derive(Debug, Deserialize, Serialize)] diff --git a/src/types/utils/mod.rs b/src/types/utils/mod.rs index ec2fd4a..7fd199f 100644 --- a/src/types/utils/mod.rs +++ b/src/types/utils/mod.rs @@ -1,8 +1,8 @@ +pub use regexes::*; +pub use rights::Rights; +pub use snowflake::{DeconstructedSnowflake, Snowflake}; + pub mod jwt; mod regexes; mod rights; mod snowflake; - -pub use regexes::*; -pub use rights::Rights; -pub use snowflake::{DeconstructedSnowflake, Snowflake}; diff --git a/tests/auth.rs b/tests/auth.rs index e80849a..24abefc 100644 --- a/tests/auth.rs +++ b/tests/auth.rs @@ -1,6 +1,7 @@ -mod common; use chorus::types; +mod common; + #[tokio::test] async fn test_registration() { let mut bundle = common::setup().await; diff --git a/tests/channel.rs b/tests/channel.rs index 8ae8e58..bd519b0 100644 --- a/tests/channel.rs +++ b/tests/channel.rs @@ -1,15 +1,16 @@ -mod common; use chorus::types::{self, Channel, PermissionFlags, PermissionOverwrite}; +mod common; + #[tokio::test] async fn get_channel() { let mut bundle = common::setup().await; let bundle_channel = bundle.channel.clone(); - let mut bundle_user = &mut bundle.user; + let bundle_user = &mut bundle.user; assert_eq!( bundle_channel, - Channel::get(&mut bundle_user, &bundle_channel.id.to_string(),) + Channel::get(bundle_user, &bundle_channel.id.to_string()) .await .unwrap() ); diff --git a/tests/gateway.rs b/tests/gateway.rs new file mode 100644 index 0000000..c6f46dd --- /dev/null +++ b/tests/gateway.rs @@ -0,0 +1,24 @@ +mod common; +use chorus::gateway::*; +use chorus::types; + +#[tokio::test] +/// Tests establishing a connection (hello and heartbeats) on the local gateway; +async fn test_gateway_establish() { + let bundle = common::setup().await; + + Gateway::new(bundle.urls.wss).await.unwrap(); +} + +#[tokio::test] +/// Tests establishing a connection and authenticating +async fn test_gateway_authenticate() { + let bundle = common::setup().await; + + let gateway = Gateway::new(bundle.urls.wss).await.unwrap(); + + let mut identify = types::GatewayIdentifyPayload::common(); + identify.token = bundle.user.token; + + gateway.send_identify(identify).await; +} diff --git a/tests/guild.rs b/tests/guild.rs index 8143532..3f7037c 100644 --- a/tests/guild.rs +++ b/tests/guild.rs @@ -1,6 +1,7 @@ -mod common; use chorus::types::{Guild, GuildCreateSchema}; +mod common; + #[tokio::test] async fn guild_creation_deletion() { let mut bundle = common::setup().await; diff --git a/tests/member.rs b/tests/member.rs index a19f5e0..c6fc6e3 100644 --- a/tests/member.rs +++ b/tests/member.rs @@ -7,7 +7,7 @@ async fn add_remove_role() { let role_id = &bundle.role.id.to_string(); let user_id = &bundle.user.object.id.to_string(); chorus::types::GuildMember::add_role(&mut bundle.user, guild_id, user_id, role_id).await; - let member = chorus::types::GuildMember::get(&mut bundle.user, &guild_id, &user_id) + let member = chorus::types::GuildMember::get(&mut bundle.user, guild_id, user_id) .await .unwrap(); let mut role_found = false; @@ -21,7 +21,7 @@ async fn add_remove_role() { assert!(false) } chorus::types::GuildMember::remove_role(&mut bundle.user, guild_id, user_id, role_id).await; - let member = chorus::types::GuildMember::get(&mut bundle.user, &guild_id, &user_id) + let member = chorus::types::GuildMember::get(&mut bundle.user, guild_id, user_id) .await .unwrap(); for role in member.roles.iter() { diff --git a/tests/message.rs b/tests/message.rs index 6ccda0b..d614538 100644 --- a/tests/message.rs +++ b/tests/message.rs @@ -1,9 +1,10 @@ -mod common; - -use chorus::types; use std::fs::File; use std::io::{BufReader, Read}; +use chorus::types; + +mod common; + #[tokio::test] async fn send_message() { let mut bundle = common::setup().await; diff --git a/tests/roles.rs b/tests/roles.rs index 2663d25..fd80de3 100644 --- a/tests/roles.rs +++ b/tests/roles.rs @@ -1,7 +1,7 @@ -mod common; - use chorus::types::{self, RoleCreateModifySchema}; +mod common; + #[tokio::test] async fn create_and_get_roles() { let mut bundle = common::setup().await;