refactor: use v2 labeling

maltesander · maltesander · commit 8284feedf7e8 · 2026-06-15T18:57:05.000+02:00
diff --git a/rust/operator-binary/src/controller/build/resource/config_map.rs b/rust/operator-binary/src/controller/build/resource/config_map.rs
@@ -6,7 +6,7 @@ use snafu::{OptionExt, ResultExt, Snafu};
 use stackable_operator::{
     builder::{configmap::ConfigMapBuilder, meta::ObjectMetaBuilder},
     k8s_openapi::api::core::v1::ConfigMap,
-    kvp::ObjectLabels,
+    kvp::Labels,
     product_logging::framework::VECTOR_CONFIG_FILE,
     utils::cluster_info::KubernetesClusterInfo,
     v2::config_file_writer::to_java_properties_string,
@@ -64,7 +64,7 @@ pub fn build_rolegroup_config_map(
     role: &TrinoRole,
     role_group_name: &str,
     cluster_info: &KubernetesClusterInfo,
-    recommended_labels: &ObjectLabels<'_, ValidatedCluster>,
+    recommended_labels: &Labels,
 ) -> Result<ConfigMap> {
     let role_group_configs =
         cluster
@@ -196,8 +196,7 @@ pub fn build_rolegroup_config_map(
                 .namespace(cluster.namespace.to_string())
                 .ownerreference_from_resource(cluster, None, Some(true))
                 .context(MetadataSnafu)?
-                .with_recommended_labels(recommended_labels)
-                .context(MetadataSnafu)?
+                .with_labels(recommended_labels.clone())
                 .build(),
         )
         .data(data)
@@ -213,7 +212,7 @@ pub fn build_rolegroup_catalog_config_map(
     cluster: &ValidatedCluster,
     role: &TrinoRole,
     role_group_name: &str,
-    recommended_labels: &ObjectLabels<'_, ValidatedCluster>,
+    recommended_labels: &Labels,
 ) -> Result<ConfigMap> {
     let catalog_config_map_name = format!(
         "{}-catalog",
@@ -228,8 +227,7 @@ pub fn build_rolegroup_catalog_config_map(
                 .namespace(cluster.namespace.to_string())
                 .ownerreference_from_resource(cluster, None, Some(true))
                 .context(MetadataSnafu)?
-                .with_recommended_labels(recommended_labels)
-                .context(MetadataSnafu)?
+                .with_labels(recommended_labels.clone())
                 .build(),
         )
         .data(
diff --git a/rust/operator-binary/src/controller/build/resource/listener.rs b/rust/operator-binary/src/controller/build/resource/listener.rs
@@ -7,7 +7,7 @@ use stackable_operator::{
     crd::listener::v1alpha1::{Listener, ListenerPort, ListenerSpec},
     k8s_openapi::api::core::v1::PersistentVolumeClaim,
     kube::ResourceExt,
-    kvp::{Labels, ObjectLabels},
+    kvp::Labels,
 };
 
 use crate::{
@@ -25,11 +25,6 @@ pub enum Error {
         source: stackable_operator::builder::meta::Error,
     },
 
-    #[snafu(display("failed to build listener object meta data"))]
-    BuildObjectMeta {
-        source: stackable_operator::builder::meta::Error,
-    },
-
     #[snafu(display("failed to build listener volume"))]
     BuildListenerPersistentVolume {
         source: stackable_operator::builder::pod::volume::ListenerOperatorVolumeSourceBuilderError,
@@ -38,7 +33,7 @@ pub enum Error {
 
 pub fn build_group_listener(
     cluster: &ValidatedCluster,
-    object_labels: ObjectLabels<ValidatedCluster>,
+    recommended_labels: Labels,
     listener_class: String,
     listener_group_name: String,
 ) -> Result<Listener, Error> {
@@ -48,8 +43,7 @@ pub fn build_group_listener(
             .name(listener_group_name)
             .ownerreference_from_resource(cluster, None, Some(true))
             .context(ObjectMissingMetadataForOwnerRefSnafu)?
-            .with_recommended_labels(&object_labels)
-            .context(BuildObjectMetaSnafu)?
+            .with_labels(recommended_labels)
             .build(),
         spec: ListenerSpec {
             class_name: Some(listener_class),
diff --git a/rust/operator-binary/src/controller/build/resource/service.rs b/rust/operator-binary/src/controller/build/resource/service.rs
@@ -4,7 +4,7 @@ use snafu::{ResultExt, Snafu};
 use stackable_operator::{
     builder::meta::ObjectMetaBuilder,
     k8s_openapi::api::core::v1::{Service, ServicePort, ServiceSpec},
-    kvp::{Annotations, Labels, ObjectLabels},
+    kvp::{Annotations, Labels},
 };
 
 use crate::{
@@ -18,11 +18,6 @@ pub enum Error {
     ObjectMissingMetadataForOwnerRef {
         source: stackable_operator::builder::meta::Error,
     },
-
-    #[snafu(display("failed to build Metadata"))]
-    MetadataBuild {
-        source: stackable_operator::builder::meta::Error,
-    },
 }
 
 /// The rolegroup headless [`Service`] is a service that allows direct access to the instances of a certain rolegroup
@@ -31,7 +26,7 @@ pub fn build_rolegroup_headless_service(
     cluster: &ValidatedCluster,
     role: &TrinoRole,
     role_group_name: &str,
-    object_labels: &ObjectLabels<ValidatedCluster>,
+    recommended_labels: &Labels,
     selector: BTreeMap<String, String>,
     ports: Vec<ServicePort>,
 ) -> Result<Service, Error> {
@@ -46,8 +41,7 @@ pub fn build_rolegroup_headless_service(
             )
             .ownerreference_from_resource(cluster, None, Some(true))
             .context(ObjectMissingMetadataForOwnerRefSnafu)?
-            .with_recommended_labels(object_labels)
-            .context(MetadataBuildSnafu)?
+            .with_labels(recommended_labels.clone())
             .build(),
         spec: Some(ServiceSpec {
             // Internal communication does not need to be exposed
@@ -67,7 +61,7 @@ pub fn build_rolegroup_metrics_service(
     cluster: &ValidatedCluster,
     role: &TrinoRole,
     role_group_name: &str,
-    object_labels: &ObjectLabels<ValidatedCluster>,
+    recommended_labels: &Labels,
     selector: BTreeMap<String, String>,
 ) -> Result<Service, Error> {
     Ok(Service {
@@ -81,8 +75,7 @@ pub fn build_rolegroup_metrics_service(
             )
             .ownerreference_from_resource(cluster, None, Some(true))
             .context(ObjectMissingMetadataForOwnerRefSnafu)?
-            .with_recommended_labels(object_labels)
-            .context(MetadataBuildSnafu)?
+            .with_labels(recommended_labels.clone())
             .with_labels(prometheus_labels())
             .with_annotations(prometheus_annotations())
             .build(),
diff --git a/rust/operator-binary/src/controller/build/resource/statefulset.rs b/rust/operator-binary/src/controller/build/resource/statefulset.rs
@@ -30,7 +30,7 @@ use stackable_operator::{
         },
         apimachinery::pkg::{apis::meta::v1::LabelSelector, util::intstr::IntOrString},
     },
-    kvp::{Annotation, Annotations, Labels},
+    kvp::{Annotation, Annotations},
     product_logging,
     shared::time::Duration,
     v2::{
@@ -54,7 +54,7 @@ use crate::{
         },
     },
     crd::{
-        APP_NAME, CONFIG_DIR_NAME, Container, ENV_INTERNAL_SECRET, ENV_SPOOLING_SECRET, HTTP_PORT,
+        CONFIG_DIR_NAME, Container, ENV_INTERNAL_SECRET, ENV_SPOOLING_SECRET, HTTP_PORT,
         HTTP_PORT_NAME, HTTPS_PORT, HTTPS_PORT_NAME, MAX_TRINO_LOG_FILES_SIZE, METRICS_PORT,
         METRICS_PORT_NAME, RW_CONFIG_DIR_NAME, STACKABLE_CLIENT_TLS_DIR,
         STACKABLE_INTERNAL_TLS_DIR, STACKABLE_MOUNT_INTERNAL_TLS_DIR,
@@ -63,7 +63,7 @@ use crate::{
     },
     trino_controller::{
         MAX_PREPARE_LOG_FILE_SIZE, STACKABLE_LOG_CONFIG_DIR, STACKABLE_LOG_DIR,
-        build_recommended_labels, shared_internal_secret_name, shared_spooling_secret_name,
+        shared_internal_secret_name, shared_spooling_secret_name,
     },
 };
 
@@ -168,7 +168,6 @@ pub fn build_rolegroup_statefulset(
         .rolegroup(trino_role, role_group_name)
         .context(InternalOperatorFailureSnafu)?;
 
-    let role_name = trino_role.to_string();
     let resource_names = cluster.resource_names(trino_role, role_group_name);
     let config_map_name = resource_names.role_group_config_map().to_string();
 
@@ -326,15 +325,10 @@ pub fn build_rolegroup_statefulset(
             .add_volume_mount(LISTENER_VOLUME_NAME, LISTENER_VOLUME_DIR)
             .context(AddVolumeMountSnafu)?;
 
-        // Used for PVC templates that cannot be modified once they are deployed
-        let unversioned_recommended_labels = Labels::recommended(&build_recommended_labels(
-            trino,
-            // A version value is required, and we do want to use the "recommended" format for the other desired labels
-            "none",
-            &role_name,
-            role_group_name,
-        ))
-        .context(LabelBuildSnafu)?;
+        // Used for PVC templates that cannot be modified once they are deployed, so a fixed
+        // "none" version is used while keeping the other recommended labels.
+        let unversioned_recommended_labels =
+            cluster.unversioned_recommended_labels(trino_role, role_group_name);
 
         persistent_volume_claims.push(
             build_group_listener_pvc(&group_listener_name, &unversioned_recommended_labels)
@@ -407,13 +401,7 @@ pub fn build_rolegroup_statefulset(
     }
 
     let metadata = ObjectMetaBuilder::new()
-        .with_recommended_labels(&build_recommended_labels(
-            trino,
-            &resolved_product_image.app_version_label_value,
-            &role_name,
-            role_group_name,
-        ))
-        .context(MetadataBuildSnafu)?
+        .with_labels(cluster.recommended_labels(trino_role, role_group_name))
         .with_annotation(
             // This is actually used by some kuttl tests (as they don't specify the container explicitly)
             Annotation::try_from(("kubectl.kubernetes.io/default-container", "trino"))
@@ -481,13 +469,7 @@ pub fn build_rolegroup_statefulset(
             .name(resource_names.stateful_set_name().to_string())
             .ownerreference_from_resource(trino, None, Some(true))
             .context(ObjectMissingMetadataForOwnerRefSnafu)?
-            .with_recommended_labels(&build_recommended_labels(
-                trino,
-                &resolved_product_image.app_version_label_value,
-                &role_name,
-                role_group_name,
-            ))
-            .context(MetadataBuildSnafu)?
+            .with_labels(cluster.recommended_labels(trino_role, role_group_name))
             .with_label(RESTART_CONTROLLER_ENABLED_LABEL.to_owned())
             .with_annotations(annotations)
             .build(),
@@ -496,8 +478,8 @@ pub fn build_rolegroup_statefulset(
             replicas: rolegroup.replicas.map(i32::from),
             selector: LabelSelector {
                 match_labels: Some(
-                    Labels::role_group_selector(trino, APP_NAME, &role_name, role_group_name)
-                        .context(LabelBuildSnafu)?
+                    cluster
+                        .role_group_selector(trino_role, role_group_name)
                         .into(),
                 ),
                 ..LabelSelector::default()
diff --git a/rust/operator-binary/src/controller/mod.rs b/rust/operator-binary/src/controller/mod.rs
@@ -10,14 +10,16 @@ use stackable_operator::{
         resources::{NoRuntimeLimits, Resources},
     },
     kube::{Resource, api::ObjectMeta},
+    kvp::Labels,
     shared::time::Duration,
     v2::{
         HasName, HasUid, NameIsValidLabelValue,
+        kvp::label::{recommended_labels, role_group_selector},
         role_group_utils::ResourceNames,
         types::{
             kubernetes::{NamespaceName, Uid},
             operator::{
-                ClusterName, ControllerName, OperatorName, ProductName,
+                ClusterName, ControllerName, OperatorName, ProductName, ProductVersion,
                 RoleGroupName as RoleGroupNameV2, RoleName,
             },
         },
@@ -172,12 +174,71 @@ impl ValidatedCluster {
     pub(crate) fn resource_names(&self, role: &TrinoRole, role_group_name: &str) -> ResourceNames {
         ResourceNames {
             cluster_name: self.name.clone(),
-            role_name: RoleName::from_str(&role.to_string())
-                .expect("a TrinoRole is a valid RFC 1123 role name"),
-            role_group_name: RoleGroupNameV2::from_str(role_group_name)
-                .expect("a validated role group name is a valid role group name"),
+            role_name: Self::role_name(role),
+            role_group_name: Self::role_group_name(role_group_name),
         }
     }
+
+    /// A [`TrinoRole`] as a type-safe [`RoleName`].
+    fn role_name(role: &TrinoRole) -> RoleName {
+        RoleName::from_str(&role.to_string()).expect("a TrinoRole is a valid RFC 1123 role name")
+    }
+
+    /// A role-group name as a type-safe [`RoleGroupName`](RoleGroupNameV2).
+    fn role_group_name(role_group_name: &str) -> RoleGroupNameV2 {
+        RoleGroupNameV2::from_str(role_group_name)
+            .expect("a validated role group name is a valid role group name")
+    }
+
+    /// The version label value (`app.kubernetes.io/version`) as a type-safe [`ProductVersion`].
+    fn version_label(&self) -> ProductVersion {
+        ProductVersion::from_str(&self.image.app_version_label_value)
+            .expect("the app version label value is a valid product version")
+    }
+
+    fn recommended_labels_with_version(
+        &self,
+        version: &ProductVersion,
+        role: &TrinoRole,
+        role_group_name: &str,
+    ) -> Labels {
+        recommended_labels(
+            self,
+            &product_name(),
+            version,
+            &operator_name(),
+            &controller_name(),
+            &Self::role_name(role),
+            &Self::role_group_name(role_group_name),
+        )
+    }
+
+    /// Recommended labels for a role-group resource (using the resolved product version).
+    pub(crate) fn recommended_labels(&self, role: &TrinoRole, role_group_name: &str) -> Labels {
+        self.recommended_labels_with_version(&self.version_label(), role, role_group_name)
+    }
+
+    /// Recommended labels using a fixed `"none"` version, for resources whose labels must not
+    /// change after creation (e.g. listener PVC templates).
+    pub(crate) fn unversioned_recommended_labels(
+        &self,
+        role: &TrinoRole,
+        role_group_name: &str,
+    ) -> Labels {
+        let none = ProductVersion::from_str("none")
+            .expect("\"none\" is a valid product version label value");
+        self.recommended_labels_with_version(&none, role, role_group_name)
+    }
+
+    /// Selector labels matching the pods of a role group.
+    pub(crate) fn role_group_selector(&self, role: &TrinoRole, role_group_name: &str) -> Labels {
+        role_group_selector(
+            self,
+            &product_name(),
+            &Self::role_name(role),
+            &Self::role_group_name(role_group_name),
+        )
+    }
 }
 
 impl Resource for ValidatedCluster {
diff --git a/rust/operator-binary/src/trino_controller.rs b/rust/operator-binary/src/trino_controller.rs
