feat: Add AZ, Flavor, and Floating IP labels for apiServerLoadBalancer #510 (#798)

Signed-off-by: okozachenko1203 <[email protected]>

Author: okozachenko1203

crates/serde_gtmpl/src/lib.rs

@@ -7,7 +7,7 @@ pub trait ToGtmplValue {
 
 fn json_to_gtmpl_value(json: &serde_json::Value, version: &str) -> gtmpl_value::Value {
     match json {
-        serde_json::Value::Null => unimplemented!(),
+        serde_json::Value::Null => gtmpl_value::Value::Nil,
         serde_json::Value::Bool(b) => (*b).into(),
         serde_json::Value::Number(n) => {
             if let Some(i) = n.as_i64() {

magnum_cluster_api/resources.py

@@ -928,6 +928,15 @@ def get_object(self) -> dict:
         worker_flavor = utils.lookup_flavor(osc, self.cluster.flavor_id)
         image = utils.lookup_image(osc, self.cluster.default_ng_master.image_id)
 
+        api_server_load_balancer = {
+            "enabled": self.cluster.master_lb_enabled,
+            "provider": self.cluster.labels.get("octavia_provider", "amphora"),
+            "availabilityZone": self.cluster.labels.get(
+                "api_server_lb_availability_zone", ""
+            ),
+            "flavor": self.cluster.labels.get("api_server_lb_flavor", ""),
+        }
+
         return {
             "metadata": {
                 "labels": self.labels,
@@ -970,12 +979,7 @@ def get_object(self) -> dict:
                     "variables": [
                         {
                             "name": "apiServerLoadBalancer",
-                            "value": {
-                                "enabled": self.cluster.master_lb_enabled,
-                                "provider": self.cluster.labels.get(
-                                    "octavia_provider", "amphora"
-                                ),
-                            },
+                            "value": api_server_load_balancer,
                         },
                         {
                             "name": "apiServerTLSCipherSuites",
@@ -984,6 +988,12 @@ def get_object(self) -> dict:
                                 "TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256,TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256,TLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384,TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384,TLS_ECDHE_ECDSA_WITH_CHACHA20_POLY1305,TLS_ECDHE_RSA_WITH_CHACHA20_POLY1305",  # noqa: E501
                             ),
                         },
+                        {
+                            "name": "apiServerFloatingIP",
+                            "value": self.cluster.labels.get(
+                                "api_server_floating_ip", ""
+                            ),
+                        },
                         {
                             "name": "openidConnect",
                             "value": {

src/features/api_server_floating_ip.rs

@@ -0,0 +1,113 @@
+use crate::{
+    cluster_api::{
+        clusterclasses::{
+            ClusterClassPatches, ClusterClassPatchesDefinitions,
+            ClusterClassPatchesDefinitionsJsonPatches,
+            ClusterClassPatchesDefinitionsJsonPatchesValueFrom,
+            ClusterClassPatchesDefinitionsSelector,
+            ClusterClassPatchesDefinitionsSelectorMatchResources, ClusterClassVariables,
+            ClusterClassVariablesSchema,
+        },
+        openstackclustertemplates::OpenStackClusterTemplate,
+    },
+    features::{
+        ClusterClassVariablesSchemaExt, ClusterFeatureEntry, ClusterFeaturePatches,
+        ClusterFeatureVariables,
+    },
+};
+use cluster_feature_derive::ClusterFeatureValues;
+use kube::CustomResourceExt;
+use serde::{Deserialize, Serialize};
+
+#[derive(Serialize, Deserialize, ClusterFeatureValues)]
+pub struct FeatureValues {
+    #[serde(rename = "apiServerFloatingIP")]
+    pub api_server_floating_ip: String,
+}
+
+pub struct Feature {}
+
+impl ClusterFeaturePatches for Feature {
+    fn patches(&self) -> Vec<ClusterClassPatches> {
+        vec![ClusterClassPatches {
+            name: "apiServerFloatingIP".into(),
+            enabled_if: Some(r#"{{ if ne .apiServerFloatingIP "" }}true{{end}}"#.into()),
+            definitions: Some(vec![ClusterClassPatchesDefinitions {
+                selector: ClusterClassPatchesDefinitionsSelector {
+                    api_version: OpenStackClusterTemplate::api_resource().api_version,
+                    kind: OpenStackClusterTemplate::api_resource().kind,
+                    match_resources: ClusterClassPatchesDefinitionsSelectorMatchResources {
+                        infrastructure_cluster: Some(true),
+                        ..Default::default()
+                    },
+                },
+                json_patches: vec![ClusterClassPatchesDefinitionsJsonPatches {
+                    op: "add".into(),
+                    path: "/spec/template/spec/apiServerFloatingIP".into(),
+                    value_from: Some(ClusterClassPatchesDefinitionsJsonPatchesValueFrom {
+                        variable: Some("apiServerFloatingIP".into()),
+                        ..Default::default()
+                    }),
+                    ..Default::default()
+                }],
+            }]),
+            ..Default::default()
+        }]
+    }
+}
+
+inventory::submit! {
+    ClusterFeatureEntry{ feature: &Feature {} }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::features::test::TestClusterResources;
+    use crate::resources::fixtures::default_values;
+    use pretty_assertions::assert_eq;
+
+    #[test]
+    fn test_patches_if_enabled() {
+        let feature = Feature {};
+
+        let mut values = default_values();
+        values.api_server_floating_ip = "1.2.3.4".to_string();
+
+        let patches = feature.patches();
+
+        let mut resources = TestClusterResources::new();
+        resources.apply_patches(&patches, &values);
+
+        assert_eq!(
+            resources
+                .openstack_cluster_template
+                .spec
+                .template
+                .spec
+                .api_server_floating_ip,
+            Some("1.2.3.4".into())
+        );
+    }
+
+    #[test]
+    fn test_patches_if_disabled() {
+        let feature = Feature {};
+
+        let values = default_values();
+        let patches = feature.patches();
+
+        let mut resources = TestClusterResources::new();
+        resources.apply_patches(&patches, &values);
+
+        assert_eq!(
+            resources
+                .openstack_cluster_template
+                .spec
+                .template
+                .spec
+                .api_server_floating_ip,
+            None
+        );
+    }
+}

src/features/api_server_load_balancer.rs

@@ -24,7 +24,13 @@ use typed_builder::TypedBuilder;
 #[derive(Clone, Serialize, Deserialize, JsonSchema, TypedBuilder)]
 pub struct APIServerLoadBalancerConfig {
     pub enabled: bool,
+
     pub provider: String,
+
+    pub flavor: String,
+
+    #[serde(rename = "availabilityZone")]
+    pub availability_zone: String,
 }
 
 #[derive(Serialize, Deserialize, ClusterFeatureValues)]
@@ -78,7 +84,14 @@ mod tests {
     fn test_patches() {
         let feature = Feature {};
 
-        let values = default_values();
+        let mut values = default_values();
+        values.api_server_load_balancer = APIServerLoadBalancerConfig::builder()
+            .enabled(true)
+            .provider("octavia".to_string())
+            .flavor("ha".to_string())
+            .availability_zone("zone-1".to_string())
+            .build();
+
         let patches = feature.patches();
 
         let mut resources = TestClusterResources::new();
@@ -100,5 +113,13 @@ mod tests {
             api_server_load_balancer.provider,
             Some(values.api_server_load_balancer.provider)
         );
+        assert_eq!(
+            api_server_load_balancer.flavor,
+            Some(values.api_server_load_balancer.flavor)
+        );
+        assert_eq!(
+            api_server_load_balancer.availability_zone,
+            Some(values.api_server_load_balancer.availability_zone)
+        );
     }
 }

src/features/mod.rs

@@ -49,6 +49,7 @@ use schemars::{gen::SchemaGenerator, JsonSchema};
 use std::sync::LazyLock;
 
 pub mod admission_plugins;
+pub mod api_server_floating_ip;
 pub mod api_server_load_balancer;
 pub mod audit_log;
 pub mod boot_volume;

src/resources.rs

@@ -186,10 +186,13 @@ pub mod fixtures {
 
     pub fn default_values() -> Values {
         Values::builder()
+            .api_server_floating_ip("".to_string())
             .api_server_load_balancer(
                 api_server_load_balancer::APIServerLoadBalancerConfig::builder()
                     .enabled(true)
-                    .provider("amphora".into())
+                    .provider("amphora".to_string())
+                    .flavor("worker".to_string())
+                    .availability_zone("zone1".to_string())
                     .build(),
             )
             .audit_log(
@@ -306,10 +309,13 @@ mod tests {
         let values = default_values();
         let variables: Vec<ClusterTopologyVariables> = values.into();
 
-        assert_eq!(variables.len(), 36);
+        assert_eq!(variables.len(), 37);
 
         for var in &variables {
             match var.name.as_str() {
+                "apiServerFloatingIP" => {
+                    assert_eq!(var.value, json!(default_values().api_server_floating_ip));
+                }
                 "apiServerLoadBalancer" => {
                     assert_eq!(var.value, json!(&default_values().api_server_load_balancer));
                 }