Apply rustfmt formatting

Author: sl5-guy

sidecar/src/bridge.rs

@@ -97,10 +97,7 @@ impl GatewayConnector {
     }
 
     /// Send a CONNECT request to the gateway. On connection error, reconnect once and retry.
-    pub async fn send_connect(
-        &self,
-        authority: &str,
-    ) -> anyhow::Result<Response<Incoming>> {
+    pub async fn send_connect(&self, authority: &str) -> anyhow::Result<Response<Incoming>> {
         let req = build_connect_request(authority)?;
         let mut sender = self.get_sender().await?;
 

src/config.rs

@@ -57,9 +57,8 @@ impl Config {
             .parse::<std::net::SocketAddr>()
             .map_err(|e| anyhow::anyhow!("invalid server.listen_addr: {e}"))?;
 
-        let _oid =
-            x509_parser::oid_registry::Oid::from_str(&self.policy.client_ext_oid)
-                .map_err(|e| anyhow::anyhow!("invalid policy.client_ext_oid: {e:?}"))?;
+        let _oid = x509_parser::oid_registry::Oid::from_str(&self.policy.client_ext_oid)
+            .map_err(|e| anyhow::anyhow!("invalid policy.client_ext_oid: {e:?}"))?;
 
         for (i, rule) in self.policy.rules.iter().enumerate() {
             anyhow::ensure!(
@@ -72,9 +71,7 @@ impl Config {
             );
             for (j, dest) in rule.allowed_destinations.iter().enumerate() {
                 policy::normalize_destination(dest).map_err(|e| {
-                    anyhow::anyhow!(
-                        "policy.rules[{i}].allowed_destinations[{j}]: {e}"
-                    )
+                    anyhow::anyhow!("policy.rules[{i}].allowed_destinations[{j}]: {e}")
                 })?;
             }
         }

src/policy.rs

@@ -56,7 +56,6 @@ impl TomlPolicyEngine {
             rules,
         })
     }
-
 }
 
 /// Parse a destination string into canonical lowercase `host:port` (or
@@ -94,8 +93,11 @@ pub fn normalize_destination(dest: &str) -> anyhow::Result<String> {
         (host_inner.to_owned(), port)
     } else if dest.matches(':').count() > 1 {
         // Multiple colons without brackets: treat as bare IPv6, validate.
-        dest.parse::<std::net::Ipv6Addr>()
-            .map_err(|_| anyhow::anyhow!("ambiguous multi-colon destination {dest:?}; use [ipv6]:port for IPv6 with port"))?;
+        dest.parse::<std::net::Ipv6Addr>().map_err(|_| {
+            anyhow::anyhow!(
+                "ambiguous multi-colon destination {dest:?}; use [ipv6]:port for IPv6 with port"
+            )
+        })?;
         (dest.to_owned(), 443)
     } else if let Some((host, port_str)) = dest.rsplit_once(':') {
         match port_str.parse::<u16>() {

src/tls.rs

@@ -26,7 +26,11 @@ pub fn build_server_config(config: &AppServerConfig) -> anyhow::Result<Arc<Serve
         "unparseable certificates in {}",
         config.client_ca_path.display()
     );
-    ensure!(added > 0, "no trust anchors in {}", config.client_ca_path.display());
+    ensure!(
+        added > 0,
+        "no trust anchors in {}",
+        config.client_ca_path.display()
+    );
 
     let client_verifier = WebPkiClientVerifier::builder(Arc::new(client_ca_store))
         .build()

tests/common/mod.rs

@@ -40,8 +40,7 @@ pub fn generate_ca() -> Result<CertifiedIssuer<'static, KeyPair>, rcgen::Error>
 pub fn generate_server_cert(
     issuer: &CertifiedIssuer<'_, impl rcgen::SigningKey>,
 ) -> Result<(rcgen::Certificate, KeyPair), rcgen::Error> {
-    let mut params =
-        CertificateParams::new(vec!["localhost".to_owned(), "127.0.0.1".to_owned()])?;
+    let mut params = CertificateParams::new(vec!["localhost".to_owned(), "127.0.0.1".to_owned()])?;
     params.distinguished_name = DistinguishedName::new();
     params
         .distinguished_name
@@ -361,8 +360,7 @@ pub async fn start_proxy(pki: &TestPki, policy_config: PolicyConfig) -> (SocketA
                         return;
                     }
                 };
-                let peer_certs =
-                    agent_gateway::proxy::extract_peer_certs(tls_stream.get_ref().1);
+                let peer_certs = agent_gateway::proxy::extract_peer_certs(tls_stream.get_ref().1);
                 let service = svc.make_service(peer_certs);
                 let io = hyper_util::rt::TokioIo::new(tls_stream);
                 let _ = hyper_util::server::conn::auto::Builder::new(
@@ -425,8 +423,7 @@ pub async fn try_request_with_tls_config(
 
     let io = hyper_util::rt::TokioIo::new(tls_stream);
     let (mut send_request, connection) =
-        hyper::client::conn::http2::handshake(hyper_util::rt::TokioExecutor::new(), io)
-            .await?;
+        hyper::client::conn::http2::handshake(hyper_util::rt::TokioExecutor::new(), io).await?;
 
     tokio::spawn(async move {
         let _ = connection.await;

tests/e2e.rs

@@ -113,8 +113,7 @@ async fn tunnel_policy_deny() {
     );
 
     let events = wait_for_event(&log, "CONNECT denied", EVENT_TIMEOUT).await;
-    let denied_evt =
-        find_event(&events, "CONNECT denied").expect("expected CONNECT denied event");
+    let denied_evt = find_event(&events, "CONNECT denied").expect("expected CONNECT denied event");
     assert!(
         denied_evt.fields.get("reason").is_some(),
         "CONNECT denied event should have reason field"

tests/integration.rs

@@ -7,9 +7,7 @@ use rustls::server::WebPkiClientVerifier;
 use rustls::{ClientConfig, RootCertStore, ServerConfig};
 
 use agent_gateway::config::{PolicyConfig, PolicyRule};
-use agent_gateway::policy::{
-    self, PolicyDecision, PolicyEngine, RequestContext, TomlPolicyEngine,
-};
+use agent_gateway::policy::{self, PolicyDecision, PolicyEngine, RequestContext, TomlPolicyEngine};
 use agent_gateway::proxy::Destination;
 
 fn test_policy_config() -> PolicyConfig {
@@ -103,18 +101,12 @@ fn normalize_bracketed_ipv6_with_port() {
 
 #[test]
 fn normalize_bracketed_ipv6_without_port_defaults_to_443() {
-    assert_eq!(
-        policy::normalize_destination("[::1]").unwrap(),
-        "[::1]:443"
-    );
+    assert_eq!(policy::normalize_destination("[::1]").unwrap(), "[::1]:443");
 }
 
 #[test]
 fn normalize_bare_ipv6_defaults_to_443() {
-    assert_eq!(
-        policy::normalize_destination("::1").unwrap(),
-        "[::1]:443"
-    );
+    assert_eq!(policy::normalize_destination("::1").unwrap(), "[::1]:443");
     assert_eq!(
         policy::normalize_destination("2001:db8::1").unwrap(),
         "[2001:db8::1]:443"
@@ -390,7 +382,10 @@ allowed_destinations = ["api.example.com"]
     let path = tmpdir.join("reject_metrics_bind.toml");
     std::fs::write(&path, toml).unwrap();
     let result = agent_gateway::config::Config::load(&path);
-    assert!(result.is_err(), "metrics_bind should be rejected as an unknown field");
+    assert!(
+        result.is_err(),
+        "metrics_bind should be rejected as an unknown field"
+    );
 }
 
 // ---- Proxy Destination parsing ----