(nifi-minifi-cpp) 16/22: add anyhow error support and fold parse errors into validation errors

[ma...@apache.org]

This is an automated email from the ASF dual-hosted git repository.

martinzink pushed a commit to branch minifi_rust_pgp
in repository https://gitbox.apache.org/repos/asf/nifi-minifi-cpp.git

commit 5f771170b75d78ce089141565771e92bd478de10
Author: Martin Zink <ma...@apache.org>
AuthorDate: Mon Aug 17 11:31:07 2026 +0200

    add anyhow error support and fold parse errors into validation errors
---
 minifi_rust/minifi_native/Cargo.toml        |  1 +
 minifi_rust/minifi_native/src/api/errors.rs | 85 +++++++++--------------------
 2 files changed, 27 insertions(+), 59 deletions(-)

diff --git a/minifi_rust/minifi_native/Cargo.toml b/minifi_rust/minifi_native/Cargo.toml
index b3f75648b..8d0a74da2 100644
--- a/minifi_rust/minifi_native/Cargo.toml
+++ b/minifi_rust/minifi_native/Cargo.toml
@@ -13,6 +13,7 @@ strum_macros = "0.28.0"
 humantime = "2.3.0"
 byte-unit = "5.1.6"
 itertools = "0.14.0"
+anyhow = "1.0.104"
 
 [features]
 test-utils = []
diff --git a/minifi_rust/minifi_native/src/api/errors.rs b/minifi_rust/minifi_native/src/api/errors.rs
index 7802e397a..9e5749fcc 100644
--- a/minifi_rust/minifi_native/src/api/errors.rs
+++ b/minifi_rust/minifi_native/src/api/errors.rs
@@ -24,18 +24,6 @@ use std::fmt;
 use std::num::{NonZeroU32, ParseFloatError, ParseIntError};
 use std::str::ParseBoolError;
 
-#[derive(Debug, Clone)]
-pub enum ParseError {
-    Strum(strum::ParseError),
-    Bool(ParseBoolError),
-    Int(ParseIntError),
-    Duration(humantime::DurationError),
-    Size(byte_unit::ParseError),
-    Nul(NulError),
-    Float(ParseFloatError),
-    Other,
-}
-
 #[derive(Debug)]
 pub struct RouteError {
     pub relationship: Cow<'static, str>,
@@ -168,7 +156,6 @@ pub enum MinifiError {
     UnscheduledProcessor,
     ValidationError(Cow<'static, str>),
     CustomError(Cow<'static, str>),
-    Parse(ParseError),
     MissingFlowFileError,
     IoError(std::io::Error),
 
@@ -181,47 +168,27 @@ impl From<std::io::Error> for MinifiError {
     }
 }
 
-impl From<strum::ParseError> for MinifiError {
-    fn from(err: strum::ParseError) -> Self {
-        MinifiError::Parse(ParseError::Strum(err))
-    }
-}
-
-impl From<ParseBoolError> for MinifiError {
-    fn from(err: ParseBoolError) -> Self {
-        MinifiError::Parse(ParseError::Bool(err))
-    }
-}
-
-impl From<ParseIntError> for MinifiError {
-    fn from(err: ParseIntError) -> Self {
-        MinifiError::Parse(ParseError::Int(err))
-    }
-}
-
-impl From<humantime::DurationError> for MinifiError {
-    fn from(err: humantime::DurationError) -> Self {
-        MinifiError::Parse(ParseError::Duration(err))
-    }
-}
-
-impl From<byte_unit::ParseError> for MinifiError {
-    fn from(err: byte_unit::ParseError) -> Self {
-        MinifiError::Parse(ParseError::Size(err))
-    }
-}
-
-impl From<NulError> for MinifiError {
-    fn from(err: NulError) -> Self {
-        MinifiError::Parse(ParseError::Nul(err))
-    }
+macro_rules! minifi_error_from_validation {
+    ($($t:ty),* $(,)?) => {
+        $(
+            impl From<$t> for MinifiError {
+                fn from(err: $t) -> Self {
+                    MinifiError::ValidationError(err.to_string().into())
+                }
+            }
+        )*
+    };
 }
 
-impl From<ParseFloatError> for MinifiError {
-    fn from(err: ParseFloatError) -> Self {
-        MinifiError::Parse(ParseError::Float(err))
-    }
-}
+minifi_error_from_validation!(
+    strum::ParseError,
+    ParseBoolError,
+    ParseIntError,
+    humantime::DurationError,
+    byte_unit::ParseError,
+    NulError,
+    ParseFloatError,
+);
 
 impl From<std::convert::Infallible> for MinifiError {
     fn from(_: std::convert::Infallible) -> Self {
@@ -229,6 +196,12 @@ impl From<std::convert::Infallible> for MinifiError {
     }
 }
 
+impl From<anyhow::Error> for MinifiError {
+    fn from(err: anyhow::Error) -> Self {
+        Self::other(err)
+    }
+}
+
 impl MinifiError {
     pub(crate) fn to_status(&self) -> minifi_status {
         match self {
@@ -241,9 +214,6 @@ impl MinifiError {
             MinifiError::ValidationError(_) => {
                 minifi_native_sys::minifi_status_MINIFI_STATUS_VALIDATION_FAILED
             }
-            MinifiError::Parse(_) => {
-                minifi_native_sys::minifi_status_MINIFI_STATUS_VALIDATION_FAILED
-            }
             MinifiError::StatusError((_, ecode)) => u32::from(*ecode),
             _ => minifi_native_sys::minifi_status_MINIFI_STATUS_UNKNOWN_ERROR,
         }
@@ -257,10 +227,6 @@ impl MinifiError {
         MinifiError::CustomError(msg.into())
     }
 
-    pub fn parse_err() -> Self {
-        MinifiError::Parse(ParseError::Other)
-    }
-
     pub fn other<E>(err: E) -> Self
     where
         E: Into<Box<dyn Error + Send + Sync + 'static>>,
@@ -294,6 +260,7 @@ impl fmt::Display for MinifiError {
                 _ => write!(f, "{} (Unknown Status Code: {})", context, code),
             },
             MinifiError::Other(err) => write!(f, "Custom error: {}", err),
+            MinifiError::ValidationError(msg) => write!(f, "{}", msg),
             _ => write!(f, "{:?}", self),
         }
     }