refactor: use v2 ownerref, labes

Author: maltesander

rust/operator-binary/src/controller.rs

@@ -22,7 +22,10 @@ use stackable_operator::{
     },
     v2::{
         cluster_resources::cluster_resources_new,
-        types::operator::{ControllerName, OperatorName, ProductName},
+        kvp::label::recommended_labels,
+        types::operator::{
+            ControllerName, OperatorName, ProductName, ProductVersion, RoleGroupName,
+        },
     },
 };
 use strum::{EnumDiscriminants, IntoStaticStr};
@@ -33,9 +36,7 @@ use crate::{
         pdb::build_pdb,
         service::{build_rolegroup_headless_service, build_rolegroup_metrics_service},
     },
-    crd::{
-        APP_NAME, DruidClusterStatus, DruidRole, OPERATOR_NAME, build_recommended_labels, v1alpha1,
-    },
+    crd::{APP_NAME, DruidClusterStatus, DruidRole, OPERATOR_NAME, v1alpha1},
     internal_secret::create_shared_internal_secret,
 };
 
@@ -158,16 +159,6 @@ pub enum Error {
         source: stackable_operator::cluster_resources::Error,
     },
 
-    #[snafu(display("failed to configure listener"))]
-    ListenerConfiguration {
-        source: crate::controller::build::resource::listener::Error,
-    },
-
-    #[snafu(display("failed to configure service"))]
-    ServiceConfiguration {
-        source: crate::controller::build::resource::service::Error,
-    },
-
     #[snafu(display("failed to validate cluster"))]
     ValidateCluster { source: validate::Error },
 
@@ -238,19 +229,15 @@ pub async fn reconcile_druid(
     let mut ss_cond_builder = StatefulSetConditionBuilder::default();
 
     for (druid_role, groups) in validated_cluster.role_group_configs.iter() {
-        let role_name = druid_role.to_string();
-
         create_shared_internal_secret(druid, client, DRUID_CONTROLLER_NAME)
             .await
             .context(FailedInternalSecretCreationSnafu)?;
 
         for (rolegroup_name, rg) in groups.iter() {
             let rg_headless_service =
-                build_rolegroup_headless_service(&validated_cluster, druid_role, rolegroup_name)
-                    .context(ServiceConfigurationSnafu)?;
+                build_rolegroup_headless_service(&validated_cluster, druid_role, rolegroup_name);
             let rg_metrics_service =
-                build_rolegroup_metrics_service(&validated_cluster, druid_role, rolegroup_name)
-                    .context(ServiceConfigurationSnafu)?;
+                build_rolegroup_metrics_service(&validated_cluster, druid_role, rolegroup_name);
 
             let rg_configmap = build::resource::config_map::build_rolegroup_config_map(
                 &validated_cluster,
@@ -305,18 +292,20 @@ pub async fn reconcile_druid(
         {
             let role_group_listener = build_group_listener(
                 &validated_cluster,
-                build_recommended_labels(
+                recommended_labels(
                     &validated_cluster,
-                    DRUID_CONTROLLER_NAME,
-                    &validated_cluster.image.app_version_label_value,
-                    &role_name,
-                    "none",
+                    &product_name(),
+                    &ProductVersion::from_str(&validated_cluster.image.app_version_label_value)
+                        .expect("a valid product version"),
+                    &operator_name(),
+                    &controller_name(),
+                    &druid_role.to_role_name(),
+                    &RoleGroupName::from_str("none").expect("a valid role group name"),
                 ),
                 listener_class.to_string(),
                 listener_group_name,
                 druid_role,
-            )
-            .context(ListenerConfigurationSnafu)?;
+            );
 
             let listener = cluster_resources
                 .add(client, role_group_listener)

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

@@ -11,7 +11,7 @@
 //! The builder does not read the raw [`v1alpha1::DruidCluster`] at all: everything it needs is
 //! carried on `ValidatedCluster` (resolved during the validate step).
 
-use std::collections::BTreeMap;
+use std::{collections::BTreeMap, str::FromStr};
 
 use snafu::{ResultExt, Snafu};
 use stackable_operator::{
@@ -20,14 +20,15 @@ use stackable_operator::{
     k8s_openapi::api::core::v1::{ConfigMap, EnvVar},
     product_logging::framework::VECTOR_CONFIG_FILE,
     v2::{
-        builder::meta::ownerreference_from_resource, config_file_writer::to_java_properties_string,
-        types::operator::RoleGroupName,
+        builder::meta::ownerreference_from_resource,
+        config_file_writer::to_java_properties_string,
+        kvp::label::recommended_labels,
+        types::operator::{ProductVersion, RoleGroupName},
     },
 };
 
 use crate::{
     controller::{
-        DRUID_CONTROLLER_NAME,
         build::{
             jvm::construct_jvm_args,
             properties::{
@@ -36,12 +37,12 @@ use crate::{
                 runtime_properties, security_properties,
             },
         },
+        controller_name, operator_name, product_name,
         validate::{DruidRoleGroupConfig, ValidatedCluster},
     },
     crd::{
         DruidConfigOverrides, DruidRole, STACKABLE_TRUST_STORE, STACKABLE_TRUST_STORE_PASSWORD,
-        STACKABLE_TRUST_STORE_TYPE, build_recommended_labels, build_string_list, env_var_reference,
-        file_reference,
+        STACKABLE_TRUST_STORE_TYPE, build_string_list, env_var_reference, file_reference,
     },
 };
 
@@ -83,11 +84,6 @@ pub enum Error {
     #[snafu(display("failed to update Druid config from resources"))]
     UpdateDruidConfigFromResources { source: crate::crd::resource::Error },
 
-    #[snafu(display("failed to build metadata"))]
-    MetadataBuild {
-        source: stackable_operator::builder::meta::Error,
-    },
-
     #[snafu(display("there was an error generating the authentication runtime settings"))]
     GenerateAuthenticationRuntimeSettings {
         source: crate::authentication::Error,
@@ -330,14 +326,16 @@ pub fn build_rolegroup_config_map(
             .name_and_namespace(cluster)
             .name(resource_names.role_group_config_map().to_string())
             .ownerreference(ownerreference_from_resource(cluster, None, Some(true)))
-            .with_recommended_labels(&build_recommended_labels(
+            .with_labels(recommended_labels(
                 cluster,
-                DRUID_CONTROLLER_NAME,
-                &cluster.image.app_version_label_value,
-                &role.to_string(),
-                role_group_name.as_ref(),
+                &product_name(),
+                &ProductVersion::from_str(&cluster.image.app_version_label_value)
+                    .expect("a valid product version"),
+                &operator_name(),
+                &controller_name(),
+                &role.to_role_name(),
+                role_group_name,
             ))
-            .context(MetadataBuildSnafu)?
             .build(),
     );
 

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

@@ -1,20 +1,26 @@
 //! Discovery for Druid.  We make Druid discoverable by putting a connection string to the router service
 //! inside a config map.  We only provide a connection string to the router service, since it serves as
 //! a gateway to the cluster for client queries.
+use std::str::FromStr;
+
 use snafu::{ResultExt, Snafu};
 use stackable_operator::{
     builder::{configmap::ConfigMapBuilder, meta::ObjectMetaBuilder},
     crd::listener::v1alpha1::Listener,
     k8s_openapi::api::core::v1::ConfigMap,
-    v2::builder::meta::ownerreference_from_resource,
+    v2::{
+        builder::meta::ownerreference_from_resource,
+        kvp::label::recommended_labels,
+        types::operator::{ProductVersion, RoleGroupName},
+    },
 };
 
 use crate::{
-    DRUID_CONTROLLER_NAME,
     controller::{
-        build::resource::listener::build_listener_connection_string, validate::ValidatedCluster,
+        build::resource::listener::build_listener_connection_string, controller_name,
+        operator_name, product_name, validate::ValidatedCluster,
     },
-    crd::{DruidRole, build_recommended_labels},
+    crd::DruidRole,
 };
 
 #[derive(Snafu, Debug)]
@@ -24,11 +30,6 @@ pub enum Error {
         source: stackable_operator::builder::configmap::Error,
     },
 
-    #[snafu(display("failed to add recommended labels"))]
-    AddRecommendedLabels {
-        source: stackable_operator::builder::meta::Error,
-    },
-
     #[snafu(display("failed to configure listener discovery configmap"))]
     ListenerConfiguration {
         source: crate::controller::build::resource::listener::Error,
@@ -65,14 +66,16 @@ fn build_discovery_configmap(
             ObjectMetaBuilder::new()
                 .name_and_namespace(cluster)
                 .ownerreference(ownerreference_from_resource(cluster, None, Some(true)))
-                .with_recommended_labels(&build_recommended_labels(
+                .with_labels(recommended_labels(
                     cluster,
-                    DRUID_CONTROLLER_NAME,
-                    &cluster.image.app_version_label_value,
-                    &DruidRole::Router.to_string(),
-                    "discovery",
+                    &product_name(),
+                    &ProductVersion::from_str(&cluster.image.app_version_label_value)
+                        .expect("a valid product version"),
+                    &operator_name(),
+                    &controller_name(),
+                    &DruidRole::Router.to_role_name(),
+                    &RoleGroupName::from_str("discovery").expect("a valid role group name"),
                 ))
-                .context(AddRecommendedLabelsSnafu)?
                 .build(),
         )
         .add_data("DRUID_ROUTER", router_host)

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

@@ -1,14 +1,15 @@
 use std::str::FromStr;
 
-use snafu::{OptionExt, ResultExt, Snafu};
+use snafu::{OptionExt, Snafu};
 use stackable_operator::{
     builder::meta::ObjectMetaBuilder,
     crd::listener::{self, v1alpha1::Listener},
     k8s_openapi::api::core::v1::PersistentVolumeClaim,
-    kvp::{Labels, ObjectLabels},
+    kvp::Labels,
     v2::{
-        builder::pod::volume::{
-            ListenerReference, listener_operator_volume_source_builder_build_pvc,
+        builder::{
+            meta::ownerreference_from_resource,
+            pod::volume::{ListenerReference, listener_operator_volume_source_builder_build_pvc},
         },
         types::kubernetes::{ListenerName, PersistentVolumeClaimName},
     },
@@ -27,16 +28,6 @@ pub const LISTENER_VOLUME_DIR: &str = "/stackable/listener";
 
 #[derive(Snafu, Debug)]
 pub enum Error {
-    #[snafu(display("listener object is missing metadata to build owner reference"))]
-    ObjectMissingMetadataForOwnerRef {
-        source: stackable_operator::builder::meta::Error,
-    },
-
-    #[snafu(display("failed to build listener object meta data"))]
-    BuildObjectMeta {
-        source: stackable_operator::builder::meta::Error,
-    },
-
     #[snafu(display("{role_name} listener has no adress"))]
     RoleListenerHasNoAddress { role_name: String },
 
@@ -49,19 +40,17 @@ pub enum Error {
 
 pub fn build_group_listener(
     cluster: &ValidatedCluster,
-    object_labels: ObjectLabels<ValidatedCluster>,
+    object_labels: Labels,
     listener_class: String,
     listener_group_name: ListenerName,
     druid_role: &DruidRole,
-) -> Result<Listener, Error> {
-    Ok(Listener {
+) -> Listener {
+    Listener {
         metadata: ObjectMetaBuilder::new()
             .name_and_namespace(cluster)
             .name(listener_group_name.to_string())
-            .ownerreference_from_resource(cluster, None, Some(true))
-            .context(ObjectMissingMetadataForOwnerRefSnafu)?
-            .with_recommended_labels(&object_labels)
-            .context(BuildObjectMetaSnafu)?
+            .ownerreference(ownerreference_from_resource(cluster, None, Some(true)))
+            .with_labels(object_labels)
             .build(),
         spec: listener::v1alpha1::ListenerSpec {
             class_name: Some(listener_class),
@@ -74,7 +63,7 @@ pub fn build_group_listener(
             ..listener::v1alpha1::ListenerSpec::default()
         },
         status: None,
-    })
+    }
 }
 
 pub fn build_group_listener_pvc(