+ log files

+ more control on auth providers
+ server info in motd
+ bans and parsing minecraft server blacklist
+ more error handling
+ panic hook to tracing

src/utils/utils.rs

@@ -1,11 +1,14 @@
-use std::{fs::File, io::Read, str::FromStr};
+use std::{fs::File, io::Read, path::{Path, PathBuf}};
 
 use base64::prelude::*;
 use rand::{distributions::Alphanumeric, thread_rng, Rng};
 use ring::digest::{self, digest};
+use tokio::io::AsyncReadExt;
+use tracing::{error, info};
 use uuid::Uuid;
+use chrono::prelude::*;
 
-use crate::auth::{AuthSystem, UManager, Userinfo};
+use crate::{auth::{UManager, Userinfo}, state::{AdvancedUsers, BannedPlayer}};
 
 // Core functions
 pub fn rand() -> [u8; 50] {
@@ -27,50 +30,79 @@ pub fn _generate_hex_string(length: usize) -> String {
     hex::encode(random_bytes)
 }
 
-pub fn get_correct_array(value: &toml::Value) -> Vec<u8> {
-    // let res: Vec<u8>;
-    value
-        .as_array()
-        .unwrap()
-        .iter()
-        .map(move |x| x.as_integer().unwrap() as u8)
-        .collect()
-}
-// pub fn collect_advanced_users(value: &toml::Table) -> Vec<(Uuid, Userinfo)> {
-//     value
-//         .iter()
-//         .map( |(uuid, userdata)| {
-//             let auth_system = AuthSystem::from_str(userdata.as_table().unwrap().get("authSystem").expect("Can't find authSystem in advancedUser!").as_str().unwrap()).unwrap();
-//             let username = userdata.as_table().unwrap().get("username").expect("Can't find username in advancedUser!").as_str().unwrap().to_string();
-//             (
-//             Uuid::parse_str(uuid).unwrap(),
-//             Userinfo { username,
-//                 uuid: Uuid::parse_str(uuid).unwrap(),
-//                 auth_system,
-//                 token: None
-//             }
-//         )})
-//         .collect()
-// }
-
-pub fn update_advanced_users(value: &toml::Table, umanager: &UManager) {
+pub fn update_advanced_users(value: &std::collections::HashMap<Uuid, AdvancedUsers>, umanager: &UManager) {
     let users: Vec<(Uuid, Userinfo)> = value
         .iter()
         .map( |(uuid, userdata)| {
-            let auth_system = AuthSystem::from_str(userdata.as_table().unwrap().get("authSystem").expect("Can't find authSystem in advancedUser!").as_str().unwrap()).unwrap();
-            let username = userdata.as_table().unwrap().get("username").expect("Can't find username in advancedUser!").as_str().unwrap().to_string();
             (
-            Uuid::parse_str(uuid).unwrap(),
-            Userinfo { username,
-                uuid: Uuid::parse_str(uuid).unwrap(),
-                auth_system,
-                token: None
+            uuid.clone(),
+            Userinfo { 
+                uuid: uuid.clone(),
+                username: userdata.username.clone(),
+                banned: userdata.banned,
+                ..Default::default()
             }
         )})
         .collect();
 
     for (uuid, userinfo) in users {
-        umanager.insert_user(uuid, userinfo);
+        umanager.insert_user(uuid, userinfo.clone());
+        if userinfo.banned {
+            umanager.ban(&userinfo)
+        }
+    }
+}
+
+pub async fn update_bans_from_minecraft(folder: PathBuf, umanager: std::sync::Arc<UManager>) {
+    let path = folder.join("banned-players.json");
+    let mut file = tokio::fs::File::open(path.clone()).await.expect("Access denied or banned-players.json doesn't exists!");
+    let mut data = String::new();
+    // vars end
+
+    // initialize
+    file.read_to_string(&mut data).await.expect("cant read banned-players.json");
+    let mut old_bans: Vec<BannedPlayer> = serde_json::from_str(&data).expect("cant parse banned-players.json");
+    
+    if !old_bans.is_empty() {
+        let names: Vec<String> = old_bans.iter().map(|user| user.name.clone()).collect();
+        info!("Banned players: {}", names.join(", "));
+    }
+
+    for player in &old_bans {
+        umanager.ban(&player.clone().into());
+    }
+
+    // old_bans
+    loop {
+        tokio::time::sleep(std::time::Duration::from_secs(10)).await;
+        let mut file = tokio::fs::File::open(path.clone()).await.expect("Access denied or file doesn't exists!");
+        let mut data = String::new();
+        file.read_to_string(&mut data).await.expect("cant read banned-players.json");
+        let new_bans: Vec<BannedPlayer> = if let Ok(res) = serde_json::from_str(&data) { res } else {
+            error!("Error occured while parsing a banned-players.json");
+            continue;
+        };
+
+        if new_bans != old_bans {
+            info!("Minecraft ban list modification detected!");
+            let unban: Vec<&BannedPlayer> = old_bans.iter().filter(|user| !new_bans.contains(user)).collect();
+            let mut unban_names = unban.iter().map(|user| user.name.clone()).collect::<Vec<String>>().join(", ");
+            if !unban.is_empty() {
+                for player in unban {
+                    umanager.unban(&player.uuid);
+                }
+            } else { unban_names = String::from("-")};
+            let ban: Vec<&BannedPlayer> = new_bans.iter().filter(|user| !old_bans.contains(user)).collect();
+            let mut ban_names = ban.iter().map(|user| user.name.clone()).collect::<Vec<String>>().join(", ");
+            if !ban.is_empty() {
+                for player in ban {
+                    umanager.ban(&player.clone().into());
+                }
+            } else { ban_names = String::from("-")};
+            info!("List of changes:\n    Banned: {ban_names}\n    Unbanned: {unban_names}");
+            // Write new to old for next iteration
+            old_bans = new_bans;
+        }
     }
 }
 
@@ -99,3 +131,16 @@ pub fn calculate_file_sha256(file_path: &str) -> Result<String, std::io::Error>
 
     Ok(hex_hash)
 }
+
+pub fn get_log_file(folder: &str) -> String {
+    let local_date = Local::now().format("%Y-%m-%d");
+    let mut index: u16 = 0;
+    loop {
+        let file_name = format!("{local_date}.{:04}.log", index);
+        let file_path = Path::new(folder).join(&file_name);
+        if !Path::new(&file_path).exists() {
+            return file_name;
+        }
+        index += 1;
+    }
+}