write endpoints to hbase-site instead of dedicated config map

Author: adwk67

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

@@ -1,10 +1,8 @@
 use std::{
-    borrow::Cow,
     collections::{BTreeMap, HashMap},
     num::TryFromIntError,
 };
 
-use futures::future::try_join_all;
 use product_config::types::PropertyNameKind;
 use security::AuthenticationConfig;
 use serde::{Deserialize, Serialize};
@@ -37,7 +35,6 @@ use stackable_operator::{
     schemars::{self, JsonSchema},
     status::condition::{ClusterCondition, HasStatusCondition},
     time::Duration,
-    utils::cluster_info::KubernetesClusterInfo,
     versioned::versioned,
 };
 use strum::{Display, EnumIter, EnumString};
@@ -591,169 +588,6 @@ impl v1alpha1::HbaseCluster {
             role_group: group_name.into(),
         }
     }
-
-    /// Returns rolegroup and replica information for a specific role.
-    /// We can't pass through the merged config for a particular role-group
-    /// here as we need more than the config. As this will be called by role,
-    /// the merged listener-class is called so that only role-group information
-    /// for externally-reachable services (based on their listener class) are
-    /// included in the collection.
-    pub fn rolegroup_ref_and_replicas(
-        &self,
-        role: &HbaseRole,
-    ) -> Vec<(RoleGroupRef<v1alpha1::HbaseCluster>, u16)> {
-        match role {
-            HbaseRole::Master => self
-                .spec
-                .masters
-                .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(HbaseRole::Master.to_string(), rolegroup_name),
-                        role_group.replicas.unwrap_or_default(),
-                    )
-                })
-                .collect(),
-            HbaseRole::RegionServer => self
-                .spec
-                .region_servers
-                .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(HbaseRole::RegionServer.to_string(), rolegroup_name),
-                        role_group.replicas.unwrap_or_default(),
-                    )
-                })
-                .collect(),
-            HbaseRole::RestServer => self
-                .spec
-                .rest_servers
-                .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(HbaseRole::RestServer.to_string(), rolegroup_name),
-                        role_group.replicas.unwrap_or_default(),
-                    )
-                })
-                .collect(),
-        }
-    }
-
-    pub fn pod_refs(
-        &self,
-        role: &HbaseRole,
-        hbase_version: &str,
-    ) -> Result<Vec<HbasePodRef>, Error> {
-        let ns = self.metadata.namespace.clone().context(NoNamespaceSnafu)?;
-        let rolegroup_ref_and_replicas = self.rolegroup_ref_and_replicas(role);
-
-        Ok(rolegroup_ref_and_replicas
-            .iter()
-            .flat_map(|(rolegroup_ref, replicas)| {
-                let ns = ns.clone();
-                (0..*replicas).map(move |i| HbasePodRef {
-                    namespace: ns.clone(),
-                    role_group_service_name: rolegroup_ref.object_name(),
-                    pod_name: format!("{}-{}", rolegroup_ref.object_name(), i),
-                    ports: self
-                        .ports(role, hbase_version)
-                        .iter()
-                        .map(|(n, p)| (n.clone(), *p))
-                        .collect(),
-                    fqdn_override: None,
-                })
-            })
-            .collect())
-    }
-
-    pub async fn listener_refs(
-        &self,
-        client: &stackable_operator::client::Client,
-        role: &HbaseRole,
-        hbase_version: &str,
-    ) -> Result<Vec<HbasePodRef>, Error> {
-        let pod_refs = self.pod_refs(role, hbase_version)?;
-        try_join_all(pod_refs.into_iter().map(|pod_ref| async {
-            // N.B. use the naming convention for persistent listener volumes as we
-            // have specified above that we only want externally-reachable endpoints.
-            let listener_name = format!("{LISTENER_VOLUME_NAME}-{}", pod_ref.pod_name);
-            let listener_ref =
-                || ObjectRef::<Listener>::new(&listener_name).within(&pod_ref.namespace);
-            let pod_obj_ref =
-                || ObjectRef::<Pod>::new(&pod_ref.pod_name).within(&pod_ref.namespace);
-            let listener = client
-                .get::<Listener>(&listener_name, &pod_ref.namespace)
-                .await
-                .context(GetPodListenerSnafu {
-                    listener: listener_ref(),
-                    pod: pod_obj_ref(),
-                })?;
-            let listener_address = listener
-                .status
-                .and_then(|s| s.ingress_addresses?.into_iter().next())
-                .context(PodListenerHasNoAddressSnafu {
-                    listener: listener_ref(),
-                    pod: pod_obj_ref(),
-                })?;
-            Ok(HbasePodRef {
-                fqdn_override: Some(listener_address.address),
-                ports: listener_address
-                    .ports
-                    .into_iter()
-                    .map(|(port_name, port)| {
-                        let port = u16::try_from(port).context(PortOutOfBoundsSnafu {
-                            port_name: &port_name,
-                            port,
-                        })?;
-                        Ok((port_name, port))
-                    })
-                    .collect::<Result<_, _>>()?,
-                ..pod_ref
-            })
-        }))
-        .await
-    }
-}
-
-/// Reference to a single `Pod` that is a component of a [`HbaseCluster`]
-///
-/// Used for service discovery.
-#[derive(Debug)]
-pub struct HbasePodRef {
-    pub namespace: String,
-    pub role_group_service_name: String,
-    pub pod_name: String,
-    pub fqdn_override: Option<String>,
-    pub ports: HashMap<String, u16>,
-}
-
-impl HbasePodRef {
-    pub fn fqdn(&self, cluster_info: &KubernetesClusterInfo) -> Cow<str> {
-        self.fqdn_override.as_deref().map_or_else(
-            || {
-                Cow::Owned(format!(
-                    "{pod_name}.{role_group_service_name}.{namespace}.svc.{cluster_domain}",
-                    pod_name = self.pod_name,
-                    role_group_service_name = self.role_group_service_name,
-                    namespace = self.namespace,
-                    cluster_domain = cluster_info.cluster_domain,
-                ))
-            },
-            Cow::Borrowed,
-        )
-    }
 }
 
 pub fn merged_env(rolegroup_config: Option<&BTreeMap<String, String>>) -> Vec<EnvVar> {

rust/operator-binary/src/discovery.rs

@@ -6,12 +6,12 @@ use stackable_operator::{
     builder::{configmap::ConfigMapBuilder, meta::ObjectMetaBuilder},
     commons::product_image_selection::ResolvedProductImage,
     k8s_openapi::api::core::v1::ConfigMap,
-    kube::{ResourceExt, runtime::reflector::ObjectRef},
+    kube::runtime::reflector::ObjectRef,
     utils::cluster_info::KubernetesClusterInfo,
 };
 
 use crate::{
-    crd::{HBASE_SITE_XML, HbasePodRef, HbaseRole, v1alpha1},
+    crd::{HBASE_SITE_XML, HbaseRole, v1alpha1},
     hbase_controller::build_recommended_labels,
     kerberos::{self, kerberos_discovery_config_properties},
     zookeeper::ZookeeperConnectionInformation,
@@ -84,48 +84,3 @@ pub fn build_discovery_configmap(
         .build()
         .context(BuildConfigMapSnafu)
 }
-
-pub fn build_endpoint_configmap(
-    hbase: &v1alpha1::HbaseCluster,
-    resolved_product_image: &ResolvedProductImage,
-    role_podrefs: BTreeMap<String, Vec<HbasePodRef>>,
-) -> Result<ConfigMap> {
-    let name = hbase.name_unchecked();
-    let mut cm = ConfigMapBuilder::new();
-
-    let cmm = cm.metadata(
-        ObjectMetaBuilder::new()
-            .name_and_namespace(hbase)
-            .name(format!("{name}-ui-endpoints"))
-            .ownerreference_from_resource(hbase, None, Some(true))
-            .with_context(|_| ObjectMissingMetadataForOwnerRefSnafu {
-                hbase: ObjectRef::from_obj(hbase),
-            })?
-            .with_recommended_labels(build_recommended_labels(
-                hbase,
-                &resolved_product_image.app_version_label,
-                "hbase-ui",
-                "discovery",
-            ))
-            .context(ObjectMetaSnafu)?
-            .build(),
-    );
-
-    for role_podref in role_podrefs {
-        for podref in role_podref.1 {
-            if let HbasePodRef {
-                fqdn_override: Some(fqdn_override),
-                ports,
-                pod_name,
-                ..
-            } = podref
-            {
-                if let Some(ui_port) = ports.get(&hbase.ui_port_name()) {
-                    cmm.add_data(pod_name, format!("{fqdn_override}:{ui_port}"));
-                }
-            }
-        }
-    }
-
-    cm.build().context(BuildConfigMapSnafu)
-}

rust/operator-binary/src/hbase_controller.rs

@@ -79,11 +79,11 @@ use crate::{
     crd::{
         APP_NAME, AnyServiceConfig, Container, HBASE_ENV_SH, HBASE_MASTER_PORT,
         HBASE_REGIONSERVER_PORT, HBASE_REST_PORT_NAME_HTTP, HBASE_REST_PORT_NAME_HTTPS,
-        HBASE_SITE_XML, HbaseClusterStatus, HbasePodRef, HbaseRole, JVM_SECURITY_PROPERTIES_FILE,
+        HBASE_SITE_XML, HbaseClusterStatus, HbaseRole, JVM_SECURITY_PROPERTIES_FILE,
         LISTENER_VOLUME_DIR, LISTENER_VOLUME_NAME, SSL_CLIENT_XML, SSL_SERVER_XML, merged_env,
         v1alpha1,
     },
-    discovery::{build_discovery_configmap, build_endpoint_configmap},
+    discovery::build_discovery_configmap,
     kerberos::{
         self, add_kerberos_pod_config, kerberos_config_properties, kerberos_ssl_client_settings,
         kerberos_ssl_server_settings,
@@ -415,7 +415,6 @@ pub async fn reconcile_hbase(
         .context(ApplyRoleBindingSnafu)?;
 
     let mut ss_cond_builder = StatefulSetConditionBuilder::default();
-    let mut listener_refs: BTreeMap<String, Vec<HbasePodRef>> = BTreeMap::new();
 
     for (role_name, group_config) in validated_config.iter() {
         let hbase_role = HbaseRole::from_str(role_name).context(UnidentifiedHbaseRoleSnafu {
@@ -485,40 +484,6 @@ pub async fn reconcile_hbase(
                 .await
                 .context(FailedToCreatePdbSnafu)?;
         }
-
-        // if the replicas are changed at the same time as the reconciliation
-        // being paused, it may be possible to have listeners that are *expected*
-        // (according to their replica number) but which are not yet created, so
-        // deactivate this action in such cases.
-        if hbase.spec.cluster_operation.reconciliation_paused
-            || hbase.spec.cluster_operation.stopped
-        {
-            tracing::info!(
-                "Cluster is in a transitional state so do not attempt to collect listener information that will only be active once cluster has returned to a non-transitional state."
-            );
-        } else {
-            listener_refs.insert(
-                hbase_role.to_string(),
-                hbase
-                    .listener_refs(client, &hbase_role, &resolved_product_image.product_version)
-                    .await
-                    .context(CollectDiscoveryConfigSnafu)?,
-            );
-        }
-    }
-
-    tracing::debug!(
-        "Listener references prepared for the ConfigMap {:#?}",
-        listener_refs
-    );
-
-    if !listener_refs.is_empty() {
-        let endpoint_cm = build_endpoint_configmap(hbase, &resolved_product_image, listener_refs)
-            .context(BuildDiscoveryConfigMapSnafu)?;
-        cluster_resources
-            .add(client, endpoint_cm)
-            .await
-            .context(ApplyDiscoveryConfigMapSnafu)?;
     }
 
     // Discovery CM will fail to build until the rest of the cluster has been deployed, so do it last

tests/templates/kuttl/external-access/03-assert.yaml

@@ -0,0 +1,6 @@
+---
+apiVersion: kuttl.dev/v1beta1
+kind: TestStep
+commands:
+  - script: |
+      envsubst < listener-classes.yaml | kubectl apply -n $NAMESPACE -f -