refactor: remove quark/web

crates/delta/src/main.rs

@@ -8,8 +8,10 @@ extern crate serde_json;
 pub mod routes;
 pub mod util;
 
+use rocket_cors::{AllowedOrigins, CorsOptions};
 use rocket_prometheus::PrometheusMetrics;
 use std::net::Ipv4Addr;
+use std::str::FromStr;
 
 use async_std::channel::unbounded;
 use revolt_quark::authifier::{Authifier, AuthifierEvent};
@@ -62,7 +64,27 @@ async fn rocket() -> _ {
     async_std::task::spawn(revolt_quark::tasks::start_workers(legacy_db.clone()));
 
     // Configure CORS
-    let cors = revolt_quark::web::cors::new();
+    let cors = CorsOptions {
+        allowed_origins: AllowedOrigins::All,
+        allowed_methods: [
+            "Get", "Put", "Post", "Delete", "Options", "Head", "Trace", "Connect", "Patch",
+        ]
+        .iter()
+        .map(|s| FromStr::from_str(s).unwrap())
+        .collect(),
+        ..Default::default()
+    }
+    .to_cors()
+    .expect("Failed to create CORS.");
+
+    // Configure Swagger
+    let swagger = revolt_rocket_okapi::swagger_ui::make_swagger_ui(
+        &revolt_rocket_okapi::swagger_ui::SwaggerUIConfig {
+            url: "../openapi.json".to_owned(),
+            ..Default::default()
+        },
+    )
+    .into();
 
     // Configure Rocket
     let rocket = rocket::build();
@@ -71,14 +93,14 @@ async fn rocket() -> _ {
     routes::mount(rocket)
         .attach(prometheus.clone())
         .mount("/metrics", prometheus)
-        .mount("/", revolt_quark::web::cors::catch_all_options_routes())
-        .mount("/", revolt_quark::web::ratelimiter::routes())
-        .mount("/swagger/", revolt_quark::web::swagger::routes())
+        .mount("/", rocket_cors::catch_all_options_routes())
+        .mount("/", util::ratelimiter::routes())
+        .mount("/swagger/", swagger)
         .manage(authifier)
         .manage(db)
         .manage(legacy_db)
         .manage(cors.clone())
-        .attach(revolt_quark::web::ratelimiter::RatelimitFairing)
+        .attach(util::ratelimiter::RatelimitFairing)
         .attach(cors)
         .configure(rocket::Config {
             limits: rocket::data::Limits::default().limit("string", 5.megabytes()),

crates/delta/src/routes/channels/message_send.rs

@@ -1,8 +1,8 @@
+use revolt_database::util::idempotency::IdempotencyKey;
 use revolt_quark::{
     models::{message::DataMessageSend, Message, User},
     perms,
     types::push::MessageAuthor,
-    web::idempotency::IdempotencyKey,
     Db, Error, Permission, Ref, Result,
 };
 

crates/delta/src/routes/customisation/emoji_create.rs

@@ -1,3 +1,5 @@
+use once_cell::sync::Lazy;
+use regex::Regex;
 use revolt_quark::models::emoji::EmojiParent;
 use revolt_quark::models::{Emoji, File, User};
 use revolt_quark::variables::delta::MAX_EMOJI_COUNT;
@@ -5,10 +7,13 @@ use revolt_quark::{perms, Db, Error, Permission, Result};
 use serde::Deserialize;
 use validator::Validate;
 
-use crate::util::regex::RE_EMOJI;
-
 use rocket::serde::json::Json;
 
+/// Regex for valid emoji names
+///
+/// Alphanumeric and underscores
+pub static RE_EMOJI: Lazy<Regex> = Lazy::new(|| Regex::new(r"^[a-z0-9_]+$").unwrap());
+
 /// # Emoji Data
 #[derive(Validate, Deserialize, JsonSchema)]
 pub struct DataCreateEmoji {
@@ -57,7 +62,9 @@ pub async fn create_emoji(
             // ! FIXME: hardcoded upper limit
             let emojis = db.fetch_emoji_by_parent_id(&server.id).await?;
             if emojis.len() > *MAX_EMOJI_COUNT {
-                return Err(Error::TooManyEmoji { max: *MAX_EMOJI_COUNT });
+                return Err(Error::TooManyEmoji {
+                    max: *MAX_EMOJI_COUNT,
+                });
             }
         }
         EmojiParent::Detached => return Err(Error::InvalidOperation),

crates/delta/src/routes/onboard/complete.rs

@@ -1,4 +1,5 @@
-use crate::util::regex::RE_USERNAME;
+use once_cell::sync::Lazy;
+use regex::Regex;
 use revolt_database::{Database, User};
 use revolt_models::v0;
 use revolt_quark::authifier::models::Session;
@@ -8,6 +9,12 @@ use rocket::{serde::json::Json, State};
 use serde::{Deserialize, Serialize};
 use validator::Validate;
 
+/// Regex for valid usernames
+///
+/// Block zero width space
+/// Block lookalike characters
+pub static RE_USERNAME: Lazy<Regex> = Lazy::new(|| Regex::new(r"^(\p{L}|[\d_.-])+$").unwrap());
+
 /// # New User Data
 #[derive(Validate, Serialize, Deserialize, JsonSchema)]
 pub struct DataOnboard {

crates/delta/src/routes/users/change_username.rs

@@ -1,9 +1,16 @@
-use crate::util::regex::RE_USERNAME;
+use once_cell::sync::Lazy;
+use regex::Regex;
 use revolt_quark::{authifier::models::Account, models::User, Database, Error, Result};
 use rocket::{serde::json::Json, State};
 use serde::{Deserialize, Serialize};
 use validator::Validate;
 
+/// Regex for valid usernames
+///
+/// Block zero width space
+/// Block lookalike characters
+pub static RE_USERNAME: Lazy<Regex> = Lazy::new(|| Regex::new(r"^(\p{L}|[\d_.-])+$").unwrap());
+
 /// # Username Information
 #[derive(Validate, Serialize, Deserialize, JsonSchema)]
 pub struct DataChangeUsername {

crates/delta/src/routes/users/edit_user.rs

@@ -1,3 +1,5 @@
+use once_cell::sync::Lazy;
+use regex::Regex;
 use revolt_quark::models::user::{FieldsUser, PartialUser, User};
 use revolt_quark::models::File;
 use revolt_quark::{Database, Error, Ref, Result};
@@ -8,7 +10,11 @@ use rocket::State;
 use serde::{Deserialize, Serialize};
 use validator::Validate;
 
-use crate::util::regex::RE_DISPLAY_NAME;
+/// Regex for valid display names
+///
+/// Block zero width space
+/// Block newline and carriage return
+pub static RE_DISPLAY_NAME: Lazy<Regex> = Lazy::new(|| Regex::new(r"^[^\u200B\n\r]+$").unwrap());
 
 /// # Profile Data
 #[derive(Validate, Serialize, Deserialize, Debug, JsonSchema)]

crates/delta/src/routes/webhooks/webhook_execute.rs

@@ -1,8 +1,10 @@
-use revolt_database::{util::reference::Reference, Database};
+use revolt_database::{
+    util::{idempotency::IdempotencyKey, reference::Reference},
+    Database,
+};
 use revolt_quark::{
     models::message::{DataMessageSend, Message},
     types::push::MessageAuthor,
-    web::idempotency::IdempotencyKey,
     Db, Error, Result,
 };
 use rocket::{serde::json::Json, State};

crates/delta/src/util/mod.rs

@@ -1 +1 @@
-pub mod regex;
+pub mod ratelimiter;

crates/delta/src/util/ratelimiter.rs

@@ -0,0 +1,326 @@
+use std::collections::hash_map::DefaultHasher;
+use std::hash::Hasher;
+use std::ops::Add;
+use std::time::{Duration, SystemTime, UNIX_EPOCH};
+
+use revolt_quark::authifier::models::Session;
+use rocket::fairing::{Fairing, Info, Kind};
+use rocket::http::uri::Origin;
+use rocket::http::{Method, Status};
+use rocket::request::{FromRequest, Outcome};
+use rocket::serde::json::Json;
+use rocket::{Data, Request, Response};
+
+use revolt_rocket_okapi::gen::OpenApiGenerator;
+use revolt_rocket_okapi::request::{OpenApiFromRequest, RequestHeaderInput};
+
+use serde::Serialize;
+
+use dashmap::DashMap;
+use once_cell::sync::Lazy;
+
+/// Ratelimit Bucket
+#[derive(Clone, Copy, Debug)]
+struct Entry {
+    used: u8,
+    reset: u128,
+}
+
+static MAP: Lazy<DashMap<u64, Entry>> = Lazy::new(DashMap::new);
+
+/// Get the current time from Unix Epoch as a Duration
+fn now() -> Duration {
+    SystemTime::now()
+        .duration_since(UNIX_EPOCH)
+        .expect("Time went backwards...")
+}
+
+impl Entry {
+    /// Find bucket by its key
+    pub fn from(key: u64) -> Entry {
+        MAP.get(&key).map(|x| *x).unwrap_or_else(|| Entry {
+            used: 0,
+            reset: now().add(Duration::from_secs(10)).as_millis(),
+        })
+    }
+
+    /// Deduct one unit from the bucket and save
+    pub fn deduct(&mut self) {
+        let current_time = now().as_millis();
+        if current_time > self.reset {
+            self.used = 1;
+            self.reset = now().add(Duration::from_secs(10)).as_millis();
+        } else {
+            self.used += 1;
+        }
+    }
+
+    /// Save information
+    pub fn save(self, key: u64) {
+        MAP.insert(key, self);
+    }
+
+    /// Get remaining units in the bucket
+    pub fn get_remaining(&self, limit: u8) -> u8 {
+        if now().as_millis() > self.reset {
+            limit
+        } else {
+            limit - self.used
+        }
+    }
+
+    /// Get how long bucket has until reset
+    pub fn left_until_reset(&self) -> u128 {
+        let current_time = now().as_millis();
+        if current_time > self.reset {
+            0
+        } else {
+            self.reset - current_time
+        }
+    }
+}
+
+/// Ratelimit Guard
+#[derive(Serialize, Clone, Copy, Debug)]
+#[allow(dead_code)]
+pub struct Ratelimiter {
+    key: u64,
+    limit: u8,
+    remaining: u8,
+    reset: u128,
+}
+
+/// Find bucket from given request
+///
+/// Optionally, include a resource id to hash against.
+fn resolve_bucket<'r>(request: &'r rocket::Request<'_>) -> (&'r str, Option<&'r str>) {
+    if let Some(segment) = request.routed_segment(0) {
+        let resource = request.routed_segment(1);
+
+        let method = request.method();
+        match (segment, resource, method) {
+            ("users", target, Method::Patch) => ("user_edit", target),
+            ("users", _, _) => {
+                if let Some("default_avatar") = request.routed_segment(2) {
+                    return ("default_avatar", None);
+                }
+
+                ("users", None)
+            }
+            ("bots", _, _) => ("bots", None),
+            ("channels", Some(id), _) => {
+                if request.method() == Method::Post {
+                    if let Some("messages") = request.routed_segment(2) {
+                        return ("messaging", Some(id));
+                    }
+                }
+
+                ("channels", Some(id))
+            }
+            ("servers", Some(id), _) => ("servers", Some(id)),
+            ("auth", _, _) => {
+                if request.method() == Method::Delete {
+                    ("auth_delete", None)
+                } else {
+                    ("auth", None)
+                }
+            }
+            ("swagger", _, _) => ("swagger", None),
+            ("safety", Some("report"), _) => ("safety_report", Some("report")),
+            ("safety", _, _) => ("safety", None),
+            _ => ("any", None),
+        }
+    } else {
+        ("any", None)
+    }
+}
+
+/// Resolve per-bucket limits
+fn resolve_bucket_limit(bucket: &str) -> u8 {
+    match bucket {
+        "user_edit" => 2,
+        "users" => 20,
+        "bots" => 10,
+        "messaging" => 10,
+        "channels" => 15,
+        "servers" => 5,
+        "auth" => 15,
+        "auth_delete" => 255,
+        "default_avatar" => 255,
+        "swagger" => 100,
+        "safety" => 15,
+        "safety_report" => 3,
+        _ => 20,
+    }
+}
+
+/// Find the remote IP of the client
+fn to_ip(request: &'_ rocket::Request<'_>) -> String {
+    request
+        .remote()
+        .map(|x| x.ip().to_string())
+        .unwrap_or_default()
+}
+
+/// Find the actual IP of the client
+fn to_real_ip(request: &'_ rocket::Request<'_>) -> String {
+    if let Ok(true) = std::env::var("TRUST_CLOUDFLARE").map(|x| x == "1") {
+        request
+            .headers()
+            .get_one("CF-Connecting-IP")
+            .map(|x| x.to_string())
+            .unwrap_or_else(|| to_ip(request))
+    } else {
+        to_ip(request)
+    }
+}
+
+impl Ratelimiter {
+    /// Generate guard from identifier and target bucket
+    pub fn from(
+        identifier: &str,
+        (bucket, resource): (&str, Option<&str>),
+    ) -> Result<Ratelimiter, u128> {
+        let mut key = DefaultHasher::new();
+        key.write(identifier.as_bytes());
+        key.write(bucket.as_bytes());
+
+        if let Some(id) = resource {
+            key.write(id.as_bytes());
+        }
+
+        let key = key.finish();
+        let limit = resolve_bucket_limit(bucket);
+        let mut entry = Entry::from(key);
+
+        let remaining = entry.get_remaining(limit);
+        if remaining > 0 {
+            entry.deduct();
+
+            let reset = entry.left_until_reset();
+            entry.save(key);
+
+            Ok(Ratelimiter {
+                key,
+                limit,
+                remaining: remaining - 1,
+                reset,
+            })
+        } else {
+            Err(entry.left_until_reset())
+        }
+    }
+}
+
+#[async_trait]
+impl<'r> FromRequest<'r> for Ratelimiter {
+    type Error = u128;
+
+    async fn from_request(request: &'r rocket::Request<'_>) -> Outcome<Self, Self::Error> {
+        let ratelimiter = request
+            .local_cache_async(async {
+                use rocket::outcome::Outcome;
+                let identifier = if let Outcome::Success(session) = request.guard::<Session>().await
+                {
+                    session.id
+                } else {
+                    to_real_ip(request)
+                };
+
+                Ratelimiter::from(&identifier, resolve_bucket(request))
+            })
+            .await;
+
+        match ratelimiter {
+            Ok(ratelimiter) => Outcome::Success(*ratelimiter),
+            Err(retry_after) => Outcome::Failure((Status::TooManyRequests, *retry_after)),
+        }
+    }
+}
+
+impl<'r> OpenApiFromRequest<'r> for Ratelimiter {
+    fn from_request_input(
+        _gen: &mut OpenApiGenerator,
+        _name: String,
+        _required: bool,
+    ) -> revolt_rocket_okapi::Result<RequestHeaderInput> {
+        Ok(RequestHeaderInput::None)
+    }
+}
+
+/// Attach ratelimiter to the Rocket application
+pub struct RatelimitFairing;
+
+#[rocket::async_trait]
+impl Fairing for RatelimitFairing {
+    fn info(&self) -> Info {
+        Info {
+            name: "Ratelimiter",
+            kind: Kind::Request | Kind::Response,
+        }
+    }
+
+    async fn on_request(&self, request: &mut Request<'_>, _: &mut Data<'_>) {
+        use rocket::outcome::Outcome;
+        if let Outcome::Failure(_) = request.guard::<Ratelimiter>().await {
+            info!(
+                "User rate-limited on route {}! (IP = {:?})",
+                request.uri(),
+                to_real_ip(request)
+            );
+
+            request.set_method(Method::Get);
+            request.set_uri(Origin::parse("/ratelimit").unwrap())
+        }
+    }
+
+    async fn on_response<'r>(&self, request: &'r Request<'_>, response: &mut Response<'r>) {
+        use rocket::outcome::Outcome;
+        match request.guard::<Ratelimiter>().await {
+            Outcome::Success(ratelimiter) => {
+                let Ratelimiter {
+                    key,
+                    limit,
+                    remaining,
+                    reset,
+                } = ratelimiter;
+
+                response.set_raw_header("X-RateLimit-Limit", limit.to_string());
+                response.set_raw_header("X-RateLimit-Bucket", key.to_string());
+                response.set_raw_header("X-RateLimit-Remaining", remaining.to_string());
+                response.set_raw_header("X-RateLimit-Reset-After", reset.to_string());
+            }
+            Outcome::Failure(_) => response.set_status(Status::TooManyRequests),
+            Outcome::Forward(_) => unreachable!(),
+        }
+    }
+}
+
+#[derive(Serialize)]
+#[serde(untagged)]
+pub enum RatelimitInformation {
+    Success(Ratelimiter),
+    Failure { retry_after: u128 },
+}
+
+#[async_trait]
+impl<'r> FromRequest<'r> for RatelimitInformation {
+    type Error = u128;
+
+    async fn from_request(request: &'r rocket::Request<'_>) -> Outcome<Self, Self::Error> {
+        Outcome::Success(match request.guard::<Ratelimiter>().await {
+            Outcome::Success(ratelimiter) => RatelimitInformation::Success(ratelimiter),
+            Outcome::Failure((_, retry_after)) => RatelimitInformation::Failure { retry_after },
+            _ => unreachable!(),
+        })
+    }
+}
+
+#[rocket::get("/ratelimit")]
+fn ratelimit_info(info: RatelimitInformation) -> Json<RatelimitInformation> {
+    Json(info)
+}
+
+pub fn routes() -> Vec<rocket::Route> {
+    rocket::routes![ratelimit_info]
+}

crates/delta/src/util/regex.rs

@@ -1,19 +0,0 @@
-use once_cell::sync::Lazy;
-use regex::Regex;
-
-/// Regex for valid display names
-///
-/// Block zero width space
-/// Block newline and carriage return
-pub static RE_DISPLAY_NAME: Lazy<Regex> = Lazy::new(|| Regex::new(r"^[^\u200B\n\r]+$").unwrap());
-
-/// Regex for valid usernames
-///
-/// Block zero width space
-/// Block lookalike characters
-pub static RE_USERNAME: Lazy<Regex> = Lazy::new(|| Regex::new(r"^(\p{L}|[\d_.-])+$").unwrap());
-
-/// Regex for valid emoji names
-///
-/// Alphanumeric and underscores
-pub static RE_EMOJI: Lazy<Regex> = Lazy::new(|| Regex::new(r"^[a-z0-9_]+$").unwrap());