Split node_primary_addresses into a separate module

nightkr · nightkr · commit 71c152c0db4a · 2024-10-10T14:51:33.000+02:00
diff --git a/rust/operator-binary/src/csi_server/node.rs b/rust/operator-binary/src/csi_server/node.rs
@@ -21,7 +21,7 @@ use crate::{
         listener_mounted_pod_label, listener_persistent_volume_label, ListenerMountedPodLabelError,
         ListenerPersistentVolumeLabelError,
     },
-    utils::{error_full_message, node_primary_address},
+    utils::{address::node_primary_addresses, error_full_message},
 };
 
 use super::{tonic_unimplemented, ListenerSelector, ListenerVolumeContext};
@@ -463,7 +463,7 @@ async fn local_listener_addresses_for_pod(
                 obj: ObjectRef::<ListenerClass>::new(listener_class_name).erase(),
             })?;
 
-        Ok(node_primary_address(&node)
+        Ok(node_primary_addresses(&node)
             .pick(listener_class.spec.preferred_address_type)
             .map(|(address, address_type)| ListenerIngress {
                 // nodes: Some(vec![node_name.to_string()]),
diff --git a/rust/operator-binary/src/listener_controller.rs b/rust/operator-binary/src/listener_controller.rs
@@ -30,7 +30,7 @@ use strum::IntoStaticStr;
 
 use crate::{
     csi_server::node::NODE_TOPOLOGY_LABEL_HOSTNAME,
-    utils::{node_primary_address, AddressCandidates},
+    utils::address::{node_primary_addresses, AddressCandidates},
 };
 
 #[cfg(doc)]
@@ -291,7 +291,7 @@ pub async fn reconcile(listener: Arc<Listener>, ctx: Arc<Ctx>) -> Result<control
             addresses = nodes
                 .iter()
                 .flat_map(|node| {
-                    node_primary_address(node).pick(listener_class.spec.preferred_address_type)
+                    node_primary_addresses(node).pick(listener_class.spec.preferred_address_type)
                 })
                 .collect::<Vec<_>>();
             ports = svc
diff --git a/rust/operator-binary/src/utils/address.rs b/rust/operator-binary/src/utils/address.rs
@@ -0,0 +1,118 @@
+use stackable_operator::{commons::listener::AddressType, k8s_openapi::api::core::v1::Node};
+
+/// The primary addresses of an entity, for each type of address.
+#[derive(Debug, Clone, Copy)]
+pub struct AddressCandidates<'a> {
+    pub ip: Option<&'a str>,
+    pub hostname: Option<&'a str>,
+}
+
+impl<'a> AddressCandidates<'a> {
+    /// Tries to pick the preferred [`AddressType`], falling back if it is not available.
+    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 addresses of a Node, which it is expected that external clients should be able to reach it on
+pub fn node_primary_addresses(node: &Node) -> AddressCandidates {
+    let addrs = node
+        .status
+        .as_ref()
+        .and_then(|s| s.addresses.as_deref())
+        .unwrap_or_default();
+
+    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)]
+mod tests {
+    use stackable_operator::{
+        commons::listener::AddressType,
+        k8s_openapi::api::core::v1::{Node, NodeAddress, NodeStatus},
+    };
+
+    use super::node_primary_addresses;
+
+    #[test]
+    fn node_with_only_ips_primary_address_returns_external_ip() {
+        let node = node_from_addresses(vec![("InternalIP", "10.1.2.3"), ("ExternalIP", "1.2.3.4")]);
+        let node_primary_address = node_primary_addresses(&node);
+        assert_eq!(
+            node_primary_address.pick(AddressType::Ip),
+            Some(("1.2.3.4", AddressType::Ip))
+        );
+        assert_eq!(
+            node_primary_address.pick(AddressType::Hostname),
+            Some(("1.2.3.4", AddressType::Ip))
+        );
+    }
+
+    #[test]
+    fn node_with_only_hostname_primary_address_returns_hostname() {
+        let node = node_from_addresses(vec![
+            ("Hostname", "first-hostname"),
+            ("Hostname", "second-hostname"),
+        ]);
+        let node_primary_address = node_primary_addresses(&node);
+        assert_eq!(
+            node_primary_address.pick(AddressType::Ip),
+            Some(("first-hostname", AddressType::Hostname))
+        );
+        assert_eq!(
+            node_primary_address.pick(AddressType::Hostname),
+            Some(("first-hostname", AddressType::Hostname))
+        );
+    }
+
+    #[test]
+    fn node_with_hostname_and_ips_primary_address() {
+        let node = node_from_addresses(vec![
+            ("Hostname", "node-0"),
+            ("ExternalIP", "1.2.3.4"),
+            ("InternalIP", "10.1.2.3"),
+        ]);
+        let node_primary_address = node_primary_addresses(&node);
+        assert_eq!(
+            node_primary_address.pick(AddressType::Ip),
+            Some(("1.2.3.4", AddressType::Ip))
+        );
+        assert_eq!(
+            node_primary_address.pick(AddressType::Hostname),
+            Some(("node-0", AddressType::Hostname))
+        );
+    }
+
+    fn node_from_addresses<'a>(addresses: impl IntoIterator<Item = (&'a str, &'a str)>) -> Node {
+        Node {
+            status: Some(NodeStatus {
+                addresses: Some(
+                    addresses
+                        .into_iter()
+                        .map(|(ty, addr)| NodeAddress {
+                            type_: ty.to_string(),
+                            address: addr.to_string(),
+                        })
+                        .collect(),
+                ),
+                ..Default::default()
+            }),
+            ..Default::default()
+        }
+    }
+}
diff --git a/rust/operator-binary/src/utils/mod.rs b/rust/operator-binary/src/utils/mod.rs
@@ -2,13 +2,14 @@ use std::{os::unix::prelude::AsRawFd, path::Path};
 
 use pin_project::pin_project;
 use socket2::Socket;
-use stackable_operator::{commons::listener::AddressType, k8s_openapi::api::core::v1::Node};
 use tokio::{
     io::{AsyncRead, AsyncWrite},
     net::{UnixListener, UnixStream},
 };
 use tonic::transport::server::Connected;
 
+pub mod address;
+
 /// Adapter for using [`UnixStream`] as a [`tonic`] connection
 /// Tonic usually communicates via TCP sockets, but the Kubernetes CSI interface expects
 /// plugins to use Unix sockets instead.
@@ -101,52 +102,9 @@ 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) -> AddressCandidates {
-    let addrs = node
-        .status
-        .as_ref()
-        .and_then(|s| s.addresses.as_deref())
-        .unwrap_or_default();
-
-    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)]
 mod tests {
-    use stackable_operator::{
-        commons::listener::AddressType,
-        k8s_openapi::api::core::v1::{Node, NodeAddress, NodeStatus},
-    };
-
-    use crate::utils::{error_full_message, node_primary_address};
+    use crate::utils::error_full_message;
 
     #[test]
     fn error_messages() {
@@ -164,71 +122,4 @@ mod tests {
             "leaf: middleware: root error"
         );
     }
-
-    #[test]
-    fn node_with_only_ips_primary_address_returns_external_ip() {
-        let node = node_from_addresses(vec![("InternalIP", "10.1.2.3"), ("ExternalIP", "1.2.3.4")]);
-        let node_primary_address = node_primary_address(&node);
-        assert_eq!(
-            node_primary_address.pick(AddressType::Ip),
-            Some(("1.2.3.4", AddressType::Ip))
-        );
-        assert_eq!(
-            node_primary_address.pick(AddressType::Hostname),
-            Some(("1.2.3.4", AddressType::Ip))
-        );
-    }
-
-    #[test]
-    fn node_with_only_hostname_primary_address_returns_hostname() {
-        let node = node_from_addresses(vec![
-            ("Hostname", "first-hostname"),
-            ("Hostname", "second-hostname"),
-        ]);
-        let node_primary_address = node_primary_address(&node);
-        assert_eq!(
-            node_primary_address.pick(AddressType::Ip),
-            Some(("first-hostname", AddressType::Hostname))
-        );
-        assert_eq!(
-            node_primary_address.pick(AddressType::Hostname),
-            Some(("first-hostname", AddressType::Hostname))
-        );
-    }
-
-    #[test]
-    fn node_with_hostname_and_ips_primary_address() {
-        let node = node_from_addresses(vec![
-            ("Hostname", "node-0"),
-            ("ExternalIP", "1.2.3.4"),
-            ("InternalIP", "10.1.2.3"),
-        ]);
-        let node_primary_address = node_primary_address(&node);
-        assert_eq!(
-            node_primary_address.pick(AddressType::Ip),
-            Some(("1.2.3.4", AddressType::Ip))
-        );
-        assert_eq!(
-            node_primary_address.pick(AddressType::Hostname),
-            Some(("node-0", AddressType::Hostname))
-        );
-    }
-
-    fn node_from_addresses<'a>(addresses: impl IntoIterator<Item = (&'a str, &'a str)>) -> Node {
-        Node {
-            status: Some(NodeStatus {
-                addresses: Some(
-                    addresses
-                        .into_iter()
-                        .map(|(ty, addr)| NodeAddress {
-                            type_: ty.to_string(),
-                            address: addr.to_string(),
-                        })
-                        .collect(),
-                ),
-                ..Default::default()
-            }),
-            ..Default::default()
-        }
-    }
 }
