refactor: extract objectMeta, recommendeclabels, chache product version

Author: maltesander

rust/operator-binary/src/controller.rs

@@ -22,10 +22,7 @@ use stackable_operator::{
     },
     v2::{
         cluster_resources::cluster_resources_new,
-        kvp::label::recommended_labels,
-        types::operator::{
-            ControllerName, OperatorName, ProductName, ProductVersion, RoleGroupName,
-        },
+        types::operator::{ControllerName, OperatorName, ProductName, RoleGroupName},
     },
 };
 use strum::{EnumDiscriminants, IntoStaticStr};
@@ -292,14 +289,8 @@ pub async fn reconcile_druid(
         {
             let role_group_listener = build_group_listener(
                 &validated_cluster,
-                recommended_labels(
-                    &validated_cluster,
-                    &product_name(),
-                    &ProductVersion::from_str(&validated_cluster.image.app_version_label_value)
-                        .expect("a valid product version"),
-                    &operator_name(),
-                    &controller_name(),
-                    &druid_role.to_role_name(),
+                validated_cluster.recommended_labels(
+                    druid_role,
                     &RoleGroupName::from_str("none").expect("a valid role group name"),
                 ),
                 listener_class.to_string(),

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

@@ -11,20 +11,15 @@
 //! The builder does not read the raw [`v1alpha1::DruidCluster`] at all: everything it needs is
 //! carried on `ValidatedCluster` (resolved during the validate step).
 
-use std::{collections::BTreeMap, str::FromStr};
+use std::collections::BTreeMap;
 
 use snafu::{ResultExt, Snafu};
 use stackable_operator::{
-    builder::{configmap::ConfigMapBuilder, meta::ObjectMetaBuilder},
+    builder::configmap::ConfigMapBuilder,
     crd::s3,
     k8s_openapi::api::core::v1::{ConfigMap, EnvVar},
     product_logging::framework::VECTOR_CONFIG_FILE,
-    v2::{
-        builder::meta::ownerreference_from_resource,
-        config_file_writer::to_java_properties_string,
-        kvp::label::recommended_labels,
-        types::operator::{ProductVersion, RoleGroupName},
-    },
+    v2::{config_file_writer::to_java_properties_string, types::operator::RoleGroupName},
 };
 
 use crate::{
@@ -37,7 +32,6 @@ use crate::{
                 runtime_properties, security_properties,
             },
         },
-        controller_name, operator_name, product_name,
         validate::{DruidRoleGroupConfig, ValidatedCluster},
     },
     crd::{
@@ -322,20 +316,12 @@ pub fn build_rolegroup_config_map(
 
     let mut config_map_builder = ConfigMapBuilder::new();
     config_map_builder.metadata(
-        ObjectMetaBuilder::new()
-            .name_and_namespace(cluster)
-            .name(resource_names.role_group_config_map().to_string())
-            .ownerreference(ownerreference_from_resource(cluster, None, Some(true)))
-            .with_labels(recommended_labels(
-                cluster,
-                &product_name(),
-                &ProductVersion::from_str(&cluster.image.app_version_label_value)
-                    .expect("a valid product version"),
-                &operator_name(),
-                &controller_name(),
-                &role.to_role_name(),
+        cluster
+            .object_meta(
+                resource_names.role_group_config_map().to_string(),
+                role,
                 role_group_name,
-            ))
+            )
             .build(),
     );
 

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

@@ -5,20 +5,13 @@ use std::str::FromStr;
 
 use snafu::{ResultExt, Snafu};
 use stackable_operator::{
-    builder::{configmap::ConfigMapBuilder, meta::ObjectMetaBuilder},
-    crd::listener::v1alpha1::Listener,
-    k8s_openapi::api::core::v1::ConfigMap,
-    v2::{
-        builder::meta::ownerreference_from_resource,
-        kvp::label::recommended_labels,
-        types::operator::{ProductVersion, RoleGroupName},
-    },
+    builder::configmap::ConfigMapBuilder, crd::listener::v1alpha1::Listener,
+    k8s_openapi::api::core::v1::ConfigMap, v2::types::operator::RoleGroupName,
 };
 
 use crate::{
     controller::{
-        build::resource::listener::build_listener_connection_string, controller_name,
-        operator_name, product_name, validate::ValidatedCluster,
+        build::resource::listener::build_listener_connection_string, validate::ValidatedCluster,
     },
     crd::DruidRole,
 };
@@ -63,19 +56,12 @@ fn build_discovery_configmap(
 
     ConfigMapBuilder::new()
         .metadata(
-            ObjectMetaBuilder::new()
-                .name_and_namespace(cluster)
-                .ownerreference(ownerreference_from_resource(cluster, None, Some(true)))
-                .with_labels(recommended_labels(
-                    cluster,
-                    &product_name(),
-                    &ProductVersion::from_str(&cluster.image.app_version_label_value)
-                        .expect("a valid product version"),
-                    &operator_name(),
-                    &controller_name(),
-                    &DruidRole::Router.to_role_name(),
+            cluster
+                .object_meta(
+                    cluster.name.to_string(),
+                    &DruidRole::Router,
                     &RoleGroupName::from_str("discovery").expect("a valid role group name"),
-                ))
+                )
                 .build(),
         )
         .add_data("DRUID_ROUTER", router_host)

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

@@ -1,18 +1,11 @@
-use std::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,
-        kvp::label::{recommended_labels, role_group_selector},
-        types::operator::{ProductVersion, RoleGroupName},
-    },
+    v2::types::operator::RoleGroupName,
 };
 
 use crate::{
-    controller::{controller_name, operator_name, product_name, validate::ValidatedCluster},
+    controller::validate::ValidatedCluster,
     crd::{DruidRole, METRICS_PORT, METRICS_PORT_NAME},
 };
 
@@ -23,33 +16,16 @@ pub fn build_rolegroup_headless_service(
     druid_role: &DruidRole,
     role_group_name: &RoleGroupName,
 ) -> Service {
-    let object_labels = recommended_labels(
-        cluster,
-        &product_name(),
-        &ProductVersion::from_str(&cluster.image.app_version_label_value)
-            .expect("a valid product version"),
-        &operator_name(),
-        &controller_name(),
-        &druid_role.to_role_name(),
-        role_group_name,
-    );
-    let selector = role_group_selector(
-        cluster,
-        &product_name(),
-        &druid_role.to_role_name(),
-        role_group_name,
-    );
     Service {
-        metadata: ObjectMetaBuilder::new()
-            .name_and_namespace(cluster)
-            .name(
+        metadata: cluster
+            .object_meta(
                 cluster
                     .resource_names(druid_role, role_group_name)
                     .headless_service_name()
                     .to_string(),
+                druid_role,
+                role_group_name,
             )
-            .ownerreference(ownerreference_from_resource(cluster, None, Some(true)))
-            .with_labels(object_labels)
             .build(),
         spec: Some(ServiceSpec {
             // Internal communication does not need to be exposed
@@ -61,7 +37,11 @@ pub fn build_rolegroup_headless_service(
                     .druid_tls_security
                     .service_ports(druid_role),
             ),
-            selector: Some(selector.into()),
+            selector: Some(
+                cluster
+                    .role_group_selector(druid_role, role_group_name)
+                    .into(),
+            ),
             publish_not_ready_addresses: Some(true),
             ..ServiceSpec::default()
         }),
@@ -75,33 +55,16 @@ pub fn build_rolegroup_metrics_service(
     druid_role: &DruidRole,
     role_group_name: &RoleGroupName,
 ) -> Service {
-    let object_labels = recommended_labels(
-        cluster,
-        &product_name(),
-        &ProductVersion::from_str(&cluster.image.app_version_label_value)
-            .expect("a valid product version"),
-        &operator_name(),
-        &controller_name(),
-        &druid_role.to_role_name(),
-        role_group_name,
-    );
-    let selector = role_group_selector(
-        cluster,
-        &product_name(),
-        &druid_role.to_role_name(),
-        role_group_name,
-    );
     Service {
-        metadata: ObjectMetaBuilder::new()
-            .name_and_namespace(cluster)
-            .name(
+        metadata: cluster
+            .object_meta(
                 cluster
                     .resource_names(druid_role, role_group_name)
                     .metrics_service_name()
                     .to_string(),
+                druid_role,
+                role_group_name,
             )
-            .ownerreference(ownerreference_from_resource(cluster, None, Some(true)))
-            .with_labels(object_labels)
             .with_labels(prometheus_labels())
             .with_annotations(prometheus_annotations())
             .build(),
@@ -110,7 +73,11 @@ pub fn build_rolegroup_metrics_service(
             type_: Some("ClusterIP".to_string()),
             cluster_ip: Some("None".to_string()),
             ports: Some(metrics_service_ports()),
-            selector: Some(selector.into()),
+            selector: Some(
+                cluster
+                    .role_group_selector(druid_role, role_group_name)
+                    .into(),
+            ),
             publish_not_ready_addresses: Some(true),
             ..ServiceSpec::default()
         }),

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

@@ -23,11 +23,7 @@ use stackable_operator::{
     kube::ResourceExt,
     product_logging,
     v2::{
-        builder::{
-            meta::ownerreference_from_resource,
-            pod::container::{EnvVarSet, new_container_builder},
-        },
-        kvp::label::{recommended_labels, role_group_selector},
+        builder::pod::container::{EnvVarSet, new_container_builder},
         product_logging::framework::{ValidatedContainerLogConfigChoice, vector_container},
         role_group_utils::ResourceNames,
         types::{
@@ -46,7 +42,6 @@ use crate::{
                 group_listener_name, secret_volume_listener_scope,
             },
         },
-        controller_name, operator_name, product_name,
         validate::{DruidRoleGroupConfig, ValidatedCluster},
     },
     crd::{
@@ -296,13 +291,9 @@ pub fn build_rolegroup_statefulset(
         // Used for PVC templates that cannot be modified once they are deployed
         // A version value is required, and we do want to use the "recommended" format for the
         // other desired labels, hence the "none" product version.
-        let unversioned_recommended_labels = recommended_labels(
-            cluster,
-            &product_name(),
+        let unversioned_recommended_labels = cluster.recommended_labels_for(
+            role,
             &ProductVersion::from_str("none").expect("a valid product version"),
-            &operator_name(),
-            &controller_name(),
-            &role.to_role_name(),
             role_group_name,
         );
 
@@ -313,16 +304,7 @@ pub fn build_rolegroup_statefulset(
     }
 
     let metadata = ObjectMetaBuilder::new()
-        .with_labels(recommended_labels(
-            cluster,
-            &product_name(),
-            &ProductVersion::from_str(&resolved_product_image.app_version_label_value)
-                .expect("a valid product version"),
-            &operator_name(),
-            &controller_name(),
-            &role.to_role_name(),
-            role_group_name,
-        ))
+        .with_labels(cluster.recommended_labels(role, role_group_name))
         .build();
 
     pb.image_pull_secrets_from_product_image(resolved_product_image)
@@ -352,35 +334,19 @@ pub fn build_rolegroup_statefulset(
     pod_template.merge_from(rg.pod_overrides.clone());
 
     Ok(StatefulSet {
-        metadata: ObjectMetaBuilder::new()
-            .name_and_namespace(cluster)
-            .name(resource_names.stateful_set_name().to_string())
-            .ownerreference(ownerreference_from_resource(cluster, None, Some(true)))
-            .with_labels(recommended_labels(
-                cluster,
-                &product_name(),
-                &ProductVersion::from_str(&resolved_product_image.app_version_label_value)
-                    .expect("a valid product version"),
-                &operator_name(),
-                &controller_name(),
-                &role.to_role_name(),
+        metadata: cluster
+            .object_meta(
+                resource_names.stateful_set_name().to_string(),
+                role,
                 role_group_name,
-            ))
+            )
             .with_label(RESTART_CONTROLLER_ENABLED_LABEL.to_owned())
             .build(),
         spec: Some(StatefulSetSpec {
             pod_management_policy: Some("Parallel".to_string()),
             replicas: Some(i32::from(rg.replicas)),
             selector: LabelSelector {
-                match_labels: Some(
-                    role_group_selector(
-                        cluster,
-                        &product_name(),
-                        &role.to_role_name(),
-                        role_group_name,
-                    )
-                    .into(),
-                ),
+                match_labels: Some(cluster.role_group_selector(role, role_group_name).into()),
                 ..LabelSelector::default()
             },
             service_name: Some(resource_names.headless_service_name().to_string()),