Config fragment/validation

nightkr · nightkr · commit 90f5f674aa34 · 2022-07-05T16:57:54.000+02:00
A slightly different take of #425, which uses the existing Atomic infra and some trait magic to determine "complex" types. It also tries to provide nice error messages for validation failures.
diff --git a/Cargo.toml b/Cargo.toml
@@ -35,6 +35,7 @@ tracing-opentelemetry = "0.17.3"
 opentelemetry = { version = "0.17.0", features = ["rt-tokio"] }
 opentelemetry-jaeger = { version = "0.16.0", features = ["rt-tokio"] }
 stackable-operator-derive = { path = "stackable-operator-derive" }
+snafu = "0.7.1"
 
 [dev-dependencies]
 rstest = "0.15.0"
diff --git a/src/config/fragment.rs b/src/config/fragment.rs
@@ -0,0 +1,198 @@
+use std::fmt::{Display, Write};
+
+pub use stackable_operator_derive::Fragment;
+
+use super::merge::Atomic;
+
+use snafu::Snafu;
+
+pub struct Validator<'a> {
+    ident: Option<&'a str>,
+    parent: Option<&'a Validator<'a>>,
+}
+
+impl<'a> Validator<'a> {
+    pub fn field<'b>(&'b self, ident: &'b str) -> Validator<'b> {
+        Validator {
+            ident: Some(ident),
+            parent: Some(self),
+        }
+    }
+
+    fn error_problem(self, problem: ValidationProblem) -> ValidationError {
+        let mut idents = Vec::new();
+        let mut curr = Some(&self);
+        while let Some(curr_some) = curr {
+            if let Some(ident) = curr_some.ident {
+                idents.push(ident.to_string());
+            }
+            curr = curr_some.parent;
+        }
+        ValidationError {
+            path: FieldPath { idents },
+            problem,
+        }
+    }
+
+    pub fn error_required(self) -> ValidationError {
+        self.error_problem(ValidationProblem::FieldRequired)
+    }
+}
+
+#[derive(Debug)]
+struct FieldPath {
+    idents: Vec<String>,
+}
+impl Display for FieldPath {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        for (i, ident) in self.idents.iter().rev().enumerate() {
+            if i > 0 {
+                f.write_char('.')?;
+            }
+            f.write_str(ident)?;
+        }
+        Ok(())
+    }
+}
+
+#[derive(Debug, Snafu)]
+#[snafu(display("failed to validate {path}"))]
+pub struct ValidationError {
+    path: FieldPath,
+    #[snafu(source)]
+    problem: ValidationProblem,
+}
+#[derive(Debug, Snafu)]
+enum ValidationProblem {
+    #[snafu(display("field is required"))]
+    FieldRequired,
+}
+
+pub trait FromFragment: Sized {
+    type Fragment;
+
+    fn from_fragment(
+        fragment: Self::Fragment,
+        validator: Validator,
+    ) -> Result<Self, ValidationError>;
+
+    fn default_fragment() -> Option<Self::Fragment>;
+}
+impl<T: Atomic> FromFragment for T {
+    type Fragment = T;
+
+    fn from_fragment(
+        fragment: Self::Fragment,
+        _validator: Validator,
+    ) -> Result<Self, ValidationError> {
+        Ok(fragment)
+    }
+
+    fn default_fragment() -> Option<Self::Fragment> {
+        None
+    }
+}
+
+pub fn validate<T: FromFragment>(fragment: T::Fragment) -> Result<T, ValidationError> {
+    T::from_fragment(
+        fragment,
+        Validator {
+            ident: None,
+            parent: None,
+        },
+    )
+}
+
+#[cfg(test)]
+mod tests {
+    use super::{validate, Fragment, FromFragment, ValidationError, Validator};
+
+    #[derive(Fragment, Debug, PartialEq, Eq)]
+    struct Empty {}
+
+    #[derive(Fragment, Debug, PartialEq, Eq)]
+    struct WithFields {
+        name: String,
+        #[fragment(default = "1")]
+        replicas: u8,
+        #[fragment(default)]
+        overhead: u8,
+        tag: Option<String>,
+    }
+
+    #[derive(Fragment, Debug, PartialEq, Eq)]
+    struct Nested {
+        required: WithFields,
+        optional: Option<WithFields>,
+    }
+
+    #[test]
+    fn validate_empty() {
+        assert_eq!(validate::<Empty>(EmptyFragment {}).unwrap(), Empty {});
+    }
+
+    #[test]
+    fn validate_basics() {
+        assert_eq!(
+            validate::<WithFields>(WithFieldsFragment {
+                name: Some("foo".to_string()),
+                replicas: Some(23),
+                overhead: Some(24),
+                tag: Some("bar".to_string()),
+            })
+            .unwrap(),
+            WithFields {
+                name: "foo".to_string(),
+                replicas: 23,
+                overhead: 24,
+                tag: Some("bar".to_string()),
+            }
+        );
+        assert_eq!(
+            validate::<WithFields>(WithFieldsFragment {
+                name: Some("foo".to_string()),
+                replicas: None,
+                overhead: None,
+                tag: None,
+            })
+            .unwrap(),
+            WithFields {
+                name: "foo".to_string(),
+                replicas: 1,
+                overhead: 0,
+                tag: None,
+            }
+        );
+
+        let err = validate::<WithFields>(WithFieldsFragment {
+            name: None,
+            replicas: None,
+            overhead: None,
+            tag: None,
+        })
+        .unwrap_err();
+        assert!(err.to_string().contains("name"));
+    }
+
+    #[test]
+    fn validate_nested() {
+        // required complex fields should automatically be defaulted (so that the "leaf" fields are validated immediately)
+        let err = validate::<Nested>(NestedFragment {
+            required: None,
+            optional: None,
+        })
+        .unwrap_err();
+        assert!(err.to_string().contains("required.name"));
+
+        // optional complex fields should still be treated as optional if not provided
+        let nested = validate::<Nested>(NestedFragment {
+            required: Some(WithFieldsFragment {
+                name: Some("name".to_string()),
+                ..Default::default()
+            }),
+            optional: None,
+        })
+        .unwrap();
+        assert_eq!(nested.optional, None);
+    }
+}
diff --git a/src/config/mod.rs b/src/config/mod.rs
@@ -1 +1,2 @@
+pub mod fragment;
 pub mod merge;
diff --git a/stackable-operator-derive/src/fragment.rs b/stackable-operator-derive/src/fragment.rs
@@ -0,0 +1,164 @@
+use darling::{ast::Data, FromDeriveInput, FromField, FromMeta, FromVariant};
+use proc_macro2::{Ident, TokenStream};
+use quote::{format_ident, quote};
+use syn::{DeriveInput, Expr, GenericArgument, Type};
+
+#[derive(FromDeriveInput)]
+#[darling(attributes(fragment))]
+pub struct FragmentInput {
+    ident: Ident,
+    data: Data<FragmentVariant, FragmentField>,
+}
+
+#[derive(FromVariant)]
+struct FragmentVariant {}
+
+#[derive(FromField)]
+#[darling(attributes(fragment))]
+struct FragmentField {
+    ident: Option<Ident>,
+    ty: Type,
+    default: Default,
+}
+
+enum Default {
+    None,
+    FromDefaultTrait,
+    Expr(Box<Expr>),
+}
+impl FromMeta for Default {
+    fn from_none() -> Option<Self> {
+        Some(Self::None)
+    }
+
+    fn from_word() -> darling::Result<Self> {
+        Ok(Self::FromDefaultTrait)
+    }
+
+    fn from_value(value: &syn::Lit) -> darling::Result<Self> {
+        Expr::from_value(value).map(Box::new).map(Self::Expr)
+    }
+}
+
+fn only<I: IntoIterator>(iter: I) -> Option<I::Item> {
+    let mut iter = iter.into_iter();
+    let item = iter.next()?;
+    if iter.next().is_some() {
+        None
+    } else {
+        Some(item)
+    }
+}
+
+fn extract_inner_option_type(ty: &Type) -> Option<&Type> {
+    let path = if let Type::Path(path) = ty {
+        path
+    } else {
+        return None;
+    };
+    let seg = only(&path.path.segments)?;
+    if seg.ident != "Option" {
+        return None;
+    }
+    let args = if let syn::PathArguments::AngleBracketed(args) = &seg.arguments {
+        args
+    } else {
+        return None;
+    };
+    let arg = only(&args.args)?;
+    if let GenericArgument::Type(arg_ty) = arg {
+        Some(arg_ty)
+    } else {
+        None
+    }
+}
+
+pub fn derive(input: DeriveInput) -> TokenStream {
+    let FragmentInput { ident, data } = match FragmentInput::from_derive_input(&input) {
+        Ok(input) => input,
+        Err(err) => return err.write_errors(),
+    };
+    let fields = match data {
+        Data::Enum(_) => todo!(),
+        Data::Struct(fields) => fields.fields,
+    };
+
+    let fragment_ident = format_ident!("{ident}Fragment");
+    let fragment_fields = fields
+        .iter()
+        .map(
+            |FragmentField {
+                 ident,
+                 ty,
+                 default: _,
+             }| {
+                let ty = extract_inner_option_type(ty).unwrap_or(ty);
+                quote! { #ident: Option<<#ty as FromFragment>::Fragment>, }
+            },
+        )
+        .collect::<TokenStream>();
+
+    let from_fragment_fields = fields
+        .iter()
+        .map(|FragmentField { ident, ty, default }| {
+            let ident_name = ident.as_ref().map(ToString::to_string);
+            let inner_option_ty = extract_inner_option_type(ty);
+            let is_option_wrapped = inner_option_ty.is_some();
+            let ty = inner_option_ty.unwrap_or(ty);
+            let wrapped_value = if is_option_wrapped {
+                quote! { Some(value) }
+            } else {
+                quote! { value }
+            };
+            let default_fragment_value = match default {
+                Default::Expr(default) => quote! { Some(#default) },
+                Default::FromDefaultTrait => quote! { Some(Default::default()) },
+                Default::None => quote! { None },
+            };
+            let mut fragment_value = quote! { fragment.#ident.or_else(|| #default_fragment_value) };
+            if !is_option_wrapped {
+                fragment_value = quote! { #fragment_value.or_else(#ty::default_fragment) };
+            }
+            let default_value = if is_option_wrapped {
+                quote! { None }
+            } else {
+                quote! { return Err(validator.error_required()) }
+            };
+            let value = quote! {
+                if let Some(value) = #fragment_value {
+                    let value = FromFragment::from_fragment(value, validator)?;
+                    #wrapped_value
+                } else {
+                    #default_value
+                }
+            };
+            quote! {
+                #ident: {
+                    let validator = validator.field(#ident_name);
+                    #value
+                },
+            }
+        })
+        .collect::<TokenStream>();
+
+    quote! {
+        #[derive(Default)]
+        struct #fragment_ident {
+            #fragment_fields
+        }
+
+        impl FromFragment for #ident {
+            type Fragment = #fragment_ident;
+
+            fn from_fragment(fragment: Self::Fragment, validator: Validator) -> Result<Self, ValidationError> {
+                Ok(Self {
+                    #from_fragment_fields
+                })
+            }
+
+            fn default_fragment() -> Option<Self::Fragment> {
+                Some(#fragment_ident::default())
+            }
+        }
+    }
+}
diff --git a/stackable-operator-derive/src/lib.rs b/stackable-operator-derive/src/lib.rs
@@ -6,6 +6,8 @@ use proc_macro2::{Ident, Span, TokenStream};
 use quote::{format_ident, quote};
 use syn::{parse_macro_input, parse_quote, Generics, Index, Path, WherePredicate};
 
+mod fragment;
+
 #[derive(FromMeta)]
 struct PathOverrides {
     #[darling(default = "PathOverrides::default_merge")]
@@ -224,3 +226,8 @@ fn prefix_ident(ident: Result<&Ident, usize>, prefix: &Ident) -> Ident {
         Err(index) => format_ident!("{prefix}_{index}"),
     }
 }
+
+#[proc_macro_derive(Fragment, attributes(fragment))]
+pub fn derive_fragment(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
+    fragment::derive(parse_macro_input!(input)).into()
+}

Original file line number	Diff line number	Diff line change
`@@ -1 +1,2 @@`
	`1`	`+pub mod fragment;`
`1`	`2`	`pub mod merge;`