refactor: extract validate_cluster into controller::validate module

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: adwk67

rust/operator-binary/src/controller.rs

@@ -1,9 +1,9 @@
 //! Ensures that `Pod`s are configured and running for each [`v1alpha1::HiveCluster`]
 
 pub mod dereference;
+pub mod validate;
 
 use std::{
-    borrow::Cow,
     collections::{BTreeMap, HashMap},
     hash::Hasher,
     sync::Arc,
@@ -64,7 +64,6 @@ use stackable_operator::{
     kvp::{Labels, ObjectLabels},
     logging::controller::ReconcilerError,
     memory::{BinaryMultiple, MemoryQuantity},
-    product_config_utils::{transform_all_roles_to_config, validate_all_roles_and_groups_config},
     product_logging::{
         self,
         framework::{
@@ -75,7 +74,7 @@ use stackable_operator::{
             CustomContainerLogConfig,
         },
     },
-    role_utils::{GenericRoleConfig, RoleGroupRef},
+    role_utils::RoleGroupRef,
     shared::time::Duration,
     status::condition::{
         compute_conditions, operations::ClusterOperationsConditionBuilder,
@@ -101,7 +100,7 @@ use crate::{
         STACKABLE_LOG_CONFIG_MOUNT_DIR, STACKABLE_LOG_CONFIG_MOUNT_DIR_NAME, STACKABLE_LOG_DIR,
         STACKABLE_LOG_DIR_NAME,
         databases::{MetadataDatabaseConnection, derby_driver_class},
-        v1alpha1::{self, HiveMetastoreRoleConfig},
+        v1alpha1,
     },
     discovery::{self},
     kerberos::{
@@ -130,41 +129,13 @@ pub struct Ctx {
     pub operator_environment: OperatorEnvironmentOptions,
 }
 
-/// Per-role configuration extracted during validation.
-#[derive(Clone, Debug)]
-pub struct ValidatedRoleConfig {
-    pub pdb: stackable_operator::commons::pdb::PdbConfig,
-    pub listener_class: String,
-}
-
-/// Per-rolegroup configuration: the merged CRD config plus the product-config properties.
-#[derive(Clone, Debug)]
-pub struct ValidatedRoleGroupConfig {
-    pub merged_config: MetaStoreConfig,
-    pub product_config_properties: HashMap<PropertyNameKind, BTreeMap<String, String>>,
-}
-
-pub use crate::controller::dereference::DereferencedObjects;
-
-/// The validated cluster: proves that product-config validation and config merging
-/// succeeded for every role and role group before any resources are created.
-#[derive(Clone, Debug)]
-pub struct ValidatedHiveCluster {
-    pub image: ResolvedProductImage,
-    pub role_groups: BTreeMap<HiveRole, BTreeMap<String, ValidatedRoleGroupConfig>>,
-    pub role_configs: BTreeMap<HiveRole, ValidatedRoleConfig>,
-}
-
 #[derive(Snafu, Debug, EnumDiscriminants)]
 #[strum_discriminants(derive(strum::IntoStaticStr))]
 #[allow(clippy::enum_variant_names)]
 pub enum Error {
     #[snafu(display("object defines no namespace"))]
     ObjectHasNoNamespace,
 
-    #[snafu(display("object defines no metastore role"))]
-    NoMetaStoreRole,
-
     #[snafu(display("failed to apply Service for {rolegroup}"))]
     ApplyRoleGroupService {
         source: stackable_operator::cluster_resources::Error,
@@ -189,16 +160,6 @@ pub enum Error {
         rolegroup: RoleGroupRef<v1alpha1::HiveCluster>,
     },
 
-    #[snafu(display("failed to generate product config"))]
-    GenerateProductConfig {
-        source: stackable_operator::product_config_utils::Error,
-    },
-
-    #[snafu(display("invalid product config"))]
-    InvalidProductConfig {
-        source: stackable_operator::product_config_utils::Error,
-    },
-
     #[snafu(display("object is missing metadata to build owner reference"))]
     ObjectMissingMetadataForOwnerRef {
         source: stackable_operator::builder::meta::Error,
@@ -227,9 +188,6 @@ pub enum Error {
     ))]
     S3TlsNoVerificationNotSupported,
 
-    #[snafu(display("failed to resolve and merge resource config for role and role group"))]
-    FailedToResolveResourceConfig { source: crate::crd::Error },
-
     #[snafu(display("failed to create hive container [{name}]"))]
     FailedToCreateHiveContainer {
         source: stackable_operator::builder::pod::container::Error,
@@ -351,6 +309,9 @@ pub enum Error {
         source: crate::controller::dereference::Error,
     },
 
+    #[snafu(display("failed to validate cluster configuration"))]
+    Validate { source: validate::Error },
+
     #[snafu(display("failed to build TLS certificate SecretClass Volume"))]
     TlsCertSecretClassVolumeBuild {
         source: stackable_operator::builder::pod::volume::SecretOperatorVolumeSourceBuilderError,
@@ -364,90 +325,6 @@ impl ReconcilerError for Error {
     }
 }
 
-fn validate_cluster(
-    hive: &v1alpha1::HiveCluster,
-    dereferenced: &DereferencedObjects,
-    product_config_manager: &ProductConfigManager,
-) -> Result<ValidatedHiveCluster> {
-    let role = hive.spec.metastore.as_ref().context(NoMetaStoreRoleSnafu)?;
-
-    let validated_config = validate_all_roles_and_groups_config(
-        &dereferenced.resolved_product_image.product_version,
-        &transform_all_roles_to_config(
-            hive,
-            &[(
-                HiveRole::MetaStore.to_string(),
-                (
-                    vec![
-                        PropertyNameKind::Env,
-                        PropertyNameKind::Cli,
-                        PropertyNameKind::File(HIVE_SITE_XML.to_string()),
-                        PropertyNameKind::File(JVM_SECURITY_PROPERTIES_FILE.to_string()),
-                    ],
-                    role.clone(),
-                ),
-            )]
-            .into(),
-        )
-        .context(GenerateProductConfigSnafu)?,
-        product_config_manager,
-        false,
-        false,
-    )
-    .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 {
-        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(),
-            },
-        );
-    }
-
-    let mut group_configs = BTreeMap::new();
-    for (rolegroup_name, rolegroup_config) in metastore_config.iter() {
-        let rolegroup = hive.metastore_rolegroup_ref(rolegroup_name);
-
-        let merged_config = hive
-            .merged_config(&hive_role, &rolegroup)
-            .context(FailedToResolveResourceConfigSnafu)?;
-
-        group_configs.insert(
-            rolegroup_name.clone(),
-            ValidatedRoleGroupConfig {
-                merged_config,
-                product_config_properties: rolegroup_config.clone(),
-            },
-        );
-    }
-
-    role_groups.insert(hive_role, group_configs);
-
-    Ok(ValidatedHiveCluster {
-        image: dereferenced.resolved_product_image.clone(),
-        role_groups,
-        role_configs,
-    })
-}
-
 pub async fn reconcile_hive(
     hive: Arc<DeserializeGuard<v1alpha1::HiveCluster>>,
     ctx: Arc<Ctx>,
@@ -471,7 +348,8 @@ pub async fn reconcile_hive(
     .await
     .context(DereferenceSnafu)?;
 
-    let validated = validate_cluster(hive, &dereferenced, &ctx.product_config)?;
+    let validated = validate::validate_cluster(hive, &dereferenced, &ctx.product_config)
+        .context(ValidateSnafu)?;
 
     let mut cluster_resources = ClusterResources::new(
         APP_NAME,

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

@@ -0,0 +1,144 @@
+use std::{
+    borrow::Cow,
+    collections::{BTreeMap, HashMap},
+};
+
+use product_config::{ProductConfigManager, types::PropertyNameKind};
+use snafu::{OptionExt, ResultExt, Snafu};
+use stackable_operator::{
+    commons::product_image_selection::ResolvedProductImage,
+    product_config_utils::{transform_all_roles_to_config, validate_all_roles_and_groups_config},
+    role_utils::GenericRoleConfig,
+};
+
+use super::dereference::DereferencedObjects;
+use crate::crd::{
+    HIVE_SITE_XML, HiveRole, JVM_SECURITY_PROPERTIES_FILE, MetaStoreConfig,
+    v1alpha1::{self, HiveMetastoreRoleConfig},
+};
+
+#[derive(Snafu, Debug)]
+pub enum Error {
+    #[snafu(display("object defines no metastore role"))]
+    NoMetaStoreRole,
+
+    #[snafu(display("failed to generate product config"))]
+    GenerateProductConfig {
+        source: stackable_operator::product_config_utils::Error,
+    },
+
+    #[snafu(display("invalid product config"))]
+    InvalidProductConfig {
+        source: stackable_operator::product_config_utils::Error,
+    },
+
+    #[snafu(display("failed to resolve and merge resource config for role and role group"))]
+    FailedToResolveResourceConfig { source: crate::crd::Error },
+}
+
+/// Per-role configuration extracted during validation.
+#[derive(Clone, Debug)]
+pub struct ValidatedRoleConfig {
+    pub pdb: stackable_operator::commons::pdb::PdbConfig,
+    pub listener_class: String,
+}
+
+/// Per-rolegroup configuration: the merged CRD config plus the product-config properties.
+#[derive(Clone, Debug)]
+pub struct ValidatedRoleGroupConfig {
+    pub merged_config: MetaStoreConfig,
+    pub product_config_properties: HashMap<PropertyNameKind, BTreeMap<String, String>>,
+}
+
+/// The validated cluster: proves that product-config validation and config merging
+/// succeeded for every role and role group before any resources are created.
+#[derive(Clone, Debug)]
+pub struct ValidatedHiveCluster {
+    pub image: ResolvedProductImage,
+    pub role_groups: BTreeMap<HiveRole, BTreeMap<String, ValidatedRoleGroupConfig>>,
+    pub role_configs: BTreeMap<HiveRole, ValidatedRoleConfig>,
+}
+
+pub fn validate_cluster(
+    hive: &v1alpha1::HiveCluster,
+    dereferenced: &DereferencedObjects,
+    product_config_manager: &ProductConfigManager,
+) -> Result<ValidatedHiveCluster, Error> {
+    let role = hive.spec.metastore.as_ref().context(NoMetaStoreRoleSnafu)?;
+
+    let validated_config = validate_all_roles_and_groups_config(
+        &dereferenced.resolved_product_image.product_version,
+        &transform_all_roles_to_config(
+            hive,
+            &[(
+                HiveRole::MetaStore.to_string(),
+                (
+                    vec![
+                        PropertyNameKind::Env,
+                        PropertyNameKind::Cli,
+                        PropertyNameKind::File(HIVE_SITE_XML.to_string()),
+                        PropertyNameKind::File(JVM_SECURITY_PROPERTIES_FILE.to_string()),
+                    ],
+                    role.clone(),
+                ),
+            )]
+            .into(),
+        )
+        .context(GenerateProductConfigSnafu)?,
+        product_config_manager,
+        false,
+        false,
+    )
+    .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 {
+        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(),
+            },
+        );
+    }
+
+    let mut group_configs = BTreeMap::new();
+    for (rolegroup_name, rolegroup_config) in metastore_config.iter() {
+        let rolegroup = hive.metastore_rolegroup_ref(rolegroup_name);
+
+        let merged_config = hive
+            .merged_config(&hive_role, &rolegroup)
+            .context(FailedToResolveResourceConfigSnafu)?;
+
+        group_configs.insert(
+            rolegroup_name.clone(),
+            ValidatedRoleGroupConfig {
+                merged_config,
+                product_config_properties: rolegroup_config.clone(),
+            },
+        );
+    }
+
+    role_groups.insert(hive_role, group_configs);
+
+    Ok(ValidatedHiveCluster {
+        image: dereferenced.resolved_product_image.clone(),
+        role_groups,
+        role_configs,
+    })
+}