initial implementaiton of login with discord, getting your own user info and websocket with auth

Author: AEnterprise

Cargo.lock

@@ -9,12 +9,18 @@ base64="0.13"
 darkredis = "0.7"
 flexi_logger = { version = "0.15", default-features = false, features = ["colors", "specfile", "ziplogs"] }
 futures-util = { version = "0.3", default-features = false }
-hyper = { version = "0.13" }
+form_urlencoded="1.0"
+hyper = { version = "0.13"}
+hyper-tls = "0.4"
 log = "0.4"
+rand="0.8"
+serde = { version = "1.0", features = ["derive"] }
+serde_json = "1"
+serde_urlencoded="0.7"
+sqlx =  { version = "0.4", default-features = false, features = ["postgres", "json", "runtime-tokio-rustls", "macros"] }
 sha-1 = "0.9"
 tokio = { version = "0.2", features = ["full", "sync", "time"] }
 tokio-tungstenite = "0.11.0"
 toml = "0.5"
-serde = { version = "1.0", features = ["derive"] }
-serde_json = "1"
+twilight-model = "0.2"
 uuid = { version = "0.8", features = ["serde", "v4"], default_features = false }

Cargo.toml

@@ -6,6 +6,11 @@ use std::fs;
 pub struct ApiConfig {
     pub redis: String,
     pub port: u16,
+    pub application_id: u64,
+    pub client_secret: String,
+    pub redirect_uri: String,
+    pub domain: String,
+    pub secure: bool
 }
 
 impl ApiConfig {

src/config.rs

@@ -1,6 +1,8 @@
 use hyper::StatusCode;
 use std::fmt;
 use tokio::sync::oneshot::error::RecvError;
+use std::fmt::Formatter;
+use std::borrow::Cow;
 
 #[derive(Debug)]
 pub enum StartupError {
@@ -29,14 +31,107 @@ pub enum CommunicationError {
 
 #[derive(Debug)]
 pub enum ServerError {
-    Hyper(hyper::http::Error),
+    HyperHttp(hyper::http::Error),
     Communication(CommunicationError),
+    Hyper(hyper::Error),
+    DiscordError(String),
+    Database(DatabaseError),
 }
 
 #[derive(Debug)]
 pub enum BadRequestError {
     UpgradeOnly,
     MissingWsKey,
+    NoAccessCode,
+}
+
+#[derive(Debug)]
+pub enum DatabaseError {
+    Sqlx(sqlx::Error),
+    Deserializing(serde_json::Error),
+    Serializing(serde_json::Error),
+    Darkredis(darkredis::Error),
+}
+
+#[derive(Debug)]
+pub enum WSMessageError {
+    Tungstenite(tokio_tungstenite::tungstenite::Error),
+    Database(DatabaseError),
+    Communication(CommunicationError),
+    CorruptMessage(serde_json::Error),
+    NotAuthorized,
+    BadAuthorization,
+    AlreadyAuthorized,
+    ClosedGracefully,
+}
+
+
+impl fmt::Display for WSMessageError {
+    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
+        match self {
+            WSMessageError::Tungstenite(e) => write!(f, "Tunstenite failure: {}", e),
+            WSMessageError::Database(e) => write!(f, "Failed to fetch database information: {}", e),
+            WSMessageError::Communication(e) => write!(f, "Failed to communicate with GearBot: {}", e),
+            WSMessageError::CorruptMessage(e) => write!(f, "Corrupt message recieved: {}", e),
+            WSMessageError::NotAuthorized => write!(f, "Someone didn't identify themselves"),
+            WSMessageError::BadAuthorization => write!(f, "Someone gave us an invalid token to try and identify"),
+            WSMessageError::AlreadyAuthorized => write!(f, "Someone double identified"),
+            WSMessageError::ClosedGracefully => write!(f, "Connection closed by client")
+        }
+    }
+}
+
+const CORRUPT_MESSAGE: &str = "Corrupt message recieved";
+const NOT_AUTHORIZED: &str = "You failed to identify yourself first, access denied!";
+const BAD_AUTHORIZATION: &str = "You failed to identify yourself first, access denied!";
+const ALREADY_AUTHORIZED: &str = "You can not identify twice!";
+const TUNGSTENITE: &str = "Unable to process message";
+
+impl WSMessageError {
+    pub fn closes_socket(&self) -> bool {
+        match self {
+            WSMessageError::Tungstenite(_) |
+            WSMessageError::CorruptMessage(_) |
+            WSMessageError::NotAuthorized |
+            WSMessageError::AlreadyAuthorized |
+            WSMessageError::BadAuthorization => true,
+            _ => false
+        }
+    }
+
+    pub fn get_close_message(&self) -> &'static str {
+        match self {
+            WSMessageError::CorruptMessage(_) => CORRUPT_MESSAGE,
+            WSMessageError::NotAuthorized => NOT_AUTHORIZED,
+            WSMessageError::BadAuthorization => BAD_AUTHORIZATION,
+            WSMessageError::AlreadyAuthorized => ALREADY_AUTHORIZED,
+            WSMessageError::Tungstenite(_) => TUNGSTENITE,
+            _ => unreachable!()
+        }
+    }
+}
+
+impl fmt::Display for DatabaseError {
+    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
+        match self {
+            DatabaseError::Sqlx(e) => write!(f, "Database failure: {:?}", e),
+            DatabaseError::Deserializing(e) => write!(f, "Failed to deserialize: {}", e),
+            DatabaseError::Serializing(e) => write!(f, "Failed to seralize: {}", e),
+            DatabaseError::Darkredis(e) => write!(f, "Redis failure: {}", e),
+        }
+    }
+}
+
+impl From<darkredis::Error> for DatabaseError {
+    fn from(e: darkredis::Error) -> Self {
+        DatabaseError::Darkredis(e)
+    }
+}
+
+impl From<sqlx::Error> for DatabaseError {
+    fn from(e: sqlx::Error) -> Self {
+        DatabaseError::Sqlx(e)
+    }
 }
 
 impl RequestError {
@@ -75,8 +170,11 @@ impl fmt::Display for StartupError {
 impl fmt::Display for ServerError {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         match self {
-            ServerError::Hyper(e) => write!(f, "Error assembling hyper response: {}", e),
+            ServerError::HyperHttp(e) => write!(f, "Error assembling hyper response: {}", e),
             ServerError::Communication(e) => write!(f, "Error communicating with GearBot: {}", e),
+            ServerError::Hyper(e) => write!(f, "Error making a request to the discord api: {}", e),
+            ServerError::Database(e) => write!(f, "Database error occured: {}", e),
+            ServerError::DiscordError(e) => write!(f, "Error making a request to discord: {}", e)
         }
     }
 }
@@ -107,7 +205,7 @@ impl fmt::Display for CommunicationError {
 
 impl From<hyper::http::Error> for RequestError {
     fn from(e: hyper::http::Error) -> Self {
-        RequestError::Server(ServerError::Hyper(e))
+        RequestError::Server(ServerError::HyperHttp(e))
     }
 }
 
@@ -140,3 +238,27 @@ impl From<BadRequestError> for RequestError {
         RequestError::BadRequest(e)
     }
 }
+
+impl From<hyper::Error> for RequestError {
+    fn from(e: hyper::Error) -> Self {
+        RequestError::Server(ServerError::Hyper(e))
+    }
+}
+
+impl From<DatabaseError> for RequestError {
+    fn from(e: DatabaseError) -> Self {
+        RequestError::Server(ServerError::Database(e))
+    }
+}
+
+impl From<DatabaseError> for WSMessageError {
+    fn from(e: DatabaseError) -> Self {
+        WSMessageError::Database(e)
+    }
+}
+
+impl From<CommunicationError> for WSMessageError {
+    fn from(e: CommunicationError) -> Self {
+        WSMessageError::Communication(e)
+    }
+}

src/error.rs

@@ -1,25 +1,33 @@
 use crate::config::ApiConfig;
 use crate::error::{RequestError, StartupError};
 use crate::redis::redis_link::RedisLink;
-use crate::routes::{hello_world, not_found, team_info, ws};
+use crate::routes::{hello_world, not_found, team_info, ws, discord::{login, auth, user_info}};
 use flexi_logger::{colored_opt_format, Age, Cleanup, Criterion, Duplicate, Logger, Naming};
 use hyper::header::ACCESS_CONTROL_ALLOW_ORIGIN;
 use hyper::service::{make_service_fn, service_fn};
-use hyper::{Body, Method, Request, Response, Server};
+use hyper::{Body, Method, Request, Response, Server, Client};
 use log::{error, info};
 use std::convert::Infallible;
 use std::env;
 use std::net::SocketAddr;
 use std::sync::Arc;
+use twilight_model::id::ApplicationId;
+use hyper_tls::HttpsConnector;
+use hyper_tls::native_tls::TlsConnector;
+use hyper::client::HttpConnector;
+
 
 mod config;
 mod error;
 mod redis;
 mod routes;
+mod models;
+mod util;
 
 pub struct ApiContext {
     pub config: ApiConfig,
     pub redis_link: RedisLink,
+    pub client: Client<HttpsConnector<HttpConnector>>,
 }
 
 #[tokio::main]
@@ -47,7 +55,9 @@ async fn main() -> Result<(), StartupError> {
     info!("Redis connection established");
 
     let port = config.port;
-    let api_context = Arc::new(ApiContext { config, redis_link });
+    let https = HttpsConnector::new();
+    let client = Client::builder().build::<_, hyper::Body>(https);
+    let api_context = Arc::new(ApiContext { config, redis_link, client });
     let addr = SocketAddr::from(([127, 0, 0, 1], port));
     let make_svc = make_service_fn(|_conn| {
         let context = api_context.clone();
@@ -86,10 +96,14 @@ async fn handle_request(
             .skip_while(|p| *p == "api")
             .collect::<Vec<&str>>();
         let method = Method::from(request.method());
+        let query = path_and_query.query();
         let response = match (&method, parts.as_slice()) {
             (&Method::GET, ["hello"]) => hello_world().await,
             (&Method::GET, ["team_info"]) => team_info(context).await,
             (&Method::GET, ["ws"]) => ws(context, request).await,
+            (&Method::GET, ["discord", "login"]) => login(context).await,
+            (&Method::GET, ["discord", "auth"]) => auth(context, query).await,
+            (&Method::GET, ["discord", "user"]) => user_info(context, request).await,
             _ => not_found(),
         };
 

src/main.rs

@@ -0,0 +1,5 @@
+mod token_response;
+pub use token_response::TokenResponse;
+
+mod user_guilds;
+pub use user_guilds::UserGuild;

src/models/mod.rs

@@ -0,0 +1,10 @@
+use serde::Deserialize;
+
+#[derive(Deserialize, Debug)]
+pub struct TokenResponse {
+    pub access_token: String,
+    pub token_type: String,
+    pub expires_in: u64,
+    pub refresh_token: String,
+    pub scope: String
+}

src/models/token_response.rs

@@ -0,0 +1,13 @@
+use twilight_model::id::GuildId;
+use twilight_model::guild::Permissions;
+use serde::{Deserialize, Serialize};
+
+#[derive(Debug, Deserialize, Serialize)]
+pub struct UserGuild {
+    pub id: GuildId,
+    pub name: String,
+    pub icon: Option<String>,
+    pub owner: bool,
+    pub permissions: Permissions,
+    pub features: Vec<String>
+}

src/models/user_guilds.rs

@@ -1,5 +1,6 @@
 use serde::{Deserialize, Serialize};
 use uuid::Uuid;
+use twilight_model::user::UserFlags;
 
 pub mod redis_link;
 
@@ -12,6 +13,7 @@ pub struct GearBotRequest {
 #[derive(Debug, Serialize, Deserialize)]
 pub enum Request {
     TeamInfo,
+    UserInfo(u64)
 }
 
 #[derive(Debug, Deserialize, Clone)]
@@ -24,6 +26,7 @@ pub struct Reply {
 pub enum ReplyData {
     Blank, //
     TeamInfo(TeamInfo),
+    UserInfo(Option<UserInfo>)
 }
 
 #[derive(Debug, Serialize, Deserialize, Clone)]
@@ -51,6 +54,20 @@ pub struct TeamSocials {
     pub website: Option<String>,
 }
 
+#[derive(Debug, Serialize, Deserialize, Clone)]
+pub struct UserInfo {
+    pub name: String,
+    pub discriminator: String,
+    #[serde(default, skip_serializing_if = "is_default")]
+    pub avatar: Option<String>,
+    #[serde(default, skip_serializing_if = "is_default")]
+    pub bot_user: bool,
+    #[serde(default, skip_serializing_if = "is_default")]
+    pub system_user: bool,
+    #[serde(default, skip_serializing_if = "is_default")]
+    pub public_flags: Option<UserFlags>,
+}
+
 fn is_default<T: Default + PartialEq>(t: &T) -> bool {
     t == &T::default()
 }