refactor(error)!: handle errors more gracefully in rustic_core.

Cargo.toml

@@ -15,7 +15,8 @@ rust-version = "1.72.1"
 aho-corasick = "1.1.2"
 anyhow = "1.0.81"
 bytes = "1.5.0"
-enum-map = "2.7.3"
+enum-map = { version = "2.7.3", features = ["serde"] }
+parking_lot = { version = "0.12.1", features = ["deadlock_detection", "arc_lock"] }
 rustic_backend = { path = "crates/backend" }
 rustic_core = { path = "crates/core" }
 rustic_testing = { path = "crates/testing" }
@@ -74,7 +75,7 @@ trivial_casts = "warn"
 unused_lifetimes = "warn"
 unused_qualifications = "warn"
 bad_style = "warn"
-dead_code = "allow" # TODO: "warn"
+dead_code = "warn"
 improper_ctypes = "warn"
 missing_copy_implementations = "warn"
 missing_debug_implementations = "warn"
@@ -99,8 +100,8 @@ unreachable_pub = "allow"
 redundant_pub_crate = "allow"
 pedantic = "warn"
 nursery = "warn"
-# expect_used = "warn" # TODO!
-# unwrap_used = "warn" # TODO!
+expect_used = "warn"
+unwrap_used = "warn"
 enum_glob_use = "warn"
 correctness = "warn"
 suspicious = "warn"

crates/backend/src/choose.rs

@@ -200,10 +200,9 @@ impl BackendChoice for SupportedBackend {
 
 #[cfg(test)]
 mod tests {
-
-    use rstest::rstest;
-
     use super::*;
+    use anyhow::Result;
+    use rstest::rstest;
 
     #[rstest]
     #[case("local", SupportedBackend::Local)]
@@ -213,12 +212,14 @@ mod tests {
     #[case("rest", SupportedBackend::Rest)]
     #[cfg(feature = "opendal")]
     #[case("opendal", SupportedBackend::OpenDAL)]
-    fn test_try_from_is_ok(#[case] input: &str, #[case] expected: SupportedBackend) {
-        assert_eq!(SupportedBackend::try_from(input).unwrap(), expected);
+    fn test_try_from_passes(#[case] input: &str, #[case] expected: SupportedBackend) -> Result<()> {
+        assert_eq!(SupportedBackend::try_from(input)?, expected);
+
+        Ok(())
     }
 
     #[test]
-    fn test_try_from_unknown_is_err() {
+    fn test_try_from_unknown_fails() {
         assert!(SupportedBackend::try_from("unknown").is_err());
     }
 }

crates/backend/src/error.rs

@@ -1,4 +1,4 @@
-use std::{num::TryFromIntError, process::ExitStatus, str::Utf8Error};
+use std::{num::TryFromIntError, path::PathBuf, process::ExitStatus, str::Utf8Error};
 
 use displaydoc::Display;
 use thiserror::Error;
@@ -78,6 +78,12 @@ pub enum RestErrorKind {
     BuildingClientFailed(reqwest::Error),
     /// joining URL failed on: {0:?}
     JoiningUrlFailed(url::ParseError),
+    /// Status code not available
+    StatusCodeNotAvailable,
+    /// Redacting the password failed
+    RedactingPasswordFailed,
+    /// Failed to clone the request
+    CloningRequestFailed,
 }
 
 /// [`LocalBackendErrorKind`] describes the errors that can be returned by an action on the filesystem in Backends
@@ -91,7 +97,7 @@ pub enum LocalBackendErrorKind {
     QueryingWalkDirMetadataFailed(walkdir::Error),
     /// executtion of command failed: `{0:?}`
     CommandExecutionFailed(std::io::Error),
-    /// command was not successful for filename {file_name}, type {file_type}, id {id}: {status}
+    /// command was not successful for file name {file_name}, type {file_type}, id {id}: {status}
     CommandNotSuccessful {
         /// File name
         file_name: String,
@@ -128,4 +134,9 @@ pub enum LocalBackendErrorKind {
     ReadingExactLengthOfFileFailed(std::io::Error),
     /// failed to sync OS Metadata to disk: `{0:?}`
     SyncingOfOsMetadataFailed(std::io::Error),
+    /// Getting string from path failed: `{path}`
+    PathToStringFailed {
+        /// Path
+        path: PathBuf,
+    },
 }

crates/backend/src/local.rs

@@ -94,7 +94,7 @@ impl LocalBackend {
     ///
     /// * `tpe` - The type of the file.
     /// * `id` - The id of the file.
-    /// * `filename` - The path to the file.
+    /// * `file_name` - The path to the file.
     /// * `command` - The command to call.
     ///
     /// # Errors
@@ -115,11 +115,19 @@ impl LocalBackend {
     /// [`LocalBackendErrorKind::FromSplitError`]: LocalBackendErrorKind::FromSplitError
     /// [`LocalBackendErrorKind::CommandExecutionFailed`]: LocalBackendErrorKind::CommandExecutionFailed
     /// [`LocalBackendErrorKind::CommandNotSuccessful`]: LocalBackendErrorKind::CommandNotSuccessful
-    fn call_command(tpe: FileType, id: &Id, filename: &Path, command: &str) -> Result<()> {
+    fn call_command(tpe: FileType, id: &Id, file_name: &Path, command: &str) -> Result<()> {
         let id = id.to_hex();
         let patterns = &["%file", "%type", "%id"];
         let ac = AhoCorasick::new(patterns).map_err(LocalBackendErrorKind::FromAhoCorasick)?;
-        let replace_with = &[filename.to_str().unwrap(), tpe.dirname(), id.as_str()];
+        let replace_with = &[
+            file_name
+                .to_str()
+                .ok_or(LocalBackendErrorKind::PathToStringFailed {
+                    path: file_name.to_owned(),
+                })?,
+            tpe.dirname(),
+            id.as_str(),
+        ];
         let actual_command = ac.replace_all(command, replace_with);
         debug!("calling {actual_command}...");
         let commands = split(&actual_command).map_err(LocalBackendErrorKind::FromSplitError)?;
@@ -141,13 +149,25 @@ impl LocalBackend {
 }
 
 impl ReadBackend for LocalBackend {
-    /// Returns the location of the backend.
+    /// Get the location name of the backend.
     ///
     /// This is `local:<path>`.
-    fn location(&self) -> String {
+    ///
+    /// # Returns
+    ///
+    /// The location of the backend.
+    ///
+    /// # Notes
+    ///
+    /// The path is the path to the backend. In case the path is not a valid UTF-8 string,
+    /// the path is converted to a string lossy.
+    fn location(&self) -> Result<String> {
         let mut location = "local:".to_string();
-        location.push_str(&self.path.to_string_lossy());
-        location
+        let string_lossy = &self.path.to_string_lossy().to_string();
+        let string_lossy = string_lossy.as_str();
+        let path = self.path.to_str().map_or_else(|| string_lossy, |path| path);
+        location.push_str(path);
+        Ok(location)
     }
 
     /// Lists all files of the given type.
@@ -173,7 +193,7 @@ impl ReadBackend for LocalBackend {
             .into_iter()
             .filter_map(walkdir::Result::ok)
             .filter(|e| e.file_type().is_file())
-            .map(|e| Id::from_hex(&e.file_name().to_string_lossy()))
+            .map(|entry| Id::from_hex(&entry.file_name().to_string_lossy()))
             .filter_map(std::result::Result::ok);
         Ok(walker.collect())
     }
@@ -215,11 +235,12 @@ impl ReadBackend for LocalBackend {
         let walker = WalkDir::new(path)
             .into_iter()
             .filter_map(walkdir::Result::ok)
-            .filter(|e| e.file_type().is_file())
-            .map(|e| -> Result<_> {
+            .filter(|entry| entry.file_type().is_file())
+            .map(|entry| -> Result<_> {
                 Ok((
-                    Id::from_hex(&e.file_name().to_string_lossy())?,
-                    e.metadata()
+                    Id::from_hex(&entry.file_name().to_string_lossy())?,
+                    entry
+                        .metadata()
                         .map_err(LocalBackendErrorKind::QueryingWalkDirMetadataFailed)?
                         .len()
                         .try_into()
@@ -343,11 +364,11 @@ impl WriteBackend for LocalBackend {
     /// [`LocalBackendErrorKind::SyncingOfOsMetadataFailed`]: LocalBackendErrorKind::SyncingOfOsMetadataFailed
     fn write_bytes(&self, tpe: FileType, id: &Id, _cacheable: bool, buf: Bytes) -> Result<()> {
         trace!("writing tpe: {:?}, id: {}", &tpe, &id);
-        let filename = self.path(tpe, id);
+        let file_name = self.path(tpe, id);
         let mut file = fs::OpenOptions::new()
             .create(true)
             .write(true)
-            .open(&filename)
+            .open(&file_name)
             .map_err(LocalBackendErrorKind::OpeningFileFailed)?;
         file.set_len(
             buf.len()
@@ -360,7 +381,7 @@ impl WriteBackend for LocalBackend {
         file.sync_all()
             .map_err(LocalBackendErrorKind::SyncingOfOsMetadataFailed)?;
         if let Some(command) = &self.post_create_command {
-            if let Err(err) = Self::call_command(tpe, id, &filename, command) {
+            if let Err(err) = Self::call_command(tpe, id, &file_name, command) {
                 warn!("post-create: {err}");
             }
         }
@@ -382,10 +403,10 @@ impl WriteBackend for LocalBackend {
     /// [`LocalBackendErrorKind::FileRemovalFailed`]: LocalBackendErrorKind::FileRemovalFailed
     fn remove(&self, tpe: FileType, id: &Id, _cacheable: bool) -> Result<()> {
         trace!("removing tpe: {:?}, id: {}", &tpe, &id);
-        let filename = self.path(tpe, id);
-        fs::remove_file(&filename).map_err(LocalBackendErrorKind::FileRemovalFailed)?;
+        let file_name = self.path(tpe, id);
+        fs::remove_file(&file_name).map_err(LocalBackendErrorKind::FileRemovalFailed)?;
         if let Some(command) = &self.post_delete_command {
-            if let Err(err) = Self::call_command(tpe, id, &filename, command) {
+            if let Err(err) = Self::call_command(tpe, id, &file_name, command) {
                 warn!("post-delete: {err}");
             }
         }

crates/backend/src/opendal.rs

@@ -27,10 +27,11 @@ pub struct OpenDALBackend {
 fn runtime() -> &'static Runtime {
     static RUNTIME: OnceLock<Runtime> = OnceLock::new();
     RUNTIME.get_or_init(|| {
+        #[allow(clippy::expect_used)]
         tokio::runtime::Builder::new_multi_thread()
             .enable_all()
             .build()
-            .unwrap()
+            .expect("Failed to create tokio runtime.")
     })
 }
 
@@ -87,7 +88,7 @@ impl OpenDALBackend {
     /// # Returns
     ///
     /// The path for the given file type and id.
-    // Let's keep this for now, as it's being used in the trait implementations.
+    // INFO!: Let's keep this for now, as it's being used in the trait implementations.
     #[allow(clippy::unused_self)]
     fn path(&self, tpe: FileType, id: &Id) -> String {
         let hex_id = id.to_hex();
@@ -105,10 +106,10 @@ impl ReadBackend for OpenDALBackend {
     /// Returns the location of the backend.
     ///
     /// This is `local:<path>`.
-    fn location(&self) -> String {
+    fn location(&self) -> Result<String> {
         let mut location = "opendal:".to_string();
         location.push_str(self.operator.info().name());
-        location
+        Ok(location)
     }
 
     /// Lists all files of the given type.
@@ -232,10 +233,18 @@ impl WriteBackend for OpenDALBackend {
     /// * `id` - The id of the file.
     /// * `cacheable` - Whether the file is cacheable.
     /// * `buf` - The bytes to write.
+    ///
+    /// # Errors
+    ///
+    /// If the file cannot be written, an error is returned.
+    ///
+    /// # Returns
+    ///
+    /// If the file is written successfully, `Ok(())` is returned.
     fn write_bytes(&self, tpe: FileType, id: &Id, _cacheable: bool, buf: Bytes) -> Result<()> {
         trace!("writing tpe: {:?}, id: {}", &tpe, &id);
-        let filename = self.path(tpe, id);
-        self.operator.write(&filename, buf)?;
+        let file_name = self.path(tpe, id);
+        self.operator.write(&file_name, buf)?;
         Ok(())
     }
 
@@ -246,10 +255,18 @@ impl WriteBackend for OpenDALBackend {
     /// * `tpe` - The type of the file.
     /// * `id` - The id of the file.
     /// * `cacheable` - Whether the file is cacheable.
+    ///
+    /// # Errors
+    ///
+    /// If the file does not exist, an error is returned.
+    ///
+    /// # Returns
+    ///
+    /// If the file is removed successfully, `Ok(())` is returned.
     fn remove(&self, tpe: FileType, id: &Id, _cacheable: bool) -> Result<()> {
         trace!("removing tpe: {:?}, id: {}", &tpe, &id);
-        let filename = self.path(tpe, id);
-        self.operator.delete(&filename)?;
+        let file_name = self.path(tpe, id);
+        self.operator.delete(&file_name)?;
         Ok(())
     }
 }