lint

src/proxy/h2/client.rs

@@ -29,7 +29,7 @@ use std::task::{Context, Poll};
 use tokio::io::{AsyncRead, AsyncWrite};
 use tokio::sync::oneshot;
 use tokio::sync::watch::Receiver;
-use tracing::{debug, error, trace, warn, Instrument};
+use tracing::{Instrument, debug, error, trace, warn};
 
 #[derive(Debug, Clone)]
 // H2ConnectClient is a wrapper abstracting h2

src/proxy/metrics.rs

@@ -458,7 +458,7 @@ impl ConnectionResult {
             src.identity = tl.source_principal.as_ref().filter(|_| mtls).map(to_value_owned),
 
             dst.addr = %dst.0,
-            dst.hbone_addr = hbone_target.as_ref(),
+            dst.hbone_addr = hbone_target.as_ref().map(display),
             dst.service = tl.destination_service.to_value(),
             dst.workload = dst.1.as_deref().map(to_value),
             dst.namespace = tl.destination_workload_namespace.to_value(),

src/proxy/outbound.rs

@@ -198,7 +198,6 @@ impl OutboundConnection {
             metrics,
         ));
 
-
         let res = match (
             req.protocol,
             req.actual_destination_workload
@@ -229,7 +228,7 @@ impl OutboundConnection {
         connection_stats: &ConnectionResult,
     ) -> Result<(), Error> {
         // Create the outer HBONE stream
-        let upgraded = Box::pin(self.send_hbone_request(remote_addr, &req)).await?;
+        let upgraded = Box::pin(self.send_hbone_request(remote_addr, req)).await?;
         // Wrap upgraded to implement tokio's Async{Write,Read}
         let upgraded = TokioH2Stream::new(upgraded);
 
@@ -703,8 +702,10 @@ mod tests {
                 Some(ExpectedRequest {
                     protocol: r.protocol,
                     hbone_destination: &r
-                        .hbone_target_destination.as_ref()
-                        .unwrap_or(&String::new()),
+                        .hbone_target_destination
+                        .as_ref()
+                        .map(|s| s.to_string())
+                        .unwrap_or_default(),
                     destination: &r.actual_destination.to_string(),
                 })
             );

src/state.rs

@@ -665,7 +665,11 @@ impl DemandProxyState {
     ) -> Result<IpAddr, Error> {
         let workload_uid = workload.uid.clone();
         // FIXME(stevenjin8) Throw a error if this a network gateway without a hostname?
-        let hostname = match workload.network_gateway.as_ref().map(|g| g.destination.clone()) {
+        let hostname = match workload
+            .network_gateway
+            .as_ref()
+            .map(|g| g.destination.clone())
+        {
             Some(Destination::Hostname(hostname)) => hostname.hostname.clone(),
             _ => workload.hostname.clone(),
         };
@@ -802,31 +806,32 @@ impl DemandProxyState {
         };
         let svc_desc = svc.clone().map(|s| ServiceDescription::from(s.as_ref()));
         let ip_family_restriction = svc.as_ref().and_then(|s| s.ip_families);
-        let (selected_workload_ip, proxy_protocol_port_override) =
-            if let Some(network_gateway) = wl.network_gateway.as_ref() {
-                match &network_gateway.destination {
-                    Destination::Address(network_address) => (
-                        network_address.address,
-                        Some(network_gateway.hbone_mtls_port),
-                    ),
-                    Destination::Hostname(_) => (
-                        self.resolve_workload_address(&wl, source_workload, original_target_address)
-                            .await?,
-                        Some(network_gateway.hbone_mtls_port),
-                    ),
-                }
-            } else {
-                (
-                    self.pick_workload_destination_or_resolve(
-                        &wl,
-                        source_workload,
-                        original_target_address,
-                        ip_family_restriction,
-                    )
-                    .await?,
-                    None,
-                ) // if we can't load balance just return the error
-            };
+        let (selected_workload_ip, proxy_protocol_port_override) = if let Some(network_gateway) =
+            wl.network_gateway.as_ref()
+        {
+            match &network_gateway.destination {
+                Destination::Address(network_address) => (
+                    network_address.address,
+                    Some(network_gateway.hbone_mtls_port),
+                ),
+                Destination::Hostname(_) => (
+                    self.resolve_workload_address(&wl, source_workload, original_target_address)
+                        .await?,
+                    Some(network_gateway.hbone_mtls_port),
+                ),
+            }
+        } else {
+            (
+                self.pick_workload_destination_or_resolve(
+                    &wl,
+                    source_workload,
+                    original_target_address,
+                    ip_family_restriction,
+                )
+                .await?,
+                None,
+            ) // if we can't load balance just return the error
+        };
 
         let res = Upstream {
             workload: wl,

tests/namespaced.rs

@@ -402,7 +402,12 @@ mod namespaced {
             .mutate_workload(|w| w.hostname = "waypoint.example.com".into())
             .register()
             .await?;
-        run_hbone_server(waypoint, "waypoint", tcp::Mode::ReadWrite, WAYPOINT_MESSAGE.into())?;
+        run_hbone_server(
+            waypoint,
+            "waypoint",
+            tcp::Mode::ReadWrite,
+            WAYPOINT_MESSAGE.into(),
+        )?;
 
         manager
             .workload_builder("server", DEFAULT_NODE)