use ephemeral volumes for master/rs

Author: adwk67

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

@@ -6,6 +6,10 @@ use serde::{Deserialize, Serialize};
 use shell_escape::escape;
 use snafu::{OptionExt, ResultExt, Snafu};
 use stackable_operator::{
+    builder::pod::volume::{
+        ListenerOperatorVolumeSourceBuilder, ListenerOperatorVolumeSourceBuilderError,
+        ListenerReference, VolumeBuilder,
+    },
     commons::{
         affinity::StackableAffinity,
         cluster_operation::ClusterOperation,
@@ -21,10 +25,11 @@ use stackable_operator::{
     },
     k8s_openapi::{
         DeepMerge,
-        api::core::v1::{EnvVar, PodTemplateSpec},
+        api::core::v1::{EnvVar, PersistentVolumeClaim, PodTemplateSpec, Volume},
         apimachinery::pkg::api::resource::Quantity,
     },
     kube::{CustomResource, ResourceExt, runtime::reflector::ObjectRef},
+    kvp::Labels,
     product_config_utils::Configuration,
     product_logging::{self, spec::Logging},
     role_utils::{GenericRoleConfig, JavaCommonConfig, Role, RoleGroupRef},
@@ -110,6 +115,21 @@ pub enum Error {
 
     #[snafu(display("role-group not found by name"))]
     RoleGroupNotFound,
+
+    #[snafu(display("failed to build listener volume source"))]
+    ListenerVolumeSource {
+        source: ListenerOperatorVolumeSourceBuilderError,
+    },
+
+    #[snafu(display("failed to build listener volume"))]
+    BuildListenerVolume {
+        source: ListenerOperatorVolumeSourceBuilderError,
+    },
+
+    #[snafu(display("failed to build listener pvc"))]
+    BuildListenerPvc {
+        source: ListenerOperatorVolumeSourceBuilderError,
+    },
 }
 
 #[versioned(version(name = "v1alpha1"))]
@@ -689,6 +709,54 @@ impl HbaseRole {
             HbaseRole::RestServer => "rest".to_string(),
         }
     }
+
+    pub fn listener_volume(
+        &self,
+        merged_config: &AnyServiceConfig,
+        recommended_labels: &Labels,
+    ) -> Result<Option<Volume>, Error> {
+        let volume = match &self {
+            // Master and regionservers should use ephemeral listener volumes
+            // since clients pull the latest address from ZooKeeper
+            HbaseRole::Master | HbaseRole::RegionServer => Some(
+                VolumeBuilder::new(LISTENER_VOLUME_NAME)
+                    .ephemeral(
+                        ListenerOperatorVolumeSourceBuilder::new(
+                            &ListenerReference::ListenerClass(
+                                merged_config.listener_class().to_string(),
+                            ),
+                            recommended_labels,
+                        )
+                        .context(ListenerVolumeSourceSnafu)?
+                        .build_ephemeral()
+                        .context(BuildListenerVolumeSnafu)?,
+                    )
+                    .build(),
+            ),
+            HbaseRole::RestServer => None,
+        };
+        Ok(volume)
+    }
+
+    pub fn listener_pvc(
+        &self,
+        merged_config: &AnyServiceConfig,
+        recommended_labels: &Labels,
+    ) -> Result<Option<Vec<PersistentVolumeClaim>>, Error> {
+        let pvc = match &self {
+            HbaseRole::Master | HbaseRole::RegionServer => None,
+            HbaseRole::RestServer => Some(vec![
+                ListenerOperatorVolumeSourceBuilder::new(
+                    &ListenerReference::ListenerClass(merged_config.listener_class().to_string()),
+                    recommended_labels,
+                )
+                .context(ListenerVolumeSourceSnafu)?
+                .build_pvc(LISTENER_VOLUME_NAME.to_string())
+                .context(BuildListenerPvcSnafu)?,
+            ]),
+        };
+        Ok(pvc)
+    }
 }
 
 fn default_resources(role: &HbaseRole) -> ResourcesFragment<HbaseStorageConfig, NoRuntimeLimits> {

rust/operator-binary/src/hbase_controller.rs

@@ -21,14 +21,8 @@ use stackable_operator::{
         configmap::ConfigMapBuilder,
         meta::ObjectMetaBuilder,
         pod::{
-            PodBuilder,
-            container::ContainerBuilder,
-            resources::ResourceRequirementsBuilder,
+            PodBuilder, container::ContainerBuilder, resources::ResourceRequirementsBuilder,
             security::PodSecurityContextBuilder,
-            volume::{
-                ListenerOperatorVolumeSourceBuilder, ListenerOperatorVolumeSourceBuilderError,
-                ListenerReference,
-            },
         },
     },
     cluster_resources::{ClusterResourceApplyStrategy, ClusterResources},
@@ -323,9 +317,10 @@ pub enum Error {
     },
 
     #[snafu(display("failed to build listener volume"))]
-    BuildListenerVolume {
-        source: ListenerOperatorVolumeSourceBuilderError,
-    },
+    ListenerVolume { source: crate::crd::Error },
+
+    #[snafu(display("failed to build listener persistent volume claim"))]
+    ListenerPersistentVolumeClaim { source: crate::crd::Error },
 }
 
 type Result<T, E = Error> = std::result::Result<T, E>;
@@ -968,15 +963,6 @@ fn build_rolegroup_statefulset(
         .service_account_name(service_account.name_any())
         .security_context(PodSecurityContextBuilder::new().fs_group(1000).build());
 
-    // externally-reachable listener endpoints should use a pvc volume...
-    let pvc = ListenerOperatorVolumeSourceBuilder::new(
-        &ListenerReference::ListenerClass(merged_config.listener_class().to_string()),
-        &recommended_labels,
-    )
-    .context(BuildListenerVolumeSnafu)?
-    .build_pvc(LISTENER_VOLUME_NAME.to_string())
-    .context(BuildListenerVolumeSnafu)?;
-
     if let Some(ContainerLogConfig {
         choice:
             Some(ContainerLogConfigChoice::Custom(CustomContainerLogConfig {
@@ -1047,7 +1033,21 @@ fn build_rolegroup_statefulset(
         }
     }
 
+    let listener_pvc = hbase_role
+        .listener_pvc(merged_config, &recommended_labels)
+        .context(ListenerPersistentVolumeClaimSnafu)?;
+
+    if let Some(listener_volume) = hbase_role
+        .listener_volume(merged_config, &recommended_labels)
+        .context(ListenerVolumeSnafu)?
+    {
+        pod_builder
+            .add_volume(listener_volume)
+            .context(AddVolumeSnafu)?;
+    };
+
     let mut pod_template = pod_builder.build_template();
+
     hbase.merge_pod_overrides(&mut pod_template, hbase_role, rolegroup_ref);
 
     let metadata = ObjectMetaBuilder::new()
@@ -1081,7 +1081,7 @@ fn build_rolegroup_statefulset(
         },
         service_name: Some(headless_service_name(&rolegroup_ref.object_name())),
         template: pod_template,
-        volume_claim_templates: Some(vec![pvc]),
+        volume_claim_templates: listener_pvc,
         ..StatefulSetSpec::default()
     };
 

tests/templates/kuttl/external-access/20-assert.yaml.j2

@@ -56,28 +56,28 @@ status:
 apiVersion: v1
 kind: Service
 metadata:
-  name: listener-test-hbase-master-external-unstable-0
+  name: test-hbase-master-external-unstable-0-listener
 spec:
   type: NodePort
 ---
 apiVersion: v1
 kind: Service
 metadata:
-  name: listener-test-hbase-master-external-unstable-1
+  name: test-hbase-master-external-unstable-1-listener
 spec:
   type: NodePort
 ---
 apiVersion: v1
 kind: Service
 metadata:
-  name: listener-test-hbase-regionserver-external-stable-0
+  name: test-hbase-regionserver-external-stable-0-listener
 spec:
   type: NodePort
 ---
 apiVersion: v1
 kind: Service
 metadata:
-  name: listener-test-hbase-regionserver-external-unstable-0
+  name: test-hbase-regionserver-external-unstable-0-listener
 spec:
   type: NodePort
 ---