Convert errors to correct respondes

Author: sbernauer

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

@@ -45,15 +45,54 @@ pub(crate) fn generate_kubernetes_conversion(
         #[automatically_derived]
         impl #enum_ident {
             pub fn convert(review: kube::core::conversion::ConversionReview) -> kube::core::conversion::ConversionResponse {
-                Self::try_convert(review).expect("Self::try_convert failed")
+                // Intentionally not using `snafu::ResultExt` here to keep the number of dependencies minimal
+                use kube::core::conversion::{ConversionRequest, ConversionResponse};
+                use kube::core::response::StatusSummary;
+                use stackable_versioned::ConversionError;
+
+                let request = match ConversionRequest::from_review(review) {
+                    Ok(request) => request,
+                    Err(err) => {
+                        return ConversionResponse::invalid(
+                            kube::client::Status {
+                                status: Some(StatusSummary::Failure),
+                                code: 400,
+                                message: format!("The ConversionReview send did not include any request: {err}"),
+                                reason: "ConversionReview request missing".to_string(),
+                                details: None,
+                            },
+                        );
+                    }
+                };
+
+                let converted = Self::try_convert(&request);
+
+                let conversion_response = ConversionResponse::for_request(request);
+                match converted {
+                    Ok(converted) => {
+                        conversion_response.success(converted)
+                    },
+                    Err(err) => {
+                        let error_message = err.as_human_readable_error_message();
+
+                        conversion_response.failure(
+                            kube::client::Status {
+                                status: Some(StatusSummary::Success),
+                                code: err.http_return_code(),
+                                message: error_message.clone(),
+                                reason: error_message,
+                                details: None,
+                            },
+                        )
+                    }
+                }
             }
 
-            fn try_convert(review: kube::core::conversion::ConversionReview) -> Result<kube::core::conversion::ConversionResponse, stackable_versioned::ConversionError> {
-                // Intentionally not using `snafu::ResultExt` here to keep the number of dependencies minimal
+            fn try_convert(request: &kube::core::conversion::ConversionRequest) -> Result<Vec<serde_json::Value>, stackable_versioned::ConversionError> {
                 use stackable_versioned::ConversionError;
 
-                let request = kube::core::conversion::ConversionRequest::from_review(review)
-                    .map_err(|err| ConversionError::ConvertReviewToRequest{source: err})?;
+                // FIXME: Check that request.types.{kind,api_version} match the expected values
+
                 let desired_object_version = <Self as std::str::FromStr>::from_str(&request.desired_api_version)
                     .map_err(|err| ConversionError::ParseDesiredResourceVersion{
                         source: err,
@@ -83,8 +122,7 @@ pub(crate) fn generate_kubernetes_conversion(
                     }
                 }
 
-                let response = kube::core::conversion::ConversionResponse::for_request(request);
-                Ok(response.success(converted))
+                Ok(converted)
             }
         }
     })

crates/stackable-versioned/src/flux_converter/mod.rs

@@ -3,7 +3,8 @@
 //! It converts between different CRD versions by using 1.21 GW of power,
 //! 142km/h and time travel.
 
-use kube::core::conversion::ConvertConversionReviewError;
+use std::{error::Error, fmt::Write};
+
 use snafu::Snafu;
 
 #[cfg(test)]
@@ -17,11 +18,6 @@ pub enum ParseResourceVersionError {
 
 #[derive(Debug, Snafu)]
 pub enum ConversionError {
-    #[snafu(display("failed to convert ConversionReview to ConversionRequest"))]
-    ConvertReviewToRequest {
-        source: ConvertConversionReviewError,
-    },
-
     #[snafu(display("failed to parse current resource version \"{version}\""))]
     ParseCurrentResourceVersion {
         source: ParseResourceVersionError,
@@ -69,3 +65,33 @@ pub enum ConversionError {
         kind: String,
     },
 }
+
+impl ConversionError {
+    pub fn http_return_code(&self) -> u16 {
+        match &self {
+            ConversionError::ParseCurrentResourceVersion { .. } => 500,
+            ConversionError::ParseDesiredResourceVersion { .. } => 500,
+            ConversionError::ObjectHasNoSpec {} => 400,
+            ConversionError::ObjectHasNoKind {} => 400,
+            ConversionError::ObjectHasNoApiVersion {} => 400,
+            ConversionError::ObjectKindNotString { .. } => 400,
+            ConversionError::ObjectApiVersionNotString { .. } => 400,
+            ConversionError::WrongObjectKind { .. } => 400,
+            ConversionError::DeserializeObjectSpec { .. } => 500,
+            ConversionError::SerializeObjectSpec { .. } => 500,
+        }
+    }
+
+    pub fn as_human_readable_error_message(&self) -> String {
+        let mut error_message = String::new();
+        write!(error_message, "{self}").expect("Writing to Strings can not fail");
+
+        let mut source = self.source();
+        while let Some(err) = source {
+            write!(error_message, ": {err}").expect("Writing to Strings can not fail");
+            source = err.source();
+        }
+
+        error_message
+    }
+}