ci: run rustfmt/clippy on standard crates (#5333)

jmayclin · web-flow · commit 0b89213d990c · 2025-07-20T17:35:32.000-07:00
diff --git a/.github/workflows/ci_rust.yml b/.github/workflows/ci_rust.yml
@@ -349,10 +349,14 @@ jobs:
       - name: Generate
         run: ./${{env.ROOT_PATH}}/generate.sh --skip-tests
 
-      - name: Run cargo fmt
+      - name: Run cargo fmt - extended packages
         run: |
           cargo fmt --manifest-path ${{env.ROOT_PATH}}/Cargo.toml --all -- --check
 
+      - name: Run cargo fmt - standard packages
+        run: |
+          cargo fmt --manifest-path ${{env.STANDARD_PATH}}/Cargo.toml --all -- --check
+
   clippy:
     runs-on: ubuntu-latest
     steps:
@@ -384,11 +388,16 @@ jobs:
         run: ${{env.ROOT_PATH}}/generate.sh
 
       # TODO translate json reports to in-action warnings
-      - name: Run cargo clippy
+      - name: Run cargo clippy - extended packages
         run: |
           cargo clippy --manifest-path ${{env.ROOT_PATH}}/Cargo.toml --all-targets -- -D warnings
           cargo clippy --manifest-path ${{env.ROOT_PATH}}/Cargo.toml --all-targets --all-features -- -D warnings
 
+      - name: Run cargo clippy - standard packages
+        run: |
+          cargo clippy --manifest-path ${{env.STANDARD_PATH}}/Cargo.toml --all-targets -- -D warnings
+          cargo clippy --manifest-path ${{env.STANDARD_PATH}}/Cargo.toml --all-targets --all-features -- -D warnings
+
   msrv:
     runs-on: ubuntu-latest
     steps:
diff --git a/bindings/rust/standard/bench/benches/handshake.rs b/bindings/rust/standard/bench/benches/handshake.rs
@@ -3,7 +3,7 @@
 
 use bench::{
     harness::TlsBenchConfig, CipherSuite, CryptoConfig, HandshakeType, KXGroup, Mode,
-    OpenSslConnection, RustlsConnection, S2NConnection, SigType, TlsConnPair, TlsConnection
+    OpenSslConnection, RustlsConnection, S2NConnection, SigType, TlsConnPair, TlsConnection,
 };
 use criterion::{
     criterion_group, criterion_main, measurement::WallTime, BatchSize, BenchmarkGroup, Criterion,
@@ -20,17 +20,19 @@ fn bench_handshake_for_library<T>(
     T::Config: TlsBenchConfig,
 {
     let crypto_config = CryptoConfig::new(CipherSuite::default(), kx_group, sig_type);
-    let client_config = &T::Config::make_config(Mode::Client, crypto_config, handshake_type).unwrap();
-    let server_config = &T::Config::make_config(Mode::Server, crypto_config, handshake_type).unwrap();
+    let client_config =
+        &T::Config::make_config(Mode::Client, crypto_config, handshake_type).unwrap();
+    let server_config =
+        &T::Config::make_config(Mode::Server, crypto_config, handshake_type).unwrap();
 
     // generate all harnesses (TlsConnPair structs) beforehand so that benchmarks
     // only include negotiation and not config/connection initialization
     bench_group.bench_function(T::name(), |b| {
         b.iter_batched_ref(
-            || -> TlsConnPair<T, T> { 
+            || -> TlsConnPair<T, T> {
                 if handshake_type == HandshakeType::Resumption {
                     // generate a session ticket to store on the config
-                    let mut pair = TlsConnPair::<T, T>::from_configs(&client_config, &server_config);
+                    let mut pair = TlsConnPair::<T, T>::from_configs(client_config, server_config);
                     pair.handshake().unwrap();
                     pair.round_trip_transfer(&mut [0]).unwrap();
                 }
@@ -39,13 +41,15 @@ fn bench_handshake_for_library<T>(
             |conn_pair| {
                 conn_pair.handshake().unwrap();
                 match handshake_type {
-                    HandshakeType::ServerAuth | HandshakeType::MutualAuth => assert!(!conn_pair.server.resumed_connection()),
+                    HandshakeType::ServerAuth | HandshakeType::MutualAuth => {
+                        assert!(!conn_pair.server.resumed_connection())
+                    }
                     HandshakeType::Resumption => assert!(conn_pair.server.resumed_connection()),
                 }
             },
-            // Use "PerIteration" benchmarking, because of the way that session 
+            // Use "PerIteration" benchmarking, because of the way that session
             // ticket setup interacts with shared configs.
-            // > In testing, the maximum measurement overhead from benchmarking 
+            // > In testing, the maximum measurement overhead from benchmarking
             // > with PerIteration is on the order of 350 nanoseconds
             BatchSize::PerIteration,
         )
diff --git a/bindings/rust/standard/bench/benches/resumption.rs b/bindings/rust/standard/bench/benches/resumption.rs
@@ -70,14 +70,14 @@ where
 pub fn bench_resumption(c: &mut Criterion) {
     // compare resumption savings across both client and server
     for sig_type in [SigType::Rsa2048, SigType::Ecdsa256] {
-        let mut bench_group = c.benchmark_group(format!("resumption-pair-{:?}", sig_type));
+        let mut bench_group = c.benchmark_group(format!("resumption-pair-{sig_type:?}"));
         bench_handshake_pair::<S2NConnection>(&mut bench_group, sig_type);
     }
 
     // only look at resumption savings for the server, specifically the work
     // done in the first rtt.
     for sig_type in [SigType::Rsa2048, SigType::Ecdsa384] {
-        let mut bench_group = c.benchmark_group(format!("resumption-server-1rtt-{:?}", sig_type));
+        let mut bench_group = c.benchmark_group(format!("resumption-server-1rtt-{sig_type:?}"));
         bench_handshake_server_1rtt::<S2NConnection>(&mut bench_group, sig_type);
     }
 }
diff --git a/bindings/rust/standard/bench/benches/throughput.rs b/bindings/rust/standard/bench/benches/throughput.rs
@@ -1,17 +1,14 @@
 // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
 // SPDX-License-Identifier: Apache-2.0
 
-use bench::OpenSslConnection;
-use bench::RustlsConnection;
 use bench::{
     harness::TlsBenchConfig, CipherSuite, CryptoConfig, HandshakeType, KXGroup, Mode,
-    S2NConnection, SigType, TlsConnPair, TlsConnection, PROFILER_FREQUENCY,
+    OpenSslConnection, RustlsConnection, S2NConnection, SigType, TlsConnPair, TlsConnection,
 };
 use criterion::{
     criterion_group, criterion_main, measurement::WallTime, BatchSize, BenchmarkGroup, Criterion,
     Throughput,
 };
-use pprof::criterion::{Output, PProfProfiler};
 use strum::IntoEnumIterator;
 
 fn bench_throughput_for_library<T>(
@@ -48,7 +45,7 @@ pub fn bench_throughput_cipher_suites(c: &mut Criterion) {
     let mut shared_buf = [0u8; 100000];
 
     for cipher_suite in CipherSuite::iter() {
-        let mut bench_group = c.benchmark_group(format!("throughput-{:?}", cipher_suite));
+        let mut bench_group = c.benchmark_group(format!("throughput-{cipher_suite:?}"));
         bench_group.throughput(Throughput::Bytes(shared_buf.len() as u64));
         bench_throughput_for_library::<S2NConnection>(
             &mut bench_group,
diff --git a/bindings/rust/standard/bench/src/rustls.rs b/bindings/rust/standard/bench/src/rustls.rs
@@ -79,7 +79,7 @@ impl RustlsConfig {
             pkcs_8_key.into()
         } else {
             // https://docs.rs/rustls-pemfile/latest/rustls_pemfile/enum.Item.html
-            panic!("unexpected key type: {:?}", key);
+            panic!("unexpected key type: {key:?}");
         }
     }
 }
diff --git a/bindings/rust/standard/integration/src/features/mldsa.rs b/bindings/rust/standard/integration/src/features/mldsa.rs
@@ -8,12 +8,11 @@ use std::{fs, path::Path, pin::Pin};
 use tokio::net::{TcpListener, TcpStream};
 use tokio_openssl::SslStream;
 
-const TEST_PEMS_PATH: &'static str =
-    concat!(env!("CARGO_MANIFEST_DIR"), "/../../../../tests/pems/");
+const TEST_PEMS_PATH: &str = concat!(env!("CARGO_MANIFEST_DIR"), "/../../../../tests/pems/");
 
 pub async fn get_streams() -> Result<(TcpStream, TcpStream), tokio::io::Error> {
     let localhost = "127.0.0.1".to_owned();
-    let listener = TcpListener::bind(format!("{}:0", localhost)).await?;
+    let listener = TcpListener::bind(format!("{localhost}:0")).await?;
     let addr = listener.local_addr()?;
     let client_stream = TcpStream::connect(&addr).await?;
     let (server_stream, _) = listener.accept().await?;
diff --git a/bindings/rust/standard/integration/src/network/tls_client.rs b/bindings/rust/standard/integration/src/network/tls_client.rs
@@ -45,10 +45,7 @@ mod kms_pq {
         let policy = Policy::from_version("PQ-TLS-1-2-2024-10-09")?;
         let tls = handshake_with_domain(DOMAIN, &policy).await?;
 
-        assert_eq!(
-            tls.as_ref().cipher_suite()?,
-            "TLS_AES_256_GCM_SHA384"
-        );
+        assert_eq!(tls.as_ref().cipher_suite()?, "TLS_AES_256_GCM_SHA384");
 
         // As of 2/5/25, some KMS hosts support ML-KEM, while other hosts still only support earlier
         // draft PQ KEM groups. As such, we currently assert that any KEM group was negotiated.
diff --git a/bindings/rust/standard/s2n-tls-hyper/src/error.rs b/bindings/rust/standard/s2n-tls-hyper/src/error.rs
@@ -19,8 +19,8 @@ impl Display for Error {
     fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
         match self {
             Error::InvalidScheme => write!(f, "The provided URI contains an invalid scheme."),
-            Error::HttpError(err) => write!(f, "{}", err),
-            Error::TlsError(err) => write!(f, "{}", err),
+            Error::HttpError(err) => write!(f, "{err}"),
+            Error::TlsError(err) => write!(f, "{err}"),
         }
     }
 }
diff --git a/bindings/rust/standard/s2n-tls-hyper/tests/http.rs b/bindings/rust/standard/s2n-tls-hyper/tests/http.rs
@@ -40,7 +40,7 @@ async fn test_get_request() -> Result<(), Box<dyn Error + Send + Sync>> {
         let client: Client<_, Empty<Bytes>> =
             Client::builder(TokioExecutor::new()).build(connector);
 
-        let uri = Uri::from_str(format!("https://localhost:{}", port).as_str())?;
+        let uri = Uri::from_str(format!("https://localhost:{port}").as_str())?;
         let response = client.get(uri).await?;
         assert_eq!(response.status(), 200);
 
@@ -62,9 +62,7 @@ async fn test_http_methods() -> Result<(), Box<dyn Error + Send + Sync>> {
                 Client::builder(TokioExecutor::new()).build(connector);
             let request: Request<Full<Bytes>> = Request::builder()
                 .method(method)
-                .uri(Uri::from_str(
-                    format!("https://localhost:{}", port).as_str(),
-                )?)
+                .uri(Uri::from_str(format!("https://localhost:{port}").as_str())?)
                 .body(Full::from(TEST_DATA))?;
 
             let response = client.request(request).await?;
@@ -89,9 +87,7 @@ async fn test_large_request() -> Result<(), Box<dyn Error + Send + Sync>> {
         let client: Client<_, Full<Bytes>> = Client::builder(TokioExecutor::new()).build(connector);
         let request: Request<Full<Bytes>> = Request::builder()
             .method(Method::POST)
-            .uri(Uri::from_str(
-                format!("https://localhost:{}", port).as_str(),
-            )?)
+            .uri(Uri::from_str(format!("https://localhost:{port}").as_str())?)
             .body(Full::from(LARGE_TEST_DATA))?;
 
         let response = client.request(request).await?;
@@ -138,7 +134,7 @@ async fn test_sni() -> Result<(), Box<dyn Error + Send + Sync>> {
             let client: Client<_, Empty<Bytes>> =
                 Client::builder(TokioExecutor::new()).build(connector);
 
-            let uri = Uri::from_str(format!("https://{}:{}", hostname, port).as_str())?;
+            let uri = Uri::from_str(format!("https://{hostname}:{port}").as_str())?;
             let response = client.get(uri).await?;
             assert_eq!(response.status(), 200);
 
@@ -288,7 +284,7 @@ async fn http2() -> Result<(), Box<dyn Error + Send + Sync>> {
             let client: Client<_, Empty<Bytes>> =
                 Client::builder(TokioExecutor::new()).build(connector);
 
-            let uri = Uri::from_str(format!("https://localhost:{}", port).as_str())?;
+            let uri = Uri::from_str(format!("https://localhost:{port}").as_str())?;
             let response = client.get(uri).await?;
             assert_eq!(response.status(), 200);
 
@@ -324,7 +320,7 @@ async fn config_alpn_ignored() -> Result<(), Box<dyn Error + Send + Sync>> {
         let client: Client<_, Empty<Bytes>> =
             Client::builder(TokioExecutor::new()).build(connector);
 
-        let uri = Uri::from_str(format!("https://localhost:{}", port).as_str())?;
+        let uri = Uri::from_str(format!("https://localhost:{port}").as_str())?;
         let response = client.get(uri).await?;
         assert_eq!(response.status(), 200);
 

Original file line number	Diff line number	Diff line change
`@@ -70,14 +70,14 @@ where`
`70`	`70`	`pub fn bench_resumption(c: &mut Criterion) {`
`71`	`71`	`// compare resumption savings across both client and server`
`72`	`72`	`for sig_type in [SigType::Rsa2048, SigType::Ecdsa256] {`
`73`		`- let mut bench_group = c.benchmark_group(format!("resumption-pair-{:?}", sig_type));`
	`73`	`+ let mut bench_group = c.benchmark_group(format!("resumption-pair-{sig_type:?}"));`
`74`	`74`	`bench_handshake_pair::<S2NConnection>(&mut bench_group, sig_type);`
`75`	`75`	`}`
`76`	`76`
`77`	`77`	`// only look at resumption savings for the server, specifically the work`
`78`	`78`	`// done in the first rtt.`
`79`	`79`	`for sig_type in [SigType::Rsa2048, SigType::Ecdsa384] {`
`80`		`- let mut bench_group = c.benchmark_group(format!("resumption-server-1rtt-{:?}", sig_type));`
	`80`	`+ let mut bench_group = c.benchmark_group(format!("resumption-server-1rtt-{sig_type:?}"));`
`81`	`81`	`bench_handshake_server_1rtt::<S2NConnection>(&mut bench_group, sig_type);`
`82`	`82`	`}`
`83`	`83`	`}`
Original file line number	Diff line number	Diff line change
`@@ -79,7 +79,7 @@ impl RustlsConfig {`
`79`	`79`	`pkcs_8_key.into()`
`80`	`80`	`} else {`
`81`	`81`	`// https://docs.rs/rustls-pemfile/latest/rustls_pemfile/enum.Item.html`
`82`		`- panic!("unexpected key type: {:?}", key);`
	`82`	`+ panic!("unexpected key type: {key:?}");`
`83`	`83`	`}`
`84`	`84`	`}`
`85`	`85`	`}`
Original file line number	Diff line number	Diff line change
`@@ -19,8 +19,8 @@ impl Display for Error {`
`19`	`19`	`fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {`
`20`	`20`	`match self {`
`21`	`21`	`Error::InvalidScheme => write!(f, "The provided URI contains an invalid scheme."),`
`22`		`- Error::HttpError(err) => write!(f, "{}", err),`
`23`		`- Error::TlsError(err) => write!(f, "{}", err),`
	`22`	`+ Error::HttpError(err) => write!(f, "{err}"),`
	`23`	`+ Error::TlsError(err) => write!(f, "{err}"),`
`24`	`24`	`}`
`25`	`25`	`}`
`26`	`26`	`}`