refactor: add uid, namespace to ValidatedCluster

maltesander · maltesander · commit 36cc1da5fe2d · 2026-06-08T19:51:22.000+02:00
diff --git a/rust/operator-binary/src/controller/build/config_map.rs b/rust/operator-binary/src/controller/build/config_map.rs
@@ -6,7 +6,7 @@ use stackable_operator::{
     k8s_openapi::api::core::v1::ConfigMap,
     product_logging::framework::VECTOR_CONFIG_FILE,
     role_utils::RoleGroupRef,
-    v2::config_file_writer::PropertiesWriterError,
+    v2::{builder::meta::ownerreference_from_resource, config_file_writer::PropertiesWriterError},
 };
 
 use crate::{
@@ -31,11 +31,6 @@ pub enum Error {
         role_group: String,
     },
 
-    #[snafu(display("object is missing metadata to build owner reference"))]
-    ObjectMissingMetadataForOwnerRef {
-        source: stackable_operator::builder::meta::Error,
-    },
-
     #[snafu(display("failed to build object meta data"))]
     ObjectMeta {
         source: stackable_operator::builder::meta::Error,
@@ -55,9 +50,6 @@ pub fn build_rolegroup_config_map(
     cluster: &ValidatedCluster,
     role: &HbaseRole,
     rolegroup_ref: &RoleGroupRef<v1alpha1::HbaseCluster>,
-    // `owner` is retained only for the ConfigMap ObjectMeta / owner reference; the rendered
-    // content comes entirely from `cluster`. To be decoupled in a follow-up.
-    owner_ref: &v1alpha1::HbaseCluster,
 ) -> Result<ConfigMap> {
     tracing::info!("Setting up ConfigMap for {:?}", rolegroup_ref);
 
@@ -110,12 +102,11 @@ pub fn build_rolegroup_config_map(
         )?;
 
     let cm_metadata = ObjectMetaBuilder::new()
-        .name_and_namespace(owner_ref)
+        .name_and_namespace(cluster)
         .name(rolegroup_ref.object_name())
-        .ownerreference_from_resource(owner_ref, None, Some(true))
-        .context(ObjectMissingMetadataForOwnerRefSnafu)?
+        .ownerreference(ownerreference_from_resource(cluster, None, Some(true)))
         .with_recommended_labels(&build_recommended_labels(
-            owner_ref,
+            cluster,
             &cluster.image.app_version_label_value,
             &rolegroup_ref.role,
             &rolegroup_ref.role_group,
diff --git a/rust/operator-binary/src/controller/build/discovery.rs b/rust/operator-binary/src/controller/build/discovery.rs
@@ -6,26 +6,19 @@ use snafu::{ResultExt, Snafu};
 use stackable_operator::{
     builder::{configmap::ConfigMapBuilder, meta::ObjectMetaBuilder},
     k8s_openapi::api::core::v1::ConfigMap,
-    kube::runtime::reflector::ObjectRef,
-    v2::config_file_writer::to_hadoop_xml,
+    v2::{builder::meta::ownerreference_from_resource, config_file_writer::to_hadoop_xml},
 };
 
 use crate::{
     controller::build::properties::ConfigFileName,
-    crd::{HbaseRole, v1alpha1},
+    crd::HbaseRole,
     hbase_controller::{ValidatedCluster, build_recommended_labels},
 };
 
 type Result<T, E = Error> = std::result::Result<T, E>;
 
 #[derive(Snafu, Debug)]
 pub enum Error {
-    #[snafu(display("object {hbase} is missing metadata to build owner reference"))]
-    ObjectMissingMetadataForOwnerRef {
-        source: stackable_operator::builder::meta::Error,
-        hbase: ObjectRef<v1alpha1::HbaseCluster>,
-    },
-
     #[snafu(display("failed to build ConfigMap"))]
     BuildConfigMap {
         source: stackable_operator::builder::configmap::Error,
@@ -38,13 +31,7 @@ pub enum Error {
 }
 
 /// Creates a discovery config map containing the `hbase-site.xml` for clients.
-///
-/// The rendered content comes entirely from `cluster`; `owner_ref` is retained only for the
-/// ConfigMap ObjectMeta / owner reference.
-pub fn build_discovery_config_map(
-    cluster: &ValidatedCluster,
-    owner_ref: &v1alpha1::HbaseCluster,
-) -> Result<ConfigMap> {
+pub fn build_discovery_config_map(cluster: &ValidatedCluster) -> Result<ConfigMap> {
     let cluster_config = &cluster.cluster_config;
 
     let mut hbase_site = cluster_config
@@ -55,13 +42,10 @@ pub fn build_discovery_config_map(
     ConfigMapBuilder::new()
         .metadata(
             ObjectMetaBuilder::new()
-                .name_and_namespace(owner_ref)
-                .ownerreference_from_resource(owner_ref, None, Some(true))
-                .with_context(|_| ObjectMissingMetadataForOwnerRefSnafu {
-                    hbase: ObjectRef::from_obj(owner_ref),
-                })?
+                .name_and_namespace(cluster)
+                .ownerreference(ownerreference_from_resource(cluster, None, Some(true)))
                 .with_recommended_labels(&build_recommended_labels(
-                    owner_ref,
+                    cluster,
                     &cluster.image.app_version_label_value,
                     &HbaseRole::RegionServer.to_string(),
                     "discovery",
diff --git a/rust/operator-binary/src/controller/validate.rs b/rust/operator-binary/src/controller/validate.rs
@@ -1,13 +1,12 @@
-use std::{collections::BTreeMap, str::FromStr};
+use std::collections::BTreeMap;
 
 use snafu::{ResultExt, Snafu};
 use stackable_operator::{
     commons::product_image_selection::{self},
     config::merge::Merge,
-    kube::ResourceExt,
     role_utils::GenericRoleConfig,
     utils::cluster_info::KubernetesClusterInfo,
-    v2::types::operator::ClusterName,
+    v2::controller_utils::{get_cluster_name, get_namespace, get_uid},
 };
 use strum::IntoEnumIterator;
 
@@ -33,9 +32,9 @@ pub enum Error {
         source: product_image_selection::Error,
     },
 
-    #[snafu(display("invalid cluster name"))]
-    InvalidClusterName {
-        source: stackable_operator::v2::macros::attributed_string_type::Error,
+    #[snafu(display("failed to determine the cluster identity (name, namespace and uid)"))]
+    GetClusterIdentity {
+        source: stackable_operator::v2::controller_utils::Error,
     },
 
     #[snafu(display("the HbaseCluster has no {role} role defined"))]
@@ -130,10 +129,16 @@ pub fn validate_cluster(
     let ssl_server_settings = kerberos_ssl_server_settings(hbase);
     let ssl_client_settings = kerberos_ssl_client_settings(hbase);
 
-    Ok(ValidatedCluster {
-        name: ClusterName::from_str(&hbase.name_any()).context(InvalidClusterNameSnafu)?,
-        image: resolved_product_image,
-        cluster_config: ValidatedClusterConfig {
+    let name = get_cluster_name(hbase).context(GetClusterIdentitySnafu)?;
+    let namespace = get_namespace(hbase).context(GetClusterIdentitySnafu)?;
+    let uid = get_uid(hbase).context(GetClusterIdentitySnafu)?;
+
+    Ok(ValidatedCluster::new(
+        name,
+        namespace,
+        uid,
+        resolved_product_image,
+        ValidatedClusterConfig {
             zookeeper_connection_information: dereferenced_objects.zookeeper_connection_information,
             hbase_opa_config: dereferenced_objects.hbase_opa_config,
             kerberos_enabled: hbase.has_kerberos_enabled(),
@@ -142,9 +147,9 @@ pub fn validate_cluster(
             ssl_server_settings,
             ssl_client_settings,
         },
-        role_group_configs: role_groups,
+        role_groups,
         role_configs,
-    })
+    ))
 }
 
 /// The names of the role groups defined for `role` in the spec.
diff --git a/rust/operator-binary/src/hbase_controller.rs b/rust/operator-binary/src/hbase_controller.rs
@@ -26,7 +26,10 @@ use stackable_operator::{
                 ServicePort, ServiceSpec, TCPSocketAction, Volume,
             },
         },
-        apimachinery::pkg::{apis::meta::v1::LabelSelector, util::intstr::IntOrString},
+        apimachinery::pkg::{
+            apis::meta::v1::{LabelSelector, ObjectMeta},
+            util::intstr::IntOrString,
+        },
     },
     kube::{
         Resource, ResourceExt,
@@ -49,7 +52,13 @@ use stackable_operator::{
         compute_conditions, operations::ClusterOperationsConditionBuilder,
         statefulset::StatefulSetConditionBuilder,
     },
-    v2::types::operator::ClusterName,
+    v2::{
+        HasName, HasUid, NameIsValidLabelValue,
+        types::{
+            kubernetes::{NamespaceName, Uid},
+            operator::ClusterName,
+        },
+    },
 };
 use strum::{EnumDiscriminants, IntoStaticStr};
 
@@ -90,16 +99,100 @@ pub struct Ctx {
 /// every role and role group before any resources are created.
 #[derive(Clone, Debug)]
 pub struct ValidatedCluster {
+    /// Backs the [`Resource`] implementation (provides `meta()`/`name_any()`) so the build
+    /// functions can derive `ObjectMeta`, owner references and labels without the full
+    /// `HbaseCluster` object. Holds only name, namespace and uid.
+    metadata: ObjectMeta,
     /// The logical (and Kubernetes object) name of the cluster.
-    // Populated now; consumed by the new build path in a later commit.
-    #[allow(dead_code)]
     pub name: ClusterName,
+    /// The namespace the cluster lives in. Part of the cluster identity; currently consumed via
+    /// the [`Resource`] metadata (`name_and_namespace`) rather than read directly.
+    #[allow(dead_code)]
+    pub namespace: NamespaceName,
+    /// The UID of the `HbaseCluster` object, used to build owner references.
+    pub uid: Uid,
     pub image: ResolvedProductImage,
     pub cluster_config: ValidatedClusterConfig,
     pub role_group_configs: BTreeMap<HbaseRole, BTreeMap<String, ValidatedRoleGroupConfig>>,
     pub role_configs: BTreeMap<HbaseRole, ValidatedRoleConfig>,
 }
 
+impl ValidatedCluster {
+    #[allow(clippy::too_many_arguments)]
+    pub fn new(
+        name: ClusterName,
+        namespace: NamespaceName,
+        uid: Uid,
+        image: ResolvedProductImage,
+        cluster_config: ValidatedClusterConfig,
+        role_group_configs: BTreeMap<HbaseRole, BTreeMap<String, ValidatedRoleGroupConfig>>,
+        role_configs: BTreeMap<HbaseRole, ValidatedRoleConfig>,
+    ) -> Self {
+        Self {
+            metadata: ObjectMeta {
+                name: Some(name.to_string()),
+                namespace: Some(namespace.to_string()),
+                uid: Some(uid.to_string()),
+                ..ObjectMeta::default()
+            },
+            name,
+            namespace,
+            uid,
+            image,
+            cluster_config,
+            role_group_configs,
+            role_configs,
+        }
+    }
+}
+
+impl Resource for ValidatedCluster {
+    type DynamicType = <v1alpha1::HbaseCluster as Resource>::DynamicType;
+    type Scope = <v1alpha1::HbaseCluster as Resource>::Scope;
+
+    fn group(dt: &Self::DynamicType) -> std::borrow::Cow<'_, str> {
+        v1alpha1::HbaseCluster::group(dt)
+    }
+
+    fn version(dt: &Self::DynamicType) -> std::borrow::Cow<'_, str> {
+        v1alpha1::HbaseCluster::version(dt)
+    }
+
+    fn kind(dt: &Self::DynamicType) -> std::borrow::Cow<'_, str> {
+        v1alpha1::HbaseCluster::kind(dt)
+    }
+
+    fn plural(dt: &Self::DynamicType) -> std::borrow::Cow<'_, str> {
+        v1alpha1::HbaseCluster::plural(dt)
+    }
+
+    fn meta(&self) -> &ObjectMeta {
+        &self.metadata
+    }
+
+    fn meta_mut(&mut self) -> &mut ObjectMeta {
+        &mut self.metadata
+    }
+}
+
+impl HasName for ValidatedCluster {
+    fn to_name(&self) -> String {
+        self.name.to_string()
+    }
+}
+
+impl HasUid for ValidatedCluster {
+    fn to_uid(&self) -> Uid {
+        self.uid.clone()
+    }
+}
+
+impl NameIsValidLabelValue for ValidatedCluster {
+    fn to_label_value(&self) -> String {
+        self.name.to_label_value()
+    }
+}
+
 /// Cluster-wide settings resolved once during validation.
 #[derive(Clone, Debug)]
 pub struct ValidatedClusterConfig {
@@ -353,7 +446,6 @@ pub async fn reconcile_hbase(
                 &validated_cluster,
                 hbase_role,
                 &rolegroup,
-                hbase,
             )
             .context(BuildRolegroupConfigMapSnafu)?;
             let rg_statefulset = build_rolegroup_statefulset(
@@ -411,8 +503,8 @@ pub async fn reconcile_hbase(
 
     // Discovery CM will fail to build until the rest of the cluster has been deployed, so do it last
     // so that failure won't inhibit the rest of the cluster from booting up.
-    let discovery_cm = build_discovery_config_map(&validated_cluster, hbase)
-        .context(BuildDiscoveryConfigMapSnafu)?;
+    let discovery_cm =
+        build_discovery_config_map(&validated_cluster).context(BuildDiscoveryConfigMapSnafu)?;
     cluster_resources
         .add(client, discovery_cm)
         .await
@@ -881,12 +973,12 @@ pub fn error_policy(
     }
 }
 
-pub fn build_recommended_labels<'a>(
-    owner: &'a v1alpha1::HbaseCluster,
+pub fn build_recommended_labels<'a, R>(
+    owner: &'a R,
     app_version: &'a str,
     role: &'a str,
     role_group: &'a str,
-) -> ObjectLabels<'a, v1alpha1::HbaseCluster> {
+) -> ObjectLabels<'a, R> {
     ObjectLabels {
         owner,
         app_name: APP_NAME,
