fmt & enhancements & changelog

Author: heydocode

Cargo.lock

@@ -7,4 +7,3 @@ edition = "2021"
 async-std = "1.12.0"
 lettre = "0.11"
 maud = "0.26.0"
-tracing-subscriber = "0.3.18"

Cargo.toml

@@ -0,0 +1,18 @@
+# 1.0.0 Release
+This is the first `ServerAPI` **stable** release you can enjoy!
+
+Added features:
+- installation wizard
+- launching rust modules in parallel
+- config support (you can change everything manually)
+- implemented fancy html header (use of `maud` crate)
+- implemented a text raw alternative to html in case client does not support it
+
+
+Waited soon:
+- crate organization, such as in my [`LimitPush`](https://github.com/heydocode/limitpush) project
+- launching of processes via the CLI environment
+- responsible CLI with commands
+- inter-operability with [`LimitPush`](https://github.com/heydocode/limitpush) template, and any other bevy game
+- feature organization
+- custom multiplayer protocol that'll work with `LimitPush` if "mp-protocol" feature enabled

changelog/1.0.0.md

@@ -1,4 +1,4 @@
-use std::fs::{create_dir_all, File, metadata};
+use std::fs::{create_dir_all, metadata, File};
 use std::io::{BufReader, Read};
 use std::path::Path;
 
@@ -41,7 +41,12 @@ pub fn mc_status_reader() -> String {
     }
 
     let contents = read_from_file(file_path.to_str().unwrap_or("config/logs.txt"));
-    if contents.clone().expect("Could not convert contents to Ok()").len() <= 5 {
+    if contents
+        .clone()
+        .expect("Could not convert contents to Ok()")
+        .len()
+        <= 5
+    {
         String::from("The server's logs are empty! Is there a problem?")
     } else {
         contents.expect("Could not convert contents to Ok()")
@@ -63,11 +68,14 @@ fn read_from_file(file_path: &str) -> Result<String, String> {
     }
 
     // Attempt to open the file
-    let file = File::open(file_path).map_err(|e| format!("Error opening file '{}': {}", file_path, e))?;
+    let file =
+        File::open(file_path).map_err(|e| format!("Error opening file '{}': {}", file_path, e))?;
     let mut buf_reader = BufReader::new(file);
     let mut contents = String::new();
-    
-    buf_reader.read_to_string(&mut contents).map_err(|e| format!("Error reading file '{}': {}", file_path, e))?;
+
+    buf_reader
+        .read_to_string(&mut contents)
+        .map_err(|e| format!("Error reading file '{}': {}", file_path, e))?;
 
     Ok(contents)
 }

src/file_reader.rs

@@ -1,6 +1,6 @@
+use async_std::fs::File;
 use async_std::fs::OpenOptions;
 use async_std::path::Path;
-use async_std::fs::File;
 use async_std::prelude::*;
 
 pub async fn write_to_file(text: String, file_path: &str) -> Result<(), String> {
@@ -11,27 +11,37 @@ pub async fn write_to_file(text: String, file_path: &str) -> Result<(), String>
         .await
         .map_err(|e| e.to_string())?;
 
-    file.write_all(text.as_bytes()).await.map_err(|e| e.to_string())
+    file.write_all(text.as_bytes())
+        .await
+        .map_err(|e| e.to_string())
 }
 
-pub async fn update_credentials(username: String, password: String, receiver: String) -> Result<(), String> {
+pub async fn update_credentials(
+    username: String,
+    password: String,
+    receiver: String,
+) -> Result<(), String> {
     let file_path = "config/smtp_account.txt";
     let path = Path::new(file_path);
 
     let mut content = String::new();
     {
-        let mut file = File::open(path)
-            .await
-            .map_err(|e| e.to_string())?;
+        let mut file = File::open(path).await.map_err(|e| e.to_string())?;
         file.read_to_string(&mut content)
             .await
             .map_err(|e| e.to_string())?;
     }
 
     let updated_content = content
-        .replace("username:example@gmail.com", &format!("username:{}", username))
+        .replace(
+            "username:example@gmail.com",
+            &format!("username:{}", username),
+        )
         .replace("password:password123123", &format!("password:{}", password))
-        .replace("receiver:example@gmail.com", &format!("receiver:{}", receiver));
+        .replace(
+            "receiver:example@gmail.com",
+            &format!("receiver:{}", receiver),
+        );
 
     {
         let mut file = OpenOptions::new()

src/file_writer.rs

@@ -1,8 +1,11 @@
 use crate::file_reader::smtp_account_reader;
 use crate::file_writer::write_to_file;
 use lettre::{
-    message::{header::{self, ContentType}, MultiPart, SinglePart}, transport::smtp::authentication::Credentials, Message,
-    SmtpTransport, Transport,
+    message::{
+        header::{self}, MaybeString, MultiPart, SinglePart
+    },
+    transport::smtp::authentication::Credentials,
+    Message, SmtpTransport, Transport,
 };
 use maud::PreEscaped;
 
@@ -28,8 +31,7 @@ pub async fn mail_sender(title: &str, html: PreEscaped<String>) {
                 .singlepart(
                     SinglePart::builder()
                         .header(header::ContentType::TEXT_PLAIN)
-                        .body(format!(
-                            "Hello there!\nYour server is working fine! The next status email will be sent in 5 minutes.\n\nServer's Logs:\nYour client does not support html...")),
+                        .body(MaybeString::String(String::from("Hello there!\nYour server is working fine! The next status email will be sent in 5 minutes.\n\nServer's Logs:\nYour client does not support html..."))),
                 )
                 .singlepart(
                     SinglePart::builder()
@@ -50,7 +52,7 @@ pub async fn mail_sender(title: &str, html: PreEscaped<String>) {
     match mailer.send(&email) {
         Ok(_) => {
             match write_to_file(
-                format!("Email has been sent successfully!"),
+                "Email has been sent successfully!".to_string(),
                 "config/mail_logs.txt",
             )
             .await

src/mail.rs

@@ -12,11 +12,8 @@ use scheduler::status_upload;
 use file_writer::write_to_file;
 use setup::check_config_components;
 use std::thread;
-use tracing_subscriber;
 
 fn main() {
-    tracing_subscriber::fmt::init();
-
     let setup_handle = thread::Builder::new().name("setup".to_string()).spawn(|| {
         println!("Setup Process has been launched");
         match check_config_components() {
@@ -26,7 +23,7 @@ fn main() {
 
         async_std::task::block_on(async {
             match write_to_file(
-                format!("All config components are OK, loading the server.."),
+                "All config components are OK, loading the server..".to_string(),
                 "config/logs.txt",
             )
             .await
@@ -37,23 +34,30 @@ fn main() {
         });
     });
 
-    if let Err(_) = setup_handle.expect("Unable to join setup handle").join() {
+    let mail_handle = thread::Builder::new()
+        .name("mail_server".to_string())
+        .spawn(|| {
+            println!("Mail Server has been enabled");
+            status_upload();
+            println!("Mail Server has been disabled");
+        });
+
+    if setup_handle
+        .expect("Unable to join setup handle")
+        .join()
+        .is_err()
+    {
         eprintln!("An error occured when tried to join setup handle");
-    } else {
-        let mail_handle = thread::Builder::new()
-            .name("mail_server".to_string())
-            .spawn(|| {
-                println!("Mail Server has been enabled");
-                status_upload();
-                println!("Mail Server has been disabled");
-            });
-        if let Err(_) = mail_handle.expect("Unable to join mail handle").join() {
-            eprintln!("An error occured when tried to join mail handle");
-        }
-        // Please consider adding `else if` blocks until all handles won't be joined
-        else {
-            println!("All config components are OK, loading the server..");
-        }
+    } else if mail_handle
+        .expect("Unable to join mail handle")
+        .join()
+        .is_err()
+    {
+        eprintln!("An error occured when tried to join mail handle");
+    }
+    // Please consider adding `else if` blocks until all handles won't be joined
+    else {
+        println!("All config components are OK, loading the server..");
     }
     /*
         MINECRAFT SERVER SUPPORT USING VALENCE

src/main.rs

@@ -1,15 +1,17 @@
-use std::path::Path;
 use std::fs::OpenOptions;
-use std::io::*;
 use std::io;
+use std::io::*;
+use std::path::Path;
 
 use crate::file_reader::smtp_account_reader;
 use crate::file_writer::update_credentials;
 
 fn read_line() -> String {
     let mut input = String::new();
     io::stdout().flush().unwrap();
-    io::stdin().read_line(&mut input).expect("Failed to read line");
+    io::stdin()
+        .read_line(&mut input)
+        .expect("Failed to read line");
     input.trim().to_string()
 }
 
@@ -18,7 +20,7 @@ pub fn check_config_components() -> std::result::Result<(), String> {
         Path::new("config/logs.txt"),
         Path::new("config/smtp_account.txt"),
         Path::new("config/mail_logs.txt"),
-        ];
+    ];
 
     for path in components.into_iter() {
         let prefix = path.parent().unwrap();
@@ -27,16 +29,12 @@ pub fn check_config_components() -> std::result::Result<(), String> {
             .read(true)
             .write(true)
             .create(true)
+            .truncate(false)
             .open(path)
             .map_err(|e| e.to_string())?;
-        if path == Path::new("config/smtp_account.txt") {
-            match smtp_account_reader() {
-                Err(_) => {
-                    let _ = write!(file, "username:example@gmail.com\npassword:password123123\nreceiver:example@gmail.com\n\n### The username is your gmail account (example@gmail.com)\n### The password is a 'password for apps' created in Google\n## NOTICE: To create an app-password, you have to have 2-step verification\n## enabled and maybe all rescue options of saving the account.").map_err(|e| e.to_string());
-                    setup_wizard();
-                },
-                _ => {}
-            }
+        if path == Path::new("config/smtp_account.txt") && smtp_account_reader().is_err() {
+            let _ = write!(file, "username:example@gmail.com\npassword:password123123\nreceiver:example@gmail.com\n\n### The username is your gmail account (example@gmail.com)\n### The password is a 'password for apps' created in Google\n## NOTICE: To create an app-password, you have to have 2-step verification\n## enabled and maybe all rescue options of saving the account.").map_err(|e| e.to_string());
+            setup_wizard();
         }
     }
     Ok(())
@@ -52,70 +50,80 @@ pub fn setup_wizard() {
         match iter {
             1 => {
                 println!("Enter your smtp account username:");
-            },
+            }
             2 => {
                 println!("Can you confirm your smtp account username (Y or N)?");
-            },
+            }
             3 => {
                 println!("Enter your smtp account password:");
-            },
+            }
             4 => {
                 println!("Can you confirm your smtp account password (Y or N)?");
-            },
+            }
             5 => {
                 println!("Enter your gmail account as a receiver\n(you will receive status emails on this gmail address):")
             }
             6 => {
                 println!("Can you confirm your gmail account username (Y or N)?");
             }
-            _ => ()
+            _ => (),
         }
         let input = read_line();
         match iter {
             1 => {
-                println!("You have entered \"{}\" as your smtp account username", input);
+                println!(
+                    "You have entered \"{}\" as your smtp account username",
+                    input
+                );
                 smtp_account_username = input.clone();
                 iter += 1;
-            },
+            }
             2 => {
                 if input.to_lowercase() == "y" {
                     iter += 1;
-                }
-                else {
+                } else {
                     iter = 1
                 }
-            },
+            }
             3 => {
-                println!("You have entered \"{}\" as your smtp account password", input);
+                println!(
+                    "You have entered \"{}\" as your smtp account password",
+                    input
+                );
                 smtp_account_password = input.clone();
                 iter += 1;
-            },
+            }
             4 => {
                 if input.to_lowercase() == "y" {
                     iter += 1;
-                }
-                else {
+                } else {
                     iter = 3
                 }
-            },
+            }
             5 => {
-                println!("You have entered \"{}\" as your gmail account username", input);
+                println!(
+                    "You have entered \"{}\" as your gmail account username",
+                    input
+                );
                 receiver_gmail = input.clone();
                 iter += 1;
             }
             6 => {
                 if input.to_lowercase() == "y" {
                     iter += 1;
-                }
-                else {
+                } else {
                     iter = 5
                 }
             }
             _ => {
                 async_std::task::block_on(async move {
-                    update_credentials(smtp_account_username, smtp_account_password, receiver_gmail)
-                        .await
-                        .expect("Failed to update credentials");
+                    update_credentials(
+                        smtp_account_username,
+                        smtp_account_password,
+                        receiver_gmail,
+                    )
+                    .await
+                    .expect("Failed to update credentials");
                 });
                 return;
             }

src/setup.rs

@@ -1,86 +1,90 @@
 #[cfg(test)]
-mod tests {
-    use crate::*;
-    use async_std::fs::{self, File};
-    use async_std::path::Path;
-    use async_std::prelude::*;
-    use file_writer::update_credentials;
+use crate::*;
+use async_std::fs::{self, File};
+use async_std::path::Path;
+use async_std::prelude::*;
+use file_writer::update_credentials;
 
-    #[test]
-    fn test_write_to_file() {
-        let test_file_path = "test_write_to_file.txt";
+#[test]
+fn test_write_to_file() {
+    let test_file_path = "test_write_to_file.txt";
 
-        // Use block_on to run the async code inside the test
-        async_std::task::block_on(async {
-            // Ensure the test file is clean
-            if Path::new(test_file_path).exists().await {
-                fs::remove_file(test_file_path)
-                    .await
-                    .expect("Failed to remove test file");
-            }
-
-            // Write to the file
-            write_to_file("Hello, world!".to_string(), test_file_path)
+    // Use block_on to run the async code inside the test
+    async_std::task::block_on(async {
+        // Ensure the test file is clean
+        if Path::new(test_file_path).exists().await {
+            fs::remove_file(test_file_path)
                 .await
-                .expect("Failed to write to file");
+                .expect("Failed to remove test file");
+        }
 
-            // Read the file content
-            let mut file = File::open(test_file_path)
-                .await
-                .expect("Failed to open test file");
-            let mut content = String::new();
-            file.read_to_string(&mut content)
-                .await
-                .expect("Failed to read test file");
+        // Write to the file
+        write_to_file("Hello, world!".to_string(), test_file_path)
+            .await
+            .expect("Failed to write to file");
 
-            // Check the content
-            assert_eq!(content, "Hello, world!");
+        // Read the file content
+        let mut file = File::open(test_file_path)
+            .await
+            .expect("Failed to open test file");
+        let mut content = String::new();
+        file.read_to_string(&mut content)
+            .await
+            .expect("Failed to read test file");
 
-            // Clean up
-            fs::remove_file(test_file_path)
-                .await
-                .expect("Failed to remove test file");
-        });
-    }
+        // Check the content
+        assert_eq!(content, "Hello, world!");
+
+        // Clean up
+        fs::remove_file(test_file_path)
+            .await
+            .expect("Failed to remove test file");
+    });
+}
 
-    #[test]
-    fn test_update_credentials() {
-        let test_file_path = "config/test_smtp_account.txt";
+#[test]
+fn test_update_credentials() {
+    let test_file_path = "config/test_smtp_account.txt";
 
-        // Use block_on to run the async code inside the test
-        async_std::task::block_on(async {
-            // Ensure the config directory exists
-            fs::create_dir_all("config")
-                .await
-                .expect("Failed to create config directory");
+    // Use block_on to run the async code inside the test
+    async_std::task::block_on(async {
+        // Ensure the config directory exists
+        fs::create_dir_all("config")
+            .await
+            .expect("Failed to create config directory");
 
-            // Prepare the test file
-            let initial_content = "username:example@gmail.com\npassword:password123123\nreceiver:example@gmail.com\n";
-            fs::write(test_file_path, initial_content)
-                .await
-                .expect("Failed to write initial content");
+        // Prepare the test file
+        let initial_content =
+            "username:example@gmail.com\npassword:password123123\nreceiver:example@gmail.com\n";
+        fs::write(test_file_path, initial_content)
+            .await
+            .expect("Failed to write initial content");
 
-            // Update credentials
-            update_credentials("new_username".to_string(), "new_password".to_string(), "examplereceiver".to_string())
-                .await
-                .expect("Failed to update credentials");
-            // Read the updated file content
-            let mut file = File::open(test_file_path)
-                .await
-                .expect("Failed to open test file");
-            let mut content = String::new();
-            file.read_to_string(&mut content)
-                .await
-                .expect("Failed to read test file");
+        // Update credentials
+        update_credentials(
+            "new_username".to_string(),
+            "new_password".to_string(),
+            "examplereceiver".to_string(),
+        )
+        .await
+        .expect("Failed to update credentials");
+        // Read the updated file content
+        let mut file = File::open(test_file_path)
+            .await
+            .expect("Failed to open test file");
+        let mut content = String::new();
+        file.read_to_string(&mut content)
+            .await
+            .expect("Failed to read test file");
 
-            // Check the updated content
-            let expected_content = "username:new_username\npassword:new_password\nreceiver:example_receiver\n";
-            assert_eq!(content, expected_content);
+        // Check the updated content
+        let expected_content =
+            "username:new_username\npassword:new_password\nreceiver:example_receiver\n";
+        assert_eq!(content, expected_content);
 
-            // Clean up
-            fs::remove_file(test_file_path)
-                .await
-                .expect("Failed to remove test file");
-        });
-    }
+        // Clean up
+        fs::remove_file(test_file_path)
+            .await
+            .expect("Failed to remove test file");
+    });
 }