feat: improve error handling for mutex locks across various commands and settings

Author: xd1i0

src-tauri/Cargo.toml

@@ -69,8 +69,8 @@ index-progress-logging = []
 index-error-logging = []
 
 # Testing features
-full = ["long-tests", "generate-test-data", "benchmarks", "open-file-in-app"]
-full-no-generate-test-data = ["long-tests", "benchmarks", "open-file-in-app"]
+full = ["long-tests", "generate-test-data", "benchmarks", "open-file-in-app", "sftp-tests"]
+full-no-generate-test-data = ["long-tests", "benchmarks", "open-file-in-app", "sftp-tests"]
 open-file-in-app = []
 generate-test-data = []
 long-tests = []

src-tauri/src/commands/file_system_operation_commands.rs

@@ -178,14 +178,14 @@ pub async fn open_directory(path: String) -> Result<String, String> {
 
         if file_type.is_dir() {
             directories.push(models::Directory {
-                name: entry.file_name().to_str().unwrap().to_string(),
-                path: path_of_entry.to_str().unwrap().to_string(),
+                name: entry.file_name().to_str().unwrap_or("[invalid name]").to_string(),
+                path: path_of_entry.to_str().unwrap_or("[invalid path]").to_string(),
                 is_symlink: path_of_entry.is_symlink(),
                 access_rights_as_string: get_access_permission_string(metadata.permissions(), true),
                 access_rights_as_number: get_access_permission_number(metadata.permissions(), true),
                 size_in_bytes: 0,
-                sub_file_count: count_subfiles(path_of_entry.to_str().unwrap()),
-                sub_dir_count: count_subdirectories(path_of_entry.to_str().unwrap()),
+                sub_file_count: path_of_entry.to_str().map(count_subfiles).unwrap_or(0),
+                sub_dir_count: path_of_entry.to_str().map(count_subdirectories).unwrap_or(0),
                 created: metadata
                     .created()
                     .map_or("1970-01-01 00:00:00".to_string(), |time| {
@@ -204,8 +204,8 @@ pub async fn open_directory(path: String) -> Result<String, String> {
             });
         } else if file_type.is_file() {
             files.push(models::File {
-                name: entry.file_name().to_str().unwrap().to_string(),
-                path: path_of_entry.to_str().unwrap().to_string(),
+                name: entry.file_name().to_str().unwrap_or("[invalid name]").to_string(),
+                path: path_of_entry.to_str().unwrap_or("[invalid path]").to_string(),
                 is_symlink: path_of_entry.is_symlink(),
                 access_rights_as_string: get_access_permission_string(
                     metadata.permissions(),
@@ -475,13 +475,13 @@ fn generate_unique_path(original_path: &str) -> String {
         return original_path.to_string();
     }
 
-    let parent = path.parent().unwrap_or(Path::new(""));
-    let file_name = path.file_name().unwrap().to_string_lossy();
+    let parent = path.parent().unwrap_or_else(|| Path::new("."));
+    let file_name = path.file_name().map(|n| n.to_string_lossy()).unwrap_or_else(|| "[invalid_name]".into());
 
     // Check if it's a file with extension or a directory
     if let Some(extension) = path.extension() {
         // It's a file with extension
-        let stem = path.file_stem().unwrap().to_string_lossy();
+        let stem = path.file_stem().map(|s| s.to_string_lossy()).unwrap_or_else(|| "[invalid_stem]".into());
         let ext = extension.to_string_lossy();
 
         for i in 1..=9999 {
@@ -595,8 +595,8 @@ pub async fn copy_file_or_dir(source_path: &str, destination_path: &str) -> Resu
             } else if entry_path.is_dir() {
                 // Recursively copy subdirectory
                 let sub_size = Box::pin(copy_file_or_dir(
-                    entry_path.to_str().unwrap(),
-                    dest_path.to_str().unwrap(),
+                    entry_path.to_str().unwrap_or("[invalid source path]"),
+                    dest_path.to_str().unwrap_or("[invalid dest path]"),
                 ))
                 .await?;
                 total_size += sub_size;

src-tauri/src/commands/hash_commands.rs

@@ -58,7 +58,7 @@ impl Display for HashError {
 async fn get_checksum_method(
     state: Arc<Mutex<SettingsState>>,
 ) -> Result<ChecksumMethod, HashError> {
-    let settings_state = state.lock().unwrap();
+    let settings_state = state.lock().map_err(|_| HashError::SettingsLockError)?;
     let inner_settings = settings_state
         .0
         .lock()

src-tauri/src/commands/meta_data_commands.rs

@@ -29,17 +29,27 @@ use tauri::State;
 /// ```
 #[tauri::command]
 pub fn get_meta_data_as_json(state: State<Arc<Mutex<MetaDataState>>>) -> Result<String, String> {
-    let meta_data = state.lock().unwrap().refresh_volumes();
+    let meta_data = state.lock().map_err(|_| {
+        Error::new(
+            ErrorCode::InternalError,
+            "Failed to acquire lock on metadata state".to_string(),
+        ).to_json()
+    })?.refresh_volumes();
 
-    if meta_data.is_err() {
+    if let Err(e) = meta_data {
         return Err(Error::new(
             ErrorCode::InternalError,
-            format!("Error: {}", meta_data.err().unwrap()),
+            format!("Error refreshing volumes: {}", e),
         )
         .to_json());
     }
 
-    let meta_data = state.lock().unwrap().0.clone();
+    let meta_data = state.lock().map_err(|_| {
+        Error::new(
+            ErrorCode::InternalError,
+            "Failed to acquire lock on metadata state".to_string(),
+        ).to_json()
+    })?.0.clone();
 
     serde_json::to_string(&meta_data).map_err(|e| {
         Error::new(
@@ -52,17 +62,27 @@ pub fn get_meta_data_as_json(state: State<Arc<Mutex<MetaDataState>>>) -> Result<
 
 #[cfg(test)]
 pub fn get_meta_data_as_json_impl(state: Arc<Mutex<MetaDataState>>) -> Result<String, String> {
-    let meta_data = state.lock().unwrap().refresh_volumes();
+    let meta_data = state.lock().map_err(|_| {
+        Error::new(
+            ErrorCode::InternalError,
+            "Failed to acquire lock on metadata state".to_string(),
+        ).to_json()
+    })?.refresh_volumes();
 
-    if meta_data.is_err() {
+    if let Err(e) = meta_data {
         return Err(Error::new(
             ErrorCode::InternalError,
-            format!("Error: {}", meta_data.err().unwrap()),
+            format!("Error refreshing volumes: {}", e),
         )
         .to_json());
     }
 
-    let meta_data = state.lock().unwrap().0.clone();
+    let meta_data = state.lock().map_err(|_| {
+        Error::new(
+            ErrorCode::InternalError,
+            "Failed to acquire lock on metadata state".to_string(),
+        ).to_json()
+    })?.0.clone();
 
     serde_json::to_string(&meta_data).map_err(|e| {
         Error::new(

src-tauri/src/commands/search_engine_commands.rs

@@ -46,7 +46,7 @@ pub fn search_impl(
         "Search implementation called with query: {}",
         query
     );
-    let engine = state.lock().unwrap();
+    let engine = state.lock().map_err(|_| "lock poisoned")?;
     engine.search(&query)
 }
 
@@ -96,7 +96,7 @@ pub fn search_with_extension_impl(
         "Search with extension called: query='{}', extensions={:?}",
         query, extensions
     );
-    let engine = state.lock().unwrap();
+    let engine = state.lock().map_err(|_| "Failed to acquire lock on search engine state")?;
     engine.search_by_extension(&query, extensions)
 }
 
@@ -173,7 +173,7 @@ pub fn add_paths_recursive_impl(
 
     log_info!("Starting optimized chunked indexing for path: {} with chunk size: {}", folder, default_chunk_size);
 
-    let engine_state = state.lock().unwrap();
+    let engine_state = state.lock().map_err(|_| "Failed to acquire lock on search engine state")?;
     let result = engine_state.start_chunked_indexing(path, default_chunk_size);
 
     match &result {
@@ -212,7 +212,7 @@ pub fn add_path(
 
 pub fn add_path_impl(path: String, state: Arc<Mutex<SearchEngineState>>) -> Result<(), String> {
     log_info!("Add path called with: {}", path);
-    let engine = state.lock().unwrap();
+    let engine = state.lock().map_err(|_| "Failed to acquire lock on search engine state")?;
     engine.add_path(&path)
 }
 
@@ -250,7 +250,7 @@ pub fn remove_paths_recursive_impl(
         "Remove paths recursive called with folder: {}",
         folder
     );
-    let engine = state.lock().unwrap();
+    let engine = state.lock().map_err(|_| "Failed to acquire lock on search engine state")?;
     engine.remove_paths_recursive(&folder)
 }
 
@@ -282,7 +282,7 @@ pub fn remove_path(
 
 pub fn remove_path_impl(path: String, state: Arc<Mutex<SearchEngineState>>) -> Result<(), String> {
     log_info!("Remove path called with: {}", path);
-    let engine = state.lock().unwrap();
+    let engine = state.lock().map_err(|_| "Failed to acquire lock on search engine state")?;
     engine.remove_path(&path)
 }
 
@@ -313,12 +313,12 @@ pub fn clear_search_engine(
 pub fn clear_search_engine_impl(state: Arc<Mutex<SearchEngineState>>) -> Result<(), String> {
     log_info!("Clear search engine called");
 
-    let state = state.lock().unwrap();
-    let mut engine = state.engine.write().unwrap();
+    let state = state.lock().map_err(|_| "Failed to acquire lock on search engine state")?;
+    let mut engine = state.engine.write().map_err(|_| "Failed to acquire write lock on search engine")?;
     engine.clear();
 
     // Update state
-    let mut data = state.data.lock().unwrap();
+    let mut data = state.data.lock().map_err(|_| "Failed to acquire lock on search engine data")?;
     data.last_updated = chrono::Utc::now().timestamp_millis() as u64;
 
     Ok(())
@@ -376,7 +376,7 @@ pub fn get_search_engine_info_impl(
     state: Arc<Mutex<SearchEngineState>>,
 ) -> Result<SearchEngineInfo, String> {
     log_info!("Get search engine info called");
-    let engine = state.lock().unwrap();
+    let engine = state.lock().map_err(|_| "Failed to acquire lock on search engine state")?;
     Ok(engine.get_search_engine_info())
 }
 
@@ -395,7 +395,7 @@ pub async fn get_indexing_progress(
         progress.files_indexed,
         progress.files_discovered,
         progress.percentage_complete,
-        progress.current_path.as_ref().map(|p| p.split('/').last().unwrap_or(p)),
+        progress.current_path.as_ref().and_then(|p| p.split('/').last()).unwrap_or(""),
         data.status
     );
 
@@ -756,11 +756,11 @@ pub fn get_suggestions_impl(
         return Ok(Vec::new());
     }
 
-    let search_engine_state = state.lock().unwrap();
+    let search_engine_state = state.lock().map_err(|_| "Failed to acquire lock on search engine state")?;
 
     // Check if search engine is enabled
     {
-        let data = search_engine_state.data.lock().unwrap();
+        let data = search_engine_state.data.lock().map_err(|_| "Failed to acquire lock on search engine data")?;
         if !data.config.search_engine_enabled {
             log_error!("Search engine is disabled in configuration.");
             return Err("Search engine is disabled in configuration".to_string());

src-tauri/src/commands/settings_commands.rs

@@ -29,8 +29,23 @@ pub fn get_settings_as_json(state: State<Arc<Mutex<SettingsState>>>) -> String {
 }
 
 pub fn get_settings_as_json_impl(state: Arc<Mutex<SettingsState>>) -> String {
-    let settings_inner = state.lock().unwrap().0.clone();
-    to_string(&settings_inner).unwrap()
+    let settings_inner = match state.lock() {
+        Ok(guard) => guard.0.clone(),
+        Err(_) => {
+            return Error::new(
+                ErrorCode::InternalError,
+                "Failed to acquire lock on settings state".to_string(),
+            ).to_json();
+        }
+    };
+    
+    match to_string(&settings_inner) {
+        Ok(json) => json,
+        Err(_) => Error::new(
+            ErrorCode::InternalError,
+            "Failed to serialize settings to JSON".to_string(),
+        ).to_json()
+    }
 }
 
 /// Retrieves the value of a specific setting field.
@@ -68,7 +83,12 @@ pub fn get_setting_field_impl(
     state: Arc<Mutex<SettingsState>>,
     key: String,
 ) -> Result<serde_json::Value, String> {
-    let settings_state = state.lock().unwrap();
+    let settings_state = state.lock().map_err(|_| {
+        Error::new(
+            ErrorCode::InternalError,
+            "Failed to acquire lock on settings state".to_string(),
+        ).to_json()
+    })?;
     settings_state.get_setting_field(&key).map_err(|e| {
         Error::new(
             ErrorCode::InternalError,
@@ -116,7 +136,12 @@ pub fn update_settings_field_impl(
     key: String,
     value: serde_json::Value,
 ) -> Result<String, String> {
-    let settings_state = state.lock().unwrap();
+    let settings_state = state.lock().map_err(|_| {
+        Error::new(
+            ErrorCode::InternalError,
+            "Failed to acquire lock on settings state".to_string(),
+        ).to_json()
+    })?;
     settings_state
         .update_setting_field(&key, value)
         .and_then(|updated| {
@@ -170,7 +195,12 @@ pub fn update_multiple_settings_impl(
     state: Arc<Mutex<SettingsState>>,
     updates: serde_json::Map<String, serde_json::Value>,
 ) -> Result<String, String> {
-    let settings_state = state.lock().unwrap();
+    let settings_state = state.lock().map_err(|_| {
+        Error::new(
+            ErrorCode::InternalError,
+            "Failed to acquire lock on settings state".to_string(),
+        ).to_json()
+    })?;
     settings_state
         .update_multiple_settings(&updates)
         .and_then(|updated| {
@@ -213,7 +243,12 @@ pub fn reset_settings_command(state: State<Arc<Mutex<SettingsState>>>) -> Result
 }
 
 pub fn reset_settings_impl(state: Arc<Mutex<SettingsState>>) -> Result<String, String> {
-    let settings_state = state.lock().unwrap();
+    let settings_state = state.lock().map_err(|_| {
+        Error::new(
+            ErrorCode::InternalError,
+            "Failed to acquire lock on settings state".to_string(),
+        ).to_json()
+    })?;
     settings_state
         .reset_settings()
         .and_then(|updated| {

src-tauri/src/commands/sftp_file_system_operation_commands.rs

@@ -266,7 +266,10 @@ pub fn copy_directory_sftp(
     let entries = sftp.readdir(&source_path).map_err(|e| e.to_string())?;
 
     for (path, stat) in entries {
-        let new_path = format!("{}/{}", destination_path, path.file_name().unwrap().to_str().unwrap());
+        let file_name = path.file_name()
+            .and_then(|name| name.to_str())
+            .unwrap_or("[invalid_filename]");
+        let new_path = format!("{}/{}", destination_path, file_name);
 
         if stat.is_file() {
             // Copy file
@@ -278,7 +281,8 @@ pub fn copy_directory_sftp(
             destination_file.write_all(&buffer).map_err(|e| e.to_string())?;
         } else if stat.is_dir() {
             // Recursively copy directory
-            copy_directory_sftp(host.clone(), port, username.clone(), password.clone(), path.to_str().unwrap().to_string(), new_path)?;
+            let path_str = path.to_str().unwrap_or("[invalid_path]").to_string();
+            copy_directory_sftp(host.clone(), port, username.clone(), password.clone(), path_str, new_path)?;
         }
     }
 

src-tauri/src/commands/template_commands.rs

@@ -105,7 +105,11 @@ pub async fn add_template_impl(
 
     // Extract what we need from the metadata state before any await points
     let dest_path = {
-        let metadata_state = state.lock().unwrap();
+        let metadata_state = state.lock().map_err(|e| {
+            let error_msg = format!("Error acquiring lock on metadata state: {:?}", e);
+            log_error!(error_msg.as_str());
+            error_msg
+        })?;
         let inner_metadata = metadata_state.0.lock().map_err(|e| {
             let error_msg = format!("Error acquiring lock on metadata state: {:?}", e);
             log_error!(error_msg.as_str());
@@ -128,7 +132,12 @@ pub async fn add_template_impl(
     }
 
     // Copy the template using our helper function
-    let size = copy_to_dest_path(template_path, dest_path.to_str().unwrap()).await?;
+    let dest_path_str = dest_path.to_str().ok_or_else(|| {
+        let error_msg = "Invalid destination path encoding".to_string();
+        log_error!(error_msg.as_str());
+        error_msg
+    })?;
+    let size = copy_to_dest_path(template_path, dest_path_str).await?;
 
     // Update the template paths in the metadata state
     let update_result = {

src-tauri/src/error_handling.rs

@@ -57,7 +57,9 @@ impl Error {
         }
     }
     pub fn to_json(&self) -> String {
-        serde_json::to_string(self).unwrap()
+        serde_json::to_string(self).unwrap_or_else(|_| {
+            r#"{"code":500,"message_from_code":"InternalError","custom_message":"Failed to serialize error"}"#.to_string()
+        })
     }
 }
 

src-tauri/src/search_engine/fast_fuzzy_v2.rs

@@ -614,10 +614,9 @@ impl PathMatcher {
                         let variation_index = variation_idx as f32 / variations.len() as f32;
                         let mut score = 0.9 - (variation_index * 0.2);
                         // Bonus for matching first char
-                        if !query_lower.is_empty() && !filename_lower.is_empty() {
-                            if query_lower.chars().next().unwrap()
-                                == filename_lower.chars().next().unwrap()
-                            {
+                        if let (Some(query_first), Some(filename_first)) = 
+                            (query_lower.chars().next(), filename_lower.chars().next()) {
+                            if query_first == filename_first {
                                 score += 0.3;
                             }
                         }