replace role_name with From impls, add missing labels

Author: adwk67

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

@@ -365,6 +365,61 @@ mod tests {
         names
     }
 
+    /// Every metrics Service must carry the Prometheus scrape label and the
+    /// `prometheus.io/path|port|scheme|scrape` annotations, or Prometheus stops discovering the
+    /// endpoints (caught by the HDFS smoke test 2026-07-23 after the labels migration dropped
+    /// them).
+    #[test]
+    fn metrics_services_carry_prometheus_label_and_annotations() {
+        let cluster = validated_cluster();
+        let resources = build(&cluster, &cluster_info()).expect("build succeeds");
+
+        let metrics_services: Vec<_> = resources
+            .services
+            .iter()
+            .filter(|service| {
+                service
+                    .metadata
+                    .name
+                    .as_deref()
+                    .is_some_and(|name| name.ends_with("-metrics"))
+            })
+            .collect();
+        assert!(!metrics_services.is_empty(), "no metrics Services built");
+
+        for service in metrics_services {
+            let name = service.metadata.name.as_deref().unwrap_or_default();
+            let labels = service.metadata.labels.as_ref().expect("labels are set");
+            assert_eq!(
+                labels.get("prometheus.io/scrape").map(String::as_str),
+                Some("true"),
+                "{name} lacks the scrape label"
+            );
+
+            // The native metrics port of the role, as asserted by the smoke test.
+            let expected_port = match name {
+                n if n.contains("-namenode-") => "9870",
+                n if n.contains("-datanode-") => "9864",
+                n if n.contains("-journalnode-") => "8480",
+                other => panic!("unexpected metrics Service {other}"),
+            };
+            let expected_annotations = BTreeMap::from(
+                [
+                    ("prometheus.io/path", "/prom"),
+                    ("prometheus.io/port", expected_port),
+                    ("prometheus.io/scheme", "http"),
+                    ("prometheus.io/scrape", "true"),
+                ]
+                .map(|(key, value)| (key.to_string(), value.to_string())),
+            );
+            assert_eq!(
+                service.metadata.annotations.as_ref(),
+                Some(&expected_annotations),
+                "{name} annotations mismatch"
+            );
+        }
+    }
+
     /// The aggregator emits, for the minimal three-role cluster (one `default` role group each):
     /// one StatefulSet and one ConfigMap per role group, one headless plus one metrics Service per
     /// role group, and one default PDB per role.

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

@@ -63,7 +63,7 @@ pub fn build_discovery_config_map(
         &operator_name(),
         &ControllerName::from_str(HDFS_CONTROLLER_NAME)
             .expect("the hdfs controller name is a valid label value"),
-        &ValidatedCluster::role_name(&HdfsNodeRole::Name),
+        &HdfsNodeRole::Name.into(),
         &DISCOVERY_ROLE_GROUP,
     );
 

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

@@ -5,7 +5,10 @@ use snafu::{ResultExt, Snafu};
 use stackable_operator::{
     k8s_openapi::api::core::v1::{Service, ServicePort, ServiceSpec},
     kvp::LabelError,
-    v2::types::operator::RoleGroupName,
+    v2::{
+        builder::service::{Scheme, Scraping, prometheus_annotations, prometheus_labels},
+        types::operator::RoleGroupName,
+    },
 };
 
 use crate::{
@@ -111,6 +114,17 @@ pub(crate) fn rolegroup_metrics_service(
                     .to_string(),
                 cluster.recommended_labels(role, role_group_name),
             )
+            .with_labels(prometheus_labels(&Scraping::Enabled))
+            .with_annotations(prometheus_annotations(
+                &Scraping::Enabled,
+                if cluster.has_https_enabled() {
+                    &Scheme::Https
+                } else {
+                    &Scheme::Http
+                },
+                "/prom",
+                &build::native_metrics_port(cluster, role),
+            ))
             .build(),
         spec: Some(service_spec),
         status: None,

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

@@ -149,10 +149,6 @@ impl ValidatedCluster {
     }
 
     /// The type-safe role name for an HDFS role (`namenode`/`datanode`/`journalnode`).
-    pub(crate) fn role_name(role: &HdfsNodeRole) -> RoleName {
-        RoleName::from_str(&role.to_string()).expect("a HdfsNodeRole is a valid role name")
-    }
-
     /// Type-safe names for the per-cluster RBAC resources: the ServiceAccount shared by all
     /// Pods, its (namespaced) RoleBinding, and the operator-deployed ClusterRole it binds.
     pub fn cluster_resource_names(&self) -> role_utils::ResourceNames {
@@ -170,7 +166,7 @@ impl ValidatedCluster {
     ) -> ResourceNames {
         ResourceNames {
             cluster_name: self.name.clone(),
-            role_name: Self::role_name(role),
+            role_name: role.into(),
             role_group_name: role_group_name.clone(),
         }
     }
@@ -207,7 +203,7 @@ impl ValidatedCluster {
         role: &HdfsNodeRole,
         role_group_name: &RoleGroupName,
     ) -> Labels {
-        self.recommended_labels_for(&Self::role_name(role), role_group_name)
+        self.recommended_labels_for(&role.into(), role_group_name)
     }
 
     /// Returns an [`ObjectMetaBuilder`] pre-filled with the namespace, the resource `name`, an owner
@@ -382,17 +378,18 @@ pub struct ValidatedRoleConfig {
 
 #[cfg(test)]
 mod tests {
+    use stackable_operator::v2::types::operator::RoleName;
     use strum::IntoEnumIterator;
 
-    use super::ValidatedCluster;
     use crate::crd::HdfsNodeRole;
 
-    /// Locks the invariant behind the `expect` in [`ValidatedCluster::role_name`]: every
-    /// `HdfsNodeRole` variant (present and future) must serialise to a valid `RoleName`.
+    /// Locks the invariant behind the `expect` in the `From<HdfsNodeRole> for RoleName` impls:
+    /// every `HdfsNodeRole` variant (present and future) must serialise to a valid `RoleName`.
     #[test]
     fn every_hdfs_node_role_serialises_to_a_valid_role_name() {
         for role in HdfsNodeRole::iter() {
-            ValidatedCluster::role_name(&role);
+            let _: RoleName = (&role).into();
+            let _: RoleName = role.into();
         }
     }
 }

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

@@ -43,6 +43,7 @@ use stackable_operator::{
         types::{
             common::Port,
             kubernetes::{ConfigMapName, ListenerClassName, NamespaceName, ServiceName},
+            operator::RoleName,
         },
     },
     versioned::versioned,
@@ -497,6 +498,18 @@ pub enum HdfsNodeRole {
     Data,
 }
 
+impl From<HdfsNodeRole> for RoleName {
+    fn from(value: HdfsNodeRole) -> Self {
+        RoleName::from_str(&value.to_string()).expect("a HdfsNodeRole is a valid role name")
+    }
+}
+
+impl From<&HdfsNodeRole> for RoleName {
+    fn from(value: &HdfsNodeRole) -> Self {
+        RoleName::from_str(&value.to_string()).expect("a HdfsNodeRole is a valid role name")
+    }
+}
+
 impl HdfsNodeRole {
     pub fn min_replicas(&self) -> u16 {
         match self {