refactor: add ValidatedCluster object meta helper

Author: maltesander

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

@@ -5,13 +5,10 @@ use std::collections::BTreeMap;
 
 use snafu::{ResultExt, Snafu};
 use stackable_operator::{
-    builder::{configmap::ConfigMapBuilder, meta::ObjectMetaBuilder},
+    builder::configmap::ConfigMapBuilder,
     k8s_openapi::api::core::v1::ConfigMap,
     product_logging::framework::VECTOR_CONFIG_FILE,
-    v2::{
-        builder::meta::ownerreference_from_resource,
-        types::operator::{RoleGroupName, RoleName},
-    },
+    v2::types::operator::{RoleGroupName, RoleName},
 };
 
 use crate::{
@@ -62,20 +59,14 @@ pub fn build_rolegroup_config_map(
 
     cm_builder
         .metadata(
-            ObjectMetaBuilder::new()
-                .name_and_namespace(validated_cluster)
-                .name(
+            validated_cluster
+                .object_meta(
                     validated_cluster
                         .resource_names(role_name, role_group_name)
                         .role_group_config_map()
                         .to_string(),
+                    validated_cluster.recommended_labels_for(role_name, role_group_name),
                 )
-                .ownerreference(ownerreference_from_resource(
-                    validated_cluster,
-                    None,
-                    Some(true),
-                ))
-                .with_labels(validated_cluster.recommended_labels_for(role_name, role_group_name))
                 .build(),
         )
         .add_data(AIRFLOW_CONFIG_FILENAME, config_file);

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

@@ -16,7 +16,7 @@ use stackable_operator::{
         api::core::v1::{ConfigMap, PodTemplateSpec},
     },
     kvp::{Label, LabelError},
-    v2::builder::{meta::ownerreference_from_resource, pod::container::new_container_builder},
+    v2::builder::pod::container::new_container_builder,
 };
 
 use crate::{
@@ -182,14 +182,14 @@ pub fn build_executor_template_config_map(
 
     cm_builder
         .metadata(
-            ObjectMetaBuilder::new()
-                .name_and_namespace(cluster)
-                .name(cluster.executor_template_configmap_name())
-                .ownerreference(ownerreference_from_resource(cluster, None, Some(true)))
-                .with_labels(cluster.recommended_labels_for(
-                    &executor_role_name(),
-                    &executor_template_role_group_name(),
-                ))
+            cluster
+                .object_meta(
+                    cluster.executor_template_configmap_name(),
+                    cluster.recommended_labels_for(
+                        &executor_role_name(),
+                        &executor_template_role_group_name(),
+                    ),
+                )
                 .with_label(restarter_label)
                 .build(),
         )

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

@@ -1,10 +1,6 @@
 use stackable_operator::{
-    builder::meta::ObjectMetaBuilder,
     crd::listener,
-    v2::{
-        builder::meta::ownerreference_from_resource,
-        types::kubernetes::{ListenerClassName, ListenerName},
-    },
+    v2::types::kubernetes::{ListenerClassName, ListenerName},
 };
 
 use crate::{
@@ -19,16 +15,16 @@ pub fn build_group_listener(
     listener_group_name: ListenerName,
 ) -> listener::v1alpha1::Listener {
     listener::v1alpha1::Listener {
-        metadata: ObjectMetaBuilder::new()
-            .name_and_namespace(cluster)
-            .name(listener_group_name)
-            .ownerreference(ownerreference_from_resource(cluster, None, Some(true)))
-            // The group listener is a role-level object, so a constant `none` role-group is used
-            // as the role-group label value.
-            .with_labels(cluster.recommended_labels_for(
-                &role.role_name(),
-                &"none".parse().expect("'none' is a valid role group name"),
-            ))
+        metadata: cluster
+            .object_meta(
+                listener_group_name,
+                // The group listener is a role-level object, so a constant `none` role-group is
+                // used as the role-group label value.
+                cluster.recommended_labels_for(
+                    &role.role_name(),
+                    &"none".parse().expect("'none' is a valid role group name"),
+                ),
+            )
             .build(),
         spec: listener::v1alpha1::ListenerSpec {
             class_name: Some(listener_class.to_string()),

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

@@ -1,11 +1,7 @@
 use stackable_operator::{
-    builder::meta::ObjectMetaBuilder,
     k8s_openapi::api::core::v1::{Service, ServicePort, ServiceSpec},
     v2::{
-        builder::{
-            meta::ownerreference_from_resource,
-            service::{Scheme, Scraping, prometheus_annotations, prometheus_labels},
-        },
+        builder::service::{Scheme, Scraping, prometheus_annotations, prometheus_labels},
         types::operator::RoleGroupName,
     },
 };
@@ -23,16 +19,14 @@ pub fn build_rolegroup_headless_service(
     role_group_name: &RoleGroupName,
 ) -> Service {
     Service {
-        metadata: ObjectMetaBuilder::new()
-            .name_and_namespace(cluster)
-            .name(
+        metadata: cluster
+            .object_meta(
                 cluster
                     .resource_names(&role.role_name(), role_group_name)
                     .headless_service_name()
                     .to_string(),
+                cluster.recommended_labels(role, role_group_name),
             )
-            .ownerreference(ownerreference_from_resource(cluster, None, Some(true)))
-            .with_labels(cluster.recommended_labels(role, role_group_name))
             .build(),
         spec: Some(ServiceSpec {
             // Internal communication does not need to be exposed
@@ -54,16 +48,14 @@ pub fn build_rolegroup_metrics_service(
     role_group_name: &RoleGroupName,
 ) -> Service {
     Service {
-        metadata: ObjectMetaBuilder::new()
-            .name_and_namespace(cluster)
-            .name(
+        metadata: cluster
+            .object_meta(
                 cluster
                     .resource_names(&role.role_name(), role_group_name)
                     .metrics_service_name()
                     .to_string(),
+                cluster.recommended_labels(role, role_group_name),
             )
-            .ownerreference(ownerreference_from_resource(cluster, None, Some(true)))
-            .with_labels(cluster.recommended_labels(role, role_group_name))
             .with_labels(prometheus_labels(&Scraping::Enabled))
             .with_annotations(prometheus_annotations(
                 &Scraping::Enabled,

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

@@ -22,12 +22,9 @@ use stackable_operator::{
     kvp::{Annotation, Label, LabelError},
     utils::COMMON_BASH_TRAP_FUNCTIONS,
     v2::{
-        builder::{
-            meta::ownerreference_from_resource,
-            pod::{
-                container::new_container_builder,
-                volume::{ListenerReference, listener_operator_volume_source_builder_build_pvc},
-            },
+        builder::pod::{
+            container::new_container_builder,
+            volume::{ListenerReference, listener_operator_volume_source_builder_build_pvc},
         },
         types::operator::RoleGroupName,
     },
@@ -95,11 +92,8 @@ fn build_rolegroup_metadata(
     prometheus_label: Label,
     name: String,
 ) -> ObjectMeta {
-    ObjectMetaBuilder::new()
-        .name_and_namespace(cluster)
-        .name(name)
-        .ownerreference(ownerreference_from_resource(cluster, None, Some(true)))
-        .with_labels(cluster.recommended_labels(role, role_group_name))
+    cluster
+        .object_meta(name, cluster.recommended_labels(role, role_group_name))
         .with_label(prometheus_label)
         .build()
 }

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

@@ -1,6 +1,7 @@
 use std::{collections::BTreeMap, str::FromStr};
 
 use stackable_operator::{
+    builder::meta::ObjectMetaBuilder,
     commons::product_image_selection::ResolvedProductImage,
     crd::git_sync,
     database_connections::drivers::{
@@ -11,6 +12,7 @@ use stackable_operator::{
     kvp::Labels,
     v2::{
         HasName, HasUid, NameIsValidLabelValue,
+        builder::meta::ownerreference_from_resource,
         kvp::label::{recommended_labels, role_group_selector},
         product_logging::framework::{ValidatedContainerLogConfigChoice, VectorContainerLogConfig},
         role_group_utils::ResourceNames,
@@ -275,6 +277,21 @@ impl ValidatedCluster {
     ) -> Labels {
         role_group_selector(self, &product_name(), &role.role_name(), role_group_name)
     }
+
+    /// Returns an [`ObjectMetaBuilder`] pre-filled with the namespace, the resource `name`, an owner
+    /// reference back to this cluster, and the given recommended `labels`.
+    ///
+    /// Consolidates the metadata chain repeated by the child-resource builders. Call sites that need
+    /// extra labels or annotations chain them onto the returned builder before `.build()`.
+    pub(crate) fn object_meta(&self, name: impl Into<String>, labels: Labels) -> ObjectMetaBuilder {
+        let mut builder = ObjectMetaBuilder::new();
+        builder
+            .name_and_namespace(self)
+            .name(name)
+            .ownerreference(ownerreference_from_resource(self, None, Some(true)))
+            .with_labels(labels);
+        builder
+    }
 }
 
 /// The product name (`airflow`) as a type-safe label value.