fix: remove raw cluster & last RoleGroupRef

Author: maltesander

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

@@ -31,7 +31,7 @@ use stackable_operator::{
         self,
         spec::{ContainerLogConfig, Logging},
     },
-    role_utils::{self, GenericRoleConfig, Role, RoleGroupRef},
+    role_utils::{self, GenericRoleConfig, Role},
     schemars::{self, JsonSchema},
     shared::time::Duration,
     status::condition::{ClusterCondition, HasStatusCondition},
@@ -264,71 +264,6 @@ impl v1alpha1::HdfsCluster {
         }
     }
 
-    pub fn rolegroup_ref(
-        &self,
-        role_name: impl Into<String>,
-        group_name: impl Into<String>,
-    ) -> RoleGroupRef<v1alpha1::HdfsCluster> {
-        RoleGroupRef {
-            cluster: ObjectRef::from_obj(self),
-            role: role_name.into(),
-            role_group: group_name.into(),
-        }
-    }
-
-    pub fn rolegroup_ref_and_replicas(
-        &self,
-        role: &HdfsNodeRole,
-    ) -> Vec<(RoleGroupRef<v1alpha1::HdfsCluster>, u16)> {
-        match role {
-            HdfsNodeRole::Name => self
-                .spec
-                .name_nodes
-                .iter()
-                .flat_map(|role| &role.role_groups)
-                // Order rolegroups consistently, to avoid spurious downstream rewrites
-                .collect::<BTreeMap<_, _>>()
-                .into_iter()
-                .map(|(rolegroup_name, role_group)| {
-                    (
-                        self.rolegroup_ref(HdfsNodeRole::Name.to_string(), rolegroup_name),
-                        role_group.replicas.unwrap_or_default(),
-                    )
-                })
-                .collect(),
-            HdfsNodeRole::Data => self
-                .spec
-                .data_nodes
-                .iter()
-                .flat_map(|role| &role.role_groups)
-                // Order rolegroups consistently, to avoid spurious downstream rewrites
-                .collect::<BTreeMap<_, _>>()
-                .into_iter()
-                .map(|(rolegroup_name, role_group)| {
-                    (
-                        self.rolegroup_ref(HdfsNodeRole::Data.to_string(), rolegroup_name),
-                        role_group.replicas.unwrap_or_default(),
-                    )
-                })
-                .collect(),
-            HdfsNodeRole::Journal => self
-                .spec
-                .journal_nodes
-                .iter()
-                .flat_map(|role| &role.role_groups)
-                // Order rolegroups consistently, to avoid spurious downstream rewrites
-                .collect::<BTreeMap<_, _>>()
-                .into_iter()
-                .map(|(rolegroup_name, role_group)| {
-                    (
-                        self.rolegroup_ref(HdfsNodeRole::Journal.to_string(), rolegroup_name),
-                        role_group.replicas.unwrap_or_default(),
-                    )
-                })
-                .collect(),
-        }
-    }
-
     pub fn upgrade_state(&self) -> Result<Option<UpgradeState>, UpgradeStateError> {
         use upgrade_state_error::*;
         let Some(status) = self.status.as_ref() else {

rust/operator-binary/src/event.rs

@@ -5,10 +5,7 @@ use stackable_operator::{
 };
 use strum::{EnumDiscriminants, IntoStaticStr};
 
-use crate::{
-    crd::{HdfsNodeRole, v1alpha1},
-    hdfs_controller::Ctx,
-};
+use crate::{controller::ValidatedCluster, crd::HdfsNodeRole, hdfs_controller::Ctx};
 
 #[derive(Snafu, Debug, EnumDiscriminants)]
 #[strum_discriminants(derive(IntoStaticStr))]
@@ -43,16 +40,18 @@ pub async fn publish_warning_event(
 }
 
 pub fn build_invalid_replica_message(
-    hdfs: &v1alpha1::HdfsCluster,
+    validated_cluster: &ValidatedCluster,
     role: &HdfsNodeRole,
-    dfs_replication: u8,
 ) -> Option<String> {
-    let replicas: u16 = hdfs
-        .rolegroup_ref_and_replicas(role)
-        .iter()
-        .map(|tuple| tuple.1)
+    let replicas: u16 = validated_cluster
+        .role_groups
+        .get(role)
+        .into_iter()
+        .flatten()
+        .map(|(_, role_group)| role_group.replicas.unwrap_or_default())
         .sum();
 
+    let dfs_replication = validated_cluster.cluster_config.dfs_replication;
     let role_name = role.to_string();
     let min_replicas = role.min_replicas();
 

rust/operator-binary/src/hdfs_controller.rs

@@ -213,7 +213,6 @@ pub async fn reconcile_hdfs(
         .await
         .context(ApplyRoleBindingSnafu)?;
 
-    let dfs_replication = hdfs.spec.cluster_config.dfs_replication;
     let mut ss_cond_builder = StatefulSetConditionBuilder::default();
 
     let upgrade_state = validated_cluster.status.upgrade_state;
@@ -238,7 +237,7 @@ pub async fn reconcile_hdfs(
             continue;
         };
 
-        if let Some(message) = build_invalid_replica_message(hdfs, &role, dfs_replication) {
+        if let Some(message) = build_invalid_replica_message(&validated_cluster, &role) {
             publish_warning_event(
                 &ctx,
                 &hdfs_obj_ref,