108 lines
3.1 KiB
Rust
108 lines
3.1 KiB
Rust
mod api;
|
|
mod config;
|
|
mod db;
|
|
pub mod error;
|
|
mod models;
|
|
mod server;
|
|
mod sql;
|
|
mod transport;
|
|
mod util;
|
|
|
|
pub use error::{OmegaError, Result};
|
|
|
|
use crate::db::initialize;
|
|
use crate::transport::omikron_connection;
|
|
use crate::util::file_util::get_directory;
|
|
use crate::util::logger::PrintType;
|
|
use crate::util::logger::startup;
|
|
use dotenv::from_path;
|
|
use mtp::crypto::Keyring;
|
|
use mtp::files::{load_keyring_raw, save_keyring_raw, save_public_key_bundle};
|
|
use once_cell::sync::Lazy;
|
|
use rustls::crypto::aws_lc_rs::default_provider;
|
|
use std::env;
|
|
use std::path::Path;
|
|
use std::time::Duration;
|
|
use tokio::time::interval;
|
|
|
|
const KEYRING_PATH: &str = "./omega.mk";
|
|
|
|
static KEYRING: Lazy<Keyring> = Lazy::new(|| {
|
|
load_keyring_raw(KEYRING_PATH).unwrap_or_else(|_| {
|
|
let kr = Keyring::generate();
|
|
if let Err(error) = save_keyring_raw(&kr, KEYRING_PATH) {
|
|
eprintln!("Failed to save generated keyring: {error}");
|
|
}
|
|
if let Err(error) = save_public_key_bundle(&kr.public_key_bundle(), KEYRING_PATH) {
|
|
eprintln!("Failed to save generated public key bundle: {error}");
|
|
}
|
|
eprintln!("Generated new keyring at {}", KEYRING_PATH);
|
|
kr
|
|
})
|
|
});
|
|
|
|
pub fn get_keyring() -> &'static Keyring {
|
|
&KEYRING
|
|
}
|
|
pub fn load_keyring() -> Keyring {
|
|
Keyring::from_bytes(&KEYRING.to_bytes()).unwrap_or_else(|error| {
|
|
eprintln!("Failed to clone keyring: {error}");
|
|
Keyring::generate()
|
|
})
|
|
}
|
|
|
|
#[tokio::main]
|
|
async fn main() {
|
|
if let Err(_) = default_provider().install_default() {
|
|
println!("Error loading Provider");
|
|
return;
|
|
}
|
|
let _ = from_path(Path::new(&get_directory()).join(".env"));
|
|
startup();
|
|
log_in!("Incoming messages");
|
|
log_out!("Outgoing messages");
|
|
|
|
log!("Started");
|
|
log!(" .env");
|
|
if let Err(e) = initialize().await {
|
|
log!("[FATAL] Database initialization failed: {}", e);
|
|
log!(
|
|
"[FATAL] Please ensure the database is running and the .env file is configured correctly."
|
|
);
|
|
return;
|
|
} else {
|
|
log!(" DB");
|
|
}
|
|
let rate_limit_cleanup = crate::server::middleware::spawn_cleanup_task();
|
|
let short_link_cleanup = tokio::spawn(async {
|
|
let mut ticker = interval(Duration::from_secs(24 * 60 * 60));
|
|
loop {
|
|
ticker.tick().await;
|
|
if let Err(error) = crate::db::short_link_repo::delete_expired().await {
|
|
log_err!(
|
|
0,
|
|
PrintType::General,
|
|
"Short-link cleanup failed: {}",
|
|
error
|
|
);
|
|
}
|
|
}
|
|
});
|
|
let port: u16 = env::var("PORT")
|
|
.ok()
|
|
.and_then(|s| s.parse().ok())
|
|
.unwrap_or(443);
|
|
|
|
tokio::select! {
|
|
result = omikron_connection::start(port) => {
|
|
if let Err(e) = result {
|
|
log_err!(0, PrintType::General, "Server error: {:?}", e);
|
|
}
|
|
}
|
|
_ = tokio::signal::ctrl_c() => {
|
|
log!("Shutting down on signal...");
|
|
}
|
|
}
|
|
rate_limit_cleanup.abort();
|
|
short_link_cleanup.abort();
|
|
}
|