refactor(deps): replace snafu and heal anyhow (#4266)

crates/heal/Cargo.toml

@@ -41,7 +41,6 @@ serde = { workspace = true, features = ["derive"] }
 serde_json = { workspace = true }
 thiserror = { workspace = true }
 uuid = { workspace = true, features = ["v4", "serde"] }
-anyhow = { workspace = true }
 async-trait = { workspace = true }
 futures = { workspace = true }
 metrics = { workspace = true }

crates/heal/src/error.rs

@@ -40,9 +40,6 @@ pub enum Error {
     #[error("Other error: {0}")]
     Other(String),
 
-    #[error(transparent)]
-    Anyhow(#[from] anyhow::Error),
-
     #[error("Serialization error: {0}")]
     Serialization(String),
 
@@ -94,11 +91,8 @@ pub type Result<T, E = Error> = std::result::Result<T, E>;
 
 impl Error {
     /// Create an Other error from any error type
-    pub fn other<E>(error: E) -> Self
-    where
-        E: Into<Box<dyn std::error::Error + Send + Sync>>,
-    {
-        Error::Other(error.into().to_string())
+    pub fn other(error: impl std::fmt::Display) -> Self {
+        Error::Other(error.to_string())
     }
 
     /// Create a transient skip error for retryable background heal checks.

crates/heal/src/heal/manager.rs

@@ -588,7 +588,7 @@ fn is_recoverable_heal_error(err: &Error, error: &str) -> bool {
         Error::TaskTimeout | Error::TransientSkip { .. } => true,
         Error::Storage(err) => is_recoverable_storage_heal_error(err) || is_recoverable_heal_error_message(error),
         Error::Disk(err) => is_recoverable_disk_heal_error(err) || is_recoverable_heal_error_message(error),
-        Error::TaskExecutionFailed { .. } | Error::Io(_) | Error::IO(_) | Error::Anyhow(_) | Error::Other(_) => {
+        Error::TaskExecutionFailed { .. } | Error::Io(_) | Error::IO(_) | Error::Other(_) => {
             is_recoverable_heal_error_message(error)
         }
         _ => false,

crates/heal/tests/endpoint_index_test.rs

@@ -24,7 +24,7 @@ mod storage_api;
 use storage_api::endpoint_index::{ECStore, Endpoint, EndpointServerPools, Endpoints, PoolEndpoints, init_local_disks};
 
 #[tokio::test(flavor = "multi_thread", worker_threads = 4)]
-async fn test_endpoint_index_settings() -> anyhow::Result<()> {
+async fn test_endpoint_index_settings() -> rustfs_heal::Result<()> {
     let temp_dir = TempDir::new()?;
 
     // create test disk paths

crates/s3select-api/Cargo.toml

@@ -40,7 +40,7 @@ http.workspace = true
 pin-project-lite.workspace = true
 s3s.workspace = true
 serde_json = { workspace = true }
-snafu = { workspace = true, features = ["backtrace"] }
+thiserror = { workspace = true }
 parking_lot.workspace = true
 tokio.workspace = true
 tokio-util.workspace = true

crates/s3select-api/src/lib.rs

@@ -13,8 +13,8 @@
 // limitations under the License.
 
 use datafusion::{common::DataFusionError, sql::sqlparser::parser::ParserError};
-use snafu::{Backtrace, Location, Snafu};
 use std::fmt::Display;
+use thiserror::Error;
 
 pub mod object_store;
 pub mod query;
@@ -31,52 +31,49 @@ pub(crate) use storage_api::crate_boundary::{
     select_is_err_version_not_found,
 };
 
-#[derive(Debug, Snafu)]
-#[snafu(visibility(pub))]
+#[derive(Debug, Error)]
 pub enum QueryError {
-    #[snafu(display("DataFusion error: {}", source))]
-    Datafusion {
-        source: Box<DataFusionError>,
-        location: Location,
-        backtrace: Backtrace,
-    },
+    #[error("DataFusion error: {source}")]
+    Datafusion { source: Box<DataFusionError> },
 
-    #[snafu(display("This feature is not implemented: {}", err))]
+    #[error("This feature is not implemented: {err}")]
     NotImplemented { err: String },
 
-    #[snafu(display("Multi-statement not allow, found num:{}, sql:{}", num, sql))]
+    #[error("Multi-statement not allow, found num:{num}, sql:{sql}")]
     MultiStatement { num: usize, sql: String },
 
-    #[snafu(display("Failed to build QueryDispatcher. err: {}", err))]
+    #[error("Failed to build QueryDispatcher. err: {err}")]
     BuildQueryDispatcher { err: String },
 
-    #[snafu(display("The query has been canceled"))]
+    #[error("The query has been canceled")]
     Cancel,
 
-    #[snafu(display("{}", source))]
-    Parser { source: ParserError },
+    #[error("{source}")]
+    Parser {
+        #[from]
+        source: ParserError,
+    },
 
-    #[snafu(display("Udf not exists, name:{}.", name))]
+    #[error("Udf not exists, name:{name}.")]
     FunctionNotExists { name: String },
 
-    #[snafu(display("Udf already exists, name:{}.", name))]
+    #[error("Udf already exists, name:{name}.")]
     FunctionExists { name: String },
 
-    #[snafu(display("Store Error, e:{}.", e))]
+    #[error("Store Error, e:{e}.")]
     StoreError { e: String },
 }
 
 impl From<DataFusionError> for QueryError {
-    #[track_caller]
     fn from(value: DataFusionError) -> Self {
         match value {
-            DataFusionError::External(e) if e.downcast_ref::<QueryError>().is_some() => *e.downcast::<QueryError>().unwrap(),
-
-            v => Self::Datafusion {
-                source: Box::new(v),
-                location: std::panic::Location::caller(),
-                backtrace: Backtrace::capture(),
+            DataFusionError::External(e) => match e.downcast::<QueryError>() {
+                Ok(query_error) => *query_error,
+                Err(e) => Self::Datafusion {
+                    source: Box::new(DataFusionError::External(e)),
+                },
             },
+            v => Self::Datafusion { source: Box::new(v) },
         }
     }
 }

crates/s3select-query/Cargo.toml

@@ -34,7 +34,6 @@ derive_builder = { workspace = true }
 futures = { workspace = true }
 parking_lot = { workspace = true }
 s3s.workspace = true
-snafu = { workspace = true, features = ["backtrace"] }
 tokio = { workspace = true }
 tracing = { workspace = true }
 

crates/s3select-query/src/sql/parser.rs

@@ -20,10 +20,9 @@ use datafusion::sql::sqlparser::{
     tokenizer::{Token, Tokenizer},
 };
 use rustfs_s3select_api::{
-    ParserSnafu,
+    QueryError,
     query::{ast::ExtStatement, parser::Parser as RustFsParser},
 };
-use snafu::ResultExt;
 
 use super::dialect::RustFsDialect;
 
@@ -41,7 +40,7 @@ pub struct DefaultParser {}
 
 impl RustFsParser for DefaultParser {
     fn parse(&self, sql: &str) -> rustfs_s3select_api::QueryResult<VecDeque<ExtStatement>> {
-        ExtParser::parse_sql(sql).context(ParserSnafu)
+        ExtParser::parse_sql(sql).map_err(QueryError::from)
     }
 }