chore: cleanup constants

Author: maltesander

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

@@ -4,7 +4,10 @@ use stackable_operator::{
     v2::jvm_argument_overrides::JvmArgumentOverrides,
 };
 
-use crate::crd::{AnyServiceConfig, CONFIG_DIR_NAME, JVM_SECURITY_PROPERTIES_FILE, v1alpha1};
+use crate::{
+    controller::build::kerberos::KRB5_CONFIG_PATH,
+    crd::{AnyServiceConfig, CONFIG_DIR_NAME, JVM_SECURITY_PROPERTIES_FILE, v1alpha1},
+};
 
 const JAVA_HEAP_FACTOR: f32 = 0.8;
 
@@ -24,7 +27,7 @@ pub fn construct_global_jvm_args(kerberos_enabled: bool) -> String {
     let mut jvm_args = Vec::new();
 
     if kerberos_enabled {
-        jvm_args.push("-Djava.security.krb5.conf=/stackable/kerberos/krb5.conf");
+        jvm_args.push(format!("-Djava.security.krb5.conf={KRB5_CONFIG_PATH}"));
     }
 
     // We do *not* add user overrides to the global JVM args, but only the role specific JVM arguments.
@@ -54,8 +57,7 @@ pub fn construct_role_specific_non_heap_jvm_args(
     )];
 
     if hbase.has_kerberos_enabled() {
-        operator_generated
-            .push("-Djava.security.krb5.conf=/stackable/kerberos/krb5.conf".to_owned());
+        operator_generated.push(format!("-Djava.security.krb5.conf={KRB5_CONFIG_PATH}"));
     }
 
     let mut jvm_args = merged_jvm_argument_overrides.apply_to(operator_generated);

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

@@ -18,6 +18,14 @@ use stackable_operator::{
 
 use crate::crd::{TLS_STORE_DIR, TLS_STORE_PASSWORD, TLS_STORE_VOLUME_NAME, v1alpha1};
 
+/// Mount path of the Kerberos secret volume (keytab + `krb5.conf`).
+pub const STACKABLE_KERBEROS_DIR: &str = "/stackable/kerberos";
+/// Path of the `krb5.conf` rendered into the Kerberos secret volume. Referenced both here (the
+/// `KRB5_CONFIG` env var) and by the JVM args builder.
+pub const KRB5_CONFIG_PATH: &str = const_format::concatcp!(STACKABLE_KERBEROS_DIR, "/krb5.conf");
+/// Name of the Kerberos secret volume.
+const KERBEROS_VOLUME_NAME: &str = "kerberos";
+
 #[derive(Snafu, Debug)]
 pub enum Error {
     #[snafu(display("object {hbase} is missing namespace"))]
@@ -188,16 +196,16 @@ pub fn add_kerberos_pod_config(
         .build()
         .context(AddKerberosSecretVolumeSnafu)?;
         pb.add_volume(
-            VolumeBuilder::new("kerberos")
+            VolumeBuilder::new(KERBEROS_VOLUME_NAME)
                 .ephemeral(kerberos_secret_operator_volume)
                 .build(),
         )
         .context(AddVolumeSnafu)?;
-        cb.add_volume_mount("kerberos", "/stackable/kerberos")
+        cb.add_volume_mount(KERBEROS_VOLUME_NAME, STACKABLE_KERBEROS_DIR)
             .context(AddVolumeMountSnafu)?;
 
         // Needed env vars
-        cb.add_env_var("KRB5_CONFIG", "/stackable/kerberos/krb5.conf");
+        cb.add_env_var("KRB5_CONFIG", KRB5_CONFIG_PATH);
     }
 
     if let Some(https_secret_class) = hbase.https_secret_class() {

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

@@ -1,6 +1,6 @@
 //! Build the per-rolegroup `StatefulSet` for the HbaseCluster.
 
-use std::{collections::BTreeMap, str::FromStr};
+use std::str::FromStr;
 
 use indoc::formatdoc;
 use snafu::{OptionExt, ResultExt, Snafu};
@@ -16,16 +16,16 @@ use stackable_operator::{
         api::{
             apps::v1::{StatefulSet, StatefulSetSpec},
             core::v1::{
-                ConfigMapVolumeSource, ContainerPort, EnvVar, Probe, ServiceAccount,
-                TCPSocketAction, Volume,
+                ConfigMapVolumeSource, ContainerPort, Probe, ServiceAccount, TCPSocketAction,
+                Volume,
             },
         },
         apimachinery::pkg::{apis::meta::v1::LabelSelector, util::intstr::IntOrString},
     },
     kube::ResourceExt,
     product_logging,
     v2::{
-        builder::pod::container::EnvVarSet,
+        builder::pod::container::{EnvVarName, EnvVarSet},
         product_logging::framework::{ValidatedContainerLogConfigChoice, vector_container},
         types::{
             kubernetes::{ContainerName, VolumeName},
@@ -43,9 +43,7 @@ use crate::{
             properties::logging::{MAX_HBASE_LOG_FILES_SIZE, STACKABLE_LOG_DIR},
         },
     },
-    crd::{
-        CONFIG_DIR_NAME, HbaseRole, LISTENER_VOLUME_DIR, LISTENER_VOLUME_NAME, merged_env, v1alpha1,
-    },
+    crd::{CONFIG_DIR_NAME, HbaseRole, LISTENER_VOLUME_DIR, LISTENER_VOLUME_NAME, v1alpha1},
 };
 
 stackable_operator::constant!(VECTOR_CONTAINER_NAME: ContainerName = "vector");
@@ -149,33 +147,30 @@ pub fn build_rolegroup_statefulset(
         ..probe_template
     };
 
-    let mut env_map: BTreeMap<String, String> = BTreeMap::from([
-        ("HBASE_CONF_DIR".to_string(), CONFIG_DIR_NAME.to_string()),
+    let merged_env = EnvVarSet::new()
+        .with_value(
+            &EnvVarName::from_str_unsafe("HBASE_CONF_DIR"),
+            CONFIG_DIR_NAME,
+        )
         // required by phoenix (for cases where Kerberos is enabled): see https://issues.apache.org/jira/browse/PHOENIX-2369
-        ("HADOOP_CONF_DIR".to_string(), CONFIG_DIR_NAME.to_string()),
-    ]);
-    for env_var in validated_rg_config.env_overrides.clone() {
-        env_map.insert(env_var.name, env_var.value.unwrap_or_default());
-    }
-    let mut merged_env = merged_env(&env_map);
-    // This env var is set for all roles to avoid bash's "unbound variable" errors
-    merged_env.extend([
-        EnvVar {
-            name: "REGION_MOVER_OPTS".to_string(),
-            value: Some(merged_config.region_mover_args()),
-            ..EnvVar::default()
-        },
-        EnvVar {
-            name: "RUN_REGION_MOVER".to_string(),
-            value: Some(merged_config.run_region_mover().to_string()),
-            ..EnvVar::default()
-        },
-        EnvVar {
-            name: "STACKABLE_LOG_DIR".to_string(),
-            value: Some(STACKABLE_LOG_DIR.to_string()),
-            ..EnvVar::default()
-        },
-    ]);
+        .with_value(
+            &EnvVarName::from_str_unsafe("HADOOP_CONF_DIR"),
+            CONFIG_DIR_NAME,
+        )
+        .merge(validated_rg_config.env_overrides.clone())
+        // These env vars are set for all roles to avoid bash's "unbound variable" errors.
+        .with_value(
+            &EnvVarName::from_str_unsafe("REGION_MOVER_OPTS"),
+            merged_config.region_mover_args(),
+        )
+        .with_value(
+            &EnvVarName::from_str_unsafe("RUN_REGION_MOVER"),
+            merged_config.run_region_mover().to_string(),
+        )
+        .with_value(
+            &EnvVarName::from_str_unsafe("STACKABLE_LOG_DIR"),
+            STACKABLE_LOG_DIR,
+        );
 
     let role_name = hbase_role.cli_role_name();
     let mut hbase_container = ContainerBuilder::new("hbase").expect("ContainerBuilder not created");

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

@@ -1,5 +1,3 @@
-use std::collections::BTreeMap;
-
 use security::AuthenticationConfig;
 use serde::{Deserialize, Serialize};
 use shell_escape::escape;
@@ -24,7 +22,7 @@ use stackable_operator::{
     },
     deep_merger::ObjectOverrides,
     k8s_openapi::{
-        api::core::v1::{EnvVar, PersistentVolumeClaim, Volume},
+        api::core::v1::{PersistentVolumeClaim, Volume},
         apimachinery::pkg::api::resource::Quantity,
     },
     kube::CustomResource,
@@ -263,17 +261,6 @@ impl v1alpha1::HbaseCluster {
     }
 }
 
-pub fn merged_env(rolegroup_config: &BTreeMap<String, String>) -> Vec<EnvVar> {
-    rolegroup_config
-        .iter()
-        .map(|(env_name, env_value)| EnvVar {
-            name: env_name.clone(),
-            value: Some(env_value.to_owned()),
-            value_from: None,
-        })
-        .collect()
-}
-
 #[derive(
     Clone,
     Debug,