enhance error handling with thiserror

Signed-off-by: linchuan <[email protected]>

api/Cargo.toml

@@ -14,6 +14,7 @@ log = "0.4.8"
 serde_json = "1.0.53"
 toml = "0.5"
 
+thiserror = "1.0.30"
 backtrace = { version = "0.3", optional = true }
 dbs-uhttp = { version = "0.3.0", optional = true }
 http = { version = "0.2.1", optional = true }

api/src/http.rs

@@ -9,16 +9,17 @@ use std::sync::mpsc::{RecvError, SendError};
 
 use serde::Deserialize;
 use serde_json::Error as SerdeError;
+use thiserror::Error;
 
 use crate::BlobCacheEntry;
 
 /// Errors related to Metrics.
-#[derive(Debug)]
+#[derive(Error, Debug)]
 pub enum MetricsError {
-    /// Non-exist counter.
+    #[error("no counter found for the metric")]
     NoCounter,
-    /// Failed to serialize message.
-    Serialize(SerdeError),
+    #[error("failed to serialize metric: {0:?}")]
+    Serialize(#[source] SerdeError),
 }
 
 /// Mount a filesystem.
@@ -145,25 +146,25 @@ pub enum MetricsErrorKind {
     Stats(MetricsError),
 }
 
-#[derive(Debug)]
+#[derive(Error, Debug)]
 #[allow(clippy::large_enum_variant)]
 pub enum ApiError {
-    /// Daemon internal error
+    #[error("daemon internal error: {0:?}")]
     DaemonAbnormal(DaemonErrorKind),
-    /// Failed to get events information
+    #[error("daemon events error: {0}")]
     Events(String),
-    /// Failed to get metrics information
+    #[error("metrics error: {0:?}")]
     Metrics(MetricsErrorKind),
-    /// Failed to mount filesystem
+    #[error("failed to mount filesystem: {0:?}")]
     MountFilesystem(DaemonErrorKind),
-    /// Failed to send request to the API service
-    RequestSend(SendError<Option<ApiRequest>>),
-    /// Unrecognized payload content
+    #[error("failed to send request to the API service: {0:?}")]
+    RequestSend(#[from] SendError<Option<ApiRequest>>),
+    #[error("failed to parse response payload type")]
     ResponsePayloadType,
-    /// Failed to receive response from the API service
-    ResponseRecv(RecvError),
-    /// Failed to send wakeup notification
-    Wakeup(io::Error),
+    #[error("failed to receive response from the API service: {0:?}")]
+    ResponseRecv(#[from] RecvError),
+    #[error("failed to wake up the daemon: {0:?}")]
+    Wakeup(#[source] io::Error),
 }
 
 /// Specialized `std::result::Result` for API replies.

rafs/src/fs.rs

@@ -85,7 +85,7 @@ impl Rafs {
         let cache_cfg = cfg.get_cache_config().map_err(RafsError::LoadConfig)?;
         let rafs_cfg = cfg.get_rafs_config().map_err(RafsError::LoadConfig)?;
         let (sb, reader) = RafsSuper::load_from_file(path, cfg.clone(), false)
-            .map_err(RafsError::FillSuperblock)?;
+            .map_err(RafsError::FillSuperBlock)?;
         let blob_infos = sb.superblock.get_blob_infos();
         let device = BlobDevice::new(cfg, &blob_infos).map_err(RafsError::CreateDevice)?;
 

rafs/src/lib.rs

@@ -39,7 +39,7 @@ extern crate nydus_storage as storage;
 
 use std::any::Any;
 use std::borrow::Cow;
-use std::fmt::{Debug, Display, Formatter, Result as FmtResult};
+use std::fmt::Debug;
 use std::fs::File;
 use std::io::{BufWriter, Error, Read, Result, Seek, SeekFrom, Write};
 use std::os::unix::io::AsRawFd;
@@ -56,37 +56,38 @@ pub mod metadata;
 pub mod mock;
 
 /// Error codes for rafs related operations.
-#[derive(Debug)]
+#[derive(thiserror::Error, Debug)]
 pub enum RafsError {
+    #[error("operation is not supported.")]
     Unsupported,
+    #[error("rafs is not initialized.")]
     Uninitialized,
+    #[error("rafs is already mounted.")]
     AlreadyMounted,
+    #[error("failed to read metadata: {0}`")]
     ReadMetadata(Error, String),
+    #[error("failed to load config: {0}`")]
     LoadConfig(Error),
-    ParseConfig(serde_json::Error),
+    #[error("failed to parse config: {0}`")]
+    ParseConfig(#[source] serde_json::Error),
+    #[error("failed to create swap backend: {0}`")]
     SwapBackend(Error),
-    FillSuperblock(Error),
+    #[error("failed to fill superBlock: {0}`")]
+    FillSuperBlock(Error),
+    #[error("failed to create device: {0}`")]
     CreateDevice(Error),
+    #[error("failed to prefetch data: {0}`")]
     Prefetch(String),
+    #[error("failed to configure device: {0}`")]
     Configure(String),
+    #[error("incompatible inode format: `{0}`")]
     Incompatible(u16),
+    #[error("illegal meta struct, type is `{0:?}` and content is `{1}`")]
     IllegalMetaStruct(MetaType, String),
+    #[error("invalid image data")]
     InvalidImageData,
 }
 
-impl std::error::Error for RafsError {
-    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
-        None
-    }
-}
-
-impl Display for RafsError {
-    fn fmt(&self, f: &mut Formatter) -> FmtResult {
-        write!(f, "{:?}", self)?;
-        Ok(())
-    }
-}
-
 #[derive(Debug)]
 pub enum MetaType {
     Regular,

rafs/src/metadata/mod.rs

@@ -847,7 +847,7 @@ impl RafsSuper {
     pub fn update(&self, r: &mut RafsIoReader) -> RafsResult<()> {
         if self.meta.is_v5() {
             self.skip_v5_superblock(r)
-                .map_err(RafsError::FillSuperblock)?;
+                .map_err(RafsError::FillSuperBlock)?;
         }
 
         self.superblock.update(r)

service/src/lib.rs

@@ -96,7 +96,7 @@ pub enum Error {
     #[error("RAFS failed to handle request, {0}")]
     Rafs(#[from] RafsError),
     #[error("VFS failed to handle request, {0:?}")]
-    Vfs(VfsError),
+    Vfs(#[from] VfsError),
 
     // fusedev
     #[error("failed to create FUSE server, {0}")]
@@ -130,12 +130,6 @@ impl From<Error> for io::Error {
     }
 }
 
-impl From<VfsError> for Error {
-    fn from(e: VfsError) -> Self {
-        Error::Vfs(e)
-    }
-}
-
 impl From<Error> for DaemonErrorKind {
     fn from(e: Error) -> Self {
         use Error::*;

utils/Cargo.toml

@@ -9,6 +9,7 @@ repository = "https://github.com/dragonflyoss/image-service"
 edition = "2018"
 
 [dependencies]
+thiserror = "1.0.30"
 blake3 = "1.3"
 httpdate = "1.0"
 lazy_static = "1.4"

utils/src/trace.rs

@@ -13,6 +13,7 @@ use std::time::SystemTime;
 
 use serde::Serialize;
 use serde_json::{error::Error, value::Value};
+use thiserror::Error;
 
 impl Display for TraceClass {
     fn fmt(&self, f: &mut Formatter) -> FmtResult {
@@ -51,8 +52,9 @@ pub enum TraceClass {
 }
 }
 
-#[derive(Debug)]
+#[derive(Error, Debug)]
 pub enum TraceError {
+    #[error("serialize error: {0}")]
     Serde(Error),
 }