feat(stackable-versioned): Add flux-converter

Author: sbernauer

Cargo.lock

@@ -16,7 +16,7 @@ versioned = []
 
 [dependencies]
 stackable-telemetry = { path = "../stackable-telemetry", features = ["clap"] }
-stackable-versioned = { path = "../stackable-versioned", features = ["k8s"] }
+stackable-versioned = { path = "../stackable-versioned", features = ["k8s", "flux-converter"] }
 stackable-operator-derive = { path = "../stackable-operator-derive" }
 stackable-shared = { path = "../stackable-shared" }
 

crates/stackable-operator/Cargo.toml

@@ -38,7 +38,7 @@
 //!     crates(
 //!         kube_core = "stackable_operator::kube::core",
 //!         k8s_openapi = "stackable_operator::k8s_openapi",
-//!         schemars = "stackable_operator::schemars"
+//!         schemars = "stackable_operator::schemars",
 //!     )
 //! )]
 //! #[serde(rename_all = "camelCase")]

crates/stackable-operator/src/commons/resources.rs

@@ -32,7 +32,7 @@ pub mod versioned {
         crates(
             kube_core = "kube::core",
             k8s_openapi = "k8s_openapi",
-            schemars = "schemars"
+            schemars = "schemars",
         )
     ))]
     #[derive(

crates/stackable-operator/src/crd/authentication/core/mod.rs

@@ -21,7 +21,7 @@ pub mod versioned {
         crates(
             kube_core = "kube::core",
             k8s_openapi = "k8s_openapi",
-            schemars = "schemars"
+            schemars = "schemars",
         ),
         namespaced
     ))]

crates/stackable-operator/src/crd/s3/bucket/mod.rs

@@ -31,7 +31,7 @@ pub mod versioned {
         crates(
             kube_core = "kube::core",
             k8s_openapi = "k8s_openapi",
-            schemars = "schemars"
+            schemars = "schemars",
         ),
         namespaced
     ))]

crates/stackable-operator/src/crd/s3/connection/mod.rs

@@ -53,4 +53,5 @@ serde.workspace = true
 serde_json.workspace = true
 serde_yaml.workspace = true
 snafu.workspace = true
+tracing.workspace = true
 trybuild.workspace = true

crates/stackable-versioned-macros/Cargo.toml

@@ -105,28 +105,50 @@ 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 fn generate_kubernetes_merge_crds(
+    pub 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(
+        let Container::Struct(s) = self else {
+            return None;
+        };
+        let kubernetes_options = s.common.options.kubernetes_options.as_ref()?;
+
+        let mut tokens = TokenStream::new();
+
+        if !kubernetes_options.skip_merged_crd {
+            tokens.extend(s.generate_kubernetes_merge_crds(
                 enum_variant_idents,
                 enum_variant_strings,
                 fn_calls,
                 vis,
                 is_nested,
-            ),
-            Container::Enum(_) => None,
+            ));
         }
+
+        tokens.extend(s.generate_from_functions(
+            enum_variant_idents,
+            enum_variant_strings,
+            is_nested,
+        ));
+        // TODO: Do we need a kubernetes_options.skip_conversion as well?
+        tokens.extend(super::flux_converter::generate_kubernetes_conversion(
+            &s.common.idents.kubernetes,
+            &s.common.idents.original,
+            enum_variant_idents,
+            enum_variant_strings,
+            kubernetes_options,
+        ));
+
+        Some(tokens)
     }
 
     pub fn generate_kubernetes_status_struct(&self) -> Option<TokenStream> {
@@ -251,7 +273,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

@@ -419,6 +419,8 @@ impl Struct {
         vis: &Visibility,
         is_nested: bool,
     ) -> Option<TokenStream> {
+        assert_eq!(enum_variant_idents.len(), enum_variant_strings.len());
+
         let kubernetes_options = self.common.options.kubernetes_options.as_ref()?;
 
         if !kubernetes_options.skip_merged_crd {
@@ -452,7 +454,10 @@ impl Struct {
                     /// 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())
                     }
                 }
@@ -462,6 +467,57 @@ impl Struct {
         }
     }
 
+    pub fn generate_from_functions(
+        &self,
+        enum_variant_idents: &[IdentString],
+        enum_variant_strings: &[String],
+        is_nested: bool,
+    ) -> Option<TokenStream> {
+        assert_eq!(enum_variant_idents.len(), enum_variant_strings.len());
+
+        let enum_ident = &self.common.idents.kubernetes;
+        let kubernetes_options = self.common.options.kubernetes_options.as_ref()?;
+        let k8s_group = &kubernetes_options.group;
+        let api_versions = enum_variant_strings
+            .iter()
+            .map(|version| format!("{k8s_group}/{version}"));
+
+        let versioned_path = &*kubernetes_options.crates.versioned;
+
+        // Only add the #[automatically_derived] attribute if this impl is used outside of a
+        // module (in standalone mode).
+        let automatically_derived = is_nested.not().then(|| quote! {#[automatically_derived]});
+
+        Some(quote! {
+            #automatically_derived
+            /// Parses the version, such as `v1alpha1`
+            impl ::std::str::FromStr for #enum_ident {
+                type Err = #versioned_path::ParseResourceVersionError;
+
+                fn from_str(version: &str) -> Result<Self, Self::Err> {
+                    match version {
+                        #(#enum_variant_strings => Ok(Self::#enum_variant_idents),)*
+                        _ => Err(#versioned_path::ParseResourceVersionError::UnknownResourceVersion{
+                            version: version.to_string()
+                        }),
+                    }
+                }
+            }
+
+            /// Parses the entire `apiVersion`, such as `zookeeper.stackable.tech/v1alpha1`.
+            impl #enum_ident {
+                pub fn from_api_version(api_version: &str) -> Result<Self, #versioned_path::ParseResourceVersionError> {
+                    match api_version {
+                        #(#api_versions => Ok(Self::#enum_variant_idents),)*
+                        _ => Err(#versioned_path::ParseResourceVersionError::UnknownApiVersion{
+                            api_version: api_version.to_string()
+                        }),
+                    }
+                }
+            }
+        })
+    }
+
     pub fn generate_kubernetes_status_struct(&self) -> Option<TokenStream> {
         let kubernetes_options = self.common.options.kubernetes_options.as_ref()?;