Unwraps removed

database/src/db.rs

@@ -5,6 +5,7 @@ pub struct Db {
 }
 
 impl Db {
+    // CHECK THIS
     pub async fn connect_to_the_pool() -> Db {
         dotenvy::from_filename("infra/.env").unwrap();
 

database/src/tables/requests/table_struct.rs

@@ -26,7 +26,8 @@ impl FromRow<'_, PgRow> for Request {
         Ok(Request {
             request_id: row.get("request_id"),
             app_id: row.get("app_id"),
-            request_type: RequestType::from_str(row.get("request_type")).unwrap(),
+            request_type: RequestType::from_str(row.get("request_type"))
+                .map_err(|_| sqlx::Error::Decode(format!("Invalid request_type")))?,
             session_id: row.get("session_id"),
             request_status: row.get("request_status"),
             network: row.get("network"),

database/src/tables/sessions/update.rs

@@ -18,7 +18,10 @@ impl Db {
         ip_address: &String,
         current_time: &DateTime<Utc>,
     ) -> Result<(), DbError> {
-        let mut tx = self.connection_pool.begin().await.unwrap();
+        let mut tx = match self.connection_pool.begin().await {
+            Ok(tx) => tx,
+            Err(err) => return Err(err.into()),
+        };
 
         // 1. Save the new session
         if let Err(err) = self.save_new_session(&mut tx, &session).await {
@@ -116,7 +119,10 @@ impl Db {
         session_id: &String,
     ) -> Result<(), DbError> {
         // Start a new transaction
-        let mut tx = self.connection_pool.begin().await.unwrap();
+        let mut tx = match self.connection_pool.begin().await {
+            Ok(tx) => tx,
+            Err(err) => return Err(err.into()),
+        };
 
         // User can't connect to the session without any connected keys
         if connected_keys.is_empty() {

database/src/tables/utils.rs

@@ -1,9 +1,19 @@
+use log::error;
 use sqlx::types::chrono::{DateTime, TimeZone, Utc};
 use std::time::{SystemTime, UNIX_EPOCH};
 
 pub fn get_timestamp_in_milliseconds() -> u64 {
     let now = SystemTime::now();
-    let since_the_epoch = now.duration_since(UNIX_EPOCH).expect("Time went backwards");
+    let since_the_epoch = match now.duration_since(UNIX_EPOCH) {
+        Ok(duration) => duration,
+        Err(err) => {
+            error!(
+                "Error getting timestamp in milliseconds: {}. Time went backwards",
+                err
+            );
+            return 0;
+        }
+    };
     since_the_epoch.as_millis() as u64
 }
 
@@ -17,7 +27,10 @@ pub fn get_current_datetime() -> DateTime<Utc> {
 
 pub fn to_microsecond_precision(datetime: &DateTime<Utc>) -> DateTime<Utc> {
     // Should never fail as we are converting from a valid DateTime<Utc>
-    Utc.timestamp_micros(datetime.timestamp_micros()).unwrap()
+    match Utc.timestamp_micros(datetime.timestamp_micros()) {
+        chrono::LocalResult::Single(dt) => dt,
+        _ => get_current_datetime(),
+    }
 }
 
 // This function is used to format the keys of a table to be used in a view query

server/src/cloud_state.rs

@@ -31,6 +31,7 @@ pub struct CloudState {
     pub grafana_client_conf: Arc<Configuration>,
 }
 
+// CHECK THIS
 impl CloudState {
     pub async fn new() -> Self {
         let sessions_cache = get_new_session();

server/src/env.rs

@@ -16,6 +16,7 @@ pub struct ENV {
     pub GF_SECURITY_ADMIN_PASSWORD: String,
     pub MAILER_ACTIVE: bool,
 }
+// CHECK THIS
 pub fn get_env() -> &'static ENV {
     static INSTANCE: OnceCell<ENV> = OnceCell::new();
 

server/src/http/cloud/change_user_privileges.rs

@@ -136,7 +136,17 @@ pub async fn change_user_privileges(
             // Update users privileges
             for requested_change in request.privileges_changes {
                 // Determine action
-                let new_privilege_level = requested_change.new_privilege_level.to_privilege_level();
+                let new_privilege_level =
+                    match requested_change.new_privilege_level.to_privilege_level() {
+                        Some(privilege) => privilege,
+                        None => {
+                            error!("Failed to convert new privilege level");
+                            return Err((
+                                StatusCode::BAD_REQUEST,
+                                CloudApiErrors::InternalServerError.to_string(),
+                            ));
+                        }
+                    };
                 let user_id = user_ids.get(&requested_change.user_email).ok_or((
                     StatusCode::BAD_REQUEST,
                     CloudApiErrors::UserDoesNotExist.to_string(),
@@ -158,8 +168,7 @@ pub async fn change_user_privileges(
                                     &mut tx,
                                     user_id,
                                     &requested_change.app_id,
-                                    // Safe unwrap
-                                    new_privilege_level.unwrap(),
+                                    new_privilege_level,
                                 )
                                 .await
                                 .map_err(|err| {
@@ -212,8 +221,7 @@ pub async fn change_user_privileges(
                                     &mut tx,
                                     user_id,
                                     &requested_change.app_id,
-                                    // Safe unwrap
-                                    new_privilege_level.unwrap(),
+                                    new_privilege_level,
                                 )
                                 .await
                                 .map_err(|err| {

server/src/http/cloud/delete_app.rs

@@ -70,7 +70,16 @@ pub async fn delete_app(
             }
             // Delete the app
             // Start a transaction
-            let mut tx = db.connection_pool.begin().await.unwrap();
+            let mut tx = match db.connection_pool.begin().await {
+                Ok(tx) => tx,
+                Err(err) => {
+                    error!("Failed to start transaction: {:?}", err);
+                    return Err((
+                        StatusCode::INTERNAL_SERVER_ERROR,
+                        CloudApiErrors::DatabaseError.to_string(),
+                    ));
+                }
+            };
 
             if let Err(err) = db
                 .remove_privileges_for_inactive_app_within_tx(&mut tx, &request.app_id)

server/src/http/cloud/delete_team.rs

@@ -32,7 +32,16 @@ pub async fn delete_team(
     validate_request(&request, &())?;
     warn!("Delete team request: {:?}", request);
     // Start a transaction
-    let mut tx = db.connection_pool.begin().await.unwrap();
+    let mut tx = match db.connection_pool.begin().await {
+        Ok(tx) => tx,
+        Err(err) => {
+            error!("Failed to start transaction: {:?}", err);
+            return Err((
+                StatusCode::INTERNAL_SERVER_ERROR,
+                CloudApiErrors::DatabaseError.to_string(),
+            ));
+        }
+    };
 
     // First check if team exists
     let team = match db.get_team_by_team_id(None, &request.team_id).await {

server/src/http/cloud/domains/remove_whitelisted_domain.rs

@@ -105,7 +105,16 @@ pub async fn remove_whitelisted_domain(
         ));
     }
 
-    let mut tx = db.connection_pool.begin().await.unwrap();
+    let mut tx = match db.connection_pool.begin().await {
+        Ok(tx) => tx,
+        Err(err) => {
+            error!("Failed to start transaction: {:?}", err);
+            return Err((
+                StatusCode::INTERNAL_SERVER_ERROR,
+                CloudApiErrors::DatabaseError.to_string(),
+            ));
+        }
+    };
 
     // Remove domain from whitelisted domains
     if let Err(err) = db

server/src/http/cloud/domains/verify_domain_finish.rs

@@ -183,7 +183,16 @@ pub async fn verify_domain_finish(
     }
 
     // Add domain to whitelist
-    let mut tx = db.connection_pool.begin().await.unwrap();
+    let mut tx = match db.connection_pool.begin().await {
+        Ok(tx) => tx,
+        Err(err) => {
+            error!("Failed to start transaction: {:?}", err);
+            return Err((
+                StatusCode::INTERNAL_SERVER_ERROR,
+                CloudApiErrors::DatabaseError.to_string(),
+            ));
+        }
+    };
 
     if let Err(err) = db
         .add_new_whitelisted_domain(&mut tx, &request.app_id, &domain_name)
@@ -249,7 +258,10 @@ async fn check_verification_code(
                 let txt_data = txt.txt_data();
                 // Each TXT record can contain multiple strings, so we iterate through them all
                 for txt_str in txt_data {
-                    let txt_str = std::str::from_utf8(txt_str).unwrap();
+                    let txt_str = match std::str::from_utf8(txt_str) {
+                        Ok(txt_str) => txt_str,
+                        Err(err) => bail!("Failed to parse TXT record: {:?}", err),
+                    };
                     // Check if the verification code is present
                     if txt_str.contains(&code) {
                         return Ok(());

server/src/http/cloud/events/processors/process_event_app_connect.rs

@@ -91,7 +91,16 @@ pub async fn process_event_app_connect(
         }
     } else {
         // Reconnection to an existing session
-        let mut tx = db.connection_pool.begin().await.unwrap();
+        let mut tx = match db.connection_pool.begin().await {
+            Ok(tx) => tx,
+            Err(err) => {
+                error!(
+                    "Failed to create new transaction to save app connection event, app_id: [{}], event: [{:?}], err: [{}]",
+                    app_id, event, err
+                );
+                return;
+            }
+        };
 
         // Get the geolocation data
         let geo_location_data = get_geolocation_data(&db, &geo_loc_requester, &ip).await;

server/src/http/cloud/events/processors/process_event_client_connect.rs

@@ -21,7 +21,16 @@ pub async fn process_event_client_connect_init(
     save_event_client_connect(db, app_id, network, event, &current_time).await;
 
     // Save connection attempt by client
-    let mut tx = db.connection_pool.begin().await.unwrap();
+    let mut tx = match db.connection_pool.begin().await {
+        Ok(tx) => tx,
+        Err(err) => {
+            error!(
+                "Failed to create new transaction to save client connect event, app_id: [{}], event: [{:?}], err: [{}]",
+                app_id, event, err
+            );
+            return;
+        }
+    };
 
     // Get the geolocation data
     let geo_location_data = get_geolocation_data(&db, &geo_loc_requester, &ip).await;

server/src/http/cloud/events/processors/process_event_client_disconnect.rs

@@ -17,7 +17,16 @@ pub async fn process_event_client_disconnect(
     save_event_client_disconnect(db, app_id, network, event, &current_timestamp).await;
 
     // Update connection status for user
-    let mut tx = db.connection_pool.begin().await.unwrap();
+    let mut tx = match db.connection_pool.begin().await {
+        Ok(tx) => tx,
+        Err(err) => {
+            error!(
+                "Failed to create new transaction to update client disconnect status, app_id: [{}], event: [{:?}], err: [{}]",
+                app_id, event, err
+            );
+            return;
+        }
+    };
 
     match db
         .close_client_connection(&mut tx, &app_id, &event.disconnected_session_id)

server/src/http/cloud/grafana_utils/import_template_dashboard.rs

@@ -14,7 +14,7 @@ use openapi::{
 use serde_json::Value;
 use std::{env, sync::Arc};
 use tokio::fs;
-
+// CHECK THIS -  used only at the begginning - better to have error
 pub async fn setup_templates_dashboard(
     grafana_conf: &Arc<Configuration>,
 ) -> Result<(), (StatusCode, String)> {

server/src/http/cloud/register_new_app.rs

@@ -140,7 +140,16 @@ pub async fn register_new_app(
 
             // Register a new app under this team
             // Start a transaction
-            let mut tx = db.connection_pool.begin().await.unwrap();
+            let mut tx = match db.connection_pool.begin().await {
+                Ok(tx) => tx,
+                Err(err) => {
+                    error!("Failed to start transaction: {:?}", err);
+                    return Err((
+                        StatusCode::INTERNAL_SERVER_ERROR,
+                        CloudApiErrors::DatabaseError.to_string(),
+                    ));
+                }
+            };
 
             // Register a new app
             let db_registered_app =

server/src/infra_env.rs

@@ -30,6 +30,7 @@ pub struct INFRA_ENV {
     pub OFELIA_EMAIL_TO: String,
 }
 
+// CHECK THIS
 pub fn get_env() -> &'static INFRA_ENV {
     static INSTANCE: OnceCell<INFRA_ENV> = OnceCell::new();
 

server/src/mailer/mailer.rs

@@ -10,7 +10,7 @@ pub struct Mailer {
     pub templates: Arc<HashMap<Templates, String>>,
     pub mailbox: Mailbox,
 }
-
+// CHECK THIS
 impl Mailer {
     pub async fn init(username: String, password: String) -> Self {
         let creds = Credentials::new(username.clone(), password);

server/src/sesssion_cleaner.rs

@@ -3,7 +3,7 @@ use crate::{
     utils::get_timestamp_in_milliseconds,
 };
 use futures::SinkExt;
-use log::info;
+use log::{error, info};
 use std::{collections::HashMap, time::Duration, vec};
 
 pub fn start_cleaning_sessions(
@@ -78,12 +78,26 @@ pub fn start_cleaning_sessions(
 
             // Remove all sessions that expired
             for (app_id, session_id) in sessions_to_remove {
-                // safe unwrap because we just checked if the session exists
-                let app_sessions = sessions_write.get_mut(&app_id).unwrap();
+                let app_sessions = match sessions_write.get_mut(&app_id) {
+                    Some(app_sessions) => app_sessions,
+                    None => {
+                        error!("App: [{}] does not have any sessions", app_id);
+                        return;
+                    }
+                };
                 let mut app_sessions_write = app_sessions.write().await;
 
                 for session_id in session_id {
-                    let session = app_sessions_write.get_mut(&session_id).unwrap();
+                    let session = match app_sessions_write.get_mut(&session_id) {
+                        Some(session) => session,
+                        None => {
+                            error!(
+                                "App: [{}] does not have session with id: [{}]",
+                                app_id, session_id
+                            );
+                            return;
+                        }
+                    };
                     let mut session_write = session.write().await;
 
                     // Remove session from client_to_sessions

server/src/state.rs

@@ -15,7 +15,7 @@ use axum::extract::{
 };
 use database::db::Db;
 use futures::{stream::SplitSink, SinkExt};
-use log::info;
+use log::{error, info};
 use openapi::apis::configuration::Configuration;
 use std::{
     collections::{HashMap, HashSet},
@@ -41,6 +41,7 @@ pub struct ServerState {
     pub cloud_state: Option<Arc<CloudState>>,
 }
 
+// CHECK THIS
 impl FromRef<ServerState> for Arc<Db> {
     fn from_ref(state: &ServerState) -> Self {
         // Safe as middleware will prevent this from being None
@@ -125,12 +126,18 @@ impl SendToClient for ClientSockets {
         match self.read().await.get(&client_id) {
             Some(client_socket) => {
                 info!("Send to client {}, msg: {:?}", client_id, msg);
+                let serialized_msg = match serde_json::to_string(&msg) {
+                    Ok(serialized_msg) => serialized_msg,
+                    Err(err) => {
+                        error!("Failed to serialize message: {:?}", err);
+                        return Err(anyhow::anyhow!("Failed to serialize message: {:?}", err));
+                    }
+                };
+
                 return Ok(client_socket
                     .write()
                     .await
-                    .send(Message::Text(
-                        serde_json::to_string(&msg).expect("Serialization should work"),
-                    ))
+                    .send(Message::Text(serialized_msg))
                     .await?);
             }
             None => Err(anyhow::anyhow!("No client socket found for session")),

server/src/statics.rs

@@ -10,6 +10,7 @@ pub const TEMPLATES_FOLDER_UID: &str = "TEMPLATE_FOLDER_UID";
 pub const POSTGRES_DATASOURCE_UID: &str = "POSTGRES_DATASOURCE_UID";
 
 // Name must be 3-30 characters long and include only alphanumeric characters, underscores, or slashes.
+// CHECK THIS - all regex creation
 pub static NAME_REGEX: Lazy<Regex> =
     Lazy::new(|| Regex::new(r"^[a-zA-Z0-9_-]{3,30}$").expect("Regex creation failed"));