assume single role in ValidatedHiveCluster

Author: adwk67

rust/operator-binary/src/controller.rs

@@ -382,112 +382,108 @@ pub async fn reconcile_hive(
 
     let mut ss_cond_builder = StatefulSetConditionBuilder::default();
 
-    for (hive_role, role_group_configs) in &validated.role_groups {
-        if let Some(role_config) = validated.role_configs.get(hive_role) {
-            add_pdbs(
-                &role_config.pdb,
-                hive,
-                hive_role,
-                client,
-                &mut cluster_resources,
-            )
-            .await
-            .context(FailedToCreatePdbSnafu)?;
-        }
+    for (rolegroup_name, validated_rg_config) in &validated.role_groups {
+        let rolegroup = hive.metastore_rolegroup_ref(rolegroup_name);
 
-        for (rolegroup_name, validated_rg_config) in role_group_configs {
-            let rolegroup = hive.metastore_rolegroup_ref(rolegroup_name);
-
-            let rg_metrics_service =
-                build_rolegroup_metrics_service(hive, &validated.image, &rolegroup)
-                    .context(ServiceConfigurationSnafu)?;
-
-            let rg_headless_service =
-                build_rolegroup_headless_service(hive, &validated.image, &rolegroup)
-                    .context(ServiceConfigurationSnafu)?;
-
-            let rg_configmap = build_metastore_rolegroup_config_map(
-                hive,
-                &hive_namespace,
-                &validated.image,
-                &rolegroup,
-                &validated_rg_config.product_config_properties,
-                &dereferenced.metadata_database_connection_details,
-                dereferenced.s3_connection_spec.as_ref(),
-                &validated_rg_config.merged_config,
-                &client.kubernetes_cluster_info,
-                dereferenced.hive_opa_config.as_ref(),
-            )?;
-            let rg_statefulset = build_metastore_rolegroup_statefulset(
-                hive,
-                hive_role,
-                &validated.image,
-                &rolegroup,
-                &validated_rg_config.product_config_properties,
-                &dereferenced.metadata_database_connection_details,
-                dereferenced.s3_connection_spec.as_ref(),
-                &validated_rg_config.merged_config,
-                &rbac_sa.name_any(),
-                dereferenced.hive_opa_config.as_ref(),
-            )?;
+        let rg_metrics_service =
+            build_rolegroup_metrics_service(hive, &validated.image, &rolegroup)
+                .context(ServiceConfigurationSnafu)?;
 
-            cluster_resources
-                .add(client, rg_metrics_service)
-                .await
-                .context(ApplyRoleGroupServiceSnafu {
-                    rolegroup: rolegroup.clone(),
-                })?;
+        let rg_headless_service =
+            build_rolegroup_headless_service(hive, &validated.image, &rolegroup)
+                .context(ServiceConfigurationSnafu)?;
+
+        let rg_configmap = build_metastore_rolegroup_config_map(
+            hive,
+            &hive_namespace,
+            &validated.image,
+            &rolegroup,
+            &validated_rg_config.product_config_properties,
+            &dereferenced.metadata_database_connection_details,
+            dereferenced.s3_connection_spec.as_ref(),
+            &validated_rg_config.merged_config,
+            &client.kubernetes_cluster_info,
+            dereferenced.hive_opa_config.as_ref(),
+        )?;
+        let rg_statefulset = build_metastore_rolegroup_statefulset(
+            hive,
+            &HiveRole::MetaStore,
+            &validated.image,
+            &rolegroup,
+            &validated_rg_config.product_config_properties,
+            &dereferenced.metadata_database_connection_details,
+            dereferenced.s3_connection_spec.as_ref(),
+            &validated_rg_config.merged_config,
+            &rbac_sa.name_any(),
+            dereferenced.hive_opa_config.as_ref(),
+        )?;
+
+        cluster_resources
+            .add(client, rg_metrics_service)
+            .await
+            .context(ApplyRoleGroupServiceSnafu {
+                rolegroup: rolegroup.clone(),
+            })?;
+
+        cluster_resources
+            .add(client, rg_headless_service)
+            .await
+            .context(ApplyRoleGroupServiceSnafu {
+                rolegroup: rolegroup.clone(),
+            })?;
 
+        cluster_resources
+            .add(client, rg_configmap)
+            .await
+            .context(ApplyRoleGroupConfigSnafu {
+                rolegroup: rolegroup.clone(),
+            })?;
+
+        // Note: The StatefulSet needs to be applied after all ConfigMaps and Secrets it mounts
+        // to prevent unnecessary Pod restarts.
+        // See https://github.com/stackabletech/commons-operator/issues/111 for details.
+        ss_cond_builder.add(
             cluster_resources
-                .add(client, rg_headless_service)
+                .add(client, rg_statefulset)
                 .await
-                .context(ApplyRoleGroupServiceSnafu {
-                    rolegroup: rolegroup.clone(),
-                })?;
-
-            cluster_resources.add(client, rg_configmap).await.context(
-                ApplyRoleGroupConfigSnafu {
+                .context(ApplyRoleGroupStatefulSetSnafu {
                     rolegroup: rolegroup.clone(),
-                },
-            )?;
-
-            // Note: The StatefulSet needs to be applied after all ConfigMaps and Secrets it mounts
-            // to prevent unnecessary Pod restarts.
-            // See https://github.com/stackabletech/commons-operator/issues/111 for details.
-            ss_cond_builder.add(
-                cluster_resources
-                    .add(client, rg_statefulset)
-                    .await
-                    .context(ApplyRoleGroupStatefulSetSnafu {
-                        rolegroup: rolegroup.clone(),
-                    })?,
-            );
-        }
+                })?,
+        );
     }
 
     // std's SipHasher is deprecated, and DefaultHasher is unstable across Rust releases.
     // We don't /need/ stability, but it's still nice to avoid spurious changes where possible.
     let mut discovery_hash = FnvHasher::with_key(0);
 
-    let hive_role = HiveRole::MetaStore;
-    if let Some(role_config) = validated.role_configs.get(&hive_role) {
+    if let Some(role_config) = validated.role_config {
+        add_pdbs(
+            &role_config.pdb,
+            hive,
+            &HiveRole::MetaStore,
+            client,
+            &mut cluster_resources,
+        )
+        .await
+        .context(FailedToCreatePdbSnafu)?;
+
         let role_listener: Listener = build_role_listener(
             hive,
             &validated.image,
-            &hive_role,
+            &HiveRole::MetaStore,
             &role_config.listener_class,
         )
         .context(ListenerConfigurationSnafu)?;
         let listener = cluster_resources.add(client, role_listener).await.context(
             ApplyGroupListenerSnafu {
-                role: hive_role.to_string(),
+                role: HiveRole::MetaStore.to_string(),
             },
         )?;
 
         for discovery_cm in discovery::build_discovery_configmaps(
             hive,
             hive,
-            hive_role,
+            HiveRole::MetaStore,
             &validated.image,
             None,
             listener,

rust/operator-binary/src/controller/validate.rs

@@ -59,8 +59,8 @@ pub struct ValidatedRoleGroupConfig {
 #[derive(Clone, Debug)]
 pub struct ValidatedHiveCluster {
     pub image: ResolvedProductImage,
-    pub role_groups: BTreeMap<HiveRole, BTreeMap<String, ValidatedRoleGroupConfig>>,
-    pub role_configs: BTreeMap<HiveRole, ValidatedRoleConfig>,
+    pub role_groups: BTreeMap<String, ValidatedRoleGroupConfig>,
+    pub role_config: Option<ValidatedRoleConfig>,
 }
 
 pub fn validate_cluster(
@@ -103,31 +103,27 @@ pub fn validate_cluster(
     )
     .context(InvalidProductConfigSnafu)?;
 
-    let mut role_groups = BTreeMap::new();
-    let mut role_configs = BTreeMap::new();
-
     let metastore_config = validated_config
         .get(&HiveRole::MetaStore.to_string())
         .map(Cow::Borrowed)
         .unwrap_or_default();
 
     let hive_role = HiveRole::MetaStore;
 
-    if let Some(HiveMetastoreRoleConfig {
+    let role_config = if let Some(HiveMetastoreRoleConfig {
         common: GenericRoleConfig {
             pod_disruption_budget: pdb,
         },
         listener_class,
     }) = hive.role_config(&hive_role)
     {
-        role_configs.insert(
-            hive_role.clone(),
-            ValidatedRoleConfig {
-                pdb: pdb.clone(),
-                listener_class: listener_class.clone(),
-            },
-        );
-    }
+        Some(ValidatedRoleConfig {
+            pdb: pdb.clone(),
+            listener_class: listener_class.clone(),
+        })
+    } else {
+        None
+    };
 
     let mut group_configs = BTreeMap::new();
     for (rolegroup_name, rolegroup_config) in metastore_config.iter() {
@@ -146,11 +142,9 @@ pub fn validate_cluster(
         );
     }
 
-    role_groups.insert(hive_role, group_configs);
-
     Ok(ValidatedHiveCluster {
         image: resolved_product_image,
-        role_groups,
-        role_configs,
+        role_groups: group_configs,
+        role_config,
     })
 }