refactor: consolidate object metadata + identity helpers

Author: adwk67

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

@@ -48,7 +48,7 @@ pub mod tls;
 /// exposing the given `zk_role`, `<cluster>-<role>`.
 ///
 /// Lives in the `crd` module (rather than the controller build tree) because it is shared by both
-/// controllers and by [`ZookeeperCluster::server_role_listener_fqdn`].
+/// controllers and by [`v1alpha1::ZookeeperCluster::server_role_listener_fqdn`].
 pub fn role_listener_name(cluster_name: &str, zk_role: &ZookeeperRole) -> ListenerName {
     ListenerName::from_str(&format!("{cluster_name}-{zk_role}"))
         .expect("the role listener name should be a valid Listener name")

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

@@ -9,6 +9,22 @@
 //! remaining submodules ([`command`], [`graceful_shutdown`], [`jvm`],
 //! [`properties`]) produce fragments that those resource builders assemble.
 
+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 command;
 pub mod graceful_shutdown;
 pub mod jvm;

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

@@ -1,5 +1,5 @@
 //! Assembles the per-rolegroup `ConfigMap` from the [`ValidatedCluster`],
-//! without reaching into the [`v1alpha1::ZookeeperCluster`] except for the owner
+//! without reaching into the [`crate::crd::v1alpha1::ZookeeperCluster`] except for the owner
 //! reference and object metadata.
 //!
 //! The individual files are rendered by the [`properties`](crate::zk_controller::build::properties)
@@ -9,11 +9,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,
         config_file_writer::{PropertiesWriterError, to_java_properties_string},
         types::operator::RoleGroupName,
     },
@@ -92,16 +91,14 @@ pub fn build_server_rolegroup_config_map(
 
     ConfigMapBuilder::new()
         .metadata(
-            ObjectMetaBuilder::new()
-                .name_and_namespace(cluster)
-                .name(
+            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(),
         )
         .data(data)

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

@@ -10,13 +10,16 @@ use stackable_operator::{
         HasName, HasUid, NameIsValidLabelValue,
         builder::meta::ownerreference_from_resource,
         kvp::label::recommended_labels,
-        types::operator::{ControllerName, ProductVersion, RoleGroupName},
+        types::operator::{ControllerName, ProductVersion},
     },
 };
 
 use crate::{
     crd::{ZOOKEEPER_SERVER_PORT_NAME, security::ZookeeperSecurity},
-    zk_controller::validate::{ValidatedCluster, operator_name, product_name},
+    zk_controller::{
+        build::PLACEHOLDER_DISCOVERY_ROLE_GROUP,
+        validate::{ValidatedCluster, operator_name, product_name},
+    },
     znode_controller::validate::ValidatedZnode,
 };
 
@@ -97,8 +100,8 @@ pub fn build_znode_discovery_configmap(
 /// Build a discovery [`ConfigMap`] containing ZooKeeper connection details from a
 /// [`listener::v1alpha1::Listener`].
 ///
-/// `owner` owns the ConfigMap (the [`ZookeeperCluster`](v1alpha1::ZookeeperCluster) for the cluster
-/// controller, or the [`ZookeeperZnode`](v1alpha1::ZookeeperZnode) for the znode controller) and
+/// `owner` owns the ConfigMap (the [`ZookeeperCluster`](crate::crd::v1alpha1::ZookeeperCluster) for the cluster
+/// controller, or the [`ZookeeperZnode`](crate::crd::v1alpha1::ZookeeperZnode) for the znode controller) and
 /// `namespace` is where the ConfigMap is placed.
 fn build_discovery_configmap_for_owner(
     owner: &(impl Resource<DynamicType = ()> + HasName + HasUid + NameIsValidLabelValue),
@@ -116,8 +119,7 @@ fn build_discovery_configmap_for_owner(
     // znode controllers, so it is passed in and validated into the type-safe newtype here.
     let controller_name = ControllerName::from_str(controller_name)
         .expect("the controller name is a valid label value");
-    let role_group_name =
-        RoleGroupName::from_str("discovery").expect("'discovery' is a valid role group name");
+    let role_group_name = PLACEHOLDER_DISCOVERY_ROLE_GROUP.clone();
 
     let listener_addresses = listener_addresses(&listener, ZOOKEEPER_SERVER_PORT_NAME)?;
 

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

@@ -1,18 +1,12 @@
 //! Types and functions for exposing product endpoints via [listener::v1alpha1::Listener].
 
-use std::str::FromStr;
-
-use stackable_operator::{
-    builder::meta::ObjectMetaBuilder,
-    crd::listener,
-    v2::{builder::meta::ownerreference_from_resource, types::operator::RoleGroupName},
-};
+use stackable_operator::crd::listener;
 
 use crate::{
     crd::{
         ZOOKEEPER_SERVER_PORT_NAME, ZookeeperRole, role_listener_name, security::ZookeeperSecurity,
     },
-    zk_controller::validate::ValidatedCluster,
+    zk_controller::{build::PLACEHOLDER_LISTENER_ROLE_GROUP, validate::ValidatedCluster},
 };
 
 /// Builds the role-level [`Listener`](listener::v1alpha1::Listener) exposing the ZooKeeper servers.
@@ -23,17 +17,12 @@ pub fn build_role_listener(
     cluster: &ValidatedCluster,
     zk_role: &ZookeeperRole,
 ) -> listener::v1alpha1::Listener {
-    // The listener is a role-level resource, so it has no role group. The recommended labels
-    // require a role-group value, so a constant "none" is used (matching the previous behaviour).
-    let role_group_name =
-        RoleGroupName::from_str("none").expect("'none' is a valid role group name");
-
     listener::v1alpha1::Listener {
-        metadata: ObjectMetaBuilder::new()
-            .name_and_namespace(cluster)
-            .name(role_listener_name(cluster.name.as_ref(), zk_role))
-            .ownerreference(ownerreference_from_resource(cluster, None, Some(true)))
-            .with_labels(cluster.recommended_labels(&role_group_name))
+        metadata: cluster
+            .object_meta(
+                role_listener_name(cluster.name.as_ref(), zk_role),
+                &PLACEHOLDER_LISTENER_ROLE_GROUP,
+            )
             .build(),
         spec: listener::v1alpha1::ListenerSpec {
             class_name: Some(cluster.cluster_config.listener_class.to_string()),

rust/operator-binary/src/zk_controller/build/resource/pdb.rs

@@ -1,23 +1,17 @@
-use std::str::FromStr;
-
 use stackable_operator::{
-    commons::pdb::PdbConfig,
-    k8s_openapi::api::policy::v1::PodDisruptionBudget,
-    v2::{
-        builder::pdb::pod_disruption_budget_builder_with_role,
-        types::operator::{ControllerName, OperatorName, ProductName, RoleName},
-    },
+    commons::pdb::PdbConfig, k8s_openapi::api::policy::v1::PodDisruptionBudget,
+    v2::builder::pdb::pod_disruption_budget_builder_with_role,
 };
 
 use crate::{
-    crd::{APP_NAME, OPERATOR_NAME, ZookeeperRole},
-    zk_controller::{ZK_CONTROLLER_NAME, validate::ValidatedCluster},
+    crd::ZookeeperRole,
+    zk_controller::validate::{ValidatedCluster, controller_name, operator_name, product_name},
 };
 
 /// Builds the [`PodDisruptionBudget`] for the given `role`, or `None` if PDBs are disabled.
 pub fn build_pdb(
     pdb: &PdbConfig,
-    validated_cluster: &ValidatedCluster,
+    cluster: &ValidatedCluster,
     role: &ZookeeperRole,
 ) -> Option<PodDisruptionBudget> {
     if !pdb.enabled {
@@ -27,23 +21,12 @@ pub fn build_pdb(
         ZookeeperRole::Server => max_unavailable_servers(),
     });
 
-    // These names are derived from compile-time constants and a validated role enum, so they are
-    // guaranteed to be valid and we use the infallible v2 builder.
-    let product_name =
-        ProductName::from_str(APP_NAME).expect("APP_NAME should be a valid product name");
-    let operator_name = OperatorName::from_str(OPERATOR_NAME)
-        .expect("OPERATOR_NAME should be a valid operator name");
-    let controller_name = ControllerName::from_str(ZK_CONTROLLER_NAME)
-        .expect("ZK_CONTROLLER_NAME should be a valid controller name");
-    let role_name =
-        RoleName::from_str(&role.to_string()).expect("role name should be a valid role name");
-
     let pdb = pod_disruption_budget_builder_with_role(
-        validated_cluster,
-        &product_name,
-        &role_name,
-        &operator_name,
-        &controller_name,
+        cluster,
+        &product_name(),
+        &ValidatedCluster::role_name(),
+        &operator_name(),
+        &controller_name(),
     )
     .with_max_unavailable(max_unavailable)
     .build();

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

@@ -1,11 +1,7 @@
 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, operator::RoleGroupName},
-    },
+    v2::types::{common::Port, operator::RoleGroupName},
 };
 
 use crate::{
@@ -24,16 +20,14 @@ pub(crate) fn build_server_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();
 
     let service_spec = ServiceSpec {
@@ -73,15 +67,13 @@ pub(crate) fn build_server_rolegroup_metrics_service(
     rolegroup_config: &ValidatedRoleGroupConfig,
 ) -> Service {
     let metrics_port = cluster.metrics_http_port(rolegroup_config);
-    let metadata = ObjectMetaBuilder::new()
-        .name_and_namespace(cluster)
-        .name(
+    let metadata = cluster
+        .object_meta(
             cluster
                 .resource_names(role_group_name)
                 .metrics_service_name(),
+            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(metrics_port.clone()))
         .build();

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

@@ -37,14 +37,11 @@ use stackable_operator::{
     },
     utils::COMMON_BASH_TRAP_FUNCTIONS,
     v2::{
-        builder::{
-            meta::ownerreference_from_resource,
-            pod::container::{EnvVarName, EnvVarSet},
-        },
+        builder::pod::container::{EnvVarName, EnvVarSet},
         product_logging::framework::{ValidatedContainerLogConfigChoice, vector_container},
         types::{
             kubernetes::{ContainerName, VolumeName},
-            operator::{ProductVersion, RoleGroupName},
+            operator::RoleGroupName,
         },
     },
 };
@@ -61,6 +58,7 @@ use crate::{
     zk_controller::{
         LISTENER_VOLUME_DIR, LISTENER_VOLUME_NAME,
         build::{
+            UNVERSIONED_PRODUCT_VERSION,
             command::create_init_container_command_args,
             graceful_shutdown::add_graceful_shutdown_config,
             jvm::{construct_non_heap_jvm_args, construct_zk_server_heap_env},
@@ -197,12 +195,10 @@ pub fn build_server_rolegroup_statefulset(
         ContainerBuilder::new(APP_NAME).expect("invalid hard-coded container name");
     let mut pod_builder = PodBuilder::new();
 
-    // Used for PVC templates that cannot be modified once they are deployed. A version value is
-    // required, so a constant "none" is used to keep the labels stable across version upgrades.
-    let unversioned_recommended_labels = cluster.recommended_labels_for(
-        &ProductVersion::from_str("none").expect("'none' is a valid product version"),
-        role_group_name,
-    );
+    // Used for PVC templates that cannot be modified once they are deployed. A constant version
+    // keeps the labels stable across version upgrades.
+    let unversioned_recommended_labels =
+        cluster.recommended_labels_for(&UNVERSIONED_PRODUCT_VERSION, role_group_name);
 
     let listener_pvc = build_role_listener_pvc(
         role_listener_name(cluster.name.as_ref(), &ZookeeperRole::Server).as_ref(),
@@ -436,11 +432,11 @@ pub fn build_server_rolegroup_statefulset(
     let mut pod_template = pod_builder.build_template();
     pod_template.merge_from(rolegroup_config.pod_overrides.clone());
 
-    let 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(cluster.recommended_labels(role_group_name))
+    let metadata = cluster
+        .object_meta(
+            resource_names.stateful_set_name().to_string(),
+            role_group_name,
+        )
         .with_label(RESTART_CONTROLLER_ENABLED_LABEL.to_owned())
         .build();
 

rust/operator-binary/src/zk_controller/validate.rs

@@ -11,6 +11,7 @@ use std::{collections::BTreeMap, str::FromStr};
 
 use snafu::{OptionExt, ResultExt, Snafu};
 use stackable_operator::{
+    builder::meta::ObjectMetaBuilder,
     cli::OperatorEnvironmentOptions,
     commons::{
         cluster_operation::ClusterOperation,
@@ -26,7 +27,10 @@ use stackable_operator::{
     utils::cluster_info::KubernetesClusterInfo,
     v2::{
         HasName, HasUid, NameIsValidLabelValue,
-        builder::pod::container::{self, EnvVarName, EnvVarSet},
+        builder::{
+            meta::ownerreference_from_resource,
+            pod::container::{self, EnvVarName, EnvVarSet},
+        },
         controller_utils::{get_cluster_name, get_namespace, get_uid},
         jvm_argument_overrides::JvmArgumentOverrides,
         kvp::label::{recommended_labels, role_group_selector},
@@ -314,6 +318,25 @@ impl ValidatedCluster {
     pub fn role_group_selector(&self, role_group_name: &RoleGroupName) -> Labels {
         role_group_selector(self, &product_name(), &Self::role_name(), role_group_name)
     }
+
+    /// Returns an [`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.
+    pub(crate) fn object_meta(
+        &self,
+        name: impl Into<String>,
+        role_group_name: &RoleGroupName,
+    ) -> ObjectMetaBuilder {
+        let mut builder = ObjectMetaBuilder::new();
+        builder
+            .name_and_namespace(self)
+            .name(name)
+            .ownerreference(ownerreference_from_resource(self, None, Some(true)))
+            .with_labels(self.recommended_labels(role_group_name));
+        builder
+    }
 }
 
 /// The product name (`zookeeper`) as a type-safe label value.
@@ -327,7 +350,7 @@ pub(crate) fn operator_name() -> OperatorName {
 }
 
 /// The controller name as a type-safe label value.
-fn controller_name() -> ControllerName {
+pub(crate) fn controller_name() -> ControllerName {
     ControllerName::from_str(ZK_CONTROLLER_NAME)
         .expect("the controller name is a valid label value")
 }