Add additional labels to the cluster manager service

Author: siegfriedweber

rust/operator-binary/src/controller.rs

@@ -255,8 +255,7 @@ pub async fn reconcile(
     .await
     .context(ApplyResourcesSnafu)?;
 
-    // create discovery ConfigMap
-    // TODO Think about: Address from Listener has to be added to some ConfigMap
+    // create discovery ConfigMap based on the applied resources (client required)
 
     // update status (client required)
     update_status(&context.client, &context.names, cluster, applied_resources)

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

@@ -20,7 +20,6 @@ use super::role_group_builder::{
 };
 use crate::{
     controller::{ContextNames, ValidatedCluster},
-    crd::v1alpha1,
     framework::{
         IsLabelValue,
         builder::{
@@ -113,18 +112,15 @@ impl<'a> RoleBuilder<'a> {
 
         let metadata = self.common_metadata(self.resource_names.discovery_service_name());
 
-        let service_selector = [(
-            v1alpha1::NodeRole::ClusterManager.to_string(),
-            "true".to_owned(),
-        )]
-        .into();
+        let service_selector =
+            RoleGroupBuilder::cluster_manager_labels(&self.cluster, self.context_names);
 
         let service_spec = ServiceSpec {
             // Internal communication does not need to be exposed
             type_: Some("ClusterIP".to_string()),
             cluster_ip: Some("None".to_string()),
             ports: Some(ports),
-            selector: Some(service_selector),
+            selector: Some(service_selector.into()),
             publish_not_ready_addresses: Some(true),
             ..ServiceSpec::default()
         };

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

@@ -19,10 +19,11 @@ use stackable_operator::{
 use super::node_config::{CONFIGURATION_FILE_OPENSEARCH_YML, NodeConfig};
 use crate::{
     controller::{ContextNames, OpenSearchRoleGroupConfig, ValidatedCluster},
+    crd::v1alpha1,
     framework::{
         RoleGroupName,
         builder::meta::ownerreference_from_resource,
-        kvp::label::{recommended_labels, role_group_selector},
+        kvp::label::{recommended_labels, role_group_selector, role_selector},
         role_group_utils::ResourceNames,
     },
 };
@@ -104,7 +105,6 @@ impl<'a> RoleGroupBuilder<'a> {
             .resources
             .storage
             .data
-            // TODO Compare name with Helm chart
             .build_pvc(DATA_VOLUME_NAME, Some(vec!["ReadWriteOnce"]));
 
         let spec = StatefulSetSpec {
@@ -131,11 +131,7 @@ impl<'a> RoleGroupBuilder<'a> {
     fn build_pod_template(&self) -> PodTemplateSpec {
         let mut node_role_labels = Labels::new();
         for node_role in self.role_group_config.config.node_roles.iter() {
-            node_role_labels.insert(
-                // TODO Prefix the key
-                Label::try_from((format!("{node_role}"), "true".to_string()))
-                    .expect("should be a valid label"),
-            );
+            node_role_labels.insert(Self::build_node_role_label(node_role));
         }
 
         let metadata = ObjectMetaBuilder::new()
@@ -197,6 +193,32 @@ impl<'a> RoleGroupBuilder<'a> {
         pod_template
     }
 
+    pub fn cluster_manager_labels(
+        cluster: &ValidatedCluster,
+        context_names: &ContextNames,
+    ) -> Labels {
+        let mut labels = role_selector(
+            cluster,
+            &context_names.product_name,
+            &ValidatedCluster::role_name(),
+        );
+
+        labels.insert(Self::build_node_role_label(
+            &v1alpha1::NodeRole::ClusterManager,
+        ));
+
+        labels
+    }
+
+    fn build_node_role_label(node_role: &v1alpha1::NodeRole) -> Label {
+        // TODO Check the maximum length at compile-time
+        Label::try_from((
+            format!("stackable.tech/opensearch-role.{node_role}"),
+            "true".to_string(),
+        ))
+        .expect("should be a valid label")
+    }
+
     fn build_container(&self, role_group_config: &OpenSearchRoleGroupConfig) -> Container {
         let product_image = self
             .cluster

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

@@ -9,13 +9,14 @@ use stackable_operator::{
 use strum::{EnumDiscriminants, IntoStaticStr};
 
 use super::{
-    ContextNames, ProductVersion, RoleGroupName, ValidatedCluster, ValidatedOpenSearchConfig,
+    ContextNames, OpenSearchRoleGroupConfig, ProductVersion, RoleGroupName, ValidatedCluster,
+    ValidatedOpenSearchConfig,
 };
 use crate::{
-    crd::v1alpha1::{self, OpenSearchConfig},
+    crd::v1alpha1::{self, OpenSearchConfig, OpenSearchConfigFragment},
     framework::{
         ClusterName,
-        role_utils::{RoleGroupConfig, with_validated_config},
+        role_utils::{GenericProductSpecificCommonConfig, RoleGroupConfig, with_validated_config},
     },
 };
 
@@ -54,10 +55,9 @@ pub enum Error {
 
 type Result<T, E = Error> = std::result::Result<T, E>;
 
-// TODO split
 // no client needed
 pub fn validate(
-    names: &ContextNames,
+    context_names: &ContextNames,
     cluster: &v1alpha1::OpenSearchCluster,
 ) -> Result<ValidatedCluster> {
     let raw_cluster_name = cluster.meta().name.clone().context(GetClusterNameSnafu)?;
@@ -75,43 +75,8 @@ pub fn validate(
         let role_group_name =
             RoleGroupName::from_str(raw_role_group_name).context(ParseRoleGroupNameSnafu)?;
 
-        let merged_role_group: RoleGroup<OpenSearchConfig, _> = with_validated_config(
-            role_group_config,
-            &cluster.spec.nodes,
-            &v1alpha1::OpenSearchConfig::default_config(
-                &names.product_name,
-                &cluster_name,
-                &ValidatedCluster::role_name(),
-            ),
-        )
-        .context(ValidateOpenSearchConfigSnafu)?;
-
-        let graceful_shutdown_timeout = merged_role_group.config.config.graceful_shutdown_timeout;
-
-        let termination_grace_period_seconds = graceful_shutdown_timeout
-            .as_secs()
-            .try_into()
-            .context(TerminationGracePeriodTooLongSnafu {
-                duration: graceful_shutdown_timeout,
-            })?;
-
-        let validated_config = ValidatedOpenSearchConfig {
-            affinity: merged_role_group.config.config.affinity,
-            node_roles: merged_role_group.config.config.node_roles,
-            resources: merged_role_group.config.config.resources,
-            termination_grace_period_seconds,
-        };
-
-        let validated_role_group_config = RoleGroupConfig {
-            // Kubernetes defaults to 1 if not set
-            replicas: merged_role_group.replicas.unwrap_or(1),
-            config: validated_config,
-            config_overrides: merged_role_group.config.config_overrides,
-            env_overrides: merged_role_group.config.env_overrides,
-            cli_overrides: merged_role_group.config.cli_overrides,
-            pod_overrides: merged_role_group.config.pod_overrides,
-            product_specific_common_config: merged_role_group.config.product_specific_common_config,
-        };
+        let validated_role_group_config =
+            validate_role_group_config(context_names, &cluster_name, cluster, role_group_config)?;
 
         role_group_configs.insert(role_group_name, validated_role_group_config);
     }
@@ -127,3 +92,46 @@ pub fn validate(
         role_group_configs,
     })
 }
+
+fn validate_role_group_config(
+    context_names: &ContextNames,
+    cluster_name: &ClusterName,
+    cluster: &v1alpha1::OpenSearchCluster,
+    role_group_config: &RoleGroup<OpenSearchConfigFragment, GenericProductSpecificCommonConfig>,
+) -> Result<OpenSearchRoleGroupConfig> {
+    let merged_role_group: RoleGroup<OpenSearchConfig, _> = with_validated_config(
+        role_group_config,
+        &cluster.spec.nodes,
+        &v1alpha1::OpenSearchConfig::default_config(
+            &context_names.product_name,
+            cluster_name,
+            &ValidatedCluster::role_name(),
+        ),
+    )
+    .context(ValidateOpenSearchConfigSnafu)?;
+
+    let graceful_shutdown_timeout = merged_role_group.config.config.graceful_shutdown_timeout;
+    let termination_grace_period_seconds = graceful_shutdown_timeout.as_secs().try_into().context(
+        TerminationGracePeriodTooLongSnafu {
+            duration: graceful_shutdown_timeout,
+        },
+    )?;
+
+    let validated_config = ValidatedOpenSearchConfig {
+        affinity: merged_role_group.config.config.affinity,
+        node_roles: merged_role_group.config.config.node_roles,
+        resources: merged_role_group.config.config.resources,
+        termination_grace_period_seconds,
+    };
+
+    Ok(RoleGroupConfig {
+        // Kubernetes defaults to 1 if not set
+        replicas: merged_role_group.replicas.unwrap_or(1),
+        config: validated_config,
+        config_overrides: merged_role_group.config.config_overrides,
+        env_overrides: merged_role_group.config.env_overrides,
+        cli_overrides: merged_role_group.config.cli_overrides,
+        pod_overrides: merged_role_group.config.pod_overrides,
+        product_specific_common_config: merged_role_group.config.product_specific_common_config,
+    })
+}

rust/operator-binary/src/framework/kvp/label.rs

@@ -33,6 +33,20 @@ pub fn recommended_labels(
         .expect("Labels should be created because all given parameters produce valid label values")
 }
 
+/// Infallible variant of `Labels::role_selector`
+pub fn role_selector(
+    owner: &(impl Resource + IsLabelValue),
+    product_name: &ProductName,
+    role_name: &RoleName,
+) -> Labels {
+    Labels::role_selector(
+        owner,
+        &product_name.to_label_value(),
+        &role_name.to_label_value(),
+    )
+    .expect("Labels should be created because all given parameters produce valid label values")
+}
+
 /// Infallible variant of `Labels::role_group_selector`
 pub fn role_group_selector(
     owner: &(impl Resource + IsLabelValue),

tests/templates/kuttl/smoke/10-assert.yaml

@@ -43,7 +43,7 @@ spec:
         app.kubernetes.io/name: opensearch
         app.kubernetes.io/role-group: cluster-manager
         app.kubernetes.io/version: 3.0.0
-        cluster_manager: "true"
+        stackable.tech/opensearch-role.cluster_manager: "true"
         stackable.tech/vendor: Stackable
     spec:
       affinity:
@@ -203,9 +203,9 @@ spec:
         app.kubernetes.io/name: opensearch
         app.kubernetes.io/role-group: data
         app.kubernetes.io/version: 3.0.0
-        data: "true"
-        ingest: "true"
-        remote_cluster_client: "true"
+        stackable.tech/opensearch-role.data: "true"
+        stackable.tech/opensearch-role.ingest: "true"
+        stackable.tech/opensearch-role.remote_cluster_client: "true"
         stackable.tech/vendor: Stackable
     spec:
       affinity:
@@ -455,6 +455,11 @@ metadata:
     app.kubernetes.io/version: 3.0.0
     stackable.tech/vendor: Stackable
   name: opensearch
+  ownerReferences:
+  - apiVersion: opensearch.stackable.tech/v1alpha1
+    controller: true
+    kind: OpenSearchCluster
+    name: opensearch
 spec:
   ports:
   - name: http
@@ -467,7 +472,10 @@ spec:
     targetPort: 9300
   publishNotReadyAddresses: true
   selector:
-    cluster_manager: "true"
+    app.kubernetes.io/component: nodes
+    app.kubernetes.io/instance: opensearch
+    app.kubernetes.io/name: opensearch
+    stackable.tech/opensearch-role.cluster_manager: "true"
   type: ClusterIP
 ---
 apiVersion: v1