chore(grpc): Apply workspace lint config to grpc crate

Author: tottoto

grpc/Cargo.toml

@@ -24,6 +24,9 @@ hickory-server =  "0.25.2"
 default = ["dns"]
 dns = ["dep:hickory-resolver"]
 
+[lints]
+workspace = true
+
 [package.metadata.cargo_check_external_types]
 allowed_external_types = [
     "tonic::*",

grpc/src/client/load_balancing/mod.rs

@@ -67,7 +67,7 @@ impl ParsedJsonLbConfig {
     pub fn new(json: &str) -> Result<Self, String> {
         match serde_json::from_str(json) {
             Ok(value) => Ok(ParsedJsonLbConfig { value }),
-            Err(e) => Err(format!("failed to parse LB config JSON: {}", e)),
+            Err(e) => Err(format!("failed to parse LB config JSON: {e}")),
         }
     }
 
@@ -82,7 +82,7 @@ impl ParsedJsonLbConfig {
         let res: T = match serde_json::from_value(self.value.clone()) {
             Ok(v) => v,
             Err(e) => {
-                return Err(format!("{}", e).into());
+                return Err(format!("{e}").into());
             }
         };
         Ok(res)

grpc/src/client/name_resolution/dns/mod.rs

@@ -204,10 +204,10 @@ impl ResolverBuilder for Builder {
         let host = match endpoint.host {
             Host::Domain(d) => d,
             Host::Ipv4(ipv4) => {
-                return nop_resolver_for_ip(IpAddr::V4(ipv4), endpoint.port, options)
+                return nop_resolver_for_ip(IpAddr::V4(ipv4), endpoint.port, options);
             }
             Host::Ipv6(ipv6) => {
-                return nop_resolver_for_ip(IpAddr::V6(ipv6), endpoint.port, options)
+                return nop_resolver_for_ip(IpAddr::V6(ipv6), endpoint.port, options);
             }
         };
         let authority = parsed.authority;
@@ -233,7 +233,7 @@ impl ResolverBuilder for Builder {
 
     fn is_valid_uri(&self, target: &Target) -> bool {
         if let Err(err) = parse_endpoint_and_authority(target) {
-            eprintln!("{}", err);
+            eprintln!("{err}");
             false
         } else {
             true
@@ -311,7 +311,7 @@ fn parse_endpoint_and_authority(target: &Target) -> Result<ParseResult, String>
     let endpoint = target.path();
     let endpoint = endpoint.strip_prefix("/").unwrap_or(endpoint);
     let parse_result = parse_host_port(endpoint, DEFAULT_PORT)
-        .map_err(|err| format!("Failed to parse target {}: {}", target, err))?;
+        .map_err(|err| format!("Failed to parse target {target}: {err}"))?;
     let endpoint = parse_result.ok_or("Received empty endpoint host.".to_string())?;
 
     // Parse the authority.
@@ -323,7 +323,7 @@ fn parse_endpoint_and_authority(target: &Target) -> Result<ParseResult, String>
         });
     }
     let parse_result = parse_host_port(&authority, DEFAULT_DNS_PORT)
-        .map_err(|err| format!("Failed to parse DNS authority {}: {}", target, err))?;
+        .map_err(|err| format!("Failed to parse DNS authority {target}: {err}"))?;
     let Some(authority) = parse_result else {
         return Ok(ParseResult {
             endpoint,
@@ -351,7 +351,7 @@ fn parse_host_port(host_and_port: &str, default_port: u16) -> Result<Option<Host
     // We need to use the https scheme otherwise url::Url::parse doesn't convert
     // IP addresses to Host::Ipv4 or Host::Ipv6 if they could represent valid
     // domains.
-    let url = format!("https://{}", host_and_port);
+    let url = format!("https://{host_and_port}");
     let url = url.parse::<url::Url>().map_err(|err| err.to_string())?;
     let port = url.port().unwrap_or(default_port);
     let host = match url.host() {

grpc/src/client/name_resolution/dns/test.rs

@@ -414,7 +414,7 @@ pub async fn rate_limit() {
         resolver.resolve_now();
         tokio::select! {
             _ = work_rx.recv() => {
-                panic!("Received unexpected work request from resolver: {:?}", event);
+                panic!("Received unexpected work request from resolver: {event:?}");
             }
             _ = tokio::time::sleep(DEFAULT_TEST_SHORT_TIMEOUT) => {
                 println!("No work requested from resolver.");

grpc/src/client/name_resolution/mod.rs

@@ -91,7 +91,7 @@ impl Target {
         let host = self.authority_host();
         let port = self.authority_port();
         if let Some(port) = port {
-            format!("{}:{}", host, port)
+            format!("{host}:{port}")
         } else {
             host.to_owned()
         }

grpc/src/client/name_resolution/registry.rs

@@ -66,8 +66,7 @@ impl ResolverRegistry {
         let scheme = builder.scheme();
         if scheme.chars().any(|c| c.is_ascii_uppercase()) {
             return Err(format!(
-                "Scheme must not contain uppercase characters: {}",
-                scheme
+                "Scheme must not contain uppercase characters: {scheme}",
             ));
         }
         self.inner

grpc/src/rt/tokio/hickory_resolver.rs

@@ -228,7 +228,7 @@ mod tests {
         let addr = socket.local_addr().unwrap();
         server.register_socket(socket);
 
-        println!("DNS server running on {}", addr);
+        println!("DNS server running on {addr}");
 
         let (tx, rx) = oneshot::channel::<()>();
         let server_task = tokio::spawn(async move {

grpc/src/rt/tokio/mod.rs

@@ -45,7 +45,7 @@ impl DnsResolver for TokioDefaultDnsResolver {
     async fn lookup_host_name(&self, name: &str) -> Result<Vec<IpAddr>, String> {
         let name_with_port = match name.parse::<IpAddr>() {
             Ok(ip) => SocketAddr::new(ip, 0).to_string(),
-            Err(_) => format!("{}:0", name),
+            Err(_) => format!("{name}:0"),
         };
         let ips = tokio::net::lookup_host(name_with_port)
             .await