Rework Scaler status to complex enum

Author: sbernauer

crates/stackable-operator/src/crd/scaler/mod.rs

@@ -1,5 +1,3 @@
-use std::borrow::Cow;
-
 use k8s_openapi::apimachinery::pkg::apis::meta::v1::Time;
 use kube::CustomResource;
 use schemars::JsonSchema;
@@ -64,20 +62,15 @@ pub struct ScalerStatus {
 // and others to be typed as objects. We therefore encode the variant data in a separate details
 // key/object. With this, all variants can be encoded as strings, while the status can still contain
 // additional data in an extra field when needed.
-#[derive(Clone, Debug, PartialEq, Eq, Deserialize, Serialize, strum::Display)]
-#[serde(
-    tag = "state",
-    content = "details",
-    rename_all = "PascalCase",
-    rename_all_fields = "camelCase"
-)]
-#[strum(serialize_all = "PascalCase")]
+#[derive(Clone, Debug, PartialEq, Eq, Deserialize, Serialize, JsonSchema, strum::Display)]
+#[serde(rename_all = "camelCase", rename_all_fields = "camelCase")]
+#[strum(serialize_all = "camelCase")]
 pub enum ScalerState {
     /// No scaling operation is in progress.
-    Idle,
+    Idle {},
 
     /// Running the `pre_scale` hook (e.g. data offload).
-    PreScaling,
+    PreScaling {},
 
     /// Waiting for the StatefulSet to converge to the new replica count.
     ///
@@ -104,41 +97,6 @@ pub enum ScalerState {
     },
 }
 
-// We manually implement the JSON schema instead of deriving it, because kube's schema transformer
-// cannot handle the derived JsonSchema and proceeds to hit the following error: "Property "state"
-// has the schema ... but was already defined as ... in another subschema. The schemas for a
-// property used in multiple subschemas must be identical".
-impl JsonSchema for ScalerState {
-    fn schema_name() -> Cow<'static, str> {
-        "ScalerState".into()
-    }
-
-    fn json_schema(generator: &mut schemars::generate::SchemaGenerator) -> schemars::Schema {
-        schemars::json_schema!({
-            "type": "object",
-            "required": ["state"],
-            "properties": {
-                "state": {
-                    "type": "string",
-                    "enum": ["idle", "preScaling", "scaling", "postScaling", "failed"]
-                },
-                "details": {
-                    "type": "object",
-                    "properties": {
-                        "failedIn": generator.subschema_for::<FailedInState>(),
-                        "previous_replicas": {
-                            "type": "uint16",
-                            "minimum": u16::MIN,
-                            "maximum": u16::MAX
-                        },
-                        "reason": { "type": "string" }
-                    }
-                }
-            }
-        })
-    }
-}
-
 /// In which state the scaling operation failed.
 #[derive(Clone, Debug, PartialEq, Eq, Deserialize, Serialize, JsonSchema)]
 #[serde(rename_all = "PascalCase")]
@@ -158,19 +116,18 @@ mod tests {
     use rstest::rstest;
 
     use super::*;
-    use crate::utils::yaml_from_str_singleton_map;
+    use crate::{
+        test_utils::serialize_to_yaml_with_singleton_map, utils::yaml_from_str_singleton_map,
+    };
 
     #[rstest]
-    #[case::idle("state: Idle", ScalerState::Idle { })]
-    #[case::pre_scaling("state: PreScaling", ScalerState::PreScaling { })]
-    #[case::scaling("state: Scaling
-details:
+    #[case::idle("idle: {}", ScalerState::Idle { })]
+    #[case::pre_scaling("preScaling: {}", ScalerState::PreScaling { })]
+    #[case::scaling("scaling:
   previousReplicas: 42", ScalerState::Scaling { previous_replicas: 42 })]
-    #[case::post_scaling("state: PostScaling
-details:
+    #[case::post_scaling("postScaling:
   previousReplicas: 42", ScalerState::PostScaling { previous_replicas: 42 })]
-    #[case::failed("state: Failed
-details:
+    #[case::failed("failed:
   failedIn: PreScaling
   reason: bruh moment", ScalerState::Failed {
          failed_in: FailedInState::PreScaling,
@@ -183,20 +140,19 @@ details:
     }
 
     #[rstest]
-    #[case::idle(ScalerState::Idle { }, "state: Idle\n")]
-    #[case::pre_scaling(ScalerState::PreScaling { }, "state: PreScaling\n")]
-    #[case::scaling(ScalerState::Scaling { previous_replicas: 42 }, "state: Scaling
-details:
+    #[case::idle(ScalerState::Idle { }, "idle: {}\n")]
+    #[case::pre_scaling(ScalerState::PreScaling { }, "preScaling: {}\n")]
+    #[case::scaling(ScalerState::Scaling { previous_replicas: 42 }, "scaling:
   previousReplicas: 42\n")]
-    #[case::post_scaling(ScalerState::PostScaling { previous_replicas: 42 }, "state: PostScaling
-details:
+    #[case::post_scaling(ScalerState::PostScaling { previous_replicas: 42 }, "postScaling:
   previousReplicas: 42\n")]
-    #[case::failed(ScalerState::Failed { failed_in: FailedInState::PreScaling, reason: "bruh moment".to_owned() }, "state: Failed
-details:
+    #[case::failed(ScalerState::Failed { failed_in: FailedInState::PreScaling, reason: "bruh moment".to_owned() }, "failed:
   failedIn: PreScaling
   reason: bruh moment\n")]
     fn serialize_state(#[case] input: ScalerState, #[case] expected: &str) {
-        let serialized = serde_yaml::to_string(&input).expect("serialization always passes");
+        let serialized =
+            serialize_to_yaml_with_singleton_map(&input).expect("serialization always passes");
+
         assert_eq!(serialized, expected);
     }
 }

crates/stackable-operator/src/lib.rs

@@ -31,6 +31,7 @@ pub mod product_config_utils;
 pub mod product_logging;
 pub mod role_utils;
 pub mod status;
+pub mod test_utils;
 pub mod utils;
 pub mod validation;
 

crates/stackable-operator/src/test_utils.rs

@@ -0,0 +1,17 @@
+/// Please use only in tests, as we have non-ideal error handling in case serde_yaml produced
+/// non-utf8 output.
+pub fn serialize_to_yaml_with_singleton_map<S>(input: &S) -> Result<String, serde_yaml::Error>
+where
+    S: serde::Serialize,
+{
+    use serde::ser::Error as _;
+
+    let mut buffer = Vec::new();
+    let mut serializer = serde_yaml::Serializer::new(&mut buffer);
+    serde_yaml::with::singleton_map_recursive::serialize(input, &mut serializer)?;
+    String::from_utf8(buffer).map_err(|err| {
+        serde_yaml::Error::custom(format!(
+            "For *some* reason, serde_yaml produced non-utf8 output: {err}"
+        ))
+    })
+}