[Add] Structure

src/main.rs

@@ -1,30 +1,41 @@
+mod api;
+mod config;
+mod db;
+pub mod error;
+mod models;
 mod server;
 mod sql;
 mod transport;
 mod util;
 
-use crate::sql::sql::initialize_db;
-use crate::sql::sql::print_users;
+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::files::{load_keyring_raw, save_keyring_raw, save_public_key_bundle};
 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();
-        save_keyring_raw(&kr, KEYRING_PATH).expect("Failed to save generated keyring");
-        save_public_key_bundle(&kr.public_key_bundle(), KEYRING_PATH)
-            .expect("Failed to save generated public key bundle");
+        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
     })
@@ -34,7 +45,10 @@ pub fn get_keyring() -> &'static Keyring {
     &KEYRING
 }
 pub fn load_keyring() -> Keyring {
-    Keyring::from_bytes(&KEYRING.to_bytes()).unwrap()
+    Keyring::from_bytes(&KEYRING.to_bytes()).unwrap_or_else(|error| {
+        eprintln!("Failed to clone keyring: {error}");
+        Keyring::generate()
+    })
 }
 
 #[tokio::main]
@@ -50,7 +64,7 @@ async fn main() {
 
     log!("Started");
     log!("  .env");
-    if let Err(e) = initialize_db().await {
+    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."
@@ -59,12 +73,21 @@ async fn main() {
     } else {
         log!("  DB");
     }
-    if let Err(e) = print_users().await {
-        log!("[ERROR] Failed to print users: {}", e);
-    } else {
-        log!("  Users");
-    }
-
+    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())
@@ -80,4 +103,6 @@ async fn main() {
             log!("Shutting down on signal...");
         }
     }
+    rate_limit_cleanup.abort();
+    short_link_cleanup.abort();
 }