refactor: use obhect meta builder

Author: maltesander

rust/operator-binary/src/controller/build/resource/config_map.rs

@@ -3,10 +3,8 @@
 
 use snafu::{ResultExt, Snafu};
 use stackable_operator::{
-    builder::{configmap::ConfigMapBuilder, meta::ObjectMetaBuilder},
-    k8s_openapi::api::core::v1::ConfigMap,
+    builder::configmap::ConfigMapBuilder, k8s_openapi::api::core::v1::ConfigMap,
     product_logging::framework::VECTOR_CONFIG_FILE,
-    v2::builder::meta::ownerreference_from_resource,
 };
 
 use crate::controller::{
@@ -44,16 +42,14 @@ pub fn build_rolegroup_config_map(
 ) -> Result<ConfigMap> {
     let mut cm_builder = ConfigMapBuilder::new();
 
-    let metadata = ObjectMetaBuilder::new()
-        .name_and_namespace(cluster)
-        .name(
+    let metadata = cluster
+        .object_meta(
             cluster
                 .resource_names(role_group_name)
                 .role_group_config_map()
                 .to_string(),
+            role_group_name,
         )
-        .ownerreference(ownerreference_from_resource(cluster, None, Some(true)))
-        .with_labels(cluster.recommended_labels(role_group_name))
         .build();
 
     cm_builder.metadata(metadata).add_data(

rust/operator-binary/src/controller/build/resource/daemonset.rs

@@ -44,10 +44,7 @@ use stackable_operator::{
     },
     utils::{COMMON_BASH_TRAP_FUNCTIONS, cluster_info::KubernetesClusterInfo},
     v2::{
-        builder::{
-            meta::ownerreference_from_resource,
-            pod::container::{EnvVarSet, new_container_builder},
-        },
+        builder::pod::container::{EnvVarSet, new_container_builder},
         product_logging::framework::{
             STACKABLE_LOG_DIR, ValidatedContainerLogConfigChoice, vector_container,
         },
@@ -583,19 +580,17 @@ pub fn build_server_rolegroup_daemonset(
     let mut pod_template = pb.build_template();
     pod_template.merge_from(rolegroup_config.pod_overrides.clone());
 
-    let metadata = ObjectMetaBuilder::new()
-        .name_and_namespace(cluster)
-        // TODO(@maltesander): `ResourceNames` has no `DaemonSet` helper (OPA is the only DaemonSet operator), so the
-        // (identical) qualified role-group name backing the `StatefulSet` name is reused.
-        // Should be replaced with upstream fix.
-        .name(
+    // TODO(@maltesander): `ResourceNames` has no `DaemonSet` helper (OPA is the only DaemonSet operator), so the
+    // (identical) qualified role-group name backing the `StatefulSet` name is reused.
+    // Should be replaced with upstream fix.
+    let metadata = cluster
+        .object_meta(
             cluster
                 .resource_names(role_group_name)
                 .stateful_set_name()
                 .to_string(),
+            role_group_name,
         )
-        .ownerreference(ownerreference_from_resource(cluster, None, Some(true)))
-        .with_labels(cluster.recommended_labels(role_group_name))
         .build();
 
     let daemonset_spec = DaemonSetSpec {

rust/operator-binary/src/controller/build/resource/discovery.rs

@@ -7,10 +7,8 @@ use std::str::FromStr;
 
 use snafu::{ResultExt, Snafu};
 use stackable_operator::{
-    builder::{configmap::ConfigMapBuilder, meta::ObjectMetaBuilder},
-    k8s_openapi::api::core::v1::ConfigMap,
+    builder::configmap::ConfigMapBuilder, k8s_openapi::api::core::v1::ConfigMap,
     utils::cluster_info::KubernetesClusterInfo,
-    v2::builder::meta::ownerreference_from_resource,
 };
 
 use super::service::{APP_PORT, APP_TLS_PORT};
@@ -47,12 +45,11 @@ pub fn build_discovery_config_map(
 
     // Discovery is a cluster-level object (named after the cluster); `discovery` is used as a
     // placeholder role-group name for the recommended labels.
-    let metadata = ObjectMetaBuilder::new()
-        .name_and_namespace(cluster)
-        .ownerreference(ownerreference_from_resource(cluster, None, Some(true)))
-        .with_labels(cluster.recommended_labels(
+    let metadata = cluster
+        .object_meta(
+            cluster.name.to_string(),
             &RoleGroupName::from_str("discovery").expect("'discovery' is a valid role group name"),
-        ))
+        )
         .build();
 
     let mut cm_builder = ConfigMapBuilder::new();

rust/operator-binary/src/controller/build/resource/service.rs

@@ -1,10 +1,9 @@
 use std::{collections::BTreeMap, str::FromStr};
 
 use stackable_operator::{
-    builder::meta::ObjectMetaBuilder,
     k8s_openapi::api::core::v1::{Service, ServicePort, ServiceSpec},
     kvp::{Annotations, Labels},
-    v2::{builder::meta::ownerreference_from_resource, types::common::Port},
+    v2::types::common::Port,
 };
 
 use crate::controller::{RoleGroupName, ValidatedCluster};
@@ -25,16 +24,16 @@ fn role_level_role_group_name() -> RoleGroupName {
 /// The server-role service is the primary endpoint that should be used by clients that do not perform internal load balancing,
 /// including targets outside of the cluster.
 pub(crate) fn build_server_role_service(cluster: &ValidatedCluster) -> Service {
-    let metadata = ObjectMetaBuilder::new()
-        .name_and_namespace(cluster)
-        .name(cluster.server_role_service_name())
-        .ownerreference(ownerreference_from_resource(cluster, None, Some(true)))
-        .with_labels(cluster.recommended_labels(&role_level_role_group_name()))
+    let metadata = cluster
+        .object_meta(
+            cluster.server_role_service_name(),
+            &role_level_role_group_name(),
+        )
         .build();
 
     let service_spec = ServiceSpec {
         type_: Some(cluster.cluster_config.listener_class.k8s_service_type()),
-        ports: Some(data_service_ports(cluster.cluster_config.tls.is_some())),
+        ports: Some(data_service_ports(cluster.is_tls_enabled())),
         selector: Some(cluster.role_selector().into()),
         // This ensures that products (e.g. Trino) on a node always talk to the OPA pod on the
         // same node, avoiding cross-node latency. The downside is that if the local OPA pod is
@@ -60,16 +59,14 @@ pub(crate) fn build_rolegroup_headless_service(
     cluster: &ValidatedCluster,
     role_group_name: &RoleGroupName,
 ) -> Service {
-    let metadata = ObjectMetaBuilder::new()
-        .name_and_namespace(cluster)
-        .name(
+    let metadata = cluster
+        .object_meta(
             cluster
                 .resource_names(role_group_name)
                 .headless_service_name()
                 .to_string(),
+            role_group_name,
         )
-        .ownerreference(ownerreference_from_resource(cluster, None, Some(true)))
-        .with_labels(cluster.recommended_labels(role_group_name))
         .build();
 
     // Currently we don't offer listener-exposition of OPA mostly due to security concerns.
@@ -80,7 +77,7 @@ pub(crate) fn build_rolegroup_headless_service(
     // Note: We have kind of similar situations for HMS and Zookeeper, as the authentication
     // options there are non-existent (mTLS still opens plain port) or suck (Kerberos).
     let service_spec = headless_cluster_ip_service_spec(
-        data_service_ports(cluster.cluster_config.tls.is_some()),
+        data_service_ports(cluster.is_tls_enabled()),
         cluster.role_group_selector(role_group_name).into(),
         true,
     );
@@ -114,17 +111,15 @@ pub(crate) fn build_rolegroup_metrics_service(
     cluster: &ValidatedCluster,
     role_group_name: &RoleGroupName,
 ) -> Service {
-    let tls_enabled = cluster.cluster_config.tls.is_some();
-    let metadata = ObjectMetaBuilder::new()
-        .name_and_namespace(cluster)
-        .name(
+    let tls_enabled = cluster.is_tls_enabled();
+    let metadata = cluster
+        .object_meta(
             cluster
                 .resource_names(role_group_name)
                 .metrics_service_name()
                 .to_string(),
+            role_group_name,
         )
-        .ownerreference(ownerreference_from_resource(cluster, None, Some(true)))
-        .with_labels(cluster.recommended_labels(role_group_name))
         .with_labels(prometheus_labels())
         .with_annotations(prometheus_annotations(tls_enabled))
         .build();

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

@@ -141,6 +141,32 @@ impl ValidatedCluster {
     pub fn role_selector(&self) -> Labels {
         role_selector(self, &product_name(), &Self::role_name())
     }
+
+    /// Returns an [`ObjectMetaBuilder`](stackable_operator::builder::meta::ObjectMetaBuilder)
+    /// pre-filled with the namespace, an owner reference back to this cluster, and the recommended
+    /// labels for a resource named `name` in `role_group_name`.
+    ///
+    /// Consolidates the metadata chain repeated by the child-resource builders. Call sites that
+    /// need extra labels/annotations chain them onto the returned builder before calling `build()`.
+    pub(crate) fn object_meta(
+        &self,
+        name: impl Into<String>,
+        role_group_name: &RoleGroupName,
+    ) -> stackable_operator::builder::meta::ObjectMetaBuilder {
+        let mut builder = stackable_operator::builder::meta::ObjectMetaBuilder::new();
+        builder
+            .name_and_namespace(self)
+            .name(name)
+            .ownerreference(
+                stackable_operator::v2::builder::meta::ownerreference_from_resource(
+                    self,
+                    None,
+                    Some(true),
+                ),
+            )
+            .with_labels(self.recommended_labels(role_group_name));
+        builder
+    }
 }
 
 /// The product name (`opa`) as a type-safe label value.