refactor: use v2 owerref, RoleGroupName, labels, ResourceNames

Author: maltesander

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

@@ -4,11 +4,9 @@ use snafu::{OptionExt, ResultExt, Snafu};
 use stackable_operator::{
     builder::{configmap::ConfigMapBuilder, meta::ObjectMetaBuilder},
     k8s_openapi::api::core::v1::ConfigMap,
-    kvp::ObjectLabels,
     product_logging::framework::VECTOR_CONFIG_FILE,
-    role_utils::RoleGroupRef,
     utils::cluster_info::KubernetesClusterInfo,
-    v2::builder::meta::ownerreference_from_resource,
+    v2::{builder::meta::ownerreference_from_resource, types::operator::RoleGroupName},
 };
 
 use crate::{
@@ -23,16 +21,11 @@ use crate::{
             proxy_hosts,
         },
     },
-    crd::{NifiRole, v1alpha1},
+    crd::NifiRole,
 };
 
 #[derive(Debug, Snafu)]
 pub enum Error {
-    #[snafu(display("failed to build metadata"))]
-    MetadataBuild {
-        source: stackable_operator::builder::meta::Error,
-    },
-
     #[snafu(display("failed to build bootstrap.conf"))]
     BootstrapConfig {
         #[snafu(source(from(crate::controller::build::Error, Box::new)))]
@@ -43,19 +36,19 @@ pub enum Error {
     BuildNifiProperties {
         #[snafu(source(from(crate::controller::build::Error, Box::new)))]
         source: Box<crate::controller::build::Error>,
-        rolegroup: RoleGroupRef<v1alpha1::NifiCluster>,
+        rolegroup: RoleGroupName,
     },
 
     #[snafu(display("failed to build ConfigMap for {rolegroup}"))]
     BuildRoleGroupConfig {
         source: stackable_operator::builder::configmap::Error,
-        rolegroup: RoleGroupRef<v1alpha1::NifiCluster>,
+        rolegroup: RoleGroupName,
     },
 
     #[snafu(display("failed to serialize JVM security properties for {}", rolegroup))]
     JvmSecurityProperties {
         source: stackable_operator::v2::config_file_writer::PropertiesWriterError,
-        rolegroup: String,
+        rolegroup: RoleGroupName,
     },
 
     #[snafu(display("failed to build login-identity-providers configuration"))]
@@ -75,23 +68,25 @@ type Result<T, E = Error> = std::result::Result<T, E>;
 /// Build the rolegroup [`ConfigMap`] configuring the rolegroup based on the
 /// resolved cluster configuration.
 ///
-/// All NiFi configuration is sourced from `cluster`. `recommended_labels` must be built by the
-/// caller (typically via `build_recommended_labels`).
+/// All NiFi configuration is sourced from `cluster`.
+///
+/// `vector_config` is the Vector agent config (`vector.yaml`) built by the caller (where a
+/// `RoleGroupRef` is available); it is `None` when the Vector agent is disabled.
 pub fn build_rolegroup_config_map(
     cluster: &ValidatedCluster,
-    rolegroup: &RoleGroupRef<v1alpha1::NifiCluster>,
-    recommended_labels: &ObjectLabels<'_, ValidatedCluster>,
+    role_group_name: &RoleGroupName,
     cluster_info: &KubernetesClusterInfo,
+    vector_config: Option<String>,
 ) -> Result<ConfigMap> {
     tracing::debug!("building rolegroup ConfigMap");
 
     let rg = cluster
         .role_group_configs
         .get(&NifiRole::Node)
-        .and_then(|groups| groups.get(&rolegroup.role_group))
+        .and_then(|groups| groups.get(role_group_name))
         .with_context(|| MissingRoleGroupSnafu {
             role: NifiRole::Node.to_string(),
-            role_group: rolegroup.role_group.clone(),
+            role_group: role_group_name.to_string(),
         })?;
 
     let proxy_hosts = proxy_hosts::compute_proxy_hosts(cluster, cluster_info);
@@ -103,11 +98,15 @@ pub fn build_rolegroup_config_map(
     cm_builder
         .metadata(
             ObjectMetaBuilder::new()
-                .namespace(&cluster.namespace)
-                .name(rolegroup.object_name())
+                .name_and_namespace(cluster)
+                .name(
+                    cluster
+                        .resource_names(role_group_name)
+                        .role_group_config_map()
+                        .to_string(),
+                )
                 .ownerreference(ownerreference_from_resource(cluster, None, Some(true)))
-                .with_recommended_labels(recommended_labels)
-                .context(MetadataBuildSnafu)?
+                .with_labels(cluster.recommended_labels(role_group_name))
                 .build(),
         )
         .add_data(
@@ -119,7 +118,7 @@ pub fn build_rolegroup_config_map(
             ConfigFileName::NifiProperties.to_string(),
             nifi_properties::build(cluster, rg, &proxy_hosts, &git_sync_resources).with_context(
                 |_| BuildNifiPropertiesSnafu {
-                    rolegroup: rolegroup.clone(),
+                    rolegroup: role_group_name.clone(),
                 },
             )?,
         )
@@ -139,21 +138,21 @@ pub fn build_rolegroup_config_map(
         .add_data(
             ConfigFileName::SecurityProperties.to_string(),
             security_properties::build(rg).with_context(|_| JvmSecurityPropertiesSnafu {
-                rolegroup: rolegroup.role_group.clone(),
+                rolegroup: role_group_name.clone(),
             })?,
         );
 
     if let Some(logback_config) = logging::build_logback_config(&rg.config.logging) {
         cm_builder.add_data(ConfigFileName::Logback.to_string(), logback_config);
     }
 
-    if let Some(vector_config) = logging::build_vector_config(rolegroup, &rg.config.logging) {
+    if let Some(vector_config) = vector_config {
         cm_builder.add_data(VECTOR_CONFIG_FILE, vector_config);
     }
 
     cm_builder
         .build()
         .with_context(|_| BuildRoleGroupConfigSnafu {
-            rolegroup: rolegroup.clone(),
+            rolegroup: role_group_name.clone(),
         })
 }

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

@@ -77,7 +77,7 @@ pub(crate) mod test_support {
         kvp::LabelValue,
         v2::types::{
             kubernetes::{NamespaceName, Uid},
-            operator::ClusterName,
+            operator::{ClusterName, ProductVersion, RoleGroupName},
         },
     };
 
@@ -144,12 +144,15 @@ pub(crate) mod test_support {
         let name = ClusterName::from_str("simple-nifi").expect("valid cluster name");
         let namespace = NamespaceName::from_str("default").expect("valid namespace");
         let uid = Uid::from_str("e6ac237d-a6d4-43a1-8135-f36506110912").expect("valid uid");
+        let product_version = ProductVersion::from_str(&image.app_version_label_value)
+            .expect("valid product version");
 
         ValidatedCluster::new(
             name,
             namespace,
             uid,
             image,
+            product_version,
             role_group_configs,
             ValidatedClusterConfig {
                 authentication: NifiAuthenticationConfig::SingleUser {
@@ -177,7 +180,9 @@ pub(crate) mod test_support {
         cluster
             .role_group_configs
             .get(&NifiRole::Node)
-            .and_then(|rgs| rgs.get("default"))
+            .and_then(|rgs| {
+                rgs.get(&RoleGroupName::from_str("default").expect("valid role-group name"))
+            })
             .expect("minimal_validated_cluster must contain a 'default' role group")
     }
 

rust/operator-binary/src/controller/build/properties/bootstrap_conf.rs

@@ -49,6 +49,7 @@ pub fn build(
 #[cfg(test)]
 mod tests {
     use indoc::indoc;
+    use stackable_operator::v2::types::operator::RoleGroupName;
 
     use super::*;
     use crate::{
@@ -64,7 +65,13 @@ mod tests {
             build_role_group_configs(&nifi).expect("failed to build role group configs");
         let rg = role_group_configs
             .get(&NifiRole::Node)
-            .and_then(|groups| groups.get("default"))
+            .and_then(|groups| {
+                groups.get(
+                    &"default"
+                        .parse::<RoleGroupName>()
+                        .expect("valid role-group name"),
+                )
+            })
             .expect("default role group must exist");
 
         build(rg, None).unwrap()

rust/operator-binary/src/controller/build/properties/nifi_properties.rs

@@ -642,6 +642,8 @@ mod tests {
     /// Verify that a user configOverride for `nifi.properties` flows through to the output.
     #[test]
     fn test_config_override_wins() {
+        use stackable_operator::v2::types::operator::RoleGroupName;
+
         use crate::{
             controller::validate::build_role_group_configs,
             crd::{NifiRole, v1alpha1},
@@ -673,9 +675,12 @@ mod tests {
         let nifi: v1alpha1::NifiCluster = serde_yaml::from_str(yaml).expect("invalid test YAML");
         let mut role_group_configs =
             build_role_group_configs(&nifi).expect("failed to build role group configs");
+        let default_rg_name = "default"
+            .parse::<RoleGroupName>()
+            .expect("valid role-group name");
         let rg = role_group_configs
             .get_mut(&NifiRole::Node)
-            .and_then(|groups| groups.remove("default"))
+            .and_then(|groups| groups.remove(&default_rg_name))
             .expect("default role group must exist");
 
         // Build a cluster with this rg substituted in
@@ -684,7 +689,7 @@ mod tests {
             .role_group_configs
             .get_mut(&NifiRole::Node)
             .unwrap()
-            .insert("default".to_string(), rg.clone());
+            .insert(default_rg_name, rg.clone());
 
         let git_sync = empty_git_sync_resources();
         let props =