refactor: introduce the build aggregator

Author: maltesander

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

@@ -3,12 +3,107 @@
 
 use std::str::FromStr;
 
-use stackable_operator::v2::types::operator::RoleGroupName;
+use snafu::{ResultExt, Snafu};
+use stackable_operator::{
+    utils::cluster_info::KubernetesClusterInfo, v2::types::operator::RoleGroupName,
+};
+
+use crate::controller::{
+    KubernetesResources, ValidatedCluster,
+    build::resource::{
+        config_map::{self, build_rolegroup_config_map},
+        pdb::build_pdb,
+        service::{build_rolegroup_metrics_service, build_rolegroup_service},
+        statefulset::{self, build_rolegroup_statefulset},
+    },
+};
 
 // Placeholder role-group name used for the recommended labels of the role-level discovery
 // `ConfigMap` (which is not tied to a single role group).
 stackable_operator::constant!(pub(crate) PLACEHOLDER_DISCOVERY_ROLE_GROUP: RoleGroupName = "discovery");
 
+#[derive(Snafu, Debug)]
+pub enum Error {
+    #[snafu(display("failed to build ConfigMap for role group {role_group}"))]
+    ConfigMap {
+        source: config_map::Error,
+        role_group: RoleGroupName,
+    },
+
+    #[snafu(display("failed to build StatefulSet for role group {role_group}"))]
+    StatefulSet {
+        source: statefulset::Error,
+        role_group: RoleGroupName,
+    },
+}
+
+/// Builds every Kubernetes resource for the given validated cluster.
+///
+/// Does not need a Kubernetes client: every reference to another Kubernetes resource is already
+/// dereferenced and validated by this point, so the errors returned here are resource-assembly
+/// failures only. `cluster_info` is static cluster metadata (not a client call), and
+/// `service_account_name` is the name of the RBAC `ServiceAccount` the role-group Pods run under
+/// (RBAC resources are built and applied separately, in the reconcile step).
+///
+/// The role-level discovery `ConfigMap` is applied separately in the reconcile step and is not
+/// part of this bundle.
+pub fn build(
+    cluster: &ValidatedCluster,
+    cluster_info: &KubernetesClusterInfo,
+    service_account_name: &str,
+) -> Result<KubernetesResources, Error> {
+    let mut stateful_sets = vec![];
+    let mut services = vec![];
+    let mut config_maps = vec![];
+    let mut pod_disruption_budgets = vec![];
+
+    for (hbase_role, role_group_configs) in &cluster.role_group_configs {
+        for (role_group_name, rg_config) in role_group_configs {
+            services.push(build_rolegroup_service(
+                cluster,
+                hbase_role,
+                role_group_name,
+            ));
+            services.push(build_rolegroup_metrics_service(
+                cluster,
+                hbase_role,
+                role_group_name,
+            ));
+            config_maps.push(
+                build_rolegroup_config_map(cluster, cluster_info, hbase_role, role_group_name)
+                    .context(ConfigMapSnafu {
+                        role_group: role_group_name.clone(),
+                    })?,
+            );
+            stateful_sets.push(
+                build_rolegroup_statefulset(
+                    cluster,
+                    hbase_role,
+                    role_group_name,
+                    rg_config,
+                    service_account_name,
+                )
+                .context(StatefulSetSnafu {
+                    role_group: role_group_name.clone(),
+                })?,
+            );
+        }
+
+        if let Some(role_config) = cluster.role_configs.get(hbase_role)
+            && let Some(pdb) = build_pdb(&role_config.pdb, cluster, hbase_role)
+        {
+            pod_disruption_budgets.push(pdb);
+        }
+    }
+
+    Ok(KubernetesResources {
+        stateful_sets,
+        services,
+        config_maps,
+        pod_disruption_budgets,
+    })
+}
+
 pub mod graceful_shutdown;
 pub mod jvm;
 pub mod kerberos;

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

@@ -10,7 +10,14 @@ pub use stackable_operator::v2::types::operator::RoleGroupName;
 use stackable_operator::{
     builder::meta::ObjectMetaBuilder,
     commons::product_image_selection::ResolvedProductImage,
-    k8s_openapi::apimachinery::pkg::apis::meta::v1::ObjectMeta,
+    k8s_openapi::{
+        api::{
+            apps::v1::StatefulSet,
+            core::v1::{ConfigMap, Service},
+            policy::v1::PodDisruptionBudget,
+        },
+        apimachinery::pkg::apis::meta::v1::ObjectMeta,
+    },
     kube::Resource,
     kvp::Labels,
     v2::{
@@ -51,6 +58,17 @@ pub(crate) fn controller_name() -> ControllerName {
         .expect("the controller name is a valid label value")
 }
 
+/// The complete set of Kubernetes resources built for a [`ValidatedCluster`], ready to be applied.
+///
+/// hbase exposes its listeners as volume/PVC sources inside the `StatefulSet` rather than as
+/// top-level `Listener` objects, so (unlike some sibling operators) there is no `listeners` field.
+pub struct KubernetesResources {
+    pub stateful_sets: Vec<StatefulSet>,
+    pub services: Vec<Service>,
+    pub config_maps: Vec<ConfigMap>,
+    pub pod_disruption_budgets: Vec<PodDisruptionBudget>,
+}
+
 /// The validated cluster: proves that config merging and validation succeeded for
 /// every role and role group before any resources are created.
 #[derive(Clone, Debug)]

rust/operator-binary/src/hbase_controller.rs

@@ -30,14 +30,7 @@ use strum::{EnumDiscriminants, IntoStaticStr};
 
 use crate::{
     controller::{
-        RoleGroupName,
-        build::resource::{
-            config_map::build_rolegroup_config_map,
-            discovery::build_discovery_config_map,
-            pdb::build_pdb,
-            service::{build_rolegroup_metrics_service, build_rolegroup_service},
-            statefulset::build_rolegroup_statefulset,
-        },
+        build::{self, resource::discovery::build_discovery_config_map},
         controller_name, operator_name, product_name,
     },
     crd::{APP_NAME, HbaseClusterStatus, OPERATOR_NAME, v1alpha1},
@@ -74,37 +67,11 @@ pub enum Error {
         source: stackable_operator::cluster_resources::Error,
     },
 
-    #[snafu(display("failed to apply Service for role group {role_group}"))]
-    ApplyRoleGroupService {
-        source: stackable_operator::cluster_resources::Error,
-        role_group: RoleGroupName,
-    },
-
-    #[snafu(display("failed to build rolegroup ConfigMap"))]
-    BuildRolegroupConfigMap {
-        source: crate::controller::build::resource::config_map::Error,
-    },
+    #[snafu(display("failed to build cluster resources"))]
+    BuildResources { source: build::Error },
 
-    #[snafu(display("failed to apply ConfigMap for role group {role_group}"))]
-    ApplyRoleGroupConfig {
-        source: stackable_operator::cluster_resources::Error,
-        role_group: RoleGroupName,
-    },
-
-    #[snafu(display("failed to build StatefulSet for role group {role_group}"))]
-    BuildRoleGroupStatefulSet {
-        source: crate::controller::build::resource::statefulset::Error,
-        role_group: RoleGroupName,
-    },
-
-    #[snafu(display("failed to apply StatefulSet for role group {role_group}"))]
-    ApplyRoleGroupStatefulSet {
-        source: stackable_operator::cluster_resources::Error,
-        role_group: RoleGroupName,
-    },
-
-    #[snafu(display("failed to apply PodDisruptionBudget"))]
-    ApplyPdb {
+    #[snafu(display("failed to apply cluster resource"))]
+    ApplyResource {
         source: stackable_operator::cluster_resources::Error,
     },
 
@@ -204,73 +171,43 @@ pub async fn reconcile_hbase(
     // depend on the applied ServiceAccount.
     let service_account_name = rbac_sa.name_any();
 
+    let resources = build::build(
+        &validated_cluster,
+        &client.kubernetes_cluster_info,
+        &service_account_name,
+    )
+    .context(BuildResourcesSnafu)?;
+
     let mut ss_cond_builder = StatefulSetConditionBuilder::default();
 
-    for (hbase_role, role_group_configs) in &validated_cluster.role_group_configs {
-        for (role_group_name, validated_rg_config) in role_group_configs {
-            let rg_service =
-                build_rolegroup_service(&validated_cluster, hbase_role, role_group_name);
-
-            let rg_metrics_service =
-                build_rolegroup_metrics_service(&validated_cluster, hbase_role, role_group_name);
-
-            let rg_configmap = build_rolegroup_config_map(
-                &validated_cluster,
-                &client.kubernetes_cluster_info,
-                hbase_role,
-                role_group_name,
-            )
-            .context(BuildRolegroupConfigMapSnafu)?;
-            let rg_statefulset = build_rolegroup_statefulset(
-                &validated_cluster,
-                hbase_role,
-                role_group_name,
-                validated_rg_config,
-                &service_account_name,
-            )
-            .with_context(|_| BuildRoleGroupStatefulSetSnafu {
-                role_group: role_group_name.clone(),
-            })?;
-            cluster_resources
-                .add(client, rg_service)
-                .await
-                .with_context(|_| ApplyRoleGroupServiceSnafu {
-                    role_group: role_group_name.clone(),
-                })?;
-            cluster_resources
-                .add(client, rg_metrics_service)
-                .await
-                .with_context(|_| ApplyRoleGroupServiceSnafu {
-                    role_group: role_group_name.clone(),
-                })?;
-            cluster_resources
-                .add(client, rg_configmap)
-                .await
-                .with_context(|_| ApplyRoleGroupConfigSnafu {
-                    role_group: role_group_name.clone(),
-                })?;
-
-            // 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.
-            ss_cond_builder.add(
-                cluster_resources
-                    .add(client, rg_statefulset)
-                    .await
-                    .with_context(|_| ApplyRoleGroupStatefulSetSnafu {
-                        role_group: role_group_name.clone(),
-                    })?,
-            );
-        }
-
-        if let Some(role_config) = validated_cluster.role_configs.get(hbase_role)
-            && let Some(pdb) = build_pdb(&role_config.pdb, &validated_cluster, hbase_role)
-        {
+    // Apply order: everything before the StatefulSets, StatefulSets last. A changed ConfigMap or
+    // Secret a Pod mounts must exist before the Pod restarts, otherwise the Pod restarts again
+    // unnecessarily. See https://github.com/stackabletech/commons-operator/issues/111 for details.
+    for service in resources.services {
+        cluster_resources
+            .add(client, service)
+            .await
+            .context(ApplyResourceSnafu)?;
+    }
+    for config_map in resources.config_maps {
+        cluster_resources
+            .add(client, config_map)
+            .await
+            .context(ApplyResourceSnafu)?;
+    }
+    for pdb in resources.pod_disruption_budgets {
+        cluster_resources
+            .add(client, pdb)
+            .await
+            .context(ApplyResourceSnafu)?;
+    }
+    for statefulset in resources.stateful_sets {
+        ss_cond_builder.add(
             cluster_resources
-                .add(client, pdb)
+                .add(client, statefulset)
                 .await
-                .context(ApplyPdbSnafu)?;
-        }
+                .context(ApplyResourceSnafu)?,
+        );
     }
 
     // Discovery CM will fail to build until the rest of the cluster has been deployed, so do it last