refactor: use prevalidated placeholder constants

Author: maltesander

rust/operator-binary/src/controller.rs

@@ -22,7 +22,7 @@ use stackable_operator::{
     },
     v2::{
         cluster_resources::cluster_resources_new,
-        types::operator::{ControllerName, OperatorName, ProductName, RoleGroupName},
+        types::operator::{ControllerName, OperatorName, ProductName},
     },
 };
 use strum::{EnumDiscriminants, IntoStaticStr};
@@ -289,10 +289,6 @@ pub async fn reconcile_druid(
         {
             let role_group_listener = build_group_listener(
                 &validated_cluster,
-                validated_cluster.recommended_labels(
-                    druid_role,
-                    &RoleGroupName::from_str("none").expect("a valid role group name"),
-                ),
                 listener_class.to_string(),
                 listener_group_name,
                 druid_role,

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

@@ -1,5 +1,21 @@
 //! Build steps that turn a `ValidatedCluster` into Kubernetes resources.
 
+use std::str::FromStr;
+
+use stackable_operator::v2::types::operator::{ProductVersion, RoleGroupName};
+
+// Placeholder role-group name used for the recommended labels of the role-level discovery
+// `ConfigMap` (which is not tied to a single role group).
+stackable_operator::constant!(pub(crate) PLACEHOLDER_DISCOVERY_ROLE_GROUP: RoleGroupName = "discovery");
+
+// Placeholder role-group name used for the recommended labels of the role-level `Listener`
+// (which is not tied to a single role group).
+stackable_operator::constant!(pub(crate) PLACEHOLDER_LISTENER_ROLE_GROUP: RoleGroupName = "none");
+
+// Placeholder product version used for labels on PVC templates, which cannot be modified once
+// deployed. A constant value keeps the labels stable across version upgrades.
+stackable_operator::constant!(pub(crate) UNVERSIONED_PRODUCT_VERSION: ProductVersion = "none");
+
 pub mod jvm;
 pub mod properties;
 pub mod resource;

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

@@ -1,17 +1,18 @@
 //! Discovery for Druid.  We make Druid discoverable by putting a connection string to the router service
 //! inside a config map.  We only provide a connection string to the router service, since it serves as
 //! a gateway to the cluster for client queries.
-use std::str::FromStr;
-
 use snafu::{ResultExt, Snafu};
 use stackable_operator::{
     builder::configmap::ConfigMapBuilder, crd::listener::v1alpha1::Listener,
-    k8s_openapi::api::core::v1::ConfigMap, v2::types::operator::RoleGroupName,
+    k8s_openapi::api::core::v1::ConfigMap,
 };
 
 use crate::{
     controller::{
-        build::resource::listener::build_listener_connection_string, validate::ValidatedCluster,
+        build::{
+            PLACEHOLDER_DISCOVERY_ROLE_GROUP, resource::listener::build_listener_connection_string,
+        },
+        validate::ValidatedCluster,
     },
     crd::DruidRole,
 };
@@ -60,7 +61,7 @@ fn build_discovery_configmap(
                 .object_meta(
                     cluster.name.to_string(),
                     &DruidRole::Router,
-                    &RoleGroupName::from_str("discovery").expect("a valid role group name"),
+                    &PLACEHOLDER_DISCOVERY_ROLE_GROUP,
                 )
                 .build(),
         )

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

@@ -2,21 +2,19 @@ use std::str::FromStr;
 
 use snafu::{OptionExt, Snafu};
 use stackable_operator::{
-    builder::meta::ObjectMetaBuilder,
     crd::listener::{self, v1alpha1::Listener},
     k8s_openapi::api::core::v1::PersistentVolumeClaim,
     kvp::Labels,
     v2::{
-        builder::{
-            meta::ownerreference_from_resource,
-            pod::volume::{ListenerReference, listener_operator_volume_source_builder_build_pvc},
+        builder::pod::volume::{
+            ListenerReference, listener_operator_volume_source_builder_build_pvc,
         },
         types::kubernetes::{ListenerName, PersistentVolumeClaimName},
     },
 };
 
 use crate::{
-    controller::validate::ValidatedCluster,
+    controller::{build::PLACEHOLDER_LISTENER_ROLE_GROUP, validate::ValidatedCluster},
     crd::{
         DruidRole,
         security::{DruidTlsSecurity, PLAINTEXT_PORT_NAME, TLS_PORT_NAME},
@@ -40,17 +38,19 @@ pub enum Error {
 
 pub fn build_group_listener(
     cluster: &ValidatedCluster,
-    object_labels: Labels,
     listener_class: String,
     listener_group_name: ListenerName,
     druid_role: &DruidRole,
 ) -> Listener {
+    // The group listener is a role-level (not role-group-level) object, so there is no real
+    // role-group name; the placeholder is used for the recommended labels.
     Listener {
-        metadata: ObjectMetaBuilder::new()
-            .name_and_namespace(cluster)
-            .name(listener_group_name.to_string())
-            .ownerreference(ownerreference_from_resource(cluster, None, Some(true)))
-            .with_labels(object_labels)
+        metadata: cluster
+            .object_meta(
+                listener_group_name.to_string(),
+                druid_role,
+                &PLACEHOLDER_LISTENER_ROLE_GROUP,
+            )
             .build(),
         spec: listener::v1alpha1::ListenerSpec {
             class_name: Some(listener_class),

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

@@ -28,14 +28,15 @@ use stackable_operator::{
         role_group_utils::ResourceNames,
         types::{
             kubernetes::{ContainerName, VolumeName},
-            operator::{ProductVersion, RoleGroupName},
+            operator::RoleGroupName,
         },
     },
 };
 
 use crate::{
     controller::{
         build::{
+            UNVERSIONED_PRODUCT_VERSION,
             properties::product_logging::MAX_DRUID_LOG_FILES_SIZE,
             resource::listener::{
                 LISTENER_VOLUME_DIR, LISTENER_VOLUME_NAME, build_group_listener_pvc,
@@ -290,12 +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 = cluster.recommended_labels_for(
-            role,
-            &ProductVersion::from_str("none").expect("a valid product version"),
-            role_group_name,
-        );
+        // other desired labels, hence the unversioned product version.
+        let unversioned_recommended_labels =
+            cluster.recommended_labels_for(role, &UNVERSIONED_PRODUCT_VERSION, role_group_name);
 
         pvcs = Some(vec![build_group_listener_pvc(
             &group_listener_name,