chore: lint fixes

shaneutt · shaneutt · commit 90385c53f1d8 · 2025-07-08T14:50:04.000-04:00
Signed-off-by: Shane Utt &lt;shaneutt@linux.com&gt;
diff --git a/Makefile b/Makefile
@@ -119,8 +119,8 @@ check.format.rust: ## Check Rust code formatting
 	cargo fmt --manifest-path Cargo.toml --all -- --check
 
 .PHONY: lint
-lint: ## Lint Rust code
-	cargo clippy --all -- -D warnings
+lint:
+	cargo clippy --workspace --all-targets --all-features -- -D warnings
 
 # ------------------------------------------------------------------------------
 # Testing
diff --git a/controlplane/src/client_manager.rs b/controlplane/src/client_manager.rs
@@ -32,6 +32,12 @@ pub struct DataplaneClientManager {
     clients: Arc<RwLock<HashMap<String, BackendsClient<Channel>>>>,
 }
 
+impl Default for DataplaneClientManager {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
 impl DataplaneClientManager {
     pub fn new() -> Self {
         Self {
@@ -62,16 +68,15 @@ impl DataplaneClientManager {
 
         for pod in dataplane_pods {
             if let Some(pod_ip) = &pod.status.as_ref().and_then(|s| s.pod_ip.as_ref()) {
-                let endpoint = format!("http://{}:9090", pod_ip);
+                let endpoint = format!("http://{pod_ip}:9090");
                 match BackendsClient::connect(endpoint.clone()).await {
                     Ok(grpc_client) => {
                         info!("Connected to dataplane pod: {}", pod_ip);
                         new_clients.insert(pod_ip.to_string(), grpc_client);
                     }
-                    Err(e) => {
+                    Err(err) => {
                         return Err(crate::Error::DataplaneError(format!(
-                            "Failed to connect to dataplane pod {}: {}",
-                            pod_ip, e
+                            "Failed to connect to dataplane pod {pod_ip}: {err}"
                         )));
                     }
                 }
@@ -97,10 +102,9 @@ impl DataplaneClientManager {
                 Ok(_) => {
                     info!("Successfully updated targets on dataplane pod: {}", pod_ip);
                 }
-                Err(e) => {
+                Err(err) => {
                     return Err(crate::Error::DataplaneError(format!(
-                        "Failed to update targets on dataplane pod {}: {}",
-                        pod_ip, e
+                        "Failed to update targets on dataplane pod {pod_ip}: {err}"
                     )));
                 }
             }
@@ -122,8 +126,8 @@ impl DataplaneClientManager {
                 Ok(_) => {
                     info!("Successfully deleted VIP on dataplane pod: {}", pod_ip);
                 }
-                Err(e) => {
-                    warn!("Failed to delete VIP on dataplane pod {}: {}", pod_ip, e);
+                Err(err) => {
+                    warn!("Failed to delete VIP on dataplane pod {}: {}", pod_ip, err);
                 }
             }
         }
diff --git a/controlplane/src/gateway_controller.rs b/controlplane/src/gateway_controller.rs
@@ -117,7 +117,7 @@ pub async fn reconcile(gateway: Arc<Gateway>, ctx: Arc<Context>) -> Result<Actio
     // Try to fetch any existing Loadbalancer service(s) for this Gateway.
     let service_api: Api<Service> = Api::namespaced(client, &ns);
     let services = service_api
-        .list(&ListParams::default().labels(&format!("{}={}", GATEWAY_SERVICE_LABEL, name)))
+        .list(&ListParams::default().labels(&format!("{GATEWAY_SERVICE_LABEL}={name}")))
         .await
         .map_err(Error::KubeError)?;
 
diff --git a/controlplane/src/gateway_utils.rs b/controlplane/src/gateway_utils.rs
@@ -225,7 +225,7 @@ pub fn update_service_for_gateway(gateway: &Gateway, svc: &mut Service) -> Resul
             let addr = addresses[0].clone();
             if let Some(t) = addr.r#type {
                 if t != "IPAddress" {
-                    return Err(Error::InvalidConfigError(format!("addresses of type {} are not supported; only type IPAddress is supported", t).to_string()));
+                    return Err(Error::InvalidConfigError(format!("addresses of type {t} are not supported; only type IPAddress is supported").to_string()));
                 }
             }
             address = Some(addresses[0].clone());
@@ -353,8 +353,7 @@ pub fn get_accepted_condition(gateway: &Gateway) -> metav1::Condition {
                     accepted.status = String::from("False");
                     accepted.reason = GatewayConditionReason::UnsupportedAddress.to_string();
                     accepted.message = format!(
-                        "found an addres of type {}, only type IPAddress is supported",
-                        addr_type
+                        "found an addres of type {addr_type}, only type IPAddress is supported"
                     );
                     break;
                 }
@@ -615,7 +614,7 @@ fn check_route_kinds(
 
     if let Some(group) = &rgk.group {
         if group.as_str() != "gateway.networking.k8s.io" {
-            return Some(format!("Unsupported API group: {}", group));
+            return Some(format!("Unsupported API group: {group}"));
         }
     }
     None
diff --git a/dataplane/api-server/src/lib.rs b/dataplane/api-server/src/lib.rs
@@ -49,7 +49,7 @@ pub async fn start(
         let addr = SocketAddrV4::new(addr, port);
         let server = server_builder.serve(addr.into(), health_service);
 
-        debug!("gRPC Health Checking service listens on {}", addr);
+        debug!("gRPC Health Checking service listens on {addr}");
         server
             .await
             .expect("Failed to serve gRPC Health Checking service");
@@ -65,7 +65,7 @@ pub async fn start(
         let tls_addr = SocketAddrV4::new(addr, port);
         let tls_server = server_builder.serve(tls_addr.into(), BackendsServer::new(server));
 
-        debug!("TLS server listens on {}", tls_addr);
+        debug!("TLS server listens on {tls_addr}");
         tls_server.await.expect("Failed to serve TLS");
     });
 
diff --git a/dataplane/api-server/src/netutils.rs b/dataplane/api-server/src/netutils.rs
@@ -72,5 +72,5 @@ pub fn if_index_for_routing_ip(ip_addr: Ipv4Addr) -> Result<u32, Error> {
             return Ok(*idex_if);
         }
     }
-    Err(Error::msg(format!("{} {}", ERR_NO_IFINDEX, ip_addr)))
+    Err(Error::msg(format!("{ERR_NO_IFINDEX} {ip_addr}")))
 }
diff --git a/dataplane/api-server/src/server.rs b/dataplane/api-server/src/server.rs
@@ -16,7 +16,7 @@ use crate::backends::backends_server::Backends;
 use crate::backends::{Confirmation, InterfaceIndexConfirmation, PodIp, Targets, Vip};
 use crate::netutils::if_index_for_routing_ip;
 use common::{
-    Backend, BackendKey, BackendList, ClientKey, LoadBalancerMapping, BACKENDS_ARRAY_CAPACITY,
+    BACKENDS_ARRAY_CAPACITY, Backend, BackendKey, BackendList, ClientKey, LoadBalancerMapping,
 };
 
 pub struct BackendService {
@@ -133,9 +133,8 @@ impl Backends for BackendService {
                         Ok(ifindex) => ifindex,
                         Err(err) => {
                             return Err(Status::internal(format!(
-                                "failed to determine ifindex: {}",
-                                err
-                            )))
+                                "failed to determine ifindex: {err}"
+                            )));
                         }
                     }
                 }
@@ -163,13 +162,12 @@ impl Backends for BackendService {
         match self.insert_and_reset_index(key, backend_list).await {
             Ok(_) => Ok(Response::new(Confirmation {
                 confirmation: format!(
-                    "success, vip {}:{} was updated with {} backends",
+                    "success, vip {}:{} was updated with {count} backends",
                     Ipv4Addr::from(vip.ip),
                     vip.port,
-                    count,
                 ),
             })),
-            Err(err) => Err(Status::internal(format!("failure: {}", err))),
+            Err(err) => Err(Status::internal(format!("failure: {err}"))),
         }
     }
 
@@ -185,14 +183,14 @@ impl Backends for BackendService {
 
         match self.remove(key).await {
             Ok(()) => Ok(Response::new(Confirmation {
-                confirmation: format!("success, vip {}:{} was deleted", addr_ddn, vip.port),
+                confirmation: format!("success, vip {addr_ddn}:{} was deleted", vip.port),
             })),
             Err(err) if err.to_string().contains("syscall failed with code -1") => {
                 Ok(Response::new(Confirmation {
-                    confirmation: format!("success, vip {}:{} did not exist", addr_ddn, vip.port),
+                    confirmation: format!("success, vip {addr_ddn}:{} did not exist", vip.port),
                 }))
             }
-            Err(err) => Err(Status::internal(format!("failure: {}", err))),
+            Err(err) => Err(Status::internal(format!("failure: {err}"))),
         }
     }
 }
diff --git a/dataplane/loader/src/main.rs b/dataplane/loader/src/main.rs
@@ -79,7 +79,7 @@ async fn main() -> Result<(), anyhow::Error> {
         "../../target/bpfel-unknown-none/release/loader"
     ))?;
     if let Err(e) = EbpfLogger::init(&mut bpf_program) {
-        warn!("failed to initialize eBPF logger: {}", e);
+        warn!("failed to initialize eBPF logger: {e}");
     }
 
     info!("attaching tc_ingress program to {}", &opt.iface);
diff --git a/tools/udp-test-server/src/main.rs b/tools/udp-test-server/src/main.rs
@@ -33,7 +33,7 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
 }
 
 async fn run_server(port: u16, start_notifier: Sender<u16>) -> std::io::Result<()> {
-    let bindaddr = format!("0.0.0.0:{}", port);
+    let bindaddr = format!("0.0.0.0:{port}");
     let sock = UdpSocket::bind(&bindaddr).await?;
 
     if let Err(err) = start_notifier.send(port).await {
@@ -43,7 +43,7 @@ async fn run_server(port: u16, start_notifier: Sender<u16>) -> std::io::Result<(
     let mut buf = [0; 1024];
     loop {
         let (len, addr) = sock.recv_from(&mut buf).await?;
-        println!("port {}: {} bytes received from {}", port, len, addr);
+        println!("port {port}: {len} bytes received from {addr}");
         println!(
             "port {}: buffer contents: {}",
             port,
@@ -53,19 +53,19 @@ async fn run_server(port: u16, start_notifier: Sender<u16>) -> std::io::Result<(
 }
 
 async fn run_health_server(port: u16, mut rx: Receiver<u16>) -> std::io::Result<()> {
-    let bindaddr = format!("0.0.0.0:{}", port);
+    let bindaddr = format!("0.0.0.0:{port}");
     let listener = TcpListener::bind(&bindaddr).await?;
 
     println!("waiting for listeners...");
     let mut wait_for = 3;
     while wait_for > 0 {
         if let Some(port) = rx.recv().await {
-            println!("UDP worker listening on port {}", port);
+            println!("UDP worker listening on port {port}");
             wait_for -= 1;
         };
     }
 
-    println!("health check server listening on {}", port);
+    println!("health check server listening on {port}");
 
     let mut peers = Peers::default();
     loop {
@@ -87,7 +87,7 @@ impl Peers {
         }
 
         if !self.peers.contains(&addr.ip()) {
-            println!("received health check from {}", addr);
+            println!("received health check from {addr}");
             self.peers.push(addr.ip());
         }
     }
diff --git a/xtask/src/build_proto.rs b/xtask/src/build_proto.rs
@@ -12,7 +12,7 @@ pub struct Options {}
 pub(crate) fn build_proto(_opts: Options) -> Result<(), anyhow::Error> {
     let proto_file = "./dataplane/api-server/proto/backends.proto";
 
-    println!("building proto {}", proto_file);
+    println!("building proto {proto_file}");
 
     tonic_build::configure()
         .protoc_arg("--experimental_allow_proto3_optional")
diff --git a/xtask/src/grpc.rs b/xtask/src/grpc.rs
@@ -36,7 +36,7 @@ pub struct Options {
 pub async fn update(opts: Options) -> Result<(), Error> {
     let server_addr: SocketAddr = format!("{}:{}", opts.server_ip, opts.server_port).parse()?;
 
-    let mut client = BackendsClient::connect(format!("http://{}", server_addr)).await?;
+    let mut client = BackendsClient::connect(format!("http://{server_addr}")).await?;
 
     let addr = net::Ipv4Addr::from_str(&opts.vip_ip)?;
     let daddr = net::Ipv4Addr::from_str(&opts.daddr)?;
diff --git a/xtask/src/main.rs b/xtask/src/main.rs
@@ -56,7 +56,7 @@ async fn main() {
     };
 
     if let Err(e) = ret {
-        eprintln!("{:#}", e);
+        eprintln!("{e:#}");
         exit(1);
     }
 }
diff --git a/xtask/src/run.rs b/xtask/src/run.rs
@@ -71,7 +71,7 @@ pub fn run_dataplane(opts: Options) -> Result<(), anyhow::Error> {
 
     // profile we are building (release or debug)
     let profile = if opts.release { "release" } else { "debug" };
-    let bin_path = format!("target/{}/loader", profile);
+    let bin_path = format!("target/{profile}/loader");
 
     // arguments to pass to the application
     let mut run_args: Vec<_> = opts.run_args.iter().map(String::as_str).collect();
@@ -96,11 +96,11 @@ pub fn run_controlplane(opts: Options) -> Result<(), anyhow::Error> {
 
     // profile we are building (release or debug)
     let profile = if opts.release { "release" } else { "debug" };
-    let bin_path = format!("target/{}/controller", profile);
+    let bin_path = format!("target/{profile}/controller");
 
     // spawn the command
     let err = Command::new(&bin_path).env("RUST_LOG", "info").exec();
 
     // we shouldn't get here unless the command failed to spawn
-    Err(anyhow::Error::from(err).context(format!("Failed to run `{}`", bin_path)))
+    Err(anyhow::Error::from(err).context(format!("Failed to run `{bin_path}`")))
 }

Original file line number	Diff line number	Diff line change
`@@ -32,6 +32,12 @@ pub struct DataplaneClientManager {`
`32`	`32`	`clients: Arc<RwLock<HashMap<String, BackendsClient<Channel>>>>,`
`33`	`33`	`}`
`34`	`34`
	`35`	`+impl Default for DataplaneClientManager {`
	`36`	`+ fn default() -> Self {`
	`37`	`+ Self::new()`
	`38`	`+ }`
	`39`	`+}`
	`40`	`+`
`35`	`41`	`impl DataplaneClientManager {`
`36`	`42`	`pub fn new() -> Self {`
`37`	`43`	`Self {`
`@@ -62,16 +68,15 @@ impl DataplaneClientManager {`
`62`	`68`
`63`	`69`	`for pod in dataplane_pods {`
`64`	`70`	`if let Some(pod_ip) = &pod.status.as_ref().and_then(\|s\| s.pod_ip.as_ref()) {`
`65`		`- let endpoint = format!("http://{}:9090", pod_ip);`
	`71`	`+ let endpoint = format!("http://{pod_ip}:9090");`
`66`	`72`	`match BackendsClient::connect(endpoint.clone()).await {`
`67`	`73`	`Ok(grpc_client) => {`
`68`	`74`	`info!("Connected to dataplane pod: {}", pod_ip);`
`69`	`75`	`new_clients.insert(pod_ip.to_string(), grpc_client);`
`70`	`76`	`}`
`71`		`- Err(e) => {`
	`77`	`+ Err(err) => {`
`72`	`78`	`return Err(crate::Error::DataplaneError(format!(`
`73`		`- "Failed to connect to dataplane pod {}: {}",`
`74`		`- pod_ip, e`
	`79`	`+ "Failed to connect to dataplane pod {pod_ip}: {err}"`
`75`	`80`	`)));`
`76`	`81`	`}`
`77`	`82`	`}`
`@@ -97,10 +102,9 @@ impl DataplaneClientManager {`
`97`	`102`	`Ok(_) => {`
`98`	`103`	`info!("Successfully updated targets on dataplane pod: {}", pod_ip);`
`99`	`104`	`}`
`100`		`- Err(e) => {`
	`105`	`+ Err(err) => {`
`101`	`106`	`return Err(crate::Error::DataplaneError(format!(`
`102`		`- "Failed to update targets on dataplane pod {}: {}",`
`103`		`- pod_ip, e`
	`107`	`+ "Failed to update targets on dataplane pod {pod_ip}: {err}"`
`104`	`108`	`)));`
`105`	`109`	`}`
`106`	`110`	`}`
`@@ -122,8 +126,8 @@ impl DataplaneClientManager {`
`122`	`126`	`Ok(_) => {`
`123`	`127`	`info!("Successfully deleted VIP on dataplane pod: {}", pod_ip);`
`124`	`128`	`}`
`125`		`- Err(e) => {`
`126`		`- warn!("Failed to delete VIP on dataplane pod {}: {}", pod_ip, e);`
	`129`	`+ Err(err) => {`
	`130`	`+ warn!("Failed to delete VIP on dataplane pod {}: {}", pod_ip, err);`
`127`	`131`	`}`
`128`	`132`	`}`
`129`	`133`	`}`
Original file line number	Diff line number	Diff line change
`@@ -225,7 +225,7 @@ pub fn update_service_for_gateway(gateway: &Gateway, svc: &mut Service) -> Resul`
`225`	`225`	`let addr = addresses[0].clone();`
`226`	`226`	`if let Some(t) = addr.r#type {`
`227`	`227`	`if t != "IPAddress" {`
`228`		`- return Err(Error::InvalidConfigError(format!("addresses of type {} are not supported; only type IPAddress is supported", t).to_string()));`
	`228`	`+ return Err(Error::InvalidConfigError(format!("addresses of type {t} are not supported; only type IPAddress is supported").to_string()));`
`229`	`229`	`}`
`230`	`230`	`}`
`231`	`231`	`address = Some(addresses[0].clone());`
`@@ -353,8 +353,7 @@ pub fn get_accepted_condition(gateway: &Gateway) -> metav1::Condition {`
`353`	`353`	`accepted.status = String::from("False");`
`354`	`354`	`accepted.reason = GatewayConditionReason::UnsupportedAddress.to_string();`
`355`	`355`	`accepted.message = format!(`
`356`		`- "found an addres of type {}, only type IPAddress is supported",`
`357`		`- addr_type`
	`356`	`+ "found an addres of type {addr_type}, only type IPAddress is supported"`
`358`	`357`	`);`
`359`	`358`	`break;`
`360`	`359`	`}`
`@@ -615,7 +614,7 @@ fn check_route_kinds(`
`615`	`614`
`616`	`615`	`if let Some(group) = &rgk.group {`
`617`	`616`	`if group.as_str() != "gateway.networking.k8s.io" {`
`618`		`- return Some(format!("Unsupported API group: {}", group));`
	`617`	`+ return Some(format!("Unsupported API group: {group}"));`
`619`	`618`	`}`
`620`	`619`	`}`
`621`	`620`	`None`
Original file line number	Diff line number	Diff line change
`@@ -72,5 +72,5 @@ pub fn if_index_for_routing_ip(ip_addr: Ipv4Addr) -> Result<u32, Error> {`
`72`	`72`	`return Ok(*idex_if);`
`73`	`73`	`}`
`74`	`74`	`}`
`75`		`- Err(Error::msg(format!("{} {}", ERR_NO_IFINDEX, ip_addr)))`
	`75`	`+ Err(Error::msg(format!("{ERR_NO_IFINDEX} {ip_addr}")))`
`76`	`76`	`}`
Original file line number	Diff line number	Diff line change
`@@ -16,7 +16,7 @@ use crate::backends::backends_server::Backends;`
`16`	`16`	`use crate::backends::{Confirmation, InterfaceIndexConfirmation, PodIp, Targets, Vip};`
`17`	`17`	`use crate::netutils::if_index_for_routing_ip;`
`18`	`18`	`use common::{`
`19`		`- Backend, BackendKey, BackendList, ClientKey, LoadBalancerMapping, BACKENDS_ARRAY_CAPACITY,`
	`19`	`+ BACKENDS_ARRAY_CAPACITY, Backend, BackendKey, BackendList, ClientKey, LoadBalancerMapping,`
`20`	`20`	`};`
`21`	`21`
`22`	`22`	`pub struct BackendService {`
`@@ -133,9 +133,8 @@ impl Backends for BackendService {`
`133`	`133`	`Ok(ifindex) => ifindex,`
`134`	`134`	`Err(err) => {`
`135`	`135`	`return Err(Status::internal(format!(`
`136`		`- "failed to determine ifindex: {}",`
`137`		`- err`
`138`		`- )))`
	`136`	`+ "failed to determine ifindex: {err}"`
	`137`	`+ )));`
`139`	`138`	`}`
`140`	`139`	`}`
`141`	`140`	`}`
`@@ -163,13 +162,12 @@ impl Backends for BackendService {`
`163`	`162`	`match self.insert_and_reset_index(key, backend_list).await {`
`164`	`163`	`Ok(_) => Ok(Response::new(Confirmation {`
`165`	`164`	`confirmation: format!(`
`166`		`- "success, vip {}:{} was updated with {} backends",`
	`165`	`+ "success, vip {}:{} was updated with {count} backends",`
`167`	`166`	`Ipv4Addr::from(vip.ip),`
`168`	`167`	`vip.port,`
`169`		`- count,`
`170`	`168`	`),`
`171`	`169`	`})),`
`172`		`- Err(err) => Err(Status::internal(format!("failure: {}", err))),`
	`170`	`+ Err(err) => Err(Status::internal(format!("failure: {err}"))),`
`173`	`171`	`}`
`174`	`172`	`}`
`175`	`173`
`@@ -185,14 +183,14 @@ impl Backends for BackendService {`
`185`	`183`
`186`	`184`	`match self.remove(key).await {`
`187`	`185`	`Ok(()) => Ok(Response::new(Confirmation {`
`188`		`- confirmation: format!("success, vip {}:{} was deleted", addr_ddn, vip.port),`
	`186`	`+ confirmation: format!("success, vip {addr_ddn}:{} was deleted", vip.port),`
`189`	`187`	`})),`
`190`	`188`	`Err(err) if err.to_string().contains("syscall failed with code -1") => {`
`191`	`189`	`Ok(Response::new(Confirmation {`
`192`		`- confirmation: format!("success, vip {}:{} did not exist", addr_ddn, vip.port),`
	`190`	`+ confirmation: format!("success, vip {addr_ddn}:{} did not exist", vip.port),`
`193`	`191`	`}))`
`194`	`192`	`}`
`195`		`- Err(err) => Err(Status::internal(format!("failure: {}", err))),`
	`193`	`+ Err(err) => Err(Status::internal(format!("failure: {err}"))),`
`196`	`194`	`}`
`197`	`195`	`}`
`198`	`196`	`}`
Original file line number	Diff line number	Diff line change
`@@ -79,7 +79,7 @@ async fn main() -> Result<(), anyhow::Error> {`
`79`	`79`	`"../../target/bpfel-unknown-none/release/loader"`
`80`	`80`	`))?;`
`81`	`81`	`if let Err(e) = EbpfLogger::init(&mut bpf_program) {`
`82`		`- warn!("failed to initialize eBPF logger: {}", e);`
	`82`	`+ warn!("failed to initialize eBPF logger: {e}");`
`83`	`83`	`}`
`84`	`84`
`85`	`85`	`info!("attaching tc_ingress program to {}", &opt.iface);`