refactor: move k8s resources to resource folder, config etc to build

Author: maltesander

…nary/src/operations/graceful_shutdown.rs …rc/controller/build/graceful_shutdown.rsrust/operator-binary/src/operations/graceful_shutdown.rs renamed to rust/operator-binary/src/controller/build/graceful_shutdown.rs rust/operator-binary/src/operations/graceful_shutdown.rs renamed to rust/operator-binary/src/controller/build/graceful_shutdown.rs

@@ -1,4 +1,9 @@
-pub mod config_map;
-pub mod discovery;
+//! Builders that turn a [`ValidatedCluster`](crate::controller::ValidatedCluster) into
+//! Kubernetes resources.
+
+pub mod graceful_shutdown;
 pub mod jvm;
+pub mod kerberos;
+pub mod opa;
 pub mod properties;
+pub mod resource;

rust/operator-binary/src/kerberos.rs …-binary/src/controller/build/kerberos.rsrust/operator-binary/src/kerberos.rs renamed to rust/operator-binary/src/controller/build/kerberos.rs rust/operator-binary/src/kerberos.rs renamed to rust/operator-binary/src/controller/build/kerberos.rs

@@ -7,12 +7,11 @@ use std::collections::BTreeMap;
 use stackable_operator::v2::config_overrides::KeyValueConfigOverrides;
 
 use crate::{
-    controller::build::properties::build_xml_config,
+    controller::build::{opa::HbaseOpaConfig, properties::build_xml_config},
     crd::{
         AnyServiceConfig, HBASE_CLUSTER_DISTRIBUTED, HBASE_MASTER_PORT, HBASE_MASTER_UI_PORT,
         HBASE_REGIONSERVER_PORT, HBASE_REGIONSERVER_UI_PORT, HBASE_ROOTDIR, HbaseRole,
     },
-    security::opa::HbaseOpaConfig,
 };
 
 /// Renders `hbase-site.xml`.

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

@@ -69,9 +69,9 @@ pub(crate) mod test_support {
     use crate::{
         controller::{
             ValidatedCluster, dereference::DereferencedObjects, validate::validate_cluster,
+            zookeeper::ZookeeperConnectionInformation,
         },
         crd::{AnyServiceConfig, HbaseRole, v1alpha1},
-        zookeeper::ZookeeperConnectionInformation,
     };
 
     /// A minimal three-role HbaseCluster used to drive the per-file builder tests.

rust/operator-binary/src/security/opa.rs …rator-binary/src/controller/build/opa.rsrust/operator-binary/src/security/opa.rs renamed to rust/operator-binary/src/controller/build/opa.rs rust/operator-binary/src/security/opa.rs renamed to rust/operator-binary/src/controller/build/opa.rs

@@ -4,15 +4,20 @@ use snafu::{ResultExt, Snafu};
 use stackable_operator::{
     builder::{configmap::ConfigMapBuilder, meta::ObjectMetaBuilder},
     k8s_openapi::api::core::v1::ConfigMap,
+    kube::Resource,
+    kvp::ObjectLabels,
     v2::{builder::meta::ownerreference_from_resource, config_file_writer::to_hadoop_xml},
 };
 
 use crate::{
     controller::{ValidatedCluster, build::properties::ConfigFileName},
-    crd::HbaseRole,
-    hbase_controller::build_recommended_labels,
+    crd::{APP_NAME, HbaseRole, OPERATOR_NAME},
 };
 
+// The discovery `ConfigMap` is a cluster-wide object (not tied to a single role group), so it is
+// labelled with the region-server role and a `discovery` placeholder role-group.
+const DISCOVERY_ROLE_GROUP: &str = "discovery";
+
 type Result<T, E = Error> = std::result::Result<T, E>;
 
 #[derive(Snafu, Debug)]
@@ -46,7 +51,7 @@ pub fn build_discovery_config_map(cluster: &ValidatedCluster) -> Result<ConfigMa
                     cluster,
                     &cluster.image.app_version_label_value,
                     &HbaseRole::RegionServer.to_string(),
-                    "discovery",
+                    DISCOVERY_ROLE_GROUP,
                 ))
                 .context(ObjectMetaSnafu)?
                 .build(),
@@ -58,3 +63,24 @@ pub fn build_discovery_config_map(cluster: &ValidatedCluster) -> Result<ConfigMa
         .build()
         .context(BuildConfigMapSnafu)
 }
+
+/// Recommended labels for the cluster-wide discovery `ConfigMap`.
+fn build_recommended_labels<'a, R>(
+    owner: &'a R,
+    app_version: &'a str,
+    role: &'a str,
+    role_group: &'a str,
+) -> ObjectLabels<'a, R>
+where
+    R: Resource,
+{
+    ObjectLabels {
+        owner,
+        app_name: APP_NAME,
+        app_version,
+        operator_name: OPERATOR_NAME,
+        controller_name: crate::controller::HBASE_CONTROLLER_NAME,
+        role,
+        role_group,
+    }
+}

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

@@ -0,0 +1,8 @@
+//! Builders that turn a [`ValidatedCluster`](crate::controller::ValidatedCluster) into
+//! Kubernetes resources.
+
+pub mod config_map;
+pub mod discovery;
+pub mod pdb;
+pub mod service;
+pub mod statefulset;

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

@@ -0,0 +1,54 @@
+//! Build the per-role `PodDisruptionBudget` for the HbaseCluster.
+
+use stackable_operator::{
+    commons::pdb::PdbConfig, k8s_openapi::api::policy::v1::PodDisruptionBudget,
+    v2::builder::pdb::pod_disruption_budget_builder_with_role,
+};
+
+use crate::{
+    controller::{ValidatedCluster, controller_name, operator_name, product_name},
+    crd::HbaseRole,
+};
+
+/// Builds the [`PodDisruptionBudget`] for the given `role`, or `None` if PDBs are disabled.
+pub fn build_pdb(
+    pdb: &PdbConfig,
+    cluster: &ValidatedCluster,
+    role: &HbaseRole,
+) -> Option<PodDisruptionBudget> {
+    if !pdb.enabled {
+        return None;
+    }
+    let max_unavailable = pdb.max_unavailable.unwrap_or(match role {
+        HbaseRole::Master => max_unavailable_masters(),
+        HbaseRole::RegionServer => max_unavailable_region_servers(),
+        HbaseRole::RestServer => max_unavailable_rest_servers(),
+    });
+    let pdb = pod_disruption_budget_builder_with_role(
+        cluster,
+        &product_name(),
+        &ValidatedCluster::role_name(role),
+        &operator_name(),
+        &controller_name(),
+    )
+    .with_max_unavailable(max_unavailable)
+    .build();
+
+    Some(pdb)
+}
+
+fn max_unavailable_masters() -> u16 {
+    1
+}
+
+fn max_unavailable_region_servers() -> u16 {
+    1
+}
+
+fn max_unavailable_rest_servers() -> u16 {
+    // RestServers are stateless, we only need to make sure we have two available, so we don't have a single point of failure.
+    // However, users probably deploy multiple rest servers for both - availability and performance. As there is the use-case
+    // of having multiple RestServers for availability reasons, we need to be restrictive and stick to our `maxUnavailable: 1`
+    // for `Multiple replicas to increase availability` rolegroups guideline.
+    1
+}