Make preferred NodePort address type configurable

Author: nightkr

Cargo.lock

@@ -21,7 +21,7 @@ prost = "0.13"
 prost-types = "0.13"
 serde = "1.0"
 snafu = "0.8"
-stackable-operator = { git = "https://github.com/stackabletech/operator-rs.git", tag = "stackable-operator-0.76.0" }
+stackable-operator = { git = "https://github.com/stackabletech/operator-rs.git", tag = "stackable-operator-0.78.0" }
 strum = { version = "0.26", features = ["derive"] }
 socket2 = { version = "0.5", features = ["all"] }
 tokio = { version = "1.40", features = ["full"] }
@@ -31,5 +31,7 @@ tonic-build = "0.12"
 tonic-reflection = "0.12"
 tracing = "0.1.40"
 
-# [patch."https://github.com/stackabletech/operator-rs.git"]
+[patch."https://github.com/stackabletech/operator-rs.git"]
+# stackable-operator = { path = "../operator-rs/crates/stackable-operator" }
 # stackable-operator = { git = "https://github.com/stackabletech//operator-rs.git", branch = "main" }
+stackable-operator = { git = "https://github.com/stackabletech//operator-rs.git", branch = "feature/listenerclass-preferred-address-type" }

Cargo.nix

@@ -24,6 +24,16 @@ spec:
             spec:
               description: Defines a policy for how [Listeners](https://docs.stackable.tech/home/nightly/listener-operator/listener) should be exposed. Read the [ListenerClass documentation](https://docs.stackable.tech/home/nightly/listener-operator/listenerclass) for more information.
               properties:
+                preferredAddressType:
+                  default: Hostname
+                  description: |-
+                    Whether addresses should prefer using the IP address (`IP`) or the hostname (`Hostname`).
+
+                    The other type will be used if the preferred type is not available.
+                  enum:
+                    - Hostname
+                    - IP
+                  type: string
                 serviceAnnotations:
                   additionalProperties:
                     type: string

Cargo.toml

@@ -4,8 +4,8 @@ use snafu::{OptionExt, ResultExt, Snafu};
 use stackable_operator::{
     builder::meta::OwnerReferenceBuilder,
     commons::listener::{
-        Listener, ListenerIngress, ListenerPort, ListenerSpec, PodListener, PodListenerScope,
-        PodListeners, PodListenersSpec,
+        Listener, ListenerClass, ListenerIngress, ListenerPort, ListenerSpec, PodListener,
+        PodListenerScope, PodListeners, PodListenersSpec,
     },
     k8s_openapi::api::core::v1::{Node, PersistentVolume, PersistentVolumeClaim, Pod, Volume},
     kube::{
@@ -72,6 +72,9 @@ enum PublishVolumeError {
         listener: ObjectRef<Listener>,
     },
 
+    #[snafu(display("{listener} has no associated ListenerClass"))]
+    ListenerHasNoClass { listener: ObjectRef<Listener> },
+
     #[snafu(display("{pod} has not been scheduled to a node yet"))]
     PodHasNoNode { pod: ObjectRef<Pod> },
 
@@ -131,6 +134,7 @@ impl From<PublishVolumeError> for Status {
             PublishVolumeError::PodHasNoNode { .. } => Status::unavailable(full_msg),
             PublishVolumeError::ListenerPvReference { .. } => Status::failed_precondition(full_msg),
             PublishVolumeError::ListenerPodSelector { .. } => Status::failed_precondition(full_msg),
+            PublishVolumeError::ListenerHasNoClass { .. } => Status::failed_precondition(full_msg),
             PublishVolumeError::BuildListenerOwnerRef { .. } => Status::unavailable(full_msg),
             PublishVolumeError::ApplyListener { .. } => Status::unavailable(full_msg),
             PublishVolumeError::AddListenerLabelToPv { .. } => Status::unavailable(full_msg),
@@ -442,10 +446,25 @@ async fn local_listener_addresses_for_pod(
             .get::<Node>(node_name, &())
             .await
             .with_context(|_| GetObjectSnafu {
-                obj: { ObjectRef::<Node>::new(node_name).erase() },
+                obj: ObjectRef::<Node>::new(node_name).erase(),
+            })?;
+        let listener_class_name =
+            listener
+                .spec
+                .class_name
+                .as_deref()
+                .with_context(|| ListenerHasNoClassSnafu {
+                    listener: ObjectRef::from_obj(listener),
+                })?;
+        let listener_class = client
+            .get::<ListenerClass>(listener_class_name, &())
+            .await
+            .with_context(|_| GetObjectSnafu {
+                obj: ObjectRef::<ListenerClass>::new(listener_class_name).erase(),
             })?;
 
         Ok(node_primary_address(&node)
+            .pick(listener_class.spec.preferred_address_type)
             .map(|(address, address_type)| ListenerIngress {
                 // nodes: Some(vec![node_name.to_string()]),
                 address: address.to_string(),

crate-hashes.json

@@ -286,7 +286,9 @@ pub async fn reconcile(listener: Arc<Listener>, ctx: Arc<Ctx>) -> Result<control
             .await?;
             addresses = nodes
                 .iter()
-                .flat_map(node_primary_address)
+                .flat_map(|node| {
+                    node_primary_address(node).pick(listener_class.spec.preferred_address_type)
+                })
                 .collect::<Vec<_>>();
             ports = svc
                 .spec

deploy/helm/listener-operator/crds/crds.yaml

@@ -101,26 +101,42 @@ pub fn error_full_message(err: &dyn std::error::Error) -> String {
     full_msg
 }
 
+#[derive(Debug, Clone, Copy)]
+pub struct AddressCandidates<'a> {
+    pub ip: Option<&'a str>,
+    pub hostname: Option<&'a str>,
+}
+
+impl<'a> AddressCandidates<'a> {
+    pub fn pick(&self, preferred_address_type: AddressType) -> Option<(&'a str, AddressType)> {
+        let ip = self.ip.zip(Some(AddressType::Ip));
+        let hostname = self.hostname.zip(Some(AddressType::Hostname));
+        match preferred_address_type {
+            AddressType::Ip => ip.or(hostname),
+            AddressType::Hostname => hostname.or(ip),
+        }
+    }
+}
+
 /// Try to guess the primary address of a Node, which it is expected that external clients should be able to reach it on
-pub fn node_primary_address(node: &Node) -> Option<(&str, AddressType)> {
+pub fn node_primary_address(node: &Node) -> AddressCandidates {
     let addrs = node
         .status
         .as_ref()
         .and_then(|s| s.addresses.as_deref())
         .unwrap_or_default();
-    // IP addresses are currently preferred over hostnames since nodes don't always have resolvable hostnames
-    addrs
-        .iter()
-        .find(|addr| addr.type_ == "ExternalIP")
-        .or_else(|| addrs.iter().find(|addr| addr.type_ == "InternalIP"))
-        .zip(Some(AddressType::Ip))
-        .or_else(|| {
-            addrs
-                .iter()
-                .find(|addr| addr.type_ == "Hostname")
-                .zip(Some(AddressType::Hostname))
-        })
-        .map(|(addr, ty)| (addr.address.as_str(), ty))
+
+    AddressCandidates {
+        ip: addrs
+            .iter()
+            .find(|addr| addr.type_ == "ExternalIP")
+            .or_else(|| addrs.iter().find(|addr| addr.type_ == "InternalIP"))
+            .map(|addr| addr.address.as_str()),
+        hostname: addrs
+            .iter()
+            .find(|addr| addr.type_ == "Hostname")
+            .map(|addr| addr.address.as_str()),
+    }
 }
 
 #[cfg(test)]