Adopting to listenerClass per role rather then roleGroup

Maleware · Maleware · commit 5996f78b93be · 2025-06-20T14:10:35.000+02:00
diff --git a/rust/operator-binary/src/config/jvm.rs b/rust/operator-binary/src/config/jvm.rs
@@ -1,13 +1,13 @@
 use snafu::{OptionExt, ResultExt, Snafu};
 use stackable_operator::{
     memory::{BinaryMultiple, MemoryQuantity},
-    role_utils::{self, GenericRoleConfig, JavaCommonConfig, JvmArgumentOverrides, Role},
+    role_utils::{self, JavaCommonConfig, JvmArgumentOverrides, Role},
 };
 
 use crate::crd::{
     JVM_SECURITY_PROPERTIES_FILE, METRICS_PORT, MetaStoreConfig, MetaStoreConfigFragment,
     STACKABLE_CONFIG_DIR, STACKABLE_TRUST_STORE, STACKABLE_TRUST_STORE_PASSWORD,
-    v1alpha1::HiveCluster,
+    v1alpha1::{HiveCluster, HiveMetastoreRoleConfig},
 };
 
 const JAVA_HEAP_FACTOR: f32 = 0.8;
@@ -29,7 +29,7 @@ pub enum Error {
 /// All JVM arguments.
 fn construct_jvm_args(
     hive: &HiveCluster,
-    role: &Role<MetaStoreConfigFragment, GenericRoleConfig, JavaCommonConfig>,
+    role: &Role<MetaStoreConfigFragment, HiveMetastoreRoleConfig, JavaCommonConfig>,
     role_group: &str,
 ) -> Result<Vec<String>, Error> {
     let mut jvm_args = vec![
@@ -60,7 +60,7 @@ fn construct_jvm_args(
 /// [`construct_hadoop_heapsize_env`]).
 pub fn construct_non_heap_jvm_args(
     hive: &HiveCluster,
-    role: &Role<MetaStoreConfigFragment, GenericRoleConfig, JavaCommonConfig>,
+    role: &Role<MetaStoreConfigFragment, HiveMetastoreRoleConfig, JavaCommonConfig>,
     role_group: &str,
 ) -> Result<String, Error> {
     let mut jvm_args = construct_jvm_args(hive, role, role_group)?;
@@ -193,7 +193,7 @@ mod tests {
     ) -> (
         HiveCluster,
         MetaStoreConfig,
-        Role<MetaStoreConfigFragment, GenericRoleConfig, JavaCommonConfig>,
+        Role<MetaStoreConfigFragment, HiveMetastoreRoleConfig, JavaCommonConfig>,
         String,
     ) {
         let hive: HiveCluster = serde_yaml::from_str(hive_cluster).expect("illegal test input");
diff --git a/rust/operator-binary/src/controller.rs b/rust/operator-binary/src/controller.rs
@@ -92,10 +92,11 @@ use crate::{
         APP_NAME, CORE_SITE_XML, Container, DB_PASSWORD_ENV, DB_USERNAME_ENV, HIVE_PORT,
         HIVE_PORT_NAME, HIVE_SITE_XML, HiveClusterStatus, HiveRole, JVM_SECURITY_PROPERTIES_FILE,
         LISTENER_VOLUME_DIR, LISTENER_VOLUME_NAME, METRICS_PORT, METRICS_PORT_NAME,
-        MetaStoreConfig, STACKABLE_CONFIG_DIR, STACKABLE_CONFIG_DIR_NAME,
+        MetaStoreConfig, MetaStoreConfigFragment, STACKABLE_CONFIG_DIR, STACKABLE_CONFIG_DIR_NAME,
         STACKABLE_CONFIG_MOUNT_DIR, STACKABLE_CONFIG_MOUNT_DIR_NAME,
         STACKABLE_LOG_CONFIG_MOUNT_DIR, STACKABLE_LOG_CONFIG_MOUNT_DIR_NAME, STACKABLE_LOG_DIR,
-        STACKABLE_LOG_DIR_NAME, v1alpha1,
+        STACKABLE_LOG_DIR_NAME,
+        v1alpha1::{self, HiveMetastoreRoleConfig},
     },
     discovery::{self, build_headless_listener_service_name},
     kerberos::{
@@ -335,10 +336,10 @@ pub enum Error {
     #[snafu(display("failed to construct JVM arguments"))]
     ConstructJvmArguments { source: crate::config::jvm::Error },
 
-    #[snafu(display("failed to apply group listener for {rolegroup}"))]
+    #[snafu(display("failed to apply group listener for {role}"))]
     ApplyGroupListener {
         source: stackable_operator::cluster_resources::Error,
-        rolegroup: RoleGroupRef<v1alpha1::HiveCluster>,
+        role: String,
     },
     #[snafu(display("failed to build listener volume"))]
     BuildListenerVolume {
@@ -370,7 +371,11 @@ pub async fn reconcile_hive(
         .spec
         .image
         .resolve(DOCKER_IMAGE_BASE_NAME, crate::built_info::PKG_VERSION);
-    let role = hive.spec.metastore.as_ref().context(NoMetaStoreRoleSnafu)?;
+    let role: &stackable_operator::role_utils::Role<
+        MetaStoreConfigFragment,
+        v1alpha1::HiveMetastoreRoleConfig,
+        stackable_operator::role_utils::JavaCommonConfig,
+    > = hive.spec.metastore.as_ref().context(NoMetaStoreRoleSnafu)?;
     let hive_role = HiveRole::MetaStore;
 
     let s3_connection_spec: Option<s3::v1alpha1::ConnectionSpec> =
@@ -440,14 +445,15 @@ pub async fn reconcile_hive(
         .add(client, rbac_sa)
         .await
         .context(ApplyServiceAccountSnafu)?;
+
     cluster_resources
         .add(client, rbac_rolebinding)
         .await
         .context(ApplyRoleBindingSnafu)?;
 
     let mut ss_cond_builder = StatefulSetConditionBuilder::default();
     // Collecting listener objects with corresponding rolegroup to fill the discovery configMap later on
-    let mut listener_refs = BTreeMap::<&String, Listener>::new();
+    // let mut listener_refs = BTreeMap::<&String, Listener>::new();
     for (rolegroup_name, rolegroup_config) in metastore_config.iter() {
         let rolegroup = hive.metastore_rolegroup_ref(rolegroup_name);
 
@@ -477,28 +483,14 @@ pub async fn reconcile_hive(
             &rbac_sa.name_any(),
         )?;
 
-        let rg_group_listener: Listener = build_group_listener(
-            hive,
-            &resolved_product_image,
-            &rolegroup,
-            config.listener_class,
-        )?;
-
-        let listener = cluster_resources
-            .add(client, rg_group_listener)
-            .await
-            .with_context(|_| ApplyGroupListenerSnafu {
-                rolegroup: rolegroup.clone(),
-            })?;
-
         cluster_resources
             .add(client, rg_service)
             .await
             .context(ApplyRoleGroupServiceSnafu {
                 rolegroup: rolegroup.clone(),
             })?;
 
-        listener_refs.insert(rolegroup_name, listener);
+        // listener_refs.insert(rolegroup_name, listener);
 
         cluster_resources
             .add(client, rg_configmap)
@@ -516,15 +508,29 @@ pub async fn reconcile_hive(
                 })?,
         );
     }
-
+    // Init listener struct. Collect listener after applied to cluster_resources
+    // to use listener object in later created discovery configMap
+    let mut listener = Listener::new("name", ListenerSpec::default());
     let role_config = hive.role_config(&hive_role);
-    if let Some(GenericRoleConfig {
-        pod_disruption_budget: pdb,
+    if let Some(HiveMetastoreRoleConfig {
+        common: GenericRoleConfig {
+            pod_disruption_budget: pdb,
+        },
+        listener_class,
     }) = role_config
     {
         add_pdbs(pdb, hive, &hive_role, client, &mut cluster_resources)
             .await
             .context(FailedToCreatePdbSnafu)?;
+
+        let group_listener: Listener =
+            build_group_listener(hive, &resolved_product_image, &hive_role, listener_class)?;
+        listener = cluster_resources
+            .add(client, group_listener)
+            .await
+            .with_context(|_| ApplyGroupListenerSnafu {
+                role: hive_role.to_string(),
+            })?;
     }
 
     // std's SipHasher is deprecated, and DefaultHasher is unstable across Rust releases.
@@ -534,9 +540,10 @@ pub async fn reconcile_hive(
     for discovery_cm in discovery::build_discovery_configmaps(
         hive,
         hive,
+        hive_role,
         &resolved_product_image,
         None,
-        listener_refs,
+        listener,
     )
     .await
     .context(BuildDiscoveryConfigSnafu)?
@@ -573,28 +580,30 @@ pub async fn reconcile_hive(
     Ok(Action::await_change())
 }
 
+// Designed to build a listener per role
+// In case of Hive we expect only one role: Metastore
 pub fn build_group_listener(
     hive: &v1alpha1::HiveCluster,
     resolved_product_image: &ResolvedProductImage,
-    rolegroup: &RoleGroupRef<v1alpha1::HiveCluster>,
-    listener_class: String,
+    hive_role: &HiveRole,
+    listener_class: &String,
 ) -> Result<Listener> {
     let metadata = ObjectMetaBuilder::new()
         .name_and_namespace(hive)
-        .name(hive.group_listener_name(rolegroup))
+        .name(hive.group_listener_name(hive_role))
         .ownerreference_from_resource(hive, None, Some(true))
         .context(ObjectMissingMetadataForOwnerRefSnafu)?
         .with_recommended_labels(build_recommended_labels(
             hive,
             &resolved_product_image.app_version_label,
-            &rolegroup.role,
-            &rolegroup.role_group,
+            &hive_role.to_string(),
+            "none",
         ))
         .context(MetadataBuildSnafu)?
         .build();
 
     let spec = ListenerSpec {
-        class_name: Some(listener_class),
+        class_name: Some(listener_class.to_owned()),
         ports: Some(listener_ports()),
         ..Default::default()
     };
@@ -1004,7 +1013,7 @@ fn build_metastore_rolegroup_statefulset(
         .build();
 
     let pvc = ListenerOperatorVolumeSourceBuilder::new(
-        &ListenerReference::ListenerName(hive.group_listener_name(rolegroup_ref)),
+        &ListenerReference::ListenerName(hive.group_listener_name(&hive_role)),
         &unversioned_recommended_labels,
     )
     .context(BuildListenerVolumeSnafu)?
diff --git a/rust/operator-binary/src/crd/mod.rs b/rust/operator-binary/src/crd/mod.rs
@@ -30,6 +30,7 @@ use stackable_operator::{
     versioned::versioned,
 };
 use strum::{Display, EnumIter, EnumString, IntoEnumIterator};
+use v1alpha1::HiveMetastoreRoleConfig;
 
 use crate::crd::affinity::get_affinity;
 
@@ -134,7 +135,20 @@ pub mod versioned {
 
         // no doc - docs in Role struct.
         #[serde(default, skip_serializing_if = "Option::is_none")]
-        pub metastore: Option<Role<MetaStoreConfigFragment, GenericRoleConfig, JavaCommonConfig>>,
+        pub metastore:
+            Option<Role<MetaStoreConfigFragment, HiveMetastoreRoleConfig, JavaCommonConfig>>,
+    }
+
+    // TODO: move generic version to op-rs?
+    #[derive(Clone, Debug, Deserialize, JsonSchema, PartialEq, Serialize)]
+    #[serde(rename_all = "camelCase")]
+    pub struct HiveMetastoreRoleConfig {
+        #[serde(flatten)]
+        pub common: GenericRoleConfig,
+
+        /// This field controls which [ListenerClass](DOCS_BASE_URL_PLACEHOLDER/listener-operator/listenerclass.html) is used to expose the coordinator.
+        #[serde(default = "metastore_default_listener_class")]
+        pub listener_class: String,
     }
 
     #[derive(Clone, Debug, Deserialize, Eq, JsonSchema, PartialEq, Serialize)]
@@ -164,6 +178,19 @@ pub mod versioned {
     }
 }
 
+impl Default for v1alpha1::HiveMetastoreRoleConfig {
+    fn default() -> Self {
+        v1alpha1::HiveMetastoreRoleConfig {
+            listener_class: metastore_default_listener_class(),
+            common: Default::default(),
+        }
+    }
+}
+
+fn metastore_default_listener_class() -> String {
+    "cluster-internal".to_string()
+}
+
 impl HasStatusCondition for v1alpha1::HiveCluster {
     fn conditions(&self) -> Vec<ClusterCondition> {
         match &self.status {
@@ -211,7 +238,8 @@ impl v1alpha1::HiveCluster {
     pub fn role(
         &self,
         role_variant: &HiveRole,
-    ) -> Result<&Role<MetaStoreConfigFragment, GenericRoleConfig, JavaCommonConfig>, Error> {
+    ) -> Result<&Role<MetaStoreConfigFragment, HiveMetastoreRoleConfig, JavaCommonConfig>, Error>
+    {
         match role_variant {
             HiveRole::MetaStore => self.spec.metastore.as_ref(),
         }
@@ -220,11 +248,14 @@ impl v1alpha1::HiveCluster {
         })
     }
 
-    /// The name of the group-listener provided for a specific role-group.
-    /// The UI will use this group listener so that only one load balancer
-    /// is needed (per role group).
-    pub fn group_listener_name(&self, rolegroup: &RoleGroupRef<Self>) -> String {
-        rolegroup.object_name()
+    /// The name of the group-listener provided for a specific role.
+    /// returns a name <cluster>-<role>
+    pub fn group_listener_name(&self, hive_role: &HiveRole) -> String {
+        format!(
+            "{name}-{role}",
+            name = self.name_any(),
+            role = hive_role.to_string()
+        )
     }
 
     pub fn rolegroup(
@@ -246,7 +277,7 @@ impl v1alpha1::HiveCluster {
             .cloned()
     }
 
-    pub fn role_config(&self, role: &HiveRole) -> Option<&GenericRoleConfig> {
+    pub fn role_config(&self, role: &HiveRole) -> Option<&HiveMetastoreRoleConfig> {
         match role {
             HiveRole::MetaStore => self.spec.metastore.as_ref().map(|m| &m.role_config),
         }
@@ -417,10 +448,9 @@ pub struct MetaStoreConfig {
     /// Time period Pods have to gracefully shut down, e.g. `30m`, `1h` or `2d`. Consult the operator documentation for details.
     #[fragment_attrs(serde(default))]
     pub graceful_shutdown_timeout: Option<Duration>,
-
-    /// This field controls which [ListenerClass](DOCS_BASE_URL_PLACEHOLDER/listener-operator/listenerclass.html) is used to expose the webserver.
-    #[serde(default)]
-    pub listener_class: String,
+    // This field controls which [ListenerClass](DOCS_BASE_URL_PLACEHOLDER/listener-operator/listenerclass.html) is used to expose the webserver.
+    // #[serde(default)]
+    // pub listener_class: String,
 }
 
 impl MetaStoreConfig {
@@ -462,7 +492,6 @@ impl MetaStoreConfig {
             logging: product_logging::spec::default_logging(),
             affinity: get_affinity(cluster_name, role),
             graceful_shutdown_timeout: Some(DEFAULT_METASTORE_GRACEFUL_SHUTDOWN_TIMEOUT),
-            listener_class: Some("cluster-internal".to_owned()),
         }
     }
 }
diff --git a/rust/operator-binary/src/discovery.rs b/rust/operator-binary/src/discovery.rs
