refactor: introduce ValidatedRoleConfig

Author: maltesander

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

@@ -17,7 +17,7 @@ use stackable_operator::{
         kvp::label::{recommended_labels, role_group_selector},
         role_group_utils::ResourceNames,
         types::{
-            kubernetes::{NamespaceName, Uid},
+            kubernetes::{ListenerClassName, NamespaceName, Uid},
             operator::{
                 ClusterName, ControllerName, OperatorName, ProductName, ProductVersion,
                 RoleGroupName as RoleGroupNameV2, RoleName,
@@ -98,6 +98,17 @@ impl ValidatedTrinoConfig {
     }
 }
 
+/// Per-role configuration extracted during validation.
+///
+/// Lets the reconciler and build steps consume this controller-owned type instead of re-reading
+/// the raw [`v1alpha1::TrinoCluster`] (mirroring the hive-operator's `ValidatedRoleConfig`).
+#[derive(Clone, Debug)]
+pub struct ValidatedRoleConfig {
+    pub pdb: stackable_operator::commons::pdb::PdbConfig,
+    /// The listener class for the role's group listener, if it has one (coordinator only).
+    pub listener_class: Option<ListenerClassName>,
+}
+
 /// The validated TrinoCluster. The output of the validate step.
 #[derive(Clone, Debug)]
 pub struct ValidatedCluster {
@@ -113,6 +124,7 @@ pub struct ValidatedCluster {
     pub image: ResolvedProductImage,
     pub product_version: u16,
     pub cluster_config: ValidatedClusterConfig,
+    pub role_configs: BTreeMap<TrinoRole, ValidatedRoleConfig>,
     pub role_group_configs: BTreeMap<TrinoRole, BTreeMap<RoleGroupName, TrinoRoleGroupConfig>>,
 }
 
@@ -125,6 +137,7 @@ impl ValidatedCluster {
         image: ResolvedProductImage,
         product_version: u16,
         cluster_config: ValidatedClusterConfig,
+        role_configs: BTreeMap<TrinoRole, ValidatedRoleConfig>,
         role_group_configs: BTreeMap<TrinoRole, BTreeMap<RoleGroupName, TrinoRoleGroupConfig>>,
     ) -> Self {
         Self {
@@ -140,10 +153,16 @@ impl ValidatedCluster {
             image,
             product_version,
             cluster_config,
+            role_configs,
             role_group_configs,
         }
     }
 
+    /// The validated per-role config for `role`, if the role is defined.
+    pub(crate) fn role_config(&self, role: &TrinoRole) -> Option<&ValidatedRoleConfig> {
+        self.role_configs.get(role)
+    }
+
     /// Whether the (client-facing) server TLS is enabled.
     pub fn server_tls_enabled(&self) -> bool {
         self.cluster_config.tls.server.is_some()

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

@@ -26,7 +26,10 @@ use stackable_operator::{
 };
 use strum::{EnumDiscriminants, IntoEnumIterator, IntoStaticStr};
 
-use super::{ValidatedCluster, ValidatedClusterConfig, ValidatedTls, ValidatedTrinoConfig};
+use super::{
+    ValidatedCluster, ValidatedClusterConfig, ValidatedRoleConfig, ValidatedTls,
+    ValidatedTrinoConfig,
+};
 use crate::{
     authentication::{self, TrinoAuthenticationConfig, TrinoAuthenticationTypes},
     controller::dereference::DereferencedObjects,
@@ -205,6 +208,7 @@ pub fn validate(
         .vector_aggregator_config_map_name
         .clone();
 
+    let mut role_configs: BTreeMap<TrinoRole, ValidatedRoleConfig> = BTreeMap::new();
     let mut role_group_configs: BTreeMap<TrinoRole, BTreeMap<RoleGroupName, TrinoRoleGroupConfig>> =
         BTreeMap::new();
     for trino_role in TrinoRole::iter() {
@@ -213,6 +217,20 @@ pub fn validate(
             .with_context(|_| MissingTrinoRoleSnafu {
                 role: trino_role.to_string(),
             })?;
+
+        // Extract the per-role PDB and (optional) listener class up-front, so the reconciler and
+        // build steps consume the validated config instead of re-reading the raw cluster.
+        role_configs.insert(
+            trino_role.clone(),
+            ValidatedRoleConfig {
+                pdb: trino
+                    .generic_role_config(&trino_role)
+                    .map(|rc| rc.pod_disruption_budget.clone())
+                    .unwrap_or_default(),
+                listener_class: trino_role.listener_class_name(trino),
+            },
+        );
+
         let default_config = v1alpha1::TrinoConfig::default_config(
             &trino.name_any(),
             &trino_role,
@@ -266,6 +284,7 @@ pub fn validate(
         image,
         product_version,
         cluster_config,
+        role_configs,
         role_group_configs,
     ))
 }

rust/operator-binary/src/trino_controller.rs

@@ -14,7 +14,6 @@ use stackable_operator::{
     },
     logging::controller::ReconcilerError,
     memory::{BinaryMultiple, MemoryQuantity},
-    role_utils::GenericRoleConfig,
     shared::time::Duration,
     status::condition::{
         compute_conditions, operations::ClusterOperationsConditionBuilder,
@@ -346,7 +345,11 @@ pub async fn reconcile_trino(
             );
         }
 
-        if let Some(listener_class) = trino_role.listener_class_name(trino)
+        let Some(role_config) = validated_cluster.role_config(trino_role) else {
+            continue;
+        };
+
+        if let Some(listener_class) = &role_config.listener_class
             && let Some(listener_group_name) = group_listener_name(&validated_cluster, trino_role)
         {
             let role_group_listener = build_group_listener(
@@ -362,12 +365,7 @@ pub async fn reconcile_trino(
                 .context(ApplyGroupListenerSnafu)?;
         }
 
-        let role_config = trino.generic_role_config(trino_role);
-        if let Some(GenericRoleConfig {
-            pod_disruption_budget: pdb,
-        }) = role_config
-            && let Some(pdb) = build_pdb(pdb, &validated_cluster, trino_role)
-        {
+        if let Some(pdb) = build_pdb(&role_config.pdb, &validated_cluster, trino_role) {
             cluster_resources
                 .add(client, pdb)
                 .await