refactor: provide name to ValidatedRoleGroupConfig

Author: maltesander

rust/operator-binary/src/controller/build/config_map.rs

@@ -1,6 +1,6 @@
 //! Build per-rolegroup `ConfigMap` for the NiFi cluster.
 
-use snafu::{OptionExt, ResultExt, Snafu};
+use snafu::{ResultExt, Snafu};
 use stackable_operator::{
     builder::{configmap::ConfigMapBuilder, meta::ObjectMetaBuilder},
     k8s_openapi::api::core::v1::ConfigMap,
@@ -9,18 +9,15 @@ use stackable_operator::{
     v2::{builder::meta::ownerreference_from_resource, types::operator::RoleGroupName},
 };
 
-use crate::{
-    controller::{
-        ValidatedCluster,
-        build::{
-            properties::{
-                ConfigFileName, authorizers, bootstrap_conf, login_identity_providers,
-                nifi_properties, product_logging, security_properties, state_management_xml,
-            },
-            proxy_hosts,
+use crate::controller::{
+    ValidatedCluster, ValidatedRoleGroupConfig,
+    build::{
+        properties::{
+            ConfigFileName, authorizers, bootstrap_conf, login_identity_providers, nifi_properties,
+            product_logging, security_properties, state_management_xml,
         },
+        proxy_hosts,
     },
-    crd::NifiRole,
 };
 
 #[derive(Debug, Snafu)]
@@ -54,9 +51,6 @@ pub enum Error {
     InvalidNifiAuthenticationConfig {
         source: crate::security::authentication::Error,
     },
-
-    #[snafu(display("the cluster has no rolegroup [{role_group}] in role [{role}]"))]
-    MissingRoleGroup { role: String, role_group: String },
 }
 
 type Result<T, E = Error> = std::result::Result<T, E>;
@@ -67,20 +61,11 @@ type Result<T, E = Error> = std::result::Result<T, E>;
 /// All NiFi configuration is sourced from `cluster`.
 pub fn build_rolegroup_config_map(
     cluster: &ValidatedCluster,
-    role_group_name: &RoleGroupName,
+    rg: &ValidatedRoleGroupConfig,
     cluster_info: &KubernetesClusterInfo,
 ) -> Result<ConfigMap> {
     tracing::debug!("building rolegroup ConfigMap");
 
-    let rg = cluster
-        .role_group_configs
-        .get(&NifiRole::Node)
-        .and_then(|groups| groups.get(role_group_name))
-        .with_context(|| MissingRoleGroupSnafu {
-            role: NifiRole::Node.to_string(),
-            role_group: role_group_name.to_string(),
-        })?;
-
     let proxy_hosts = proxy_hosts::compute_proxy_hosts(cluster, cluster_info);
 
     let mut cm_builder = ConfigMapBuilder::new();
@@ -91,12 +76,12 @@ pub fn build_rolegroup_config_map(
                 .name_and_namespace(cluster)
                 .name(
                     cluster
-                        .resource_names(role_group_name)
+                        .resource_names(&rg.name)
                         .role_group_config_map()
                         .to_string(),
                 )
                 .ownerreference(ownerreference_from_resource(cluster, None, Some(true)))
-                .with_labels(cluster.recommended_labels(role_group_name))
+                .with_labels(cluster.recommended_labels(&rg.name))
                 .build(),
         )
         .add_data(
@@ -108,7 +93,7 @@ pub fn build_rolegroup_config_map(
             ConfigFileName::NifiProperties.to_string(),
             nifi_properties::build(cluster, rg, &proxy_hosts).with_context(|_| {
                 BuildNifiPropertiesSnafu {
-                    rolegroup: role_group_name.clone(),
+                    rolegroup: rg.name.clone(),
                 }
             })?,
         )
@@ -128,7 +113,7 @@ pub fn build_rolegroup_config_map(
         .add_data(
             ConfigFileName::SecurityProperties.to_string(),
             security_properties::build(rg).with_context(|_| JvmSecurityPropertiesSnafu {
-                rolegroup: role_group_name.clone(),
+                rolegroup: rg.name.clone(),
             })?,
         );
 
@@ -146,6 +131,6 @@ pub fn build_rolegroup_config_map(
     cm_builder
         .build()
         .with_context(|_| BuildRoleGroupConfigSnafu {
-            rolegroup: role_group_name.clone(),
+            rolegroup: rg.name.clone(),
         })
 }

rust/operator-binary/src/controller/build/properties/security_properties.rs

@@ -35,8 +35,13 @@ mod tests {
     };
 
     fn make_rg(overrides: Option<BTreeMap<String, String>>) -> ValidatedRoleGroupConfig {
-        use stackable_operator::v2::role_utils::JavaCommonConfig;
+        use std::str::FromStr as _;
+
+        use stackable_operator::v2::{
+            role_utils::JavaCommonConfig, types::operator::RoleGroupName,
+        };
         ValidatedRoleGroupConfig {
+            name: RoleGroupName::from_str("default").expect("valid role-group name"),
             replicas: 1,
             config: NifiConfig::default(),
             config_overrides: NifiConfigOverrides {

rust/operator-binary/src/controller/build/resource/statefulset.rs

@@ -43,10 +43,7 @@ use stackable_operator::{
             pod::container::{EnvVarSet, new_container_builder},
         },
         product_logging::framework::vector_container,
-        types::{
-            kubernetes::{ContainerName, VolumeName},
-            operator::RoleGroupName,
-        },
+        types::kubernetes::{ContainerName, VolumeName},
     },
 };
 
@@ -67,7 +64,7 @@ use crate::{
     },
     crd::{
         BALANCE_PORT, BALANCE_PORT_NAME, Container, HTTPS_PORT, HTTPS_PORT_NAME, METRICS_PORT,
-        METRICS_PORT_NAME, NifiConfig, NifiRole, NifiRoleType, PROTOCOL_PORT, PROTOCOL_PORT_NAME,
+        METRICS_PORT_NAME, NifiRole, NifiRoleType, PROTOCOL_PORT, PROTOCOL_PORT_NAME,
         STACKABLE_LOG_CONFIG_DIR, STACKABLE_LOG_DIR,
         authorization::NifiAccessPolicyProvider,
         constants::{NIFI_CONFIG_DIRECTORY, NIFI_PYTHON_WORKING_DIRECTORY},
@@ -165,7 +162,6 @@ stackable_operator::constant!(VECTOR_LOG_VOLUME_NAME: VolumeName = "log");
 pub(crate) async fn build_node_rolegroup_statefulset(
     cluster: &ValidatedCluster,
     cluster_info: &KubernetesClusterInfo,
-    role_group_name: &RoleGroupName,
     role: &NifiRoleType,
     rg: &ValidatedRoleGroupConfig,
     rolling_update_supported: bool,
@@ -182,7 +178,7 @@ pub(crate) async fn build_node_rolegroup_statefulset(
     let git_sync_resources = &rg.git_sync_resources;
 
     // Type-safe names for this role group's resources (StatefulSet, ConfigMap, headless Service).
-    let resource_names = cluster.resource_names(role_group_name);
+    let resource_names = cluster.resource_names(&rg.name);
 
     // The validated, merged `NifiConfig` is the single source of truth; the ConfigMap builder
     // sources the same `rg.config`.
@@ -459,7 +455,7 @@ pub(crate) async fn build_node_rolegroup_statefulset(
 
     let mut pod_builder = PodBuilder::new();
 
-    let recommended_object_labels = cluster.recommended_labels(role_group_name);
+    let recommended_object_labels = cluster.recommended_labels(&rg.name);
 
     add_graceful_shutdown_config(merged_config, &mut pod_builder).context(GracefulShutdownSnafu)?;
 
@@ -616,8 +612,7 @@ pub(crate) async fn build_node_rolegroup_statefulset(
                 KEYSTORE_VOLUME_NAME,
                 [
                     crate::controller::build::resource::service::metrics_service_name(
-                        cluster,
-                        role_group_name,
+                        cluster, &rg.name,
                     ),
                     build_reporting_task_service_name(&nifi_cluster_name),
                 ],
@@ -675,7 +670,7 @@ pub(crate) async fn build_node_rolegroup_statefulset(
             pod_management_policy: Some("Parallel".to_string()),
             replicas,
             selector: LabelSelector {
-                match_labels: Some(cluster.role_group_selector(role_group_name).into()),
+                match_labels: Some(cluster.role_group_selector(&rg.name).into()),
                 ..LabelSelector::default()
             },
             service_name: Some(resource_names.headless_service_name().to_string()),
@@ -688,11 +683,7 @@ pub(crate) async fn build_node_rolegroup_statefulset(
                 },
                 ..StatefulSetUpdateStrategy::default()
             }),
-            volume_claim_templates: Some(get_volume_claim_templates(
-                cluster,
-                role_group_name,
-                merged_config,
-            )?),
+            volume_claim_templates: Some(get_volume_claim_templates(cluster, rg)?),
             ..StatefulSetSpec::default()
         }),
         status: None,
@@ -701,9 +692,9 @@ pub(crate) async fn build_node_rolegroup_statefulset(
 
 fn get_volume_claim_templates(
     cluster: &ValidatedCluster,
-    role_group_name: &RoleGroupName,
-    merged_config: &NifiConfig,
+    rg: &ValidatedRoleGroupConfig,
 ) -> Result<Vec<PersistentVolumeClaim>> {
+    let merged_config = &rg.config;
     let authorization_config = &cluster.cluster_config.authorization;
     let mut pvcs = vec![
         merged_config.resources.storage.content_repo.build_pvc(
@@ -730,7 +721,7 @@ fn get_volume_claim_templates(
 
     // Used for PVC templates that cannot be modified once they are deployed, so the version label
     // is set to the placeholder `none` to keep the labels stable across version upgrades.
-    let unversioned_recommended_labels = cluster.recommended_labels_unversioned(role_group_name);
+    let unversioned_recommended_labels = cluster.recommended_labels_unversioned(&rg.name);
 
     // listener endpoints will use persistent volumes
     // so that load balancers can hard-code the target addresses and

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

@@ -53,6 +53,10 @@ pub(crate) mod validate;
 /// [`with_validated_config`](stackable_operator::v2::role_utils::with_validated_config) in the
 /// [`validate`] step; downstream builders consume this rather than the raw `NifiCluster`.
 pub struct ValidatedRoleGroupConfig {
+    /// The role-group name (the key under which this config is stored in
+    /// [`ValidatedCluster::role_group_configs`]). Carried here so builders that consume the config
+    /// don't also need the name threaded through as a separate parameter.
+    pub name: RoleGroupName,
     /// The desired number of replicas (defaulted to 1 during validation).
     ///
     /// The StatefulSet replica count is sourced from the raw role-group spec in `nifi_controller`

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

@@ -259,8 +259,9 @@ pub(crate) fn build_role_group_configs(
         .context(BuildGitSyncResourcesSnafu)?;
 
         groups.insert(
-            role_group_name,
+            role_group_name.clone(),
             ValidatedRoleGroupConfig {
+                name: role_group_name,
                 replicas: validated.replicas.unwrap_or(1),
                 config,
                 config_overrides,

rust/operator-binary/src/nifi_controller.rs

@@ -295,7 +295,7 @@ pub async fn reconcile_nifi(
 
             let rg_configmap = build::config_map::build_rolegroup_config_map(
                 &validated_cluster,
-                role_group_name,
+                rg,
                 &client.kubernetes_cluster_info,
             )
             .context(BuildRoleGroupConfigMapSnafu {
@@ -313,7 +313,6 @@ pub async fn reconcile_nifi(
             let rg_statefulset = build_node_rolegroup_statefulset(
                 &validated_cluster,
                 &client.kubernetes_cluster_info,
-                role_group_name,
                 role,
                 rg,
                 rolling_upgrade_supported,