src/util/mod.rs

-use hashbrown::HashSet;
-use rand::{distributions::Alphanumeric, Rng};
-use std::iter::FromIterator;
-
-pub mod captcha;
-pub mod email;
+pub mod result;
 pub mod variables;
-
-pub fn vec_to_set<T: Clone + Eq + std::hash::Hash>(data: &[T]) -> HashSet<T> {
-    HashSet::from_iter(data.iter().cloned())
-}
-
-pub fn gen_token(l: usize) -> String {
-    rand::thread_rng()
-        .sample_iter(&Alphanumeric)
-        .take(l)
-        .collect::<String>()
-}

src/util/result.rs

+use json;
+use rocket::http::{ContentType, Status};
+use rocket::request::Request;
+use rocket::response::{self, Responder, Response};
+use serde::Serialize;
+use std::io::Cursor;
+use validator::ValidationErrors;
+
+#[derive(Serialize, Debug)]
+#[serde(tag = "type")]
+pub enum Error {
+    LabelMe,
+
+    // ? Onboarding related errors.
+    AlreadyOnboarded,
+
+    // ? User related errors.
+    UsernameTaken,
+    UnknownUser,
+    AlreadyFriends,
+    AlreadySentRequest,
+    Blocked,
+    BlockedByOther,
+    NotFriends,
+
+    // ? Channel related errors.
+    UnknownChannel,
+    UnknownAttachment,
+    UnknownMessage,
+    CannotEditMessage,
+    CannotJoinCall,
+    TooManyAttachments,
+    TooManyReplies,
+    EmptyMessage,
+    CannotRemoveYourself,
+    GroupTooLarge {
+        max: usize,
+    },
+    AlreadyInGroup,
+    NotInGroup,
+
+    // ? Server related errors.
+    UnknownServer,
+    InvalidRole,
+    Banned,
+
+    // ? General errors.
+    TooManyIds,
+    FailedValidation {
+        error: ValidationErrors,
+    },
+    DatabaseError {
+        operation: &'static str,
+        with: &'static str,
+    },
+    InternalError,
+    MissingPermission,
+    InvalidOperation,
+    InvalidCredentials,
+    DuplicateNonce,
+    VosoUnavailable,
+    NotFound,
+    NoEffect,
+}
+
+pub type Result<T, E = Error> = std::result::Result<T, E>;
+
+/// HTTP response builder for Error enum
+impl<'r> Responder<'r, 'static> for Error {
+    fn respond_to(self, _: &'r Request<'_>) -> response::Result<'static> {
+        let status = match self {
+            Error::LabelMe => Status::InternalServerError,
+
+            Error::AlreadyOnboarded => Status::Forbidden,
+
+            Error::UnknownUser => Status::NotFound,
+            Error::UsernameTaken => Status::Conflict,
+            Error::AlreadyFriends => Status::Conflict,
+            Error::AlreadySentRequest => Status::Conflict,
+            Error::Blocked => Status::Conflict,
+            Error::BlockedByOther => Status::Forbidden,
+            Error::NotFriends => Status::Forbidden,
+
+            Error::UnknownChannel => Status::NotFound,
+            Error::UnknownMessage => Status::NotFound,
+            Error::UnknownAttachment => Status::BadRequest,
+            Error::CannotEditMessage => Status::Forbidden,
+            Error::CannotJoinCall => Status::BadRequest,
+            Error::TooManyAttachments => Status::BadRequest,
+            Error::TooManyReplies => Status::BadRequest,
+            Error::EmptyMessage => Status::UnprocessableEntity,
+            Error::CannotRemoveYourself => Status::BadRequest,
+            Error::GroupTooLarge { .. } => Status::Forbidden,
+            Error::AlreadyInGroup => Status::Conflict,
+            Error::NotInGroup => Status::NotFound,
+
+            Error::UnknownServer => Status::NotFound,
+            Error::InvalidRole => Status::NotFound,
+            Error::Banned => Status::Forbidden,
+
+            Error::FailedValidation { .. } => Status::UnprocessableEntity,
+            Error::DatabaseError { .. } => Status::InternalServerError,
+            Error::InternalError => Status::InternalServerError,
+            Error::MissingPermission => Status::Forbidden,
+            Error::InvalidOperation => Status::BadRequest,
+            Error::TooManyIds => Status::BadRequest,
+            Error::InvalidCredentials => Status::Forbidden,
+            Error::DuplicateNonce => Status::Conflict,
+            Error::VosoUnavailable => Status::BadRequest,
+            Error::NotFound => Status::NotFound,
+            Error::NoEffect => Status::Ok,
+        };
+
+        // Serialize the error data structure into JSON.
+        let string = json!(self).to_string();
+
+        // Build and send the request.
+        Response::build()
+            .sized_body(string.len(), Cursor::new(string))
+            .header(ContentType::new("application", "json"))
+            .status(status)
+            .ok()
+    }
+}

src/util/variables.rs

 use std::env;
 
+#[cfg(debug_assertions)]
+use log::warn;
+
 lazy_static! {
+    // Application Settings
     pub static ref MONGO_URI: String =
         env::var("REVOLT_MONGO_URI").expect("Missing REVOLT_MONGO_URI environment variable.");
+    pub static ref WS_HOST: String =
+        env::var("REVOLT_WS_HOST").unwrap_or_else(|_| "0.0.0.0:9000".to_string());
     pub static ref PUBLIC_URL: String =
         env::var("REVOLT_PUBLIC_URL").expect("Missing REVOLT_PUBLIC_URL environment variable.");
-    pub static ref USE_EMAIL_VERIFICATION: bool = env::var("REVOLT_USE_EMAIL_VERIFICATION").map_or(
+    pub static ref APP_URL: String =
+        env::var("REVOLT_APP_URL").expect("Missing REVOLT_APP_URL environment variable.");
+    pub static ref EXTERNAL_WS_URL: String =
+        env::var("REVOLT_EXTERNAL_WS_URL").expect("Missing REVOLT_EXTERNAL_WS_URL environment variable.");
+
+    pub static ref AUTUMN_URL: String =
+        env::var("AUTUMN_PUBLIC_URL").unwrap_or_else(|_| "https://example.com".to_string());
+    pub static ref JANUARY_URL: String =
+        env::var("JANUARY_PUBLIC_URL").unwrap_or_else(|_| "https://example.com".to_string());
+    pub static ref VOSO_URL: String =
+        env::var("VOSO_PUBLIC_URL").unwrap_or_else(|_| "https://example.com".to_string());
+    pub static ref VOSO_WS_HOST: String =
+        env::var("VOSO_WS_HOST").unwrap_or_else(|_| "wss://example.com".to_string());
+    pub static ref VOSO_MANAGE_TOKEN: String =
+        env::var("VOSO_MANAGE_TOKEN").unwrap_or_else(|_| "0".to_string());
+
+    pub static ref HCAPTCHA_KEY: String =
+        env::var("REVOLT_HCAPTCHA_KEY").unwrap_or_else(|_| "0x0000000000000000000000000000000000000000".to_string());
+    pub static ref HCAPTCHA_SITEKEY: String =
+        env::var("REVOLT_HCAPTCHA_SITEKEY").unwrap_or_else(|_| "10000000-ffff-ffff-ffff-000000000001".to_string());
+    pub static ref VAPID_PRIVATE_KEY: String =
+        env::var("REVOLT_VAPID_PRIVATE_KEY").expect("Missing REVOLT_VAPID_PRIVATE_KEY environment variable.");
+    pub static ref VAPID_PUBLIC_KEY: String =
+        env::var("REVOLT_VAPID_PUBLIC_KEY").expect("Missing REVOLT_VAPID_PUBLIC_KEY environment variable.");
+
+    // Application Flags
+    pub static ref INVITE_ONLY: bool = env::var("REVOLT_INVITE_ONLY").map_or(false, |v| v == "1");
+    pub static ref USE_EMAIL: bool = env::var("REVOLT_USE_EMAIL_VERIFICATION").map_or(
         env::var("REVOLT_SMTP_HOST").is_ok()
             && env::var("REVOLT_SMTP_USERNAME").is_ok()
             && env::var("REVOLT_SMTP_PASSWORD").is_ok()
@@ -13,15 +46,53 @@ lazy_static! {
         |v| v == *"1"
     );
     pub static ref USE_HCAPTCHA: bool = env::var("REVOLT_HCAPTCHA_KEY").is_ok();
+    pub static ref USE_PROMETHEUS: bool = env::var("REVOLT_ENABLE_PROMETHEUS").map_or(false, |v| v == "1");
+    pub static ref USE_AUTUMN: bool = env::var("AUTUMN_PUBLIC_URL").is_ok();
+    pub static ref USE_JANUARY: bool = env::var("JANUARY_PUBLIC_URL").is_ok();
+    pub static ref USE_VOSO: bool = env::var("VOSO_PUBLIC_URL").is_ok() && env::var("VOSO_MANAGE_TOKEN").is_ok();
+
+    // SMTP Settings
     pub static ref SMTP_HOST: String =
         env::var("REVOLT_SMTP_HOST").unwrap_or_else(|_| "".to_string());
     pub static ref SMTP_USERNAME: String =
-        env::var("SMTP_USERNAME").unwrap_or_else(|_| "".to_string());
+        env::var("REVOLT_SMTP_USERNAME").unwrap_or_else(|_| "".to_string());
     pub static ref SMTP_PASSWORD: String =
-        env::var("SMTP_PASSWORD").unwrap_or_else(|_| "".to_string());
-    pub static ref SMTP_FROM: String = env::var("SMTP_FROM").unwrap_or_else(|_| "".to_string());
-    pub static ref HCAPTCHA_KEY: String =
-        env::var("REVOLT_HCAPTCHA_KEY").unwrap_or_else(|_| "".to_string());
-    pub static ref WS_HOST: String =
-        env::var("REVOLT_WS_HOST").unwrap_or_else(|_| "0.0.0.0:9999".to_string());
+        env::var("REVOLT_SMTP_PASSWORD").unwrap_or_else(|_| "".to_string());
+    pub static ref SMTP_FROM: String = env::var("REVOLT_SMTP_FROM").unwrap_or_else(|_| "".to_string());
+
+    // Application Logic Settings
+    pub static ref MAX_GROUP_SIZE: usize =
+        env::var("REVOLT_MAX_GROUP_SIZE").unwrap_or_else(|_| "50".to_string()).parse().unwrap();
+    pub static ref EARLY_ADOPTER_BADGE: i64 =
+        env::var("REVOLT_EARLY_ADOPTER_BADGE").unwrap_or_else(|_| "0".to_string()).parse().unwrap();
+}
+
+pub fn preflight_checks() {
+    format!("{}", *APP_URL);
+    format!("{}", *MONGO_URI);
+    format!("{}", *PUBLIC_URL);
+    format!("{}", *EXTERNAL_WS_URL);
+
+    format!("{}", *VAPID_PRIVATE_KEY);
+    format!("{}", *VAPID_PUBLIC_KEY);
+
+    if *USE_EMAIL == false {
+        #[cfg(not(debug_assertions))]
+        if !env::var("REVOLT_UNSAFE_NO_EMAIL").map_or(false, |v| v == *"1") {
+            panic!("Running in production without email is not recommended, set REVOLT_UNSAFE_NO_EMAIL=1 to override.");
+        }
+
+        #[cfg(debug_assertions)]
+        warn!("No SMTP settings specified! Remember to configure email.");
+    }
+
+    if *USE_HCAPTCHA == false {
+        #[cfg(not(debug_assertions))]
+        if !env::var("REVOLT_UNSAFE_NO_CAPTCHA").map_or(false, |v| v == *"1") {
+            panic!("Running in production without CAPTCHA is not recommended, set REVOLT_UNSAFE_NO_CAPTCHA=1 to override.");
+        }
+
+        #[cfg(debug_assertions)]
+        warn!("No Captcha key specified! Remember to add hCaptcha key.");
+    }
 }

src/version.rs

+pub const VERSION: &str = "0.5.1-alpha.21";