Error handling & config file update

Cargo.toml

@@ -3,8 +3,6 @@ name = "RustyServer"
 version = "0.1.0"
 edition = "2021"
 
-# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
-
 [dependencies]
 serde = { version = "1.0.145", features = ["derive"] }
 toml = "0.8.14"
@@ -14,4 +12,6 @@ time = "0.3.36"
 tokio = { version = "1", features = ["full"] }
 tokio-postgres = "0.7"
 async-std = "1.12.0"
-futures = "0.3.30"
+futures = "0.3.30"
+hyper = "1.4.1"
+serde_json = "1.0.120"

src/config/config.toml

@@ -1,4 +1,5 @@
 [database]
+typedb = "postgreSQL" # Only postgreSQL for the moment
 host = "localhost"
 port = 5432
 username = "postgres"

src/config/mod.rs

@@ -14,6 +14,7 @@ pub(crate) struct configToml {
 
 #[derive(Serialize, Deserialize, Debug)]
 pub struct configTomlDatabase {
+    pub typedb: String,
     pub host: String,
     pub port: u16,
     pub username: String,
@@ -23,6 +24,7 @@ pub struct configTomlDatabase {
 
 #[derive(Debug)]
 pub struct configData {
+    pub typedb: String,
     pub host: String,
     pub port: u16,
     pub username: String,
@@ -71,10 +73,11 @@ impl configToml {
             }
         });
 
-        let (host, port, username, password, database):
-            (String, u16, String, String, String) = match configToml.database {
+        let (typedb, host, port, username, password, database):
+            (String, String, u16, String, String, String) = match configToml.database {
             Some(database) => {
                 (
+                    database.typedb,
                     database.host,
                     database.port,
                     database.username,
@@ -83,6 +86,7 @@ impl configToml {
                 )
             }
             None => (
+                "unknown".to_owned(),
                 "unknown".to_owned(),
                 0.to_owned(),
                 "unknown".to_owned(),
@@ -107,6 +111,7 @@ impl configToml {
 
         configToml {
             database: Some(configTomlDatabase {
+                        typedb,
                         host,
                         port,
                         username,

src/database/database.rs

@@ -15,25 +15,47 @@ pub async fn connectToDB() -> Result<tokio_postgres::Client, tokio_postgres::Err
                                     db.port,
                                     db.username.trim(),
                                     db.password.trim(),
-                                    );
+    );
 
-    match tokio_postgres::connect(&connection_string, NoTls).await {
-        Ok((client, connection)) => {
-            tokio::spawn(async move {
-                if let Err(e) = connection.await {
-                    let logs = utils::Logs::initLog(None, format!("Impossible to connect to the database : {}", e), None);
-                    utils::Logs::error(logs);
-                }
-            });
-            let logs = utils::Logs::initLog(None, format!("Connected to the database ({}:{})", db.host, db.port), None);
-            utils::Logs::success(logs);
-            Ok(client)
+    if (db.typedb == "postgreSQL") {
+
+        match tokio_postgres::connect(&connection_string, NoTls).await {
+            Ok((client, connection)) => {
+                tokio::spawn(async move {
+                    if let Err(e) = connection.await {
+                        let logs = utils::Logs::initLog(None, format!("Impossible to connect to the database : {}", e), None);
+                        utils::Logs::error(logs);
+                    }
+                });
+                let logs = utils::Logs::initLog(None, format!("Connected to the database ({}:{})", db.host, db.port), None);
+                utils::Logs::success(logs);
+                Ok(client)
+            }
+            Err(e) => {
+                let error_message = format!("Impossible to connect to the database : {}", e);
+                let logs = utils::Logs::initLog(None, error_message, None);
+                utils::Logs::error(logs);
+                Err(e)
+            }
         }
-        Err(e) => {
-            let error_message = format!("Impossible to connect to the database : {}", e);
-            let logs = utils::Logs::initLog(None, error_message, None);
-            utils::Logs::error(logs);
-            Err(e)
+    } else {
+        match tokio_postgres::connect("null", NoTls).await {
+            Ok((client, connection)) => {
+                tokio::spawn(async move {
+                    if let Err(e) = connection.await {
+                        let logs = utils::Logs::initLog(None, format!("Impossible to connect to the database : {}", e), None);
+                        utils::Logs::error(logs);
+                    }
+                });
+                let logs = utils::Logs::initLog(None, format!("Connected to the database ({}:{})", db.host, db.port), None);
+                utils::Logs::success(logs);
+                Ok(client)
+            }
+            Err(e) => {
+                let logs = utils::Logs::initLog(None, format!("Only postgreSQL for the moment, but later MySQL, MariaDB, OracleDB, MongoDB : {}", e), None);
+                utils::Logs::warning(logs);
+                Err(e)
+            }
         }
     }
 }

src/main.rs

@@ -3,7 +3,10 @@ mod server;
 mod database;
 mod config;
 
+use std::env;
+
 #[tokio::main]
 async fn main() {
+    env::set_var("RUST_BACKTRACE", "0");
     server::startServer().await.unwrap();
 }

src/utils/exception.rs

@@ -0,0 +1,5 @@
+
+enum Error{
+    DatabaseTypeError(tokio_postgres::Error),
+
+}

src/utils/mod.rs

@@ -1,6 +1,9 @@
+mod exception;
+
 use colored::Colorize;
 
 pub mod Logs {
+    use std::fmt;
     use std::fmt::DebugStruct;
     use std::task::Context;
     use colored::Colorize;