lookup waypoint svc by proxy port

avoids needing the service to specify the zTunnel's HBONE port

Author: stevenctl

src/proxy/outbound.rs

@@ -432,7 +432,18 @@ impl OutboundConnection {
                             self.pi.metrics.clone(),
                         )
                         .await?;
-                    let wp_socket_addr = SocketAddr::new(waypoint_ip, waypoint_us.port);
+
+                    // For sandwich, the inbound side resolves the waypoints port.
+                    // When using PROXY we want to use the Waypoint's zTunnel
+                    // TODO tunnel protocol should hint this to allow PROXY + HBONE?
+                    let wp_port = mutable_us
+                        .workload
+                        .waypoint
+                        .as_ref()
+                        .map(|w| w.proxy_protocol_port)
+                        .map_or_else(|| waypoint_us.port, |_| self.pi.hbone_port);
+
+                    let wp_socket_addr = SocketAddr::new(waypoint_ip, wp_port);
                     return Ok(Request {
                         // Always use HBONE here
                         protocol: Protocol::HBONE,

src/state.rs

@@ -451,15 +451,16 @@ impl DemandProxyState {
         target_addr: &NetworkAddress,
         waypoint_addr: &NetworkAddress,
     ) -> Option<GatewayAddress> {
-        let fetch =
-            |target_addr: &NetworkAddress, waypoint_addr: &NetworkAddress| -> Result<Option<GatewayAddress>, Error> {
-                let state = self.state.read().unwrap();
+        let fetch = |target_addr: &NetworkAddress,
+                     waypoint_addr: &NetworkAddress|
+         -> Result<Option<GatewayAddress>, Error> {
+            let state = self.state.read().unwrap();
 
-                // Collect all the possible waypoints for the target. 
-                let Some(target) = state.find_address(target_addr) else {
+            // Collect all the possible waypoints for the target.
+            let Some(target) = state.find_address(target_addr) else {
                     return Err(Error::UnknownDestination(target_addr.address));
                 };
-                let Some(mut target_waypoints) = (match target {
+            let Some(mut target_waypoints) = (match target {
                     Address::Workload(wl) => wl
                         .waypoint
                         .map(|addr| vec![(addr.destination.clone(), (1, addr))].into_iter().collect()),
@@ -468,27 +469,35 @@ impl DemandProxyState {
                     debug!("No waypoints for target workload: {target_addr}");
                     return Ok(None);
                 };
-                if target_waypoints.is_empty() {
-                    debug!("No waypoints for target service: {target_addr}");
-                    return Ok(None);
-                }
+            if target_waypoints.is_empty() {
+                debug!("No waypoints for target service: {target_addr}");
+                return Ok(None);
+            }
 
-                // Waypoint instance is referenced directly
-                if let Some((_, gw_addr)) = target_waypoints.remove(&Destination::Address(waypoint_addr.clone())) {
-                    return Ok(Some(gw_addr));
-                }
+            // Waypoint instance is referenced directly
+            if let Some((_, gw_addr)) =
+                target_waypoints.remove(&Destination::Address(waypoint_addr.clone()))
+            {
+                return Ok(Some(gw_addr));
+            }
 
-                // Waypoint is referenced by the service it's part of
-                Ok(state.workloads.find_address(waypoint_addr).map(|wl| {
+            // Waypoint is referenced by the service it's part of
+            Ok(state
+                .workloads
+                .find_address(waypoint_addr)
+                .map(|wl| {
                     state
                         .services
                         .get_by_workload(&wl)
                         .iter()
                         .flat_map(|svc| &svc.vips)
-                        .find_map(|wp_vip| target_waypoints.remove(&Destination::Address(wp_vip.clone())))
+                        .find_map(|wp_vip| {
+                            target_waypoints.remove(&Destination::Address(wp_vip.clone()))
+                        })
                         .map(|el| el.1)
-                }).flatten())
-            };
+                })
+                .flatten())
+        };
         if let Ok(result) = fetch(target_addr, waypoint_addr) {
             return result;
         }
@@ -565,7 +574,12 @@ impl DemandProxyState {
                 ));
             }
         };
-        let wp_socket_addr = SocketAddr::new(wp_nw_addr.address, gw_address.hbone_mtls_port);
+        let wp_socket_addr = SocketAddr::new(
+            wp_nw_addr.address,
+            gw_address
+                .proxy_protocol_port
+                .unwrap_or(gw_address.hbone_mtls_port),
+        );
         match self
             .fetch_upstream(&wp_nw_addr.network, wp_socket_addr)
             .await