chore(stackable-versioned): Move code, add error handling

Author: Techassi

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

@@ -304,9 +304,7 @@ impl Struct {
     ) -> Option<TokenStream> {
         let kubernetes_arguments = self.common.options.kubernetes_arguments.as_ref()?;
 
-        let variant_data_ident = &self.common.idents.kubernetes_parameter;
         let struct_ident = &self.common.idents.kubernetes;
-        let spec_ident = &self.common.idents.original;
 
         let kube_client_path = &*kubernetes_arguments.crates.kube_client;
         let serde_json_path = &*kubernetes_arguments.crates.serde_json;
@@ -316,93 +314,17 @@ impl Struct {
         let convert_object_error = quote! { #versioned_path::ConvertObjectError };
 
         // Generate conversion paths and the match arms for these paths
-        let conversion_chain = conversion_path(versions);
-        let match_arms: Vec<_> = conversion_chain
-            .iter()
-            .map(|(start, path)| {
-                let current_object_version_ident = &start.idents.variant;
-                let current_object_version_string = &start.inner.to_string();
-
-                let desired_object_version = path.last().expect("the path always contains at least one element");
-                let desired_object_version_string = desired_object_version.inner.to_string();
-                let desired_object_variant_ident = &desired_object_version.idents.variant;
-                let desired_object_module_ident = &desired_object_version.idents.module;
-
-                let conversions = path.iter().enumerate().map(|(i, v)| {
-                    let module_ident = &v.idents.module;
-
-                    if i == 0 {
-                        quote! {
-                            let converted: #module_ident::#spec_ident = #variant_data_ident.spec.into();
-                        }
-                    } else {
-                        quote! {
-                            let converted: #module_ident::#spec_ident = converted.into();
-                        }
-                    }
-                });
-
-                let kind = self.common.idents.kubernetes.to_string();
-                let steps = path.len();
-
-                let convert_object_trace = kubernetes_arguments.options.enable_tracing.is_present().then(|| quote! {
-                    ::tracing::trace!(
-                        k8s.crd.conversion.api_version = #current_object_version_string,
-                        k8s.crd.conversion.desired_api_version = #desired_object_version_string,
-                        k8s.crd.conversion.steps = #steps,
-                        k8s.crd.kind = #kind,
-                        "Successfully converted object"
-                    );
-                });
-
-                quote! {
-                    (Self::#current_object_version_ident(#variant_data_ident), #desired_object_version_string) => {
-                        #(#conversions)*
-
-                        let desired_object = Self::#desired_object_variant_ident(#desired_object_module_ident::#struct_ident {
-                            metadata: #variant_data_ident.metadata,
-                            spec: converted,
-                        });
-
-                        let desired_object = desired_object.into_json_value()
-                            .map_err(|source| #convert_object_error::Serialize { source })?;
-
-                        #convert_object_trace
-
-                        converted_objects.push(desired_object);
-                    }
-                }
-            })
-            .collect();
-
-        // Generate tracing attribute of tracing is enabled
-        let (try_convert_instrumentation, convert_objects_instrumentation) = kubernetes_arguments
-            .options
-            .enable_tracing
-            .is_present()
-            .then(|| {
-                // TODO (@Techassi): Make tracing path configurable. Currently not possible, needs
-                // upstream change
-                let try_convert_instrumentation = quote! {
-                    #[::tracing::instrument(
-                        skip_all,
-                        fields(
-                            k8s.crd.conversion.kind = review.types.kind,
-                            k8s.crd.conversion.api_version = review.types.api_version,
-                        )
-                    )]
-                };
-
-                let convert_objects_instrumentation = quote! {
-                    #[::tracing::instrument(
-                        skip_all,
-                        err
-                    )]
-                };
-
-                (try_convert_instrumentation, convert_objects_instrumentation)
-            })
-            .unzip();
+        let match_arms =
+            self.generate_kubernetes_conversion_match_arms(versions, kubernetes_arguments);
+
+        // TODO (@Techassi): Make this a feature, drop the option from the macro arguments
+        // Generate tracing attributes and events if tracing is enabled
+        let TracingTokens {
+            successful_conversion_response_event,
+            convert_objects_instrumentation,
+            invalid_conversion_review_event,
+            try_convert_instrumentation,
+        } = self.generate_kubernetes_conversion_tracing(kubernetes_arguments);
 
         // Generate doc comments
         let conversion_review_reference =
@@ -426,15 +348,31 @@ impl Struct {
                 -> #kube_core_path::conversion::ConversionReview
             {
                 // First, turn the review into a conversion request
-                // TODO (@Techassi): Handle this error and return status Invalid
-                let request = #kube_core_path::conversion::ConversionRequest::from_review(review).unwrap();
+                let request = match #kube_core_path::conversion::ConversionRequest::from_review(review) {
+                    ::std::result::Result::Ok(request) => request,
+                    ::std::result::Result::Err(err) => {
+                        #invalid_conversion_review_event
+
+                        return #kube_core_path::conversion::ConversionResponse::invalid(
+                            #kube_client_path::Status {
+                                status: Some(#kube_core_path::response::StatusSummary::Failure),
+                                message: err.to_string(),
+                                reason: err.to_string(),
+                                details: None,
+                                code: 400,
+                            }
+                        ).into_review()
+                    }
+                };
 
                 // Extract the desired api version
                 let desired_api_version = request.desired_api_version.as_str();
 
                 // Convert all objects into the desired version
                 let response = match Self::convert_objects(request.objects, desired_api_version) {
                     ::std::result::Result::Ok(converted_objects) => {
+                        #successful_conversion_response_event
+
                         // We construct the response from the ground up as the helper functions
                         // don't provide any benefit over manually doing it. Constructing a
                         // ConversionResponse via for_request is not possible due to a partial move
@@ -449,7 +387,23 @@ impl Struct {
                             converted_objects,
                         }
                     },
-                    ::std::result::Result::Err(_) => todo!(),
+                    ::std::result::Result::Err(err) => {
+                        let code = err.http_status_code();
+                        let message = err.join_errors();
+
+                        #kube_core_path::conversion::ConversionResponse {
+                            result: #kube_client_path::Status {
+                                status: Some(#kube_core_path::response::StatusSummary::Failure),
+                                message: message.clone(),
+                                reason: message,
+                                details: None,
+                                code,
+                            },
+                            types: request.types,
+                            uid: request.uid,
+                            converted_objects: vec![],
+                        }
+                    },
                 };
 
                 response.into_review()
@@ -478,14 +432,142 @@ impl Struct {
                         // apiserver should never send such a conversion review.
                         _ => converted_objects.push(object),
                     }
-
-
                 }
 
                 ::std::result::Result::Ok(converted_objects)
             }
         })
     }
+
+    fn generate_kubernetes_conversion_match_arms(
+        &self,
+        versions: &[VersionDefinition],
+        kubernetes_arguments: &KubernetesArguments,
+    ) -> Vec<TokenStream> {
+        let variant_data_ident = &self.common.idents.kubernetes_parameter;
+        let struct_ident = &self.common.idents.kubernetes;
+        let spec_ident = &self.common.idents.original;
+
+        let versioned_path = &*kubernetes_arguments.crates.versioned;
+        let convert_object_error = quote! { #versioned_path::ConvertObjectError };
+
+        let conversion_chain = conversion_path(versions);
+
+        conversion_chain
+            .iter()
+            .map(|(start, path)| {
+                let current_object_version_ident = &start.idents.variant;
+                let current_object_version_string = &start.inner.to_string();
+
+                let desired_object_version = path.last().expect("the path always contains at least one element");
+                let desired_object_version_string = desired_object_version.inner.to_string();
+                let desired_object_variant_ident = &desired_object_version.idents.variant;
+                let desired_object_module_ident = &desired_object_version.idents.module;
+
+                let conversions = path.iter().enumerate().map(|(i, v)| {
+                    let module_ident = &v.idents.module;
+
+                    if i == 0 {
+                        quote! {
+                            let converted: #module_ident::#spec_ident = #variant_data_ident.spec.into();
+                        }
+                    } else {
+                        quote! {
+                            let converted: #module_ident::#spec_ident = converted.into();
+                        }
+                    }
+                });
+
+                let kind = self.common.idents.kubernetes.to_string();
+                let steps = path.len();
+
+                let convert_object_trace = kubernetes_arguments.options.enable_tracing.is_present().then(|| quote! {
+                    ::tracing::trace!(
+                        k8s.crd.conversion.desired_api_version = #desired_object_version_string,
+                        k8s.crd.conversion.api_version = #current_object_version_string,
+                        k8s.crd.conversion.steps = #steps,
+                        k8s.crd.kind = #kind,
+                        "Successfully converted object"
+                    );
+                });
+
+                quote! {
+                    (Self::#current_object_version_ident(#variant_data_ident), #desired_object_version_string) => {
+                        #(#conversions)*
+
+                        let desired_object = Self::#desired_object_variant_ident(#desired_object_module_ident::#struct_ident {
+                            metadata: #variant_data_ident.metadata,
+                            spec: converted,
+                        });
+
+                        let desired_object = desired_object.into_json_value()
+                            .map_err(|source| #convert_object_error::Serialize { source })?;
+
+                        #convert_object_trace
+
+                        converted_objects.push(desired_object);
+                    }
+                }
+            })
+            .collect()
+    }
+
+    fn generate_kubernetes_conversion_tracing(
+        &self,
+        kubernetes_arguments: &KubernetesArguments,
+    ) -> TracingTokens {
+        if kubernetes_arguments.options.enable_tracing.is_present() {
+            // TODO (@Techassi): Make tracing path configurable. Currently not possible, needs
+            // upstream change
+            let kind = self.common.idents.kubernetes.to_string();
+
+            let successful_conversion_response_event = Some(quote! {
+                ::tracing::debug!(
+                    k8s.crd.conversion.converted_object_count = converted_objects.len(),
+                    k8s.crd.kind = #kind,
+                    "Successfully converted objects"
+                );
+            });
+
+            let convert_objects_instrumentation = Some(quote! {
+                #[::tracing::instrument(
+                    skip_all,
+                    err
+                )]
+            });
+
+            let invalid_conversion_review_event = Some(quote! {
+                ::tracing::warn!(?err, "received invalid conversion review");
+            });
+
+            let try_convert_instrumentation = Some(quote! {
+                #[::tracing::instrument(
+                    skip_all,
+                    fields(
+                        k8s.crd.conversion.api_version = review.types.api_version,
+                        k8s.crd.kind = review.types.kind,
+                    )
+                )]
+            });
+
+            TracingTokens {
+                successful_conversion_response_event,
+                convert_objects_instrumentation,
+                invalid_conversion_review_event,
+                try_convert_instrumentation,
+            }
+        } else {
+            TracingTokens::default()
+        }
+    }
+}
+
+#[derive(Debug, Default)]
+struct TracingTokens {
+    successful_conversion_response_event: Option<TokenStream>,
+    convert_objects_instrumentation: Option<TokenStream>,
+    invalid_conversion_review_event: Option<TokenStream>,
+    try_convert_instrumentation: Option<TokenStream>,
 }
 
 fn conversion_path<'a, T>(elements: &'a [T]) -> Vec<(&'a T, Cow<'a, [T]>)>