feat: Add flux-converter :)

Author: sbernauer

Cargo.lock

@@ -87,3 +87,7 @@ rsa.opt-level = 3
 [profile.dev.package]
 insta.opt-level = 3
 similar.opt-level = 3
+
+[patch.crates-io]
+# https://github.com/kube-rs/kube/pull/1759 will be in 1.1.0
+kube = { git = 'https://github.com/sbernauer/kube.git', branch = "fix/derive-conversion-types-0.99" }

Cargo.toml

@@ -25,8 +25,9 @@ normal = ["k8s-openapi", "kube"]
 proc-macro = true
 
 [features]
-full = ["k8s"]
-k8s = ["dep:kube", "dep:k8s-openapi"]
+full = ["k8s", "flux-converter"]
+k8s = ["dep:kube", "dep:k8s-openapi", "dep:snafu"]
+flux-converter = ["k8s"]
 
 [dependencies]
 k8s-version = { path = "../k8s-version", features = ["darling"] }
@@ -37,6 +38,7 @@ itertools.workspace = true
 k8s-openapi = { workspace = true, optional = true }
 kube = { workspace = true, optional = true }
 proc-macro2.workspace = true
+snafu = { workspace = true, optional = true }
 syn.workspace = true
 quote.workspace = true
 

crates/stackable-versioned-macros/Cargo.toml

@@ -84,28 +84,40 @@ impl Container {
         }
     }
 
-    /// Generates Kubernetes specific code to merge two or more CRDs into one.
+    /// Generates Kubernetes specific code to merge two CRDs or convert between different versions.
     ///
     /// This function only returns `Some` if it is a struct. Enums cannot be used to define
     /// Kubernetes custom resources.
-    pub(crate) fn generate_kubernetes_merge_crds(
+    pub(crate) fn generate_kubernetes_code(
         &self,
         enum_variant_idents: &[IdentString],
         enum_variant_strings: &[String],
         fn_calls: &[TokenStream],
         vis: &Visibility,
         is_nested: bool,
     ) -> Option<TokenStream> {
-        match self {
-            Container::Struct(s) => s.generate_kubernetes_merge_crds(
-                enum_variant_idents,
-                enum_variant_strings,
-                fn_calls,
-                vis,
-                is_nested,
-            ),
-            Container::Enum(_) => None,
-        }
+        let Container::Struct(s) = self else {
+            return None;
+        };
+
+        let mut tokens = TokenStream::new();
+        tokens.extend(s.generate_kubernetes_merge_crds(
+            enum_variant_idents,
+            enum_variant_strings,
+            fn_calls,
+            vis,
+            is_nested,
+        ));
+
+        #[cfg(feature = "flux-converter")]
+        tokens.extend(super::flux_converter::generate_kubernetes_conversion(
+            &s.common.idents.kubernetes,
+            &s.common.idents.original,
+            enum_variant_idents,
+            enum_variant_strings,
+        ));
+
+        Some(tokens)
     }
 
     pub(crate) fn get_original_ident(&self) -> &Ident {
@@ -214,7 +226,7 @@ impl StandaloneContainer {
             });
         }
 
-        tokens.extend(self.container.generate_kubernetes_merge_crds(
+        tokens.extend(self.container.generate_kubernetes_code(
             &kubernetes_enum_variant_idents,
             &kubernetes_enum_variant_strings,
             &kubernetes_merge_crds_fn_calls,

crates/stackable-versioned-macros/src/codegen/container/mod.rs

@@ -349,6 +349,8 @@ impl Struct {
         vis: &Visibility,
         is_nested: bool,
     ) -> Option<TokenStream> {
+        assert_eq!(enum_variant_idents.len(), enum_variant_strings.len());
+
         match &self.common.options.kubernetes_options {
             Some(kubernetes_options) if !kubernetes_options.skip_merged_crd => {
                 let enum_ident = &self.common.idents.kubernetes;
@@ -377,12 +379,27 @@ impl Struct {
                         }
                     }
 
+                    #automatically_derived
+                    impl ::std::str::FromStr for #enum_ident {
+                        type Err = stackable_versioned::UnknownResourceVersionError;
+
+                        fn from_str(version: &str) -> Result<Self, Self::Err> {
+                            match version {
+                                #(#enum_variant_strings => Ok(Self::#enum_variant_idents),)*
+                                _ => Err(stackable_versioned::UnknownResourceVersionError{version: version.to_string()}),
+                            }
+                        }
+                    }
+
                     #automatically_derived
                     impl #enum_ident {
                         /// Generates a merged CRD containing all versions and marking `stored_apiversion` as stored.
                         pub fn merged_crd(
                             stored_apiversion: Self
-                        ) -> ::std::result::Result<#k8s_openapi_path::apiextensions_apiserver::pkg::apis::apiextensions::v1::CustomResourceDefinition, #kube_core_path::crd::MergeError> {
+                        ) -> ::std::result::Result<
+                                #k8s_openapi_path::apiextensions_apiserver::pkg::apis::apiextensions::v1::CustomResourceDefinition,
+                                #kube_core_path::crd::MergeError
+                            > {
                             #kube_core_path::crd::merge_crds(vec![#(#fn_calls),*], &stored_apiversion.to_string())
                         }
                     }

crates/stackable-versioned-macros/src/codegen/container/struct.rs

@@ -0,0 +1,147 @@
+use darling::util::IdentString;
+use proc_macro2::TokenStream;
+use quote::quote;
+
+pub(crate) fn generate_kubernetes_conversion(
+    enum_ident: &IdentString,
+    struct_ident: &IdentString,
+    enum_variant_idents: &[IdentString],
+    enum_variant_strings: &[String],
+) -> Option<TokenStream> {
+    assert_eq!(enum_variant_idents.len(), enum_variant_strings.len());
+
+    let versions = enum_variant_idents
+        .iter()
+        .zip(enum_variant_strings)
+        .collect::<Vec<_>>();
+    let conversion_chain = generate_conversion_chain(versions);
+
+    let matches = conversion_chain.into_iter().map(
+        |((src, src_lower), (dst, _dst_lower), version_chain)| {
+            let version_chain_string = version_chain.iter()
+                .map(|(_,v)| v.parse::<TokenStream>()
+                    .expect("The versions always needs to be a valid TokenStream"));
+
+            // TODO: Is there a bit more clever way how we can get this?
+            let src_lower = src_lower.parse::<TokenStream>().expect("The versions always needs to be a valid TokenStream");
+
+            quote! { (Self::#src, Self::#dst) => {
+                let resource: #src_lower::#struct_ident = serde_json::from_value(object_spec)
+                    .expect(&format!("Failed to deserialize {}", stringify!(#enum_ident)));
+
+                #(
+                    let resource: #version_chain_string::#struct_ident = resource.into();
+                )*
+
+                converted.push(
+                    serde_json::to_value(resource).expect(&format!("Failed to serialize {}", stringify!(#enum_ident)))
+                );
+            }}
+        },
+    );
+
+    Some(quote! {
+        #[automatically_derived]
+        impl #enum_ident {
+            pub fn convert(review: kube::core::conversion::ConversionReview) -> kube::core::conversion::ConversionResponse {
+                let request = kube::core::conversion::ConversionRequest::from_review(review)
+                    .unwrap();
+                let desired_api_version = <Self as std::str::FromStr>::from_str(&request.desired_api_version)
+                    .expect(&format!("invalid desired version for {} resource", stringify!(#enum_ident)));
+
+                let mut converted: Vec<serde_json::Value> = Vec::with_capacity(request.objects.len());
+                for object in &request.objects {
+                    let object_spec = object
+                        .get("spec")
+                        .expect("The passed object had no spec")
+                        .clone();
+                    let kind = object
+                        .get("kind")
+                        .expect("The objected asked to convert has no kind");
+                    let api_version = object
+                        .get("apiVersion")
+                        .expect("The objected asked to convert has no apiVersion")
+                        .as_str()
+                        .expect("The apiVersion of the objected asked to convert wasn't a String");
+
+                    assert_eq!(kind, stringify!(#enum_ident));
+
+                    let current_api_version = <Self as std::str::FromStr>::from_str(api_version)
+                        .expect(&format!("invalid current version for {} resource", stringify!(#enum_ident)));
+
+                    match (&current_api_version, &desired_api_version) {
+                        #(#matches),*
+                    }
+                }
+
+                let response = kube::core::conversion::ConversionResponse::for_request(request);
+                response.success(converted)
+            }
+        }
+    })
+}
+
+pub fn generate_conversion_chain<Version: Clone>(
+    versions: Vec<Version>,
+) -> Vec<(Version, Version, Vec<Version>)> {
+    let mut result = Vec::with_capacity(versions.len().pow(2));
+    let n = versions.len();
+
+    for i in 0..n {
+        for j in 0..n {
+            let source = versions[i].clone();
+            let destination = versions[j].clone();
+            let chain = if i == j {
+                vec![]
+            } else if i < j {
+                versions[i + 1..=j].to_vec()
+            } else {
+                versions[j..i].iter().rev().cloned().collect()
+            };
+            result.push((source, destination, chain));
+        }
+    }
+
+    result
+}
+
+#[cfg(test)]
+mod tests {
+    use super::generate_conversion_chain;
+
+    #[test]
+    fn test_generate_conversion_chains() {
+        let versions = vec!["v1alpha1", "v1alpha2", "v1beta1", "v1", "v2"];
+        let conversion_chain = generate_conversion_chain(versions);
+
+        assert_eq!(conversion_chain, vec![
+            ("v1alpha1", "v1alpha1", vec![]),
+            ("v1alpha1", "v1alpha2", vec!["v1alpha2"]),
+            ("v1alpha1", "v1beta1", vec!["v1alpha2", "v1beta1"]),
+            ("v1alpha1", "v1", vec!["v1alpha2", "v1beta1", "v1"]),
+            ("v1alpha1", "v2", vec!["v1alpha2", "v1beta1", "v1", "v2"]),
+            ("v1alpha2", "v1alpha1", vec!["v1alpha1"]),
+            ("v1alpha2", "v1alpha2", vec![]),
+            ("v1alpha2", "v1beta1", vec!["v1beta1"]),
+            ("v1alpha2", "v1", vec!["v1beta1", "v1"]),
+            ("v1alpha2", "v2", vec!["v1beta1", "v1", "v2"]),
+            ("v1beta1", "v1alpha1", vec!["v1alpha2", "v1alpha1"]),
+            ("v1beta1", "v1alpha2", vec!["v1alpha2"]),
+            ("v1beta1", "v1beta1", vec![]),
+            ("v1beta1", "v1", vec!["v1"]),
+            ("v1beta1", "v2", vec!["v1", "v2"]),
+            ("v1", "v1alpha1", vec!["v1beta1", "v1alpha2", "v1alpha1"]),
+            ("v1", "v1alpha2", vec!["v1beta1", "v1alpha2"]),
+            ("v1", "v1beta1", vec!["v1beta1"]),
+            ("v1", "v1", vec![]),
+            ("v1", "v2", vec!["v2"]),
+            ("v2", "v1alpha1", vec![
+                "v1", "v1beta1", "v1alpha2", "v1alpha1"
+            ]),
+            ("v2", "v1alpha2", vec!["v1", "v1beta1", "v1alpha2"]),
+            ("v2", "v1beta1", vec!["v1", "v1beta1"]),
+            ("v2", "v1", vec!["v1"]),
+            ("v2", "v2", vec![])
+        ]);
+    }
+}

crates/stackable-versioned-macros/src/codegen/flux_converter.rs

@@ -10,6 +10,9 @@ pub(crate) mod container;
 pub(crate) mod item;
 pub(crate) mod module;
 
+#[cfg(feature = "flux-converter")]
+pub(crate) mod flux_converter;
+
 #[derive(Debug)]
 pub(crate) struct VersionDefinition {
     /// Indicates that the container version is deprecated.

crates/stackable-versioned-macros/src/codegen/mod.rs

@@ -221,7 +221,7 @@ impl Module {
                 kubernetes_enum_variant_strings,
             )) = kubernetes_container_items.get(container.get_original_ident())
             {
-                kubernetes_tokens.extend(container.generate_kubernetes_merge_crds(
+                kubernetes_tokens.extend(container.generate_kubernetes_code(
                     kubernetes_enum_variant_idents,
                     kubernetes_enum_variant_strings,
                     kubernetes_merge_crds_fn_calls,

crates/stackable-versioned-macros/src/codegen/module.rs

@@ -11,10 +11,25 @@ repository.workspace = true
 all-features = true
 
 [features]
-full = ["k8s"]
+full = ["k8s", "flux-converter"]
 k8s = [
   "stackable-versioned-macros/k8s", # Forward the k8s feature to the underlying macro crate
 ]
+flux-converter = [
+  "k8s",
+  "stackable-versioned-macros/flux-converter",
+  "dep:kube",
+  "dep:k8s-openapi",
+  "dep:serde",
+  "dep:schemars",
+  "dep:serde_json",
+]
 
 [dependencies]
 stackable-versioned-macros = { path = "../stackable-versioned-macros" }
+
+kube = { workspace = true, optional = true }
+k8s-openapi = { workspace = true, optional = true }
+serde = { workspace = true, optional = true }
+schemars = { workspace = true, optional = true }
+serde_json = { workspace = true, optional = true }