jmug/stoatchat
1
0
Fork 1
Code Issues Packages Projects Releases Wiki Activity

chore: remove webhooks from production

Browse Source
This commit is contained in:
Paul Makles
2023-06-11 10:09:50 +01:00
parent ac525466b8
commit 9975de01bc
3 changed files with 176 additions and 64 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
crates/core/database/src/models/admin_migrations/ops/mongodb/scripts.rs
View File

@@ -830,7 +830,8 @@ pub async fn run_migrations(db: &MongoDb, revision: i32) -> i32 {
claimed.insert(format!("{}#{}", info.username, discriminator)); claimed.insert(format!("{}#{}", info.username, discriminator));
info!( info!(
"({i}/{}) Migrating user \"{}\" to #{} - compliant", "({}/{}) Migrating user \"{}\" to #{} - compliant",
i + 1,
users.len(), users.len(),
info.username, info.username,
discriminator discriminator
@@ -874,7 +875,8 @@ pub async fn run_migrations(db: &MongoDb, revision: i32) -> i32 {
claimed.insert(format!("{}#{}", sanitised, discriminator)); claimed.insert(format!("{}#{}", sanitised, discriminator));
info!( info!(
"({i}/{}) Migrating user \"{}\" to #{} - sanitised: \"{}\"", "({}/{}) Migrating user \"{}\" to #{} - sanitised: \"{}\"",
i + 1,
users.len(), users.len(),
info.username, info.username,
discriminator, discriminator,

69
crates/delta/src/routes/mod.rs
View File

@@ -1,3 +1,4 @@
use revolt_quark::variables::delta::IS_STAGING;
use revolt_rocket_okapi::{revolt_okapi::openapi3::OpenApi, settings::OpenApiSettings}; use revolt_rocket_okapi::{revolt_okapi::openapi3::OpenApi, settings::OpenApiSettings};
pub use rocket::http::Status; pub use rocket::http::Status;
pub use rocket::response::Redirect; pub use rocket::response::Redirect;
@@ -20,26 +21,48 @@ mod webhooks;
pub fn mount(mut rocket: Rocket<Build>) -> Rocket<Build> { pub fn mount(mut rocket: Rocket<Build>) -> Rocket<Build> {
let settings = OpenApiSettings::default(); let settings = OpenApiSettings::default();
mount_endpoints_and_merged_docs! { if *IS_STAGING {
rocket, "/".to_owned(), settings, mount_endpoints_and_merged_docs! {
"/" => (vec![], custom_openapi_spec()), rocket, "/".to_owned(), settings,
"" => openapi_get_routes_spec![root::root, root::ping], "/" => (vec![], custom_openapi_spec()),
"/admin" => admin::routes(), "" => openapi_get_routes_spec![root::root, root::ping],
"/users" => users::routes(), "/admin" => admin::routes(),
"/bots" => bots::routes(), "/users" => users::routes(),
"/channels" => channels::routes(), "/bots" => bots::routes(),
"/servers" => servers::routes(), "/channels" => channels::routes(),
"/invites" => invites::routes(), "/servers" => servers::routes(),
"/custom" => customisation::routes(), "/invites" => invites::routes(),
"/safety" => safety::routes(), "/custom" => customisation::routes(),
"/auth/account" => rocket_authifier::routes::account::routes(), "/safety" => safety::routes(),
"/auth/session" => rocket_authifier::routes::session::routes(), "/auth/account" => rocket_authifier::routes::account::routes(),
"/auth/mfa" => rocket_authifier::routes::mfa::routes(), "/auth/session" => rocket_authifier::routes::session::routes(),
"/onboard" => onboard::routes(), "/auth/mfa" => rocket_authifier::routes::mfa::routes(),
"/push" => push::routes(), "/onboard" => onboard::routes(),
"/sync" => sync::routes(), "/push" => push::routes(),
"/webhooks" => webhooks::routes() "/sync" => sync::routes(),
}; "/webhooks" => webhooks::routes()
};
} else {
mount_endpoints_and_merged_docs! {
rocket, "/".to_owned(), settings,
"/" => (vec![], custom_openapi_spec()),
"" => openapi_get_routes_spec![root::root, root::ping],
"/admin" => admin::routes(),
"/users" => users::routes(),
"/bots" => bots::routes(),
"/channels" => channels::routes(),
"/servers" => servers::routes(),
"/invites" => invites::routes(),
"/custom" => customisation::routes(),
"/safety" => safety::routes(),
"/auth/account" => rocket_authifier::routes::account::routes(),
"/auth/session" => rocket_authifier::routes::session::routes(),
"/auth/mfa" => rocket_authifier::routes::mfa::routes(),
"/onboard" => onboard::routes(),
"/push" => push::routes(),
"/sync" => sync::routes()
};
}
rocket rocket
} }
@@ -298,11 +321,9 @@ fn custom_openapi_spec() -> OpenApi {
}, },
Tag { Tag {
name: "Webhooks".to_owned(), name: "Webhooks".to_owned(),
description: Some( description: Some("Send messages from 3rd party services".to_owned()),
"Send messages from 3rd party services".to_owned(),
),
..Default::default() ..Default::default()
} },
], ],
..Default::default() ..Default::default()
} }

165
crates/quark/src/util/variables/delta.rs
View File

@@ -1,56 +1,141 @@
use std::env;
use once_cell::sync::Lazy; use once_cell::sync::Lazy;
use std::env;
// Application Settings // Application Settings
pub static PUBLIC_URL: Lazy<String> = Lazy::new(|| env::var("REVOLT_PUBLIC_URL").expect("Missing REVOLT_PUBLIC_URL environment variable.")); pub static PUBLIC_URL: Lazy<String> = Lazy::new(|| {
pub static APP_URL: Lazy<String> = Lazy::new(|| env::var("REVOLT_APP_URL").expect("Missing REVOLT_APP_URL environment variable.")); env::var("REVOLT_PUBLIC_URL").expect("Missing REVOLT_PUBLIC_URL environment variable.")
pub static EXTERNAL_WS_URL: Lazy<String> = Lazy::new(|| env::var("REVOLT_EXTERNAL_WS_URL").expect("Missing REVOLT_EXTERNAL_WS_URL environment variable.")); });
pub static APP_URL: Lazy<String> =
Lazy::new(|| env::var("REVOLT_APP_URL").expect("Missing REVOLT_APP_URL environment variable."));
pub static EXTERNAL_WS_URL: Lazy<String> = Lazy::new(|| {
env::var("REVOLT_EXTERNAL_WS_URL")
.expect("Missing REVOLT_EXTERNAL_WS_URL environment variable.")
});
pub static AUTUMN_URL: Lazy<String> = Lazy::new(|| env::var("AUTUMN_PUBLIC_URL").unwrap_or_else(|_| "https://example.com".to_string())); pub static AUTUMN_URL: Lazy<String> = Lazy::new(|| {
pub static JANUARY_URL: Lazy<String> = Lazy::new(|| env::var("JANUARY_PUBLIC_URL").unwrap_or_else(|_| "https://example.com".to_string())); env::var("AUTUMN_PUBLIC_URL").unwrap_or_else(|_| "https://example.com".to_string())
pub static JANUARY_CONCURRENT_CONNECTIONS: Lazy<usize> = Lazy::new(|| env::var("JANUARY_CONCURRENT_CONNECTIONS").map_or(50, |v| v.parse().unwrap())); });
pub static VOSO_URL: Lazy<String> = Lazy::new(|| env::var("VOSO_PUBLIC_URL").unwrap_or_else(|_| "https://example.com".to_string())); pub static JANUARY_URL: Lazy<String> = Lazy::new(|| {
pub static VOSO_WS_HOST: Lazy<String> = Lazy::new(|| env::var("VOSO_WS_HOST").unwrap_or_else(|_| "wss://example.com".to_string())); env::var("JANUARY_PUBLIC_URL").unwrap_or_else(|_| "https://example.com".to_string())
pub static VOSO_MANAGE_TOKEN: Lazy<String> = Lazy::new(|| env::var("VOSO_MANAGE_TOKEN").unwrap_or_else(|_| "0".to_string())); });
pub static JANUARY_CONCURRENT_CONNECTIONS: Lazy<usize> =
Lazy::new(|| env::var("JANUARY_CONCURRENT_CONNECTIONS").map_or(50, |v| v.parse().unwrap()));
pub static VOSO_URL: Lazy<String> =
Lazy::new(|| env::var("VOSO_PUBLIC_URL").unwrap_or_else(|_| "https://example.com".to_string()));
pub static VOSO_WS_HOST: Lazy<String> =
Lazy::new(|| env::var("VOSO_WS_HOST").unwrap_or_else(|_| "wss://example.com".to_string()));
pub static VOSO_MANAGE_TOKEN: Lazy<String> =
Lazy::new(|| env::var("VOSO_MANAGE_TOKEN").unwrap_or_else(|_| "0".to_string()));
pub static HCAPTCHA_KEY: Lazy<String> = Lazy::new(|| env::var("REVOLT_HCAPTCHA_KEY").unwrap_or_else(|_| "0x0000000000000000000000000000000000000000".to_string())); pub static HCAPTCHA_KEY: Lazy<String> = Lazy::new(|| {
pub static HCAPTCHA_SITEKEY: Lazy<String> = Lazy::new(|| env::var("REVOLT_HCAPTCHA_SITEKEY").unwrap_or_else(|_| "10000000-ffff-ffff-ffff-000000000001".to_string())); env::var("REVOLT_HCAPTCHA_KEY")
pub static VAPID_PRIVATE_KEY: Lazy<String> = Lazy::new(|| env::var("REVOLT_VAPID_PRIVATE_KEY").expect("Missing REVOLT_VAPID_PRIVATE_KEY environment variable.")); .unwrap_or_else(|_| "0x0000000000000000000000000000000000000000".to_string())
pub static VAPID_PUBLIC_KEY: Lazy<String> = Lazy::new(|| env::var("REVOLT_VAPID_PUBLIC_KEY").expect("Missing REVOLT_VAPID_PUBLIC_KEY environment variable.")); });
pub static AUTHIFIER_SHIELD_KEY: Lazy<Option<String>> = Lazy::new(|| env::var("REVOLT_AUTHIFIER_SHIELD_KEY").ok()); pub static HCAPTCHA_SITEKEY: Lazy<String> = Lazy::new(|| {
env::var("REVOLT_HCAPTCHA_SITEKEY")
.unwrap_or_else(|_| "10000000-ffff-ffff-ffff-000000000001".to_string())
});
pub static VAPID_PRIVATE_KEY: Lazy<String> = Lazy::new(|| {
env::var("REVOLT_VAPID_PRIVATE_KEY")
.expect("Missing REVOLT_VAPID_PRIVATE_KEY environment variable.")
});
pub static VAPID_PUBLIC_KEY: Lazy<String> = Lazy::new(|| {
env::var("REVOLT_VAPID_PUBLIC_KEY")
.expect("Missing REVOLT_VAPID_PUBLIC_KEY environment variable.")
});
pub static AUTHIFIER_SHIELD_KEY: Lazy<Option<String>> =
Lazy::new(|| env::var("REVOLT_AUTHIFIER_SHIELD_KEY").ok());
// Application Flags // Application Flags
pub static INVITE_ONLY: Lazy<bool> = Lazy::new(|| env::var("REVOLT_INVITE_ONLY").map_or(false, |v| v == "1")); pub static INVITE_ONLY: Lazy<bool> =
pub static USE_EMAIL: Lazy<bool> = Lazy::new(|| env::var("REVOLT_USE_EMAIL_VERIFICATION").map_or( Lazy::new(|| env::var("REVOLT_INVITE_ONLY").map_or(false, |v| v == "1"));
env::var("REVOLT_SMTP_HOST").is_ok() pub static USE_EMAIL: Lazy<bool> = Lazy::new(|| {
&& env::var("REVOLT_SMTP_USERNAME").is_ok() env::var("REVOLT_USE_EMAIL_VERIFICATION").map_or(
&& env::var("REVOLT_SMTP_PASSWORD").is_ok() env::var("REVOLT_SMTP_HOST").is_ok()
&& env::var("REVOLT_SMTP_FROM").is_ok(), && env::var("REVOLT_SMTP_USERNAME").is_ok()
|v| v == *"1" && env::var("REVOLT_SMTP_PASSWORD").is_ok()
)); && env::var("REVOLT_SMTP_FROM").is_ok(),
|v| v == *"1",
)
});
pub static USE_HCAPTCHA: Lazy<bool> = Lazy::new(|| env::var("REVOLT_HCAPTCHA_KEY").is_ok()); pub static USE_HCAPTCHA: Lazy<bool> = Lazy::new(|| env::var("REVOLT_HCAPTCHA_KEY").is_ok());
pub static USE_AUTUMN: Lazy<bool> = Lazy::new(|| env::var("AUTUMN_PUBLIC_URL").is_ok()); pub static USE_AUTUMN: Lazy<bool> = Lazy::new(|| env::var("AUTUMN_PUBLIC_URL").is_ok());
pub static USE_JANUARY: Lazy<bool> = Lazy::new(|| env::var("JANUARY_PUBLIC_URL").is_ok()); pub static USE_JANUARY: Lazy<bool> = Lazy::new(|| env::var("JANUARY_PUBLIC_URL").is_ok());
pub static USE_VOSO: Lazy<bool> = Lazy::new(|| env::var("VOSO_PUBLIC_URL").is_ok() && env::var("VOSO_MANAGE_TOKEN").is_ok()); pub static USE_VOSO: Lazy<bool> =
Lazy::new(|| env::var("VOSO_PUBLIC_URL").is_ok() && env::var("VOSO_MANAGE_TOKEN").is_ok());
// SMTP Settings // SMTP Settings
pub static SMTP_HOST: Lazy<String> = Lazy::new(|| env::var("REVOLT_SMTP_HOST").unwrap_or_else(|_| "".to_string())); pub static SMTP_HOST: Lazy<String> =
pub static SMTP_USERNAME: Lazy<String> = Lazy::new(|| env::var("REVOLT_SMTP_USERNAME").unwrap_or_else(|_| "".to_string())); Lazy::new(|| env::var("REVOLT_SMTP_HOST").unwrap_or_else(|_| "".to_string()));
pub static SMTP_PASSWORD: Lazy<String> = Lazy::new(|| env::var("REVOLT_SMTP_PASSWORD").unwrap_or_else(|_| "".to_string())); pub static SMTP_USERNAME: Lazy<String> =
pub static SMTP_FROM: Lazy<String> = Lazy::new(|| env::var("REVOLT_SMTP_FROM").unwrap_or_else(|_| "".to_string())); Lazy::new(|| env::var("REVOLT_SMTP_USERNAME").unwrap_or_else(|_| "".to_string()));
pub static SMTP_PASSWORD: Lazy<String> =
Lazy::new(|| env::var("REVOLT_SMTP_PASSWORD").unwrap_or_else(|_| "".to_string()));
pub static SMTP_FROM: Lazy<String> =
Lazy::new(|| env::var("REVOLT_SMTP_FROM").unwrap_or_else(|_| "".to_string()));
// Application Logic Settings // Application Logic Settings
pub static MAX_GROUP_SIZE: Lazy<usize> = Lazy::new(|| env::var("REVOLT_MAX_GROUP_SIZE").unwrap_or_else(|_| "50".to_string()).parse().unwrap()); pub static MAX_GROUP_SIZE: Lazy<usize> = Lazy::new(|| {
pub static MAX_BOT_COUNT: Lazy<usize> = Lazy::new(|| env::var("REVOLT_MAX_BOT_COUNT").unwrap_or_else(|_| "10".to_string()).parse().unwrap()); env::var("REVOLT_MAX_GROUP_SIZE")
pub static MAX_EMBED_COUNT: Lazy<usize> = Lazy::new(|| env::var("REVOLT_MAX_EMBED_COUNT").unwrap_or_else(|_| "5".to_string()).parse().unwrap()); .unwrap_or_else(|_| "50".to_string())
pub static MAX_SERVER_COUNT: Lazy<usize> = Lazy::new(|| env::var("REVOLT_MAX_SERVER_COUNT").unwrap_or_else(|_| "100".to_string()).parse().unwrap()); .parse()
pub static MAX_CHANNEL_COUNT: Lazy<usize> = Lazy::new(|| env::var("REVOLT_MAX_CHANNEL_COUNT").unwrap_or_else(|_| "200".to_string()).parse().unwrap()); .unwrap()
pub static MAX_ROLE_COUNT: Lazy<usize> = Lazy::new(|| env::var("REVOLT_MAX_ROLE_COUNT").unwrap_or_else(|_| "200".to_string()).parse().unwrap()); });
pub static MAX_EMOJI_COUNT: Lazy<usize> = Lazy::new(|| env::var("REVOLT_MAX_EMOJI_COUNT").unwrap_or_else(|_| "100".to_string()).parse().unwrap()); pub static MAX_BOT_COUNT: Lazy<usize> = Lazy::new(|| {
pub static MAX_ATTACHMENT_COUNT: Lazy<usize> = Lazy::new(|| env::var("REVOLT_MAX_ATTACHMENT_COUNT").unwrap_or_else(|_| "5".to_string()).parse().unwrap()); env::var("REVOLT_MAX_BOT_COUNT")
pub static MAX_REPLY_COUNT: Lazy<usize> = Lazy::new(|| env::var("REVOLT_MAX_REPLY_COUNT").unwrap_or_else(|_| "5".to_string()).parse().unwrap()); .unwrap_or_else(|_| "10".to_string())
.parse()
.unwrap()
});
pub static MAX_EMBED_COUNT: Lazy<usize> = Lazy::new(|| {
env::var("REVOLT_MAX_EMBED_COUNT")
.unwrap_or_else(|_| "5".to_string())
.parse()
.unwrap()
});
pub static MAX_SERVER_COUNT: Lazy<usize> = Lazy::new(|| {
env::var("REVOLT_MAX_SERVER_COUNT")
.unwrap_or_else(|_| "100".to_string())
.parse()
.unwrap()
});
pub static MAX_CHANNEL_COUNT: Lazy<usize> = Lazy::new(|| {
env::var("REVOLT_MAX_CHANNEL_COUNT")
.unwrap_or_else(|_| "200".to_string())
.parse()
.unwrap()
});
pub static MAX_ROLE_COUNT: Lazy<usize> = Lazy::new(|| {
env::var("REVOLT_MAX_ROLE_COUNT")
.unwrap_or_else(|_| "200".to_string())
.parse()
.unwrap()
});
pub static MAX_EMOJI_COUNT: Lazy<usize> = Lazy::new(|| {
env::var("REVOLT_MAX_EMOJI_COUNT")
.unwrap_or_else(|_| "100".to_string())
.parse()
.unwrap()
});
pub static MAX_ATTACHMENT_COUNT: Lazy<usize> = Lazy::new(|| {
env::var("REVOLT_MAX_ATTACHMENT_COUNT")
.unwrap_or_else(|_| "5".to_string())
.parse()
.unwrap()
});
pub static MAX_REPLY_COUNT: Lazy<usize> = Lazy::new(|| {
env::var("REVOLT_MAX_REPLY_COUNT")
.unwrap_or_else(|_| "5".to_string())
.parse()
.unwrap()
});
pub static EARLY_ADOPTER_BADGE: Lazy<i64> = Lazy::new(|| env::var("REVOLT_EARLY_ADOPTER_BADGE").unwrap_or_else(|_| "0".to_string()).parse().unwrap()); pub static EARLY_ADOPTER_BADGE: Lazy<i64> = Lazy::new(|| {
env::var("REVOLT_EARLY_ADOPTER_BADGE")
.unwrap_or_else(|_| "0".to_string())
.parse()
.unwrap()
});
pub fn preflight_checks() { pub fn preflight_checks() {
format!("url = {}", *APP_URL); format!("url = {}", *APP_URL);
@@ -80,3 +165,7 @@ pub fn preflight_checks() {
warn!("No Captcha key specified! Remember to add hCaptcha key."); warn!("No Captcha key specified! Remember to add hCaptcha key.");
} }
} }
// Production / staging configuration
pub static IS_STAGING: Lazy<bool> =
Lazy::new(|| env::var("REVOLT_IS_STAGING").map_or(false, |v| v == "1"));