refactor: move to v2 types, clusterresources, pdbs, container builders

Author: maltesander

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

@@ -1,61 +1,36 @@
-use snafu::{ResultExt, Snafu};
 use stackable_operator::{
-    builder::pdb::PodDisruptionBudgetBuilder, client::Client, cluster_resources::ClusterResources,
-    commons::pdb::PdbConfig, kube::ResourceExt,
+    commons::pdb::PdbConfig, k8s_openapi::api::policy::v1::PodDisruptionBudget,
+    v2::builder::pdb::pod_disruption_budget_builder_with_role,
 };
 
 use crate::{
-    OPERATOR_NAME,
-    crd::{APP_NAME, NifiRole, v1alpha1},
-    nifi_controller::NIFI_CONTROLLER_NAME,
+    controller::{ValidatedCluster, controller_name, operator_name, product_name},
+    crd::NifiRole,
 };
 
-#[derive(Snafu, Debug)]
-pub enum Error {
-    #[snafu(display("Cannot create PodDisruptionBudget for role [{role}]"))]
-    CreatePdb {
-        source: stackable_operator::builder::pdb::Error,
-        role: String,
-    },
-    #[snafu(display("Cannot apply PodDisruptionBudget [{name}]"))]
-    ApplyPdb {
-        source: stackable_operator::cluster_resources::Error,
-        name: String,
-    },
-}
-
-pub async fn add_pdbs(
+/// Builds the [`PodDisruptionBudget`] for the given `role`, or `None` if PDBs are disabled.
+pub fn build_pdb(
     pdb: &PdbConfig,
-    nifi: &v1alpha1::NifiCluster,
+    cluster: &ValidatedCluster,
     role: &NifiRole,
-    client: &Client,
-    cluster_resources: &mut ClusterResources<'_>,
-) -> Result<(), Error> {
+) -> Option<PodDisruptionBudget> {
     if !pdb.enabled {
-        return Ok(());
+        return None;
     }
     let max_unavailable = pdb.max_unavailable.unwrap_or(match role {
         NifiRole::Node => max_unavailable_nodes(),
     });
-    let pdb = PodDisruptionBudgetBuilder::new_with_role(
-        nifi,
-        APP_NAME,
-        &role.to_string(),
-        OPERATOR_NAME,
-        NIFI_CONTROLLER_NAME,
+    let pdb = pod_disruption_budget_builder_with_role(
+        cluster,
+        &product_name(),
+        &ValidatedCluster::role_name(),
+        &operator_name(),
+        &controller_name(),
     )
-    .with_context(|_| CreatePdbSnafu {
-        role: role.to_string(),
-    })?
     .with_max_unavailable(max_unavailable)
     .build();
-    let pdb_name = pdb.name_any();
-    cluster_resources
-        .add(client, pdb)
-        .await
-        .with_context(|_| ApplyPdbSnafu { name: pdb_name })?;
 
-    Ok(())
+    Some(pdb)
 }
 
 fn max_unavailable_nodes() -> u16 {

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

@@ -30,7 +30,7 @@ use stackable_operator::{
         self,
         meta::ObjectMetaBuilder,
         pod::{
-            PodBuilder, container::ContainerBuilder, resources::ResourceRequirementsBuilder,
+            PodBuilder, resources::ResourceRequirementsBuilder,
             security::PodSecurityContextBuilder, volume::SecretFormat,
         },
     },
@@ -46,8 +46,11 @@ use stackable_operator::{
     shared::time::Duration,
     utils::cluster_info::KubernetesClusterInfo,
     v2::{
-        builder::meta::ownerreference_from_resource,
-        types::{kubernetes::NamespaceName, operator::RoleGroupName},
+        builder::{meta::ownerreference_from_resource, pod::container::new_container_builder},
+        types::{
+            kubernetes::{ContainerName, NamespaceName},
+            operator::RoleGroupName,
+        },
     },
 };
 
@@ -62,19 +65,13 @@ use crate::{
 
 const REPORTING_TASK_CERT_VOLUME_NAME: &str = "tls";
 const REPORTING_TASK_CERT_VOLUME_MOUNT: &str = "/stackable/cert";
-const REPORTING_TASK_CONTAINER_NAME: &str = "reporting-task";
+stackable_operator::constant!(REPORTING_TASK_CONTAINER_NAME: ContainerName = "reporting-task");
 
 #[derive(Snafu, Debug)]
 pub enum Error {
     #[snafu(display("object defines no name"))]
     ObjectHasNoName,
 
-    #[snafu(display("illegal container name: [{container_name}]"))]
-    IllegalContainerName {
-        source: stackable_operator::builder::pod::container::Error,
-        container_name: String,
-    },
-
     #[snafu(display("failed to add Authentication Volumes and VolumeMounts"))]
     AddAuthVolumes {
         source: crate::security::authentication::Error,
@@ -147,7 +144,10 @@ fn reporting_task_role_group() -> RoleGroupName {
 
 /// Return the name of the reporting task Service.
 pub fn build_reporting_task_service_name(nifi_cluster_name: &str) -> String {
-    format!("{nifi_cluster_name}-{REPORTING_TASK_CONTAINER_NAME}")
+    format!(
+        "{nifi_cluster_name}-{container}",
+        container = &*REPORTING_TASK_CONTAINER_NAME
+    )
 }
 
 /// Return the FQDN (with namespace, domain) of the reporting task.
@@ -284,11 +284,7 @@ fn build_reporting_task_job(
         format!("-m {METRICS_PORT}"),
         format!("-c {REPORTING_TASK_CERT_VOLUME_MOUNT}/ca.crt"),
     ];
-    let mut cb = ContainerBuilder::new(REPORTING_TASK_CONTAINER_NAME).with_context(|_| {
-        IllegalContainerNameSnafu {
-            container_name: REPORTING_TASK_CONTAINER_NAME.to_string(),
-        }
-    })?;
+    let mut cb = new_container_builder(&REPORTING_TASK_CONTAINER_NAME);
     cb.image_from_product_image(resolved_product_image)
         .command(vec!["sh".to_string(), "-c".to_string()])
         .args(vec![args.join(" ")])

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

@@ -9,7 +9,7 @@ use stackable_operator::{
         self,
         meta::ObjectMetaBuilder,
         pod::{
-            PodBuilder, container::ContainerBuilder, resources::ResourceRequirementsBuilder,
+            PodBuilder, resources::ResourceRequirementsBuilder,
             security::PodSecurityContextBuilder, volume::SecretFormat,
         },
     },
@@ -40,7 +40,10 @@ use stackable_operator::{
     },
     utils::{COMMON_BASH_TRAP_FUNCTIONS, cluster_info::KubernetesClusterInfo},
     v2::{
-        builder::{meta::ownerreference_from_resource, pod::container::EnvVarSet},
+        builder::{
+            meta::ownerreference_from_resource,
+            pod::container::{EnvVarSet, new_container_builder},
+        },
         product_logging::framework::vector_container,
         types::{
             kubernetes::{ContainerName, VolumeName},
@@ -92,12 +95,6 @@ pub enum Error {
     #[snafu(display("object defines no name"))]
     ObjectHasNoName,
 
-    #[snafu(display("illegal container name: [{container_name}]"))]
-    IllegalContainerName {
-        source: stackable_operator::builder::pod::container::Error,
-        container_name: String,
-    },
-
     #[snafu(display("failed to add Authentication Volumes and VolumeMounts"))]
     AddAuthVolumes {
         source: crate::security::authentication::Error,
@@ -152,6 +149,10 @@ const LOG_CONFIG_VOLUME_NAME: &str = "log-config";
 /// git-sync container, see [`crate::controller::build::git_sync`]).
 pub(crate) const LOG_VOLUME_NAME: &str = "log";
 
+// Container names. These must match the corresponding (kebab-cased) `crate::crd::Container`
+// variants, which key the per-container logging config.
+stackable_operator::constant!(PREPARE_CONTAINER_NAME: ContainerName = "prepare");
+stackable_operator::constant!(NIFI_CONTAINER_NAME: ContainerName = "nifi");
 stackable_operator::constant!(VECTOR_CONTAINER_NAME: ContainerName = "vector");
 
 // Typed `VolumeName`s for the Vector container's log-config and log volumes. They reuse the
@@ -256,7 +257,7 @@ pub(crate) async fn build_node_rolegroup_statefulset(
 
     let sensitive_key_secret = &nifi.spec.cluster_config.sensitive_properties.key_secret;
 
-    let prepare_container_name = Container::Prepare.to_string();
+    let prepare_container_name = PREPARE_CONTAINER_NAME.to_string();
     let mut prepare_args = vec![];
 
     if let Some(ContainerLogConfig {
@@ -328,12 +329,7 @@ pub(crate) async fn build_node_rolegroup_statefulset(
         "config-utils template /stackable/nifi/conf/security.properties".to_string(),
     ]);
 
-    let mut container_prepare =
-        ContainerBuilder::new(&prepare_container_name).with_context(|_| {
-            IllegalContainerNameSnafu {
-                container_name: prepare_container_name.to_string(),
-            }
-        })?;
+    let mut container_prepare = new_container_builder(&PREPARE_CONTAINER_NAME);
 
     container_prepare
         .image_from_product_image(resolved_product_image)
@@ -379,13 +375,7 @@ pub(crate) async fn build_node_rolegroup_statefulset(
                 .build(),
         );
 
-    let nifi_container_name = Container::Nifi.to_string();
-    let mut container_nifi_builder =
-        ContainerBuilder::new(&nifi_container_name).with_context(|_| {
-            IllegalContainerNameSnafu {
-                container_name: nifi_container_name,
-            }
-        })?;
+    let mut container_nifi_builder = new_container_builder(&NIFI_CONTAINER_NAME);
 
     let nifi_args = vec![formatdoc! {"
             {COMMON_BASH_TRAP_FUNCTIONS}

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

@@ -214,17 +214,17 @@ impl ValidatedCluster {
 }
 
 /// The product name (`nifi`) as a type-safe label value.
-fn product_name() -> ProductName {
+pub(crate) fn product_name() -> ProductName {
     ProductName::from_str(APP_NAME).expect("'nifi' is a valid product name")
 }
 
 /// The operator name as a type-safe label value.
-fn operator_name() -> OperatorName {
+pub(crate) fn operator_name() -> OperatorName {
     OperatorName::from_str(OPERATOR_NAME).expect("the operator name is a valid label value")
 }
 
 /// The controller name as a type-safe label value.
-fn controller_name() -> ControllerName {
+pub(crate) fn controller_name() -> ControllerName {
     ControllerName::from_str(NIFI_CONTROLLER_NAME)
         .expect("the controller name is a valid label value")
 }

rust/operator-binary/src/nifi_controller.rs

@@ -7,10 +7,10 @@ use snafu::{OptionExt, ResultExt, Snafu};
 use stackable_operator::{
     cli::OperatorEnvironmentOptions,
     client::Client,
-    cluster_resources::{ClusterResourceApplyStrategy, ClusterResources},
+    cluster_resources::ClusterResourceApplyStrategy,
     commons::rbac::build_rbac_resources,
     kube::{
-        Resource, ResourceExt,
+        ResourceExt,
         core::{DeserializeGuard, error_boundary},
         runtime::controller::Action,
     },
@@ -21,7 +21,7 @@ use stackable_operator::{
         compute_conditions, operations::ClusterOperationsConditionBuilder,
         statefulset::StatefulSetConditionBuilder,
     },
-    v2::types::operator::RoleGroupName,
+    v2::{cluster_resources::cluster_resources_new, types::operator::RoleGroupName},
 };
 use strum::{EnumDiscriminants, IntoStaticStr};
 use tracing::Instrument;
@@ -32,12 +32,12 @@ use crate::{
         build,
         build::resource::{
             listener::{build_group_listener, group_listener_name},
-            pdb::add_pdbs,
+            pdb::build_pdb,
             reporting_task::build_maybe_reporting_task,
             service::{build_rolegroup_headless_service, build_rolegroup_metrics_service},
             statefulset::build_node_rolegroup_statefulset,
         },
-        dereference,
+        controller_name, dereference, operator_name, product_name,
         upgrade::{self, ClusterVersionUpdateState},
         validate,
     },
@@ -71,11 +71,6 @@ pub enum Error {
     #[snafu(display("failed to validate cluster"))]
     ValidateCluster { source: validate::Error },
 
-    #[snafu(display("failed to create cluster resources"))]
-    CreateClusterResources {
-        source: stackable_operator::cluster_resources::Error,
-    },
-
     #[snafu(display("failed to delete orphaned resources"))]
     DeleteOrphanedResources {
         source: stackable_operator::cluster_resources::Error,
@@ -147,9 +142,9 @@ pub enum Error {
         source: stackable_operator::commons::rbac::Error,
     },
 
-    #[snafu(display("failed to create PodDisruptionBudget"))]
-    FailedToCreatePdb {
-        source: crate::controller::build::resource::pdb::Error,
+    #[snafu(display("failed to apply PodDisruptionBudget"))]
+    ApplyPdb {
+        source: stackable_operator::cluster_resources::Error,
     },
 
     #[snafu(display("failed to get required labels"))]
@@ -249,15 +244,16 @@ pub async fn reconcile_nifi(
     }
     // end todo
 
-    let mut cluster_resources = ClusterResources::new(
-        APP_NAME,
-        OPERATOR_NAME,
-        NIFI_CONTROLLER_NAME,
-        &nifi.object_ref(&()),
+    let mut cluster_resources = cluster_resources_new(
+        &product_name(),
+        &operator_name(),
+        &controller_name(),
+        &validated_cluster.name,
+        &validated_cluster.namespace,
+        &validated_cluster.uid,
         ClusterResourceApplyStrategy::from(&nifi.spec.cluster_operation),
         &nifi.spec.object_overrides,
-    )
-    .context(CreateClusterResourcesSnafu)?;
+    );
 
     if let NifiAuthenticationConfig::Oidc { .. } = authentication_config {
         check_or_generate_oidc_admin_password(client, nifi, &validated_cluster.namespace)
@@ -392,9 +388,12 @@ pub async fn reconcile_nifi(
         listener_class,
     }) = role_config
     {
-        add_pdbs(pdb, nifi, &nifi_role, client, &mut cluster_resources)
-            .await
-            .context(FailedToCreatePdbSnafu)?;
+        if let Some(pdb) = build_pdb(pdb, &validated_cluster, &nifi_role) {
+            cluster_resources
+                .add(client, pdb)
+                .await
+                .context(ApplyPdbSnafu)?;
+        }
 
         let role_group_listener = build_group_listener(
             &validated_cluster,