chore: Add demo/stack labels if applicable

xeniape · xeniape · commit 5a59aaa2d968 · 2026-03-03T17:37:18.000+01:00
diff --git a/rust/operator-binary/src/container.rs b/rust/operator-binary/src/container.rs
@@ -37,7 +37,7 @@ use stackable_operator::{
         apimachinery::pkg::util::intstr::IntOrString,
     },
     kube::{ResourceExt, core::ObjectMeta},
-    kvp::Labels,
+    kvp::{LabelExt, Labels},
     product_logging::{
         self,
         framework::{
@@ -428,13 +428,19 @@ impl ContainerConfig {
                 .unwrap();
 
                 let pvcs = vec![
-                    node.resources.storage.data.build_pvc(
-                        ContainerConfig::DATA_VOLUME_MOUNT_NAME,
-                        Some(vec!["ReadWriteOnce"]),
-                    ),
+                    node.resources
+                        .storage
+                        .data
+                        .build_pvc(
+                            ContainerConfig::DATA_VOLUME_MOUNT_NAME,
+                            Some(vec!["ReadWriteOnce"]),
+                        )
+                        .add_labels(labels.clone())
+                        .to_owned(),
                     PersistentVolumeClaim {
                         metadata: ObjectMeta {
                             name: Some(LISTENER_VOLUME_NAME.to_string()),
+                            labels: Some(labels.clone().into()),
                             ..listener.metadata.unwrap()
                         },
                         spec: Some(listener.spec),
@@ -444,14 +450,24 @@ impl ContainerConfig {
 
                 Ok(pvcs)
             }
-            AnyNodeConfig::Journal(node) => Ok(vec![node.resources.storage.data.build_pvc(
-                ContainerConfig::DATA_VOLUME_MOUNT_NAME,
-                Some(vec!["ReadWriteOnce"]),
-            )]),
+            AnyNodeConfig::Journal(node) => Ok(vec![
+                node.resources
+                    .storage
+                    .data
+                    .build_pvc(
+                        ContainerConfig::DATA_VOLUME_MOUNT_NAME,
+                        Some(vec!["ReadWriteOnce"]),
+                    )
+                    .add_labels(labels.clone())
+                    .to_owned(),
+            ]),
             AnyNodeConfig::Data(node) => Ok(DataNodeStorageConfig {
                 pvcs: node.resources.storage.clone(),
             }
-            .build_pvcs()),
+            .build_pvcs()
+            .into_iter()
+            .map(|mut pvc| pvc.add_labels(labels.clone()).to_owned())
+            .collect()),
         }
     }
 
diff --git a/rust/operator-binary/src/crd/storage.rs b/rust/operator-binary/src/crd/storage.rs
@@ -156,10 +156,11 @@ fn default_number_of_datanode_pvcs() -> Option<u16> {
     Some(1)
 }
 
-#[derive(Clone, Debug, Deserialize, Eq, JsonSchema, PartialEq, Serialize)]
+#[derive(Clone, Debug, Deserialize, Eq, JsonSchema, PartialEq, Serialize, Default)]
 #[serde(rename_all = "PascalCase")]
 pub enum HdfsStorageType {
     Archive,
+    #[default]
     Disk,
     #[serde(rename = "SSD")]
     Ssd,
@@ -169,12 +170,6 @@ pub enum HdfsStorageType {
 
 impl Atomic for HdfsStorageType {}
 
-impl Default for HdfsStorageType {
-    fn default() -> Self {
-        Self::Disk
-    }
-}
-
 impl HdfsStorageType {
     pub fn as_hdfs_config_literal(&self) -> &str {
         match self {
diff --git a/rust/operator-binary/src/discovery.rs b/rust/operator-binary/src/discovery.rs
@@ -4,6 +4,7 @@ use stackable_operator::{
     commons::product_image_selection::ResolvedProductImage,
     k8s_openapi::api::core::v1::ConfigMap,
     kube::{ResourceExt, runtime::reflector::ObjectRef},
+    kvp::{LabelError, Labels},
     utils::cluster_info::KubernetesClusterInfo,
 };
 
@@ -15,6 +16,7 @@ use crate::{
         constants::{CORE_SITE_XML, HDFS_SITE_XML},
         v1alpha1,
     },
+    labels::add_stackable_labels,
     security::kerberos,
 };
 
@@ -39,6 +41,9 @@ pub enum Error {
         source: stackable_operator::builder::meta::Error,
     },
 
+    #[snafu(display("failed to build stackable label"))]
+    BuildStackableLabel { source: LabelError },
+
     #[snafu(display("failed to build security discovery config map"))]
     BuildSecurityDiscoveryConfigMap { source: kerberos::Error },
 }
@@ -66,6 +71,10 @@ pub fn build_discovery_configmap(
             "discovery",
         ))
         .context(ObjectMetaSnafu)?
+        .with_labels(
+            add_stackable_labels(Labels::new(), hdfs.metadata.labels.clone())
+                .context(BuildStackableLabelSnafu)?,
+        )
         .build();
 
     ConfigMapBuilder::new()
diff --git a/rust/operator-binary/src/event.rs b/rust/operator-binary/src/event.rs
@@ -60,7 +60,7 @@ pub fn build_invalid_replica_message(
         Some(format!(
             "{role_name}: only has {replicas} replicas configured, it is strongly recommended to use at least [{min_replicas}]"
         ))
-    } else if !role.replicas_can_be_even() && replicas % 2 == 0 {
+    } else if !role.replicas_can_be_even() && replicas.is_multiple_of(2) {
         Some(format!(
             "{role_name}: currently has an even number of replicas [{replicas}], but should always have an odd number to ensure quorum"
         ))
diff --git a/rust/operator-binary/src/hdfs_controller.rs b/rust/operator-binary/src/hdfs_controller.rs
@@ -63,6 +63,7 @@ use crate::{
     },
     discovery::{self, build_discovery_configmap},
     event::{build_invalid_replica_message, publish_warning_event},
+    labels::add_stackable_labels,
     operations::{
         graceful_shutdown::{self, add_graceful_shutdown_config},
         pdb::add_pdbs,
@@ -222,6 +223,9 @@ pub enum Error {
     #[snafu(display("failed to build cluster resources label"))]
     BuildClusterResourcesLabel { source: LabelError },
 
+    #[snafu(display("failed to build stackable label"))]
+    BuildStackableLabel { source: LabelError },
+
     #[snafu(display("failed to build role-group volume claim templates from config"))]
     BuildRoleGroupVolumeClaimTemplates { source: container::Error },
 
@@ -320,9 +324,13 @@ pub async fn reconcile_hdfs(
     let (rbac_sa, rbac_rolebinding) = build_rbac_resources(
         hdfs,
         APP_NAME,
-        cluster_resources
-            .get_required_labels()
-            .context(BuildClusterResourcesLabelSnafu)?,
+        add_stackable_labels(
+            cluster_resources
+                .get_required_labels()
+                .context(BuildClusterResourcesLabelSnafu)?,
+            hdfs.metadata.labels.clone(),
+        )
+        .context(BuildStackableLabelSnafu)?,
     )
     .context(BuildRbacResourcesSnafu)?;
 
@@ -383,12 +391,6 @@ pub async fn reconcile_hdfs(
         }
 
         for (rolegroup_name, rolegroup_config) in group_config.iter() {
-            let merged_config = role
-                .merged_config(hdfs, rolegroup_name)
-                .context(ConfigMergeSnafu)?;
-
-            let env_overrides = rolegroup_config.get(&PropertyNameKind::Env);
-
             let rolegroup_ref = hdfs.rolegroup_ref(role_name, rolegroup_name);
 
             let rg_service =
@@ -398,6 +400,26 @@ pub async fn reconcile_hdfs(
                 rolegroup_metrics_service(hdfs, &role, &rolegroup_ref, &resolved_product_image)
                     .context(BuildServiceSnafu)?;
 
+            let rg_service_name = rg_service.name_any();
+            let rg_metrics_service_name = rg_metrics_service.name_any();
+
+            cluster_resources
+                .add(client, rg_service)
+                .await
+                .with_context(|_| ApplyRoleGroupServiceSnafu {
+                    name: rg_service_name,
+                })?;
+            cluster_resources
+                .add(client, rg_metrics_service)
+                .await
+                .with_context(|_| ApplyRoleGroupServiceSnafu {
+                    name: rg_metrics_service_name,
+                })?;
+
+            let merged_config = role
+                .merged_config(hdfs, rolegroup_name)
+                .context(ConfigMergeSnafu)?;
+
             // We need to split the creation and the usage of the "metadata" variable in two statements.
             // to avoid the compiler error "E0716 (temporary value dropped while borrowed)".
             let mut metadata = ObjectMetaBuilder::new();
@@ -415,7 +437,11 @@ pub async fn reconcile_hdfs(
                     &rolegroup_ref.role,
                     &rolegroup_ref.role_group,
                 ))
-                .context(ObjectMetaSnafu)?;
+                .context(ObjectMetaSnafu)?
+                .with_labels(
+                    add_stackable_labels(Labels::new(), hdfs.metadata.labels.clone())
+                        .context(BuildStackableLabelSnafu)?,
+                );
 
             let rg_configmap = rolegroup_config_map(
                 hdfs,
@@ -429,6 +455,17 @@ pub async fn reconcile_hdfs(
                 &hdfs_opa_config,
             )?;
 
+            let rg_configmap_name = rg_configmap.name_any();
+
+            cluster_resources
+                .add(client, rg_configmap.clone())
+                .await
+                .with_context(|_| ApplyRoleGroupConfigMapSnafu {
+                    name: rg_configmap_name,
+                })?;
+
+            let env_overrides = rolegroup_config.get(&PropertyNameKind::Env);
+
             let rg_statefulset = rolegroup_statefulset(
                 hdfs,
                 &client.kubernetes_cluster_info,
@@ -442,29 +479,6 @@ pub async fn reconcile_hdfs(
                 &rbac_sa,
             )?;
 
-            let rg_service_name = rg_service.name_any();
-            let rg_metrics_service_name = rg_metrics_service.name_any();
-
-            cluster_resources
-                .add(client, rg_service)
-                .await
-                .with_context(|_| ApplyRoleGroupServiceSnafu {
-                    name: rg_service_name,
-                })?;
-            cluster_resources
-                .add(client, rg_metrics_service)
-                .await
-                .with_context(|_| ApplyRoleGroupServiceSnafu {
-                    name: rg_metrics_service_name,
-                })?;
-            let rg_configmap_name = rg_configmap.name_any();
-            cluster_resources
-                .add(client, rg_configmap.clone())
-                .await
-                .with_context(|_| ApplyRoleGroupConfigMapSnafu {
-                    name: rg_configmap_name,
-                })?;
-
             // Note: The StatefulSet needs to be applied after all ConfigMaps and Secrets it mounts
             // to prevent unnecessary Pod restarts.
             // See https://github.com/stackabletech/commons-operator/issues/111 for details.
@@ -865,7 +879,11 @@ fn rolegroup_statefulset(
         env_overrides,
         &hdfs.spec.cluster_config.zookeeper_config_map_name,
         namenode_podrefs,
-        &rolegroup_selector_labels,
+        &add_stackable_labels(
+            rolegroup_selector_labels.clone(),
+            hdfs.metadata.labels.clone(),
+        )
+        .context(BuildStackableLabelSnafu)?,
     )
     .context(FailedToCreateContainerAndVolumeConfigurationSnafu)?;
 
@@ -881,8 +899,15 @@ fn rolegroup_statefulset(
     }
 
     // The same comment regarding labels is valid here as it is for the ContainerConfig::add_containers_and_volumes() call above.
-    let pvcs = ContainerConfig::volume_claim_templates(merged_config, &rolegroup_selector_labels)
-        .context(BuildRoleGroupVolumeClaimTemplatesSnafu)?;
+    let pvcs = ContainerConfig::volume_claim_templates(
+        merged_config,
+        &add_stackable_labels(
+            rolegroup_selector_labels.clone(),
+            hdfs.metadata.labels.clone(),
+        )
+        .context(BuildStackableLabelSnafu)?,
+    )
+    .context(BuildRoleGroupVolumeClaimTemplatesSnafu)?;
 
     let statefulset_spec = StatefulSetSpec {
         pod_management_policy: Some("OrderedReady".to_string()),
diff --git a/rust/operator-binary/src/labels.rs b/rust/operator-binary/src/labels.rs
@@ -0,0 +1,25 @@
+use std::collections::BTreeMap;
+
+use stackable_operator::kvp::{Label, LabelError, Labels};
+
+/// Add Stackable stack/demo labels to the provided Labels if present in the cluster labels
+///
+/// These Stackable labels are used, for example, by stackablectl to delete stack/demo resources
+/// The "stackable.tech/vendor" label is already added by [`ObjectMetaBuilder::with_recommended_labels()`]
+pub(crate) fn add_stackable_labels(
+    mut labels: Labels,
+    cluster_labels: Option<BTreeMap<String, String>>,
+) -> Result<Labels, LabelError> {
+    if let Some(cluster_labels) = cluster_labels {
+        for (key, value) in cluster_labels {
+            match key.as_str() {
+                "stackable.tech/stack" | "stackable.tech/demo" => {
+                    labels.insert(Label::try_from((key, value))?);
+                }
+                _ => {}
+            }
+        }
+    }
+
+    Ok(labels)
+}
diff --git a/rust/operator-binary/src/main.rs b/rust/operator-binary/src/main.rs
@@ -48,6 +48,7 @@ mod discovery;
 mod event;
 mod hdfs_clusterrolebinding_nodes_controller;
 mod hdfs_controller;
+mod labels;
 mod operations;
 mod product_logging;
 mod security;
diff --git a/rust/operator-binary/src/operations/pdb.rs b/rust/operator-binary/src/operations/pdb.rs
@@ -2,14 +2,19 @@ use std::cmp::{max, min};
 
 use snafu::{ResultExt, Snafu};
 use stackable_operator::{
-    builder::pdb::PodDisruptionBudgetBuilder, client::Client, cluster_resources::ClusterResources,
-    commons::pdb::PdbConfig, kube::ResourceExt,
+    builder::pdb::PodDisruptionBudgetBuilder,
+    client::Client,
+    cluster_resources::ClusterResources,
+    commons::pdb::PdbConfig,
+    kube::ResourceExt,
+    kvp::{LabelError, LabelExt, Labels},
 };
 
 use crate::{
     OPERATOR_NAME,
     crd::{HdfsNodeRole, constants::APP_NAME, v1alpha1},
     hdfs_controller::RESOURCE_MANAGER_HDFS_CONTROLLER,
+    labels::add_stackable_labels,
 };
 
 #[derive(Snafu, Debug)]
@@ -25,6 +30,9 @@ pub enum Error {
         source: stackable_operator::cluster_resources::Error,
         name: String,
     },
+
+    #[snafu(display("failed to build stackable label"))]
+    BuildStackableLabel { source: LabelError },
 }
 
 pub async fn add_pdbs(
@@ -45,7 +53,7 @@ pub async fn add_pdbs(
         ),
         HdfsNodeRole::Journal => max_unavailable_journal_nodes(),
     });
-    let pdb = PodDisruptionBudgetBuilder::new_with_role(
+    let mut pdb = PodDisruptionBudgetBuilder::new_with_role(
         hdfs,
         APP_NAME,
         &role.to_string(),
@@ -57,6 +65,12 @@ pub async fn add_pdbs(
     })?
     .with_max_unavailable(max_unavailable)
     .build();
+
+    pdb.add_labels(
+        add_stackable_labels(Labels::new(), hdfs.metadata.labels.clone())
+            .context(BuildStackableLabelSnafu)?,
+    );
+
     let pdb_name = pdb.name_any();
     cluster_resources
         .add(client, pdb)
diff --git a/rust/operator-binary/src/service.rs b/rust/operator-binary/src/service.rs
