AWS SDK

rev. 174400987dccd7e137fefa96b1143d21c7ddfb78

Files changed:

tmp-codegen-diff/aws-sdk/sdk/aws-smithy-http-client/tests/proxy_tests.rs

@@ -764,764 +911,914 @@

             assert_eq!(body, "direct connection");
-765
             // Verify the proxy received no requests (disabled)
             let proxy_requests = mock_proxy.requests();
             assert_eq!(
                 proxy_requests.len(),
 ,
                 "Proxy should not receive requests when explicitly disabled"
             );
-773
             // Verify the direct server received the request
             let direct_requests = direct_server.requests();
             assert_eq!(
                 direct_requests.len(),
 ,
                 "Direct server should have received the request"
             );
         },
-782
+    )
     .await;

-784
+}
-785
 // ================================================================================================
 // HTTPS/CONNECT Tunneling Tests
 // ================================================================================================
 //
 // These tests are for HTTPS tunneling through HTTP proxies using the CONNECT method.
-791
 /// Helper function to make HTTPS requests through proxy using TLS providers
 /// This is similar to make_http_request_through_proxy but uses TLS-enabled connectors
 #[cfg(any(feature = "rustls-ring", feature = "s2n-tls"))]
 async fn make_https_request_through_proxy(
     proxy_config: ProxyConfig,
     target_url: &str,
     tls_provider: tls::Provider,
 ) -> Result<(StatusCode, String), Box<dyn std::error::Error + Send + Sync>> {
     let http_client = http_client_fn(move |settings, _components| {
         let connector = Connector::builder()
             .proxy_config(proxy_config.clone())
             .connector_settings(settings.clone())
             .tls_provider(tls_provider.clone())
             .build();
-806
         aws_smithy_runtime_api::client::http::SharedHttpConnector::new(connector)
     });
-809
     let connector_settings = HttpConnectorSettings::builder().build();
     let runtime_components = RuntimeComponentsBuilder::for_tests()
         .with_time_source(Some(SystemTimeSource::new()))
         .build()
         .unwrap();
-815
     let http_connector = http_client.http_connector(&connector_settings, &runtime_components);
-817
     let request = HttpRequest::get(target_url)
         .map_err(|e| Box::new(e) as Box<dyn std::error::Error + Send + Sync>)?;
-820
     let response = http_connector.call(request).await?;
-822
     let status = response.status();
     let body_bytes = response.into_body().collect().await?.to_bytes();
     let body_string = String::from_utf8(body_bytes.to_vec())?;
-826
     Ok((status.into(), body_string))
-828
+}
-829
 /// Generic test function for HTTPS CONNECT with authentication
 /// Tests that HTTPS requests through HTTP proxy use CONNECT method with proper auth headers
 #[cfg(any(feature = "rustls-ring", feature = "s2n-tls"))]
 async fn run_https_connect_with_auth_test(tls_provider: tls::Provider, provider_name: &str) {
     let mock_proxy = MockProxyServer::new(|req| {
         // For HTTPS through HTTP proxy, we should see a CONNECT request
         assert_eq!(req.method, "CONNECT");
         assert_eq!(req.uri, "secure.aws.amazon.com:443");
-838
         // Verify authentication header is present
         let expected_auth = format!(
             "Basic {}",
             base64::prelude::BASE64_STANDARD.encode("connectuser:connectpass")
         );
         assert_eq!(req.headers.get("proxy-authorization"), Some(&expected_auth));
-845
         // Return 400 to avoid dealing with actual TLS tunneling
         // The important part is that we got the CONNECT request with correct auth
         Response::builder()
             .status(StatusCode::BAD_REQUEST)
             .body("CONNECT tunnel setup failed".to_string())
             .unwrap()
     })
     .await;
-854
     // Configure proxy with authentication
     let proxy_config = ProxyConfig::all(format!("http://{}", mock_proxy.addr()))
         .unwrap()
         .with_basic_auth("connectuser", "connectpass");
-859
     // Make HTTPS request - should trigger CONNECT method
     let target_url = "https://secure.aws.amazon.com/api/secure";
     let result = make_https_request_through_proxy(proxy_config, target_url, tls_provider).await;
-863
     // We expect this to fail with a connection error since we returned 400
     // The important thing is that the CONNECT request was made correctly
     assert!(
         result.is_err(),
         "CONNECT tunnel should fail with 400 response for {}",
         provider_name
     );
-871
     // Verify the proxy received the CONNECT request
     let requests = mock_proxy.requests();
     assert_eq!(
         requests.len(),
 ,
         "Proxy should have received exactly one CONNECT request for {}",
         provider_name
     );
-880
+}
-881
 /// Generic test function for CONNECT without authentication (should get 407)
 /// Tests that HTTPS requests without auth get proper 407 response
 #[cfg(any(feature = "rustls-ring", feature = "s2n-tls"))]
 async fn run_https_connect_auth_required_test(tls_provider: tls::Provider, provider_name: &str) {
     let mock_proxy = MockProxyServer::new(|req| {
         // For HTTPS through HTTP proxy, we should see a CONNECT request
         assert_eq!(req.method, "CONNECT");
         assert_eq!(req.uri, "secure.aws.amazon.com:443");
-890
         // No auth header should be present
         assert!(!req.headers.contains_key("proxy-authorization"));
-893
         // Return 407 Proxy Authentication Required

↧ Expand context

         Response::builder()
             .status(StatusCode::PROXY_AUTHENTICATION_REQUIRED)
             .body("Proxy authentication required for CONNECT".to_string())
             .unwrap()
     })
     .await;
-901
     // Configure proxy without authentication
     let proxy_config = ProxyConfig::all(format!("http://{}", mock_proxy.addr())).unwrap();
-904
     // Make HTTPS request - should trigger CONNECT method and get 407
     let target_url = "https://secure.aws.amazon.com/api/secure";
     let result = make_https_request_through_proxy(proxy_config, target_url, tls_provider).await;
-908
     // We expect this to fail with a connection error since we returned 407
     assert!(
         result.is_err(),
         "CONNECT tunnel should fail with 407 response for {}",
         provider_name
     );

@@ -1096,1099 +1155,1159 @@

↥ Expand context

-1099
+    }
-1100
     // Test 2: Direct connection - should use origin form
-1102
+    {
         let target_path_clone = target_path.to_string();
-1104
         let direct_server = MockProxyServer::new(move |req| {
             // Should receive only the path part
             assert!(!req.uri.starts_with("http://"));
             assert!(req.uri == target_path_clone || req.uri.ends_with(&target_path_clone));
-1109
             Response::builder()
                 .status(StatusCode::OK)
                 .body("direct response".to_string())
                 .unwrap()
         })
         .await;
-1116
         let proxy_config = ProxyConfig::disabled();
         let direct_url = format!("http://{}{}", direct_server.addr(), target_path);

         let result = make_http_request_through_proxy(proxy_config, &direct_url).await;
-1120
         assert!(result.is_ok(), "Direct request should succeed");
         let requests = direct_server.requests();
         assert_eq!(requests.len(), 1);
-1124
+    }
-1125
+}
-1126
 /// Generic test function for CONNECT URI form validation
 /// Tests that CONNECT requests use the correct host:port format
 #[cfg(any(feature = "rustls-ring", feature = "s2n-tls"))]
 async fn run_connect_uri_form_test(tls_provider: tls::Provider, provider_name: &str) {
     let target_host = "secure.example.com";
     let target_port = 443;
     let expected_connect_uri = format!("{}:{}", target_host, target_port);
-1134
     // Clone for use in closure
     let expected_uri_clone = expected_connect_uri.clone();
-1137
     let mock_proxy = MockProxyServer::new(move |req| {
         if req.method == "CONNECT" {

↧ Expand context

             // CONNECT should use host:port format
             assert_eq!(req.uri, expected_uri_clone);
-1142
             // CONNECT requests should not have a Host header in the CONNECT line
             // (the Host header is for the tunneled HTTP request, not the CONNECT)
-1145
             Response::builder()
                 .status(StatusCode::OK)
                 .body("Connection established".to_string())
                 .unwrap()
         } else {
             // This shouldn't happen in our test, but handle it gracefully
             Response::builder()
                 .status(StatusCode::BAD_REQUEST)
                 .body("Unexpected non-CONNECT request".to_string())
                 .unwrap()
-1156
+        }
     })
     .await;
-1159

@@ -1165,1169 +0,1623 @@

↥ Expand context

     let requests = mock_proxy.requests();
     assert_eq!(
         requests.len(),
 ,
         "Should have received exactly one CONNECT request for {}",
         provider_name
     );
     assert_eq!(requests[0].method, "CONNECT");
     assert_eq!(requests[0].uri, expected_connect_uri);
-1178
+}
-1179
 /// Tests CONNECT method URI form for HTTPS tunneling - rustls provider
 /// Verifies that CONNECT requests use the correct host:port format
 #[cfg(feature = "rustls-ring")]
 #[tokio::test]
 async fn test_connect_uri_form_rustls() {
     run_connect_uri_form_test(
         tls::Provider::rustls(tls::rustls_provider::CryptoMode::Ring),
         "rustls",
-1188
+    )

     .await;
-1190
+}
-1191
 /// Tests CONNECT method URI form for HTTPS tunneling - s2n-tls provider
 /// Verifies that CONNECT requests use the correct host:port format
 #[cfg(feature = "s2n-tls")]
 #[tokio::test]
 async fn test_connect_uri_form_s2n_tls() {
     run_connect_uri_form_test(tls::Provider::S2nTls, "s2n-tls").await;
-1198
+}
-+
 // ================================================================================================
 // V2 client proxy parity tests
 // ================================================================================================
-+
 async fn make_v2_http_request_through_proxy(
     proxy_config: ProxyConfig,
     target_url: &str,
 ) -> Result<(StatusCode, String), Box<dyn std::error::Error + Send + Sync>> {
     use aws_smithy_http_client::pool::{Client, SharedPool};
-+
     let pool = SharedPool::builder()
         .proxy_config(proxy_config)
         .build_http();
     let http_client = Client::new(&pool);
     let connector_settings = HttpConnectorSettings::builder().build();
     let runtime_components = RuntimeComponentsBuilder::for_tests()
         .with_time_source(Some(SystemTimeSource::new()))
         .build()
         .unwrap();
     let http_connector = http_client.http_connector(&connector_settings, &runtime_components);
-+
     let request = HttpRequest::get(target_url)
         .map_err(|e| Box::new(e) as Box<dyn std::error::Error + Send + Sync>)?;
     let response = http_connector.call(request).await?;
     let status = response.status();
     let body_bytes = response.into_body().collect().await?.to_bytes();
     let body_string = String::from_utf8(body_bytes.to_vec())?;
     Ok((status.into(), body_string))
-+
+}
-+
 #[cfg(any(
     feature = "rustls-aws-lc",
     feature = "rustls-aws-lc-fips",
     feature = "rustls-ring"
 ))]
 async fn make_v2_https_request_through_proxy(
     proxy_config: ProxyConfig,
     target_url: &str,
     tls_provider: tls::Provider,
 ) -> Result<(StatusCode, String), Box<dyn std::error::Error + Send + Sync>> {
     use aws_smithy_http_client::pool::{Client, SharedPool};
-+
     let pool = SharedPool::builder()
         .tls_provider(tls_provider)
         .proxy_config(proxy_config)
         .build_https();
     let http_client = Client::new(&pool);
     let connector_settings = HttpConnectorSettings::builder().build();
     let runtime_components = RuntimeComponentsBuilder::for_tests()
         .with_time_source(Some(SystemTimeSource::new()))
         .build()
         .unwrap();
     let http_connector = http_client.http_connector(&connector_settings, &runtime_components);
-+
     let request = HttpRequest::get(target_url)
         .map_err(|e| Box::new(e) as Box<dyn std::error::Error + Send + Sync>)?;
     let response = http_connector.call(request).await?;
     let status = response.status();
     let body_bytes = response.into_body().collect().await?.to_bytes();
     let body_string = String::from_utf8(body_bytes.to_vec())?;
     Ok((status.into(), body_string))
-+
+}
-+
 #[tokio::test]
 async fn test_v2_http_proxy_basic_request() {
     let mock_proxy = MockProxyServer::new(|req| {
         assert_eq!(req.method, "GET");
         assert_eq!(req.uri, "http://aws.amazon.com/v2/api");
         Response::builder()
             .status(StatusCode::OK)
             .body("v2 proxied response".to_string())
             .unwrap()
     })
     .await;
-+
     let proxy_config = ProxyConfig::http(format!("http://{}", mock_proxy.addr())).unwrap();
     let (status, body) =
         make_v2_http_request_through_proxy(proxy_config, "http://aws.amazon.com/v2/api")
             .await
             .expect("v2 HTTP request through proxy should succeed");
-+
     assert_eq!(status, StatusCode::OK);
     assert_eq!(body, "v2 proxied response");
     assert_eq!(mock_proxy.requests()[0].uri, "http://aws.amazon.com/v2/api");
-+
+}
-+
 #[tokio::test]
 async fn test_v2_proxy_authentication() {
     let mock_proxy = MockProxyServer::with_auth_validation("v2user", "v2pass").await;
-+
     let proxy_config = ProxyConfig::http(format!("http://{}", mock_proxy.addr()))
         .unwrap()
         .with_basic_auth("v2user", "v2pass");
-+
     let (status, _) =
         make_v2_http_request_through_proxy(proxy_config, "http://aws.amazon.com/auth/test")
             .await
             .expect("authenticated v2 proxy request should succeed");
     assert_eq!(status, StatusCode::OK);
-+
     let requests = mock_proxy.requests();
     let auth_header = requests[0]
         .headers
         .get("proxy-authorization")
         .expect("Proxy-Authorization header should be set");
     let expected = format!(
         "Basic {}",
         base64::engine::general_purpose::STANDARD.encode("v2user:v2pass")
     );
     assert_eq!(auth_header, &expected);
-+
+}
-+
 #[tokio::test]
 async fn test_v2_proxy_disabled_uses_direct_connection() {
     let mock_proxy = MockProxyServer::new(|_| {
         Response::builder()
             .status(StatusCode::OK)
             .body("should never reach proxy".to_string())
             .unwrap()
     })
     .await;
     let direct_mock = MockProxyServer::new(|_| {
         Response::builder()
             .status(StatusCode::OK)
             .body("direct response".to_string())
             .unwrap()
     })
     .await;
-+
     let target_url = format!("http://{}/direct", direct_mock.addr());
     let (status, body) = make_v2_http_request_through_proxy(ProxyConfig::disabled(), &target_url)
         .await
         .expect("direct v2 request should succeed");
     assert_eq!(status, StatusCode::OK);
     assert_eq!(body, "direct response");
     assert_eq!(mock_proxy.requests().len(), 0);
     assert_eq!(direct_mock.requests().len(), 1);
-+
+}
-+
 #[tokio::test]
 async fn test_v2_proxy_from_environment_variables() {
     let mock_proxy = MockProxyServer::new(|req| {
         assert_eq!(req.uri, "http://aws.amazon.com/env/api");
         Response::builder()
             .status(StatusCode::OK)
             .body("env-proxy response".to_string())
             .unwrap()
     })
     .await;
     let proxy_url = format!("http://{}", mock_proxy.addr());
-+
     let result = with_env_vars(&[("HTTP_PROXY", &proxy_url)], || async {
         let proxy_config = ProxyConfig::from_env();
         make_v2_http_request_through_proxy(proxy_config, "http://aws.amazon.com/env/api").await
     })
     .await;
-+
     let (status, body) = result.expect("env-var v2 proxy request should succeed");
     assert_eq!(status, StatusCode::OK);
     assert_eq!(body, "env-proxy response");
     assert_eq!(mock_proxy.requests().len(), 1);
-+
+}
-+
 #[tokio::test]
 async fn test_v2_no_proxy_bypass_rules() {
     let mock_proxy = MockProxyServer::new(|_| {
         Response::builder()
             .status(StatusCode::OK)
             .body("proxied".to_string())
             .unwrap()
     })
     .await;
     let direct_mock = MockProxyServer::new(|_| {
         Response::builder()
             .status(StatusCode::OK)
             .body("direct".to_string())
             .unwrap()
     })
     .await;
-+
     let proxy_url = format!("http://{}", mock_proxy.addr());
     let result = with_env_vars(
         &[("HTTP_PROXY", &proxy_url), ("NO_PROXY", "127.0.0.1")],
         || async {
             let proxy_config = ProxyConfig::from_env();
             let target_url = format!("http://{}/bypassed", direct_mock.addr());
             make_v2_http_request_through_proxy(proxy_config, &target_url).await
         },
-+
+    )
     .await;
-+
     let (status, body) = result.expect("bypassed request should succeed");
     assert_eq!(status, StatusCode::OK);
     assert_eq!(body, "direct");
     assert_eq!(mock_proxy.requests().len(), 0, "proxy should be bypassed");
     assert_eq!(direct_mock.requests().len(), 1);
-+
+}
-+
 #[tokio::test]
 async fn test_v2_proxy_connection_failure() {
     let proxy_config = ProxyConfig::http("http://127.0.0.1:1").unwrap();
     let result =
         make_v2_http_request_through_proxy(proxy_config, "http://aws.amazon.com/fail").await;
     assert!(
         result.is_err(),
         "connection to non-existent proxy should fail"
     );
-+
+}
-+
 #[tokio::test]
 async fn test_v2_proxy_authentication_failure() {
     let mock_proxy = MockProxyServer::with_auth_validation("correct", "password").await;
-+
     let proxy_config = ProxyConfig::http(format!("http://{}", mock_proxy.addr()))
         .unwrap()
         .with_basic_auth("wrong", "creds");
-+
     let (status, _) =
         make_v2_http_request_through_proxy(proxy_config, "http://aws.amazon.com/auth/fail")
             .await
             .expect("request should complete (proxy returns 407)");
     assert_eq!(status, StatusCode::PROXY_AUTHENTICATION_REQUIRED);
-+
+}
-+
 #[tokio::test]
 async fn test_v2_explicit_proxy_disable_overrides_environment() {
     let mock_proxy = MockProxyServer::new(|_| {
         Response::builder()
             .status(StatusCode::OK)
             .body("via proxy".to_string())
             .unwrap()
     })
     .await;
     let direct_mock = MockProxyServer::new(|_| {
         Response::builder()
             .status(StatusCode::OK)
             .body("direct".to_string())
             .unwrap()
     })
     .await;
-+
     let proxy_url = format!("http://{}", mock_proxy.addr());
     let result = with_env_vars(&[("HTTP_PROXY", &proxy_url)], || async {
         let proxy_config = ProxyConfig::disabled();
         let target_url = format!("http://{}/path", direct_mock.addr());
         make_v2_http_request_through_proxy(proxy_config, &target_url).await
     })
     .await;
-+
     let (status, body) = result.expect("direct request should succeed");
     assert_eq!(status, StatusCode::OK);
     assert_eq!(body, "direct");
     assert_eq!(mock_proxy.requests().len(), 0);
     assert_eq!(direct_mock.requests().len(), 1);
-+
+}
-+
 #[tokio::test]
 async fn test_v2_http_proxy_absolute_uri_form() {
     let mock_proxy = MockProxyServer::new(|req| {
         assert_eq!(
             req.uri, "http://aws.amazon.com/path?query=1",
             "proxy should receive absolute-form URI"
         );
         Response::builder()
             .status(StatusCode::OK)
             .body("ok".to_string())
             .unwrap()
     })
     .await;
-+
     let proxy_config = ProxyConfig::http(format!("http://{}", mock_proxy.addr())).unwrap();
     let (status, _) =
         make_v2_http_request_through_proxy(proxy_config, "http://aws.amazon.com/path?query=1")
             .await
             .expect("request should succeed");
     assert_eq!(status, StatusCode::OK);
-+
+}
-+
 #[tokio::test]
 async fn test_v2_direct_http_origin_uri_form() {
     let direct_mock = MockProxyServer::new(|req| {
         assert_eq!(
             req.uri, "/path?query=1",
             "direct server should receive origin-form URI"
         );
         Response::builder()
             .status(StatusCode::OK)
             .body("ok".to_string())
             .unwrap()
     })
     .await;
-+
     let target_url = format!("http://{}/path?query=1", direct_mock.addr());
     let (status, _) = make_v2_http_request_through_proxy(ProxyConfig::disabled(), &target_url)
         .await
         .expect("request should succeed");
     assert_eq!(status, StatusCode::OK);
-+
+}
-+
 #[tokio::test]
 async fn test_v2_set_proxy_config_none_clears_proxy() {
     use aws_smithy_http_client::pool::{Client, SharedPool};
-+
     let mock_proxy = MockProxyServer::new(|_| {
         Response::builder()
             .status(StatusCode::OK)
             .body("via proxy".to_string())
             .unwrap()
     })
     .await;
     let direct_mock = MockProxyServer::new(|_| {
         Response::builder()
             .status(StatusCode::OK)
             .body("direct".to_string())
             .unwrap()
     })
     .await;
-+
     let mut builder = SharedPool::builder();
     builder.set_proxy_config(Some(
         ProxyConfig::http(format!("http://{}", mock_proxy.addr())).unwrap(),
     ));
     builder.set_proxy_config(None);
     let pool = builder.build_http();
     let http_client = Client::new(&pool);
-+
     let connector_settings = HttpConnectorSettings::builder().build();
     let runtime_components = RuntimeComponentsBuilder::for_tests()
         .with_time_source(Some(SystemTimeSource::new()))
         .build()
         .unwrap();
     let http_connector = http_client.http_connector(&connector_settings, &runtime_components);
-+
     let target_url = format!("http://{}/path", direct_mock.addr());
     let request = HttpRequest::get(&target_url).unwrap();
     let response = http_connector.call(request).await.unwrap();
     assert_eq!(response.status(), StatusCode::OK.into());
     assert_eq!(mock_proxy.requests().len(), 0);
     assert_eq!(direct_mock.requests().len(), 1);
-+
+}
-+
 #[cfg(any(
     feature = "rustls-aws-lc",
     feature = "rustls-aws-lc-fips",
     feature = "rustls-ring"
 ))]
 #[tokio::test]
 async fn test_v2_https_connect_with_auth() {
     let mock_proxy = MockProxyServer::new(|req| {
         assert_eq!(req.method, "CONNECT");
         assert_eq!(req.uri, "secure.aws.amazon.com:443");
-+
         let expected_auth = format!(
             "Basic {}",
             base64::prelude::BASE64_STANDARD.encode("connectuser:connectpass")
         );
         assert_eq!(req.headers.get("proxy-authorization"), Some(&expected_auth));
-+
         Response::builder()
             .status(StatusCode::BAD_REQUEST)
             .body("CONNECT tunnel setup failed".to_string())
             .unwrap()
     })
     .await;
-+
     let proxy_config = ProxyConfig::all(format!("http://{}", mock_proxy.addr()))
         .unwrap()
         .with_basic_auth("connectuser", "connectpass");
-+
     let tls_provider = tls::Provider::Rustls(tls::rustls_provider::CryptoMode::AwsLc);
     let result = make_v2_https_request_through_proxy(
         proxy_config,
         "https://secure.aws.amazon.com/api/secure",
         tls_provider,
-+
+    )
     .await;
-+
     assert!(
         result.is_err(),
         "CONNECT tunnel should fail with 400 response"
     );
     let requests = mock_proxy.requests();
     assert_eq!(requests.len(), 1);
     assert_eq!(requests[0].method, "CONNECT");
     assert_eq!(requests[0].uri, "secure.aws.amazon.com:443");
-+
+}
-+
 #[cfg(any(
     feature = "rustls-aws-lc",
     feature = "rustls-aws-lc-fips",
     feature = "rustls-ring"
 ))]
 #[tokio::test]
 async fn test_v2_https_connect_auth_required() {
     let mock_proxy = MockProxyServer::new(|req| {
         assert_eq!(req.method, "CONNECT");
         if req.headers.get("proxy-authorization").is_none() {
             return Response::builder()
                 .status(StatusCode::PROXY_AUTHENTICATION_REQUIRED)
                 .body("auth required".to_string())
                 .unwrap();
-+
+        }
         Response::builder()
             .status(StatusCode::OK)
             .body(String::new())
             .unwrap()
     })
     .await;
-+
     let proxy_config = ProxyConfig::all(format!("http://{}", mock_proxy.addr())).unwrap();
     let tls_provider = tls::Provider::Rustls(tls::rustls_provider::CryptoMode::AwsLc);
     let result = make_v2_https_request_through_proxy(
         proxy_config,
         "https://secure.aws.amazon.com/api",
         tls_provider,
-+
+    )
     .await;
-+
     assert!(result.is_err(), "should fail without proxy auth");
     let requests = mock_proxy.requests();
     assert_eq!(requests.len(), 1);
     assert_eq!(requests[0].method, "CONNECT");
     assert!(requests[0].headers.get("proxy-authorization").is_none());
-+
+}

tmp-codegen-diff/aws-sdk/sdk/aws-smithy-http-client/tests/smoke_test_clients.rs

@@ -98,98 +0,241 @@

↥ Expand context

         tls::Provider::Rustls(tls::rustls_provider::CryptoMode::Ring),
         #[cfg(feature = "s2n-tls")]
         tls::Provider::S2nTls,
     ];
-102
     for provider in providers {
         let resolver = PassThroughResolver {
             inner: GaiResolver::new(),
             count: Default::default(),
         };
         let client = Builder::new()
             .tls_provider(provider)
             .build_with_resolver(resolver.clone());
         smoke_test_client(&client).await.unwrap();
         assert_eq!(resolver.count.load(Ordering::Relaxed), 1);
-113
+    }
-114
+}
-115
 async fn smoke_test_client(client: &dyn HttpClient) -> Result<(), Box<dyn Error>> {
     let connector_settings = HttpConnectorSettings::builder().build();

     let runtime_components = RuntimeComponentsBuilder::for_tests()
         .with_time_source(Some(SystemTimeSource::new()))
         .build()
         .unwrap();
     let connector = client.http_connector(&connector_settings, &runtime_components);
     let _response = connector
         .call(HttpRequest::get("https://amazon.com").unwrap())
         .await?;
     Ok(())
-127
+}
-+
 // ---------------------------------------------------------------------------
 // v2 smoke tests
 // ---------------------------------------------------------------------------
-+
 use aws_smithy_http_client::pool::{Client as PoolClient, SharedPool};
-+
 #[cfg(feature = "rustls-aws-lc")]
 #[tokio::test]
 async fn v2_aws_lc_client() {
     let pool = SharedPool::builder()
         .tls_provider(tls::Provider::Rustls(
             tls::rustls_provider::CryptoMode::AwsLc,
         ))
         .build_https();
     smoke_test_client(&PoolClient::new(&pool)).await.unwrap();
-+
+}
-+
 #[cfg(feature = "rustls-aws-lc-fips")]
 #[tokio::test]
 async fn v2_aws_lc_fips_client() {
     let pool = SharedPool::builder()
         .tls_provider(tls::Provider::Rustls(
             tls::rustls_provider::CryptoMode::AwsLcFips,
         ))
         .build_https();
     smoke_test_client(&PoolClient::new(&pool)).await.unwrap();
-+
+}
-+
 #[cfg(feature = "rustls-ring")]
 #[tokio::test]
 async fn v2_ring_client() {
     let pool = SharedPool::builder()
         .tls_provider(tls::Provider::Rustls(
             tls::rustls_provider::CryptoMode::Ring,
         ))
         .build_https();
     smoke_test_client(&PoolClient::new(&pool)).await.unwrap();
-+
+}
-+
 #[cfg(feature = "s2n-tls")]
 #[tokio::test]
 async fn v2_s2n_tls_client() {
     let pool = SharedPool::builder()
         .tls_provider(tls::Provider::S2nTls)
         .build_https();
     smoke_test_client(&PoolClient::new(&pool)).await.unwrap();
-+
+}
-+
 #[cfg(feature = "s2n-tls")]
 #[tokio::test]
 async fn v2_s2n_tls_timing_populated() {
     use aws_smithy_http_client::pool::{ConnectionCreatedEvent, ConnectionEventListener};
     use std::sync::Mutex;
     use std::time::Duration;
-+
     struct TimingListener(Mutex<Option<Duration>>);
     impl ConnectionEventListener for TimingListener {
         fn on_created(&self, event: &ConnectionCreatedEvent) {
             *self.0.lock().unwrap() = Some(event.timing().connect_duration());
-+
+        }
-+
+    }
-+
     let listener = Arc::new(TimingListener(Mutex::new(None)));
     let pool = SharedPool::builder()
         .tls_provider(tls::Provider::S2nTls)
         .connection_event_listener(listener.clone() as Arc<dyn ConnectionEventListener>)
         .build_https();
     smoke_test_client(&PoolClient::new(&pool)).await.unwrap();
-+
     let duration = listener
         .0
         .lock()
         .unwrap()
         .expect("timing should be populated");
     assert!(
         duration > Duration::ZERO,
         "connect_duration should be > 0 (was {duration:?})"
     );
-+
+}
-+
 #[cfg(feature = "rustls-aws-lc")]
 #[tokio::test]
 async fn v2_rustls_timing_populated() {
     use aws_smithy_http_client::pool::{ConnectionCreatedEvent, ConnectionEventListener};
     use std::sync::Mutex;
     use std::time::Duration;
-+
     struct TimingListener(Mutex<Option<Duration>>);
     impl ConnectionEventListener for TimingListener {
         fn on_created(&self, event: &ConnectionCreatedEvent) {
             *self.0.lock().unwrap() = Some(event.timing().connect_duration());
-+
+        }
-+
+    }
-+
     let listener = Arc::new(TimingListener(Mutex::new(None)));
     let pool = SharedPool::builder()
         .tls_provider(tls::Provider::Rustls(
             tls::rustls_provider::CryptoMode::AwsLc,
         ))
         .connection_event_listener(listener.clone() as Arc<dyn ConnectionEventListener>)
         .build_https();
     smoke_test_client(&PoolClient::new(&pool)).await.unwrap();
-+
     let duration = listener
         .0
         .lock()
         .unwrap()
         .expect("timing should be populated");
     assert!(
         duration > Duration::ZERO,
         "connect_duration should be > 0 (was {duration:?})"
     );
-+
+}

tmp-codegen-diff/aws-sdk/sdk/aws-smithy-http-client/tests/tls.rs

@@ -12,12 +72,72 @@

↥ Expand context

 use aws_smithy_runtime_api::client::http::{HttpClient, HttpConnector, HttpConnectorSettings};
 use aws_smithy_runtime_api::client::orchestrator::HttpRequest;
 use aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder;
 use aws_smithy_types::byte_stream::ByteStream;
 use http_1x::{Method, Request, Response, StatusCode};
 use http_body_util::{BodyExt, Full};
 use hyper::body::{Bytes, Incoming};
 use hyper::service::service_fn;
 use hyper_util::rt::{TokioExecutor, TokioIo};
 use hyper_util::server::conn::auto::Builder;
 use rustls::ServerConfig;
 use rustls_pki_types::{CertificateDer, PrivateKeyDer};
 use std::net::SocketAddr;
 use std::sync::Arc;
 use std::time::Duration;
 use std::{fs, io};
 use tokio::net::TcpListener;
 use tokio::task::JoinHandle;
 use tokio_rustls::TlsAcceptor;
 use tracing::{debug, error};

-32
 struct TestServer {
     _handle: JoinHandle<()>,
     listen_addr: SocketAddr,
     conn_count: Arc<()>,
-37
+}
-38
 impl TestServer {
     /// Return the number of active connections to this server
     fn conn_count(&self) -> usize {
         // 1 reference for the struct MockProxyServer, 1 reference for the
         // 1 reference for the struct TestServer, 1 reference for the
         // socket task.
         Arc::strong_count(&self.conn_count)
             .checked_sub(2)
             .expect("de-count 2 refs")
-47
+    }
-48
+}
-49
 async fn server() -> Result<TestServer, BoxError> {
     // Set process wide crypto provider
     let _ = rustls::crypto::aws_lc_rs::default_provider().install_default();

↧ Expand context

-53
     let listener = TcpListener::bind("127.0.0.1:0").await.unwrap();
     let addr = listener.local_addr().unwrap();
-56
     // load public certificate.
     let certs = load_certs("tests/server.pem")?;
-59
     // load private key.
     let key = load_private_key("tests/server.rsa")?;
-62
     debug!("Starting to serve on https://{}", addr);
-64
     // TLS config
     let mut server_config = ServerConfig::builder()
         .with_no_client_auth()
         .with_single_cert(certs, key)
         .map_err(|e| error(e.to_string()))?;
-70
     server_config.alpn_protocols = vec![b"h2".to_vec(), b"http/1.1".to_vec(), b"http/1.0".to_vec()];
     let tls_acceptor = TlsAcceptor::from(Arc::new(server_config));

@@ -280,280 +339,437 @@

↥ Expand context

     let client = aws_smithy_http_client::Builder::new()
         .tls_provider(tls::Provider::Rustls(
             tls::rustls_provider::CryptoMode::Custom(ring_provider),
         ))
         .tls_context(tls_context_from_pem("tests/server.pem"))
         .build_https();
     run_tls_test(&client).await.unwrap()
-287
+}
-288
 #[cfg(feature = "s2n-tls")]
 #[should_panic(expected = "Certificate is untrusted")]
 #[tokio::test]
 async fn test_s2n_native_ca() {
     let client = aws_smithy_http_client::Builder::new()
         .tls_provider(tls::Provider::S2nTls)
         .build_https();
-296
     run_tls_test(&client).await.unwrap()
-298
+}
-299

 #[cfg(feature = "s2n-tls")]
 #[tokio::test]
 async fn test_s2n_tls_custom_ca() {
     let client = aws_smithy_http_client::Builder::new()
         .tls_provider(tls::Provider::S2nTls)
         .tls_context(tls_context_from_pem("tests/server.pem"))
         .build_https();
     run_tls_test(&client).await.unwrap()
-308
+}
-309
 // ---------------------------------------------------------------------------
 // v2 TLS tests
 // ---------------------------------------------------------------------------
-+
 use aws_smithy_http_client::pool::{Client as PoolClient, SharedPool};
-+
 #[cfg(feature = "rustls-aws-lc")]
 #[should_panic(expected = "InvalidCertificate(UnknownIssuer)")]
 #[tokio::test]
 async fn test_v2_rustls_aws_lc_native_ca() {
     let pool = SharedPool::builder()
         .tls_provider(tls::Provider::Rustls(
             tls::rustls_provider::CryptoMode::AwsLc,
         ))
         .build_https();
     run_tls_test(&PoolClient::new(&pool)).await.unwrap()
-+
+}
-+
 #[cfg(feature = "rustls-aws-lc")]
 #[tokio::test]
 async fn test_v2_rustls_aws_lc_custom_ca() {
     let pool = SharedPool::builder()
         .tls_provider(tls::Provider::Rustls(
             tls::rustls_provider::CryptoMode::AwsLc,
         ))
         .tls_context(tls_context_from_pem("tests/server.pem"))
         .build_https();
     run_tls_test(&PoolClient::new(&pool)).await.unwrap()
-+
+}
-+
 #[cfg(feature = "rustls-aws-lc-fips")]
 #[should_panic(expected = "InvalidCertificate(UnknownIssuer)")]
 #[tokio::test]
 async fn test_v2_rustls_aws_lc_fips_native_ca() {
     let pool = SharedPool::builder()
         .tls_provider(tls::Provider::Rustls(
             tls::rustls_provider::CryptoMode::AwsLcFips,
         ))
         .build_https();
     run_tls_test(&PoolClient::new(&pool)).await.unwrap()
-+
+}
-+
 #[cfg(feature = "rustls-aws-lc-fips")]
 #[tokio::test]
 async fn test_v2_rustls_aws_lc_fips_custom_ca() {
     let pool = SharedPool::builder()
         .tls_provider(tls::Provider::Rustls(
             tls::rustls_provider::CryptoMode::AwsLcFips,
         ))
         .tls_context(tls_context_from_pem("tests/server.pem"))
         .build_https();
     run_tls_test(&PoolClient::new(&pool)).await.unwrap()
-+
+}
-+
 #[cfg(feature = "rustls-ring")]
 #[should_panic(expected = "InvalidCertificate(UnknownIssuer)")]
 #[tokio::test]
 async fn test_v2_rustls_ring_native_ca() {
     let pool = SharedPool::builder()
         .tls_provider(tls::Provider::Rustls(
             tls::rustls_provider::CryptoMode::Ring,
         ))
         .build_https();
     run_tls_test(&PoolClient::new(&pool)).await.unwrap()
-+
+}
-+
 #[cfg(feature = "rustls-ring")]
 #[tokio::test]
 async fn test_v2_rustls_ring_custom_ca() {
     let pool = SharedPool::builder()
         .tls_provider(tls::Provider::Rustls(
             tls::rustls_provider::CryptoMode::Ring,
         ))
         .tls_context(tls_context_from_pem("tests/server.pem"))
         .build_https();
     run_tls_test(&PoolClient::new(&pool)).await.unwrap()
-+
+}
-+
 #[cfg(feature = "s2n-tls")]
 #[should_panic(expected = "Certificate is untrusted")]
 #[tokio::test]
 async fn test_v2_s2n_native_ca() {
     let pool = SharedPool::builder()
         .tls_provider(tls::Provider::S2nTls)
         .build_https();
     run_tls_test(&PoolClient::new(&pool)).await.unwrap()
-+
+}
-+
 #[cfg(feature = "s2n-tls")]
 #[tokio::test]
 async fn test_v2_s2n_tls_custom_ca() {
     let pool = SharedPool::builder()
         .tls_provider(tls::Provider::S2nTls)
         .tls_context(tls_context_from_pem("tests/server.pem"))
         .build_https();
     run_tls_test(&PoolClient::new(&pool)).await.unwrap()
-+
+}
-+
 async fn run_tls_test(client: &dyn HttpClient) -> Result<(), BoxError> {
     run_tls_test_with_idle_timeout(client, None).await
-410
+}
-411
 async fn run_tls_test_with_idle_timeout(
     client: &dyn HttpClient,
     pool_timeout: Option<Duration>,
 ) -> Result<(), BoxError> {
     let server = server().await?;
     let start = tokio::time::Instant::now();

↧ Expand context

     assert_eq!(server.conn_count(), 0); // calibrate conn_count
     let endpoint = format!("https://localhost:{}/", server.listen_addr.port());
-420
     let connector_settings = HttpConnectorSettings::builder().build();
     let runtime_components = RuntimeComponentsBuilder::for_tests()
         .with_time_source(Some(SystemTimeSource::new()))
         .build()
         .unwrap();
     let connector = client.http_connector(&connector_settings, &runtime_components);
     let mut response = connector.call(HttpRequest::get(endpoint).unwrap()).await?;
-428
     let sdk_body = response.take_body();
     let body_stream = ByteStream::new(sdk_body);
     let resp_bytes = body_stream.collect().await?.into_bytes();
     assert_eq!(b"Hello TLS!", &resp_bytes[..]);
-433
     if let Some(pool_timeout) = pool_timeout {
         assert_eq!(server.conn_count(), 1);
         tokio::time::sleep_until(start + pool_timeout - Duration::from_secs(1)).await;
         assert_eq!(server.conn_count(), 1);

tmp-codegen-diff/aws-sdk/sdk/aws-smithy-mocks/Cargo.toml

@@ -2,2 +45,45 @@

↥ Expand context

 [package]
 name = "aws-smithy-mocks"
 version = "0.3.0"
 authors = ["AWS Rust SDK Team <aws-sdk-rust@amazon.com>"]
 description = "Testing utilities for smithy-rs generated clients"
 edition = "2021"
 license = "Apache-2.0"
 repository = "https://github.com/smithy-lang/smithy-rs"
 rust-version = "1.94.1"
 [package.metadata.docs.rs]
 all-features = true
 targets = ["x86_64-unknown-linux-gnu"]
 cargo-args = ["-Zunstable-options", "-Zrustdoc-scrape-examples"]
 rustdoc-args = ["--cfg", "docsrs"]
-16
 [dependencies]
 http = "1.3.1"
-19
 [dependencies.aws-smithy-types]
 path = "../aws-smithy-types"

 version = "1.6.0"
-23
 [dependencies.aws-smithy-runtime-api]
 path = "../aws-smithy-runtime-api"
 features = ["client", "http-1x", "test-util"]
 version = "1.13.0"
-28
 [dependencies.aws-smithy-http-client]
 path = "../aws-smithy-http-client"
 features = ["test-util"]
 version = "1.2.0"
 version = "1.3.0"
 [dev-dependencies.tokio]
 version = "1"
 features = ["full"]
-36
 [dev-dependencies.aws-smithy-async]
 path = "../aws-smithy-async"
 features = ["rt-tokio"]
 version = "1.3.0"
-41
 [dev-dependencies.aws-smithy-runtime]

↧ Expand context

tmp-codegen-diff/aws-sdk/sdk/aws-smithy-runtime-api/src/client/connection.rs

@@ -1,1 +113,150 @@

↥ Expand context

  * SPDX-License-Identifier: Apache-2.0
  */
-5
 //! Types related to connection monitoring and management.
-7
 use aws_smithy_types::config_bag::{Storable, StoreReplace};
 use std::fmt;
 use std::net::SocketAddr;
 use std::sync::{Arc, Mutex};
-12
 /// Opaque identifier for a physical connection within a pool.
 ///
 /// Distinct within a pool's lifetime under normal operation (backed by a
 /// monotonic 64-bit counter). All requests dispatched on the same
 /// connection (including H2 multiplexed requests) share the same id.
 /// Useful for correlating requests with connection lifecycle tracing events.
 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
 pub struct ConnectionId(u64);
-+
 impl ConnectionId {
     /// Create a connection id from a raw numeric value.
     ///
     /// For HTTP client/pool implementations that assign connection
     /// identifiers; the value should be distinct per live connection.
     pub fn new(id: u64) -> Self {
         Self(id)
-+
+    }
-+
+}
-+
 impl fmt::Display for ConnectionId {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         self.0.fmt(f)
-+
+    }
-+
+}
-+
 /// Metadata that tracks the state of an active connection.
 #[derive(Clone)]
 pub struct ConnectionMetadata {
     is_proxied: bool,
     remote_addr: Option<SocketAddr>,
     local_addr: Option<SocketAddr>,
     poison_fn: Arc<dyn Fn() + Send + Sync>,
     connection_id: Option<ConnectionId>,
-46
+}
-47
 impl ConnectionMetadata {
     /// Poison this connection, ensuring that it won't be reused.
     pub fn poison(&self) {
         tracing::debug!(
             see_for_more_info = "https://smithy-lang.github.io/smithy-rs/design/client/detailed_error_explanations.html",
             "Connection encountered an issue and should not be re-used. Marking it for closure"
         );
         (self.poison_fn)()
-56
+    }
-57
     /// Create a new [`ConnectionMetadata`].
     #[deprecated(
         since = "1.1.0",
         note = "`ConnectionMetadata::new` is deprecated in favour of `ConnectionMetadata::builder`."
     )]
     pub fn new(
         is_proxied: bool,
         remote_addr: Option<SocketAddr>,
         poison: impl Fn() + Send + Sync + 'static,
     ) -> Self {
         Self {
             is_proxied,
             remote_addr,
             // need to use builder to set this field
             local_addr: None,
             poison_fn: Arc::new(poison),
             connection_id: None,
-75
+        }
-76
+    }
-77
     /// Builder for this connection metadata
     pub fn builder() -> ConnectionMetadataBuilder {
         ConnectionMetadataBuilder::new()
-81
+    }
-82
     /// Get the remote address for this connection, if one is set.
     pub fn remote_addr(&self) -> Option<SocketAddr> {
         self.remote_addr
-86
+    }
-87
     /// Get the local address for this connection, if one is set.
     pub fn local_addr(&self) -> Option<SocketAddr> {
         self.local_addr
-91
+    }
-+
     /// Get the connection id, if one was assigned by the HTTP client.
     ///
     /// `Some` when the HTTP client assigns pool-level connection identifiers;
     /// `None` for clients that do not track connection identity.
     pub fn connection_id(&self) -> Option<ConnectionId> {
         self.connection_id
-+
+    }
-100
+}
-101
 impl fmt::Debug for ConnectionMetadata {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         f.debug_struct("SmithyConnection")
             .field("is_proxied", &self.is_proxied)
             .field("remote_addr", &self.remote_addr)
             .field("local_addr", &self.local_addr)
             .field("connection_id", &self.connection_id)
             .finish()
-110
+    }
-111
+}
-112
 /// Builder type that is used to construct a [`ConnectionMetadata`] value.
 #[derive(Default)]
 pub struct ConnectionMetadataBuilder {
     is_proxied: Option<bool>,
     remote_addr: Option<SocketAddr>,
     local_addr: Option<SocketAddr>,
     poison_fn: Option<Arc<dyn Fn() + Send + Sync>>,
     connection_id: Option<ConnectionId>,
-121
+}
-122
 impl fmt::Debug for ConnectionMetadataBuilder {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         f.debug_struct("ConnectionMetadataBuilder")
             .field("is_proxied", &self.is_proxied)
             .field("remote_addr", &self.remote_addr)
             .field("local_addr", &self.local_addr)
             .finish()
-130
+    }

↧ Expand context

-131
+}
-132
 impl ConnectionMetadataBuilder {
     /// Creates a new builder.
     pub fn new() -> Self {
         Self::default()
-137
+    }
-138
     /// Set whether or not the associated connection is to an HTTP proxy.
     pub fn proxied(mut self, proxied: bool) -> Self {
         self.set_proxied(Some(proxied));
         self
-143
+    }
-144
     /// Set whether or not the associated connection is to an HTTP proxy.
     pub fn set_proxied(&mut self, proxied: Option<bool>) -> &mut Self {
         self.is_proxied = proxied;
         self
-149
+    }
-150

@@ -128,165 +202,252 @@

↥ Expand context

         self.set_local_addr(Some(local_addr));
         self
-167
+    }
-168
     /// Set the local address of the connection used.
     pub fn set_local_addr(&mut self, local_addr: Option<SocketAddr>) -> &mut Self {
         self.local_addr = local_addr;
         self
-173
+    }
-174
     /// Set a closure which will poison the associated connection.
     ///
     /// A poisoned connection will not be reused for subsequent requests by the pool
     pub fn poison_fn(mut self, poison_fn: impl Fn() + Send + Sync + 'static) -> Self {
         self.set_poison_fn(Some(poison_fn));
         self
-181
+    }
-182
     /// Set a closure which will poison the associated connection.
     ///

     /// A poisoned connection will not be reused for subsequent requests by the pool
     pub fn set_poison_fn(
         &mut self,
         poison_fn: Option<impl Fn() + Send + Sync + 'static>,
     ) -> &mut Self {
         self.poison_fn =
             poison_fn.map(|poison_fn| Arc::new(poison_fn) as Arc<dyn Fn() + Send + Sync>);
         self
-193
+    }
-194
     /// Set the [`ConnectionId`] the HTTP client assigned to this connection.
     pub fn connection_id(mut self, id: ConnectionId) -> Self {
         self.connection_id = Some(id);
         self
-+
+    }
-+
     /// Set the [`ConnectionId`] the HTTP client assigned to this connection.
     pub fn set_connection_id(&mut self, id: Option<ConnectionId>) -> &mut Self {
         self.connection_id = id;
         self
-+
+    }
-+
     /// Build a [`ConnectionMetadata`] value.
     ///
     /// # Panics
     ///
     /// If either the `is_proxied` or `poison_fn` has not been set, then this method will panic
     pub fn build(self) -> ConnectionMetadata {
         ConnectionMetadata {
             is_proxied: self
                 .is_proxied
                 .expect("is_proxied should be set for ConnectionMetadata"),
             remote_addr: self.remote_addr,
             local_addr: self.local_addr,
             poison_fn: self
                 .poison_fn
                 .expect("poison_fn should be set for ConnectionMetadata"),
             connection_id: self.connection_id,
-223
+        }
-224
+    }
-225
+}
-226
 type LoaderFn = dyn Fn() -> Option<ConnectionMetadata> + Send + Sync;
-228
 /// State for a middleware that will monitor and manage connections.
 #[derive(Clone, Default)]
 pub struct CaptureSmithyConnection {
     loader: Arc<Mutex<Option<Box<LoaderFn>>>>,

↧ Expand context

-233
+}
-234
 impl CaptureSmithyConnection {
     /// Create a new connection monitor.
     pub fn new() -> Self {
         Self {
             loader: Default::default(),
-240
+        }
-241
+    }
-242
     /// Set the retriever that will capture the `hyper` connection.
     pub fn set_connection_retriever<F>(&self, f: F)
     where
         F: Fn() -> Option<ConnectionMetadata> + Send + Sync + 'static,
-247
+    {
         *self.loader.lock().unwrap() = Some(Box::new(f));
-249
+    }
-250
     /// Get the associated connection metadata.
     pub fn get(&self) -> Option<ConnectionMetadata> {

tmp-codegen-diff/aws-sdk/sdk/aws-smithy-runtime/Cargo.toml

@@ -39,39 +99,99 @@

↥ Expand context

 tracing = "0.1.44"
-40
 [dependencies.aws-smithy-async]
 path = "../aws-smithy-async"
 version = "1.3.0"
-44
 [dependencies.aws-smithy-http]
 path = "../aws-smithy-http"
 version = "0.64.0"
-48
 [dependencies.aws-smithy-observability]
 path = "../aws-smithy-observability"
 version = "0.3.0"
-52
 [dependencies.aws-smithy-runtime-api]
 path = "../aws-smithy-runtime-api"
 version = "1.13.0"
-56
 [dependencies.aws-smithy-schema]
 path = "../aws-smithy-schema"

 version = "0.1.1"
-60
 [dependencies.aws-smithy-types]
 path = "../aws-smithy-types"
 features = ["http-body-0-4-x"]
 version = "1.6.0"
-65
 [dependencies.aws-smithy-http-client]
 path = "../aws-smithy-http-client"
 optional = true
 version = "1.2.0"
 version = "1.3.0"
-70
 [dependencies.http-02x]
 package = "http"
 version = "0.2.12"
-74
 [dependencies.http-1x]
 package = "http"
 version = "1.3.1"
-78
 [dependencies.http-body-04x]

↧ Expand context

 package = "http-body"
 version = "0.4.6"
-82
 [dependencies.http-body-1x]
 package = "http-body"
 version = "1.0.1"
-86
 [dependencies.tokio]
 version = "1.49.0"
 features = []
-90
 [dependencies.tracing-subscriber]
 version = "0.3.22"
 optional = true
 features = ["env-filter", "fmt", "json"]
-95
 [dev-dependencies]
 approx = "0.5.1"
 fastrand = "2.3.0"
 futures-util = "0.3.29"

tmp-codegen-diff/aws-sdk/sdk/aws-smithy-runtime/tests/reconnect_on_transient_error.rs

@@ -1,1 +309,366 @@

↥ Expand context

 /*
  * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
  * SPDX-License-Identifier: Apache-2.0
  */
-5
 #![cfg(all(feature = "client", feature = "wire-mock",))]
-7
 use ::aws_smithy_runtime::client::retries::classifiers::{

     HttpStatusCodeClassifier, TransientErrorClassifier,
 };
 use aws_smithy_async::rt::sleep::TokioSleep;
 use aws_smithy_runtime::client::http::hyper_014::HyperClientBuilder;
 use aws_smithy_runtime::client::http::test_util::wire::{
     RecordedEvent, ReplayedEvent, WireMockServer,
 };
 use aws_smithy_runtime::client::orchestrator::operation::Operation;
 use aws_smithy_runtime::test_util::capture_test_logs::capture_test_logs;
 use aws_smithy_runtime::{ev, match_events};
 use aws_smithy_runtime_api::client::http::SharedHttpClient;
 use aws_smithy_runtime_api::client::interceptors::context::InterceptorContext;
 use aws_smithy_runtime_api::client::orchestrator::OrchestratorError;
 use aws_smithy_runtime_api::client::retries::classifiers::{ClassifyRetry, RetryAction};
 use aws_smithy_runtime_api::shared::IntoShared;
 use aws_smithy_types::body::SdkBody;
 use aws_smithy_types::retry::{ErrorKind, ProvideErrorKind, ReconnectMode, RetryConfig};
 use aws_smithy_types::timeout::TimeoutConfig;
 use hyper_0_14::client::Builder as HyperBuilder;
 use std::fmt;
 use std::time::Duration;
-29
 const END_OF_TEST: &str = "end_of_test";
-31
 #[derive(Debug)]
 struct OperationError(ErrorKind);
-34
 impl fmt::Display for OperationError {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         write!(f, "{:?}", self)
-38
+    }
-39
+}
-40
 impl ProvideErrorKind for OperationError {
     fn retryable_error_kind(&self) -> Option<ErrorKind> {
         Some(self.0)
-44
+    }
-45
     fn code(&self) -> Option<&str> {
         None
-48
+    }
-49
+}
-50
 impl std::error::Error for OperationError {}
-52
 #[derive(Debug)]
 struct TestRetryClassifier;
-55
 impl ClassifyRetry for TestRetryClassifier {
     fn classify_retry(&self, ctx: &InterceptorContext) -> RetryAction {
         tracing::info!("classifying retry for {ctx:?}");
         // Check for a result
         let output_or_error = ctx.output_or_error();
         // Check for an error
         let error = match output_or_error {
             Some(Ok(_)) | None => return RetryAction::NoActionIndicated,
             Some(Err(err)) => err,
         };
-64
         let action = if let Some(err) = error.as_operation_error() {
             tracing::info!("its an operation error: {err:?}");
             let err = err.downcast_ref::<OperationError>().unwrap();
             RetryAction::retryable_error(err.0)
         } else {
             tracing::info!("its something else... using other classifiers");
             let action = TransientErrorClassifier::<OperationError>::new().classify_retry(ctx);
             if action == RetryAction::NoActionIndicated {
                 HttpStatusCodeClassifier::default().classify_retry(ctx)
             } else {
                 action
-76
+            }
         };
-78
         tracing::info!("classified as {action:?}");
         action
-81
+    }
-82
     fn name(&self) -> &'static str {
         "test"
-85
+    }
-86
+}
-87
 async fn h1_and_h2(events: Vec<ReplayedEvent>, match_clause: impl Fn(&[RecordedEvent])) {
     wire_level_test(
         events.clone(),
         |_b| {},
         ReconnectMode::ReconnectOnTransientError,
         &match_clause,
--
+    )
     .await;
     wire_level_test(
         events,
         |b| {
             b.http2_only(true);
         },
         ReconnectMode::ReconnectOnTransientError,
         match_clause,
--
+    )
     .await;
     tracing::info!("h2 ok!");
 /// MakeClient — parameterizes tests over HTTP stacks
 trait MakeClient: Send + Sync {
     fn make(&self, mock: &WireMockServer) -> SharedHttpClient;
-+
+}
-+
 /// hyper 0.14 legacy stack
 struct Hyper014Client;
-+
 impl MakeClient for Hyper014Client {
     fn make(&self, mock: &WireMockServer) -> SharedHttpClient {
         HyperClientBuilder::new()
             .build(hyper_0_14::client::HttpConnector::new_with_resolver(
                 mock.dns_resolver(),
             ))
             .into_shared()
-+
+    }
-+
+}
-+
 /// hyper 0.14 with HTTP/2 only
 struct Hyper014H2Client;
-+
 impl MakeClient for Hyper014H2Client {
     fn make(&self, mock: &WireMockServer) -> SharedHttpClient {
         let mut hyper_builder = hyper_0_14::Client::builder();
         hyper_builder.http2_only(true);
         HyperClientBuilder::new()
             .hyper_builder(hyper_builder)
             .build(hyper_0_14::client::HttpConnector::new_with_resolver(
                 mock.dns_resolver(),
             ))
             .into_shared()
-+
+    }
-+
+}
-+
 /// hyper 1.x stack via public Builder API
 struct Hyper1xClient;
-+
 impl MakeClient for Hyper1xClient {
     fn make(&self, mock: &WireMockServer) -> SharedHttpClient {
         aws_smithy_http_client::Builder::new().build_with_resolver(mock.dns_resolver())
-+
+    }
-+
+}
-+
 /// HTTP client backed by the composable connection pool.
 struct Hyper1xV2Client;
-+
 impl MakeClient for Hyper1xV2Client {
     fn make(&self, mock: &WireMockServer) -> SharedHttpClient {
         let pool = aws_smithy_http_client::pool::SharedPool::builder()
             .dns_resolver(mock.dns_resolver())
             .build_http();
         aws_smithy_http_client::pool::Client::new(&pool).into_shared()
-+
+    }
-141
+}
-142
 /// Repeatedly send test operation until `end_of_test` is received
 ///
 /// When the test is over, match_clause is evaluated
 async fn wire_level_test(
 /// Repeatedly send test operation until `end_of_test` is received, then run match_clause.
 async fn run_test(
     make_client: &dyn MakeClient,
     events: Vec<ReplayedEvent>,
     hyper_builder_settings: impl Fn(&mut HyperBuilder),
     reconnect_mode: ReconnectMode,
     match_clause: impl Fn(&[RecordedEvent]),
 ) {
     let mut hyper_builder = hyper_0_14::Client::builder();
     hyper_builder_settings(&mut hyper_builder);
--
     let mock = WireMockServer::start(events).await;
     let http_client = HyperClientBuilder::new()
         .hyper_builder(hyper_builder)
         .build(hyper_0_14::client::HttpConnector::new_with_resolver(
             mock.dns_resolver(),
         ));
     let http_client = make_client.make(&mock);
-152
     let operation = Operation::builder()
         .service_name("test")
         .operation_name("test")
         .no_auth()
         .endpoint_url(&mock.endpoint_url())
         .http_client(http_client)
         .timeout_config(
             TimeoutConfig::builder()
                 .operation_attempt_timeout(Duration::from_millis(100))
                 .build(),
-163
+        )
         .standard_retry(&RetryConfig::standard().with_reconnect_mode(reconnect_mode))
         .retry_classifier(TestRetryClassifier)
         .sleep_impl(TokioSleep::new())
         .with_connection_poisoning()
         .serializer({
             let endpoint_url = mock.endpoint_url();
             move |_| {
                 let request = http_02x::Request::builder()
                 let request = http_1x::Request::builder()
                     .uri(endpoint_url.clone())
                     // Make the body non-replayable since we don't actually want to retry
                     .body(SdkBody::from_body_0_4(SdkBody::from("body")))
                     .body(SdkBody::from("body"))
                     .unwrap()
                     .try_into()
                     .unwrap();
                 tracing::info!("serializing request: {request:?}");
                 Ok(request)
-179
+            }
         })
         .deserializer(|response| {
             tracing::info!("deserializing response: {:?}", response);
             match response.status() {
                 s if s.is_success() => {
                     Ok(String::from_utf8(response.body().bytes().unwrap().into()).unwrap())
-186
+                }
                 s if s.is_client_error() => Err(OrchestratorError::operation(OperationError(
                     ErrorKind::ServerError,
                 ))),
                 s if s.is_server_error() => Err(OrchestratorError::operation(OperationError(
                     ErrorKind::TransientError,
                 ))),
                 _ => panic!("unexpected status: {}", response.status()),
-194
+            }
         })
         .build();
-197
     let mut iteration = 0;
     loop {
         tracing::info!("iteration {iteration}...");
         match operation.invoke(()).await {
             Ok(resp) => {
                 tracing::info!("response: {:?}", resp);
                 if resp == END_OF_TEST {
                     break;
-206
+                }
-207
+            }
             Err(e) => tracing::info!("error: {:?}", e),
-209
+        }
         iteration += 1;
         if iteration > 50 {
             panic!("probably an infinite loop; no satisfying 'end_of_test' response received");
-213
+        }
-214
+    }
     let events = mock.events();
     match_clause(&events);
     mock.shutdown();
-218
+}
-219
 /// Run a test against all HTTP stacks
 async fn all_stacks(
     events: Vec<ReplayedEvent>,
     reconnect_mode: ReconnectMode,
     match_clause: impl Fn(&[RecordedEvent]),
 ) {
     run_test(
         &Hyper014Client,
         events.clone(),
         reconnect_mode,
         &match_clause,
-+
+    )
     .await;
     run_test(
         &Hyper014H2Client,
         events.clone(),
         reconnect_mode,
         &match_clause,
-+
+    )
     .await;
     run_test(
         &Hyper1xClient,
         events.clone(),
         reconnect_mode,
         &match_clause,
-+
+    )
     .await;
     run_test(&Hyper1xV2Client, events, reconnect_mode, &match_clause).await;
-+
+}
-+
 #[tokio::test]
 async fn non_transient_errors_no_reconnect() {
     let _logs = capture_test_logs();
     h1_and_h2(
     all_stacks(
         vec![
             ReplayedEvent::status(400),
             ReplayedEvent::with_body(END_OF_TEST),
         ],
         ReconnectMode::ReconnectOnTransientError,
         match_events!(ev!(dns), ev!(connect), ev!(http(400)), ev!(http(200))),
-260
+    )
     .await
     .await;
-262
+}
-263
 #[tokio::test]
 async fn reestablish_dns_on_503() {
     let _logs = capture_test_logs();
     h1_and_h2(
     all_stacks(
         vec![
             ReplayedEvent::status(503),
             ReplayedEvent::status(503),
             ReplayedEvent::status(503),
             ReplayedEvent::with_body(END_OF_TEST),
         ],
         ReconnectMode::ReconnectOnTransientError,
         match_events!(
             // first request
             ev!(dns),
             ev!(connect),
             ev!(http(503)),
             // second request
             ev!(dns),
             ev!(connect),
             ev!(http(503)),
             // third request
             ev!(dns),
             ev!(connect),
             ev!(http(503)),
             // all good
             ev!(dns),
             ev!(connect),
             ev!(http(200))
         ),
-293
+    )
     .await;
-295
+}
-296
 #[tokio::test]
 async fn connection_shared_on_success() {
     let _logs = capture_test_logs();
     h1_and_h2(
     all_stacks(
         vec![
             ReplayedEvent::ok(),
             ReplayedEvent::ok(),
             ReplayedEvent::status(503),
             ReplayedEvent::with_body(END_OF_TEST),
         ],
         ReconnectMode::ReconnectOnTransientError,
         match_events!(
             ev!(dns),
             ev!(connect),
             ev!(http(200)),
             ev!(http(200)),
             ev!(http(503)),
             ev!(dns),
             ev!(connect),
             ev!(http(200))
         ),
-318
+    )
     .await;
-320
+}
-321
 #[tokio::test]
 async fn no_reconnect_when_disabled() {
     let _logs = capture_test_logs();
     wire_level_test(
     all_stacks(
         vec![
             ReplayedEvent::status(503),
             ReplayedEvent::with_body(END_OF_TEST),
         ],
         |_b| {},
         ReconnectMode::ReuseAllConnections,
         match_events!(ev!(dns), ev!(connect), ev!(http(503)), ev!(http(200))),
-332
+    )
     .await;
-334
+}
-335
 #[tokio::test]
 async fn connection_reestablished_after_timeout() {
     let _logs = capture_test_logs();
     h1_and_h2(
     all_stacks(
         vec![
             ReplayedEvent::ok(),
             ReplayedEvent::Timeout,
             ReplayedEvent::ok(),
             ReplayedEvent::Timeout,
             ReplayedEvent::with_body(END_OF_TEST),
         ],
         ReconnectMode::ReconnectOnTransientError,
         match_events!(
             // first connection
             ev!(dns),
             ev!(connect),
             ev!(http(200)),
             // reuse but got a timeout
             ev!(timeout),
             // so we reconnect
             ev!(dns),
             ev!(connect),

↧ Expand context

             ev!(http(200)),
             ev!(timeout),
             ev!(dns),
             ev!(connect),
             ev!(http(200))
         ),
-364
+    )
     .await;
-366
+}

tmp-codegen-diff/aws-sdk/sdk/bedrockruntime/Cargo.toml

@@ -89,89 +149,149 @@

↥ Expand context

-89
 [dependencies.tracing]
 version = "0.1"
 [dev-dependencies.aws-config]
 path = "../aws-config"
 version = "1.9.0"
-95
 [dev-dependencies.aws-credential-types]
 path = "../aws-credential-types"
 features = ["test-util"]
 version = "1.3.0"
-100
 [dev-dependencies.aws-runtime]
 path = "../aws-runtime"
 features = ["test-util"]
 version = "1.8.0"
-105
 [dev-dependencies.aws-smithy-async]
 path = "../aws-smithy-async"
 features = ["test-util"]

 version = "1.3.0"
-110
 [dev-dependencies.aws-smithy-eventstream]
 path = "../aws-smithy-eventstream"
 features = ["test-util"]
 version = "0.61.1"
-115
 [dev-dependencies.aws-smithy-http-client]
 path = "../aws-smithy-http-client"
 features = ["test-util", "wire-mock"]
 version = "1.2.0"
 version = "1.3.0"
-120
 [dev-dependencies.aws-smithy-protocol-test]
 path = "../aws-smithy-protocol-test"
 version = "0.64.0"
-124
 [dev-dependencies.aws-smithy-runtime]
 path = "../aws-smithy-runtime"
 features = ["test-util"]
 version = "1.12.0"
-129

↧ Expand context

 [dev-dependencies.aws-smithy-runtime-api]
 path = "../aws-smithy-runtime-api"
 features = ["test-util"]
 version = "1.13.0"
-134
 [dev-dependencies.aws-smithy-types]
 path = "../aws-smithy-types"
 features = ["http-body-1-x", "test-util"]
 version = "1.6.0"
-139
 [dev-dependencies.futures-util]
 version = "0.3.25"
 features = ["alloc"]
 default-features = false
-144
 [dev-dependencies.proptest]
 version = "1"
-147
 [dev-dependencies.serde_json]
 version = "1.0.0"

tmp-codegen-diff/aws-sdk/sdk/cloudwatchlogs/Cargo.toml

@@ -82,82 +142,142 @@

↥ Expand context

-82
 [dependencies.tracing]
 version = "0.1"
 [dev-dependencies.aws-config]
 path = "../aws-config"
 version = "1.9.0"
-88
 [dev-dependencies.aws-credential-types]
 path = "../aws-credential-types"
 features = ["test-util"]
 version = "1.3.0"
-93
 [dev-dependencies.aws-runtime]
 path = "../aws-runtime"
 features = ["test-util"]
 version = "1.8.0"
-98
 [dev-dependencies.aws-smithy-async]
 path = "../aws-smithy-async"
 features = ["test-util"]

 version = "1.3.0"
-103
 [dev-dependencies.aws-smithy-eventstream]
 path = "../aws-smithy-eventstream"
 features = ["test-util"]
 version = "0.61.1"
-108
 [dev-dependencies.aws-smithy-http-client]
 path = "../aws-smithy-http-client"
 features = ["test-util", "wire-mock"]
 version = "1.2.0"
 version = "1.3.0"
-113
 [dev-dependencies.aws-smithy-protocol-test]
 path = "../aws-smithy-protocol-test"
 version = "0.64.0"
-117
 [dev-dependencies.aws-smithy-runtime]
 path = "../aws-smithy-runtime"
 features = ["test-util"]
 version = "1.12.0"
-122

↧ Expand context

 [dev-dependencies.aws-smithy-runtime-api]
 path = "../aws-smithy-runtime-api"
 features = ["test-util"]
 version = "1.13.0"
-127
 [dev-dependencies.aws-smithy-types]
 path = "../aws-smithy-types"
 features = ["http-body-1-x", "test-util"]
 version = "1.6.0"
-132
 [dev-dependencies.futures-util]
 version = "0.3.25"
 features = ["alloc"]
 default-features = false
-137
 [dev-dependencies.proptest]
 version = "1"
-140
 [dev-dependencies.serde_json]
 version = "1.0.0"

tmp-codegen-diff/aws-sdk/sdk/codecatalyst/Cargo.toml

@@ -71,71 +131,131 @@

↥ Expand context

 version = "1"
 package = "http"
-73
 [dependencies.regex-lite]
 version = "0.1.5"
-76
 [dependencies.tracing]
 version = "0.1"
 [dev-dependencies.aws-config]
 path = "../aws-config"
 version = "1.9.0"
-82
 [dev-dependencies.aws-credential-types]
 path = "../aws-credential-types"
 features = ["test-util"]
 version = "1.3.0"
-87
 [dev-dependencies.aws-runtime]
 path = "../aws-runtime"
 features = ["test-util"]

 version = "1.8.0"
-92
 [dev-dependencies.aws-smithy-async]
 path = "../aws-smithy-async"
 features = ["test-util"]
 version = "1.3.0"
-97
 [dev-dependencies.aws-smithy-http-client]
 path = "../aws-smithy-http-client"
 features = ["test-util", "wire-mock"]
 version = "1.2.0"
 version = "1.3.0"
-102
 [dev-dependencies.aws-smithy-protocol-test]
 path = "../aws-smithy-protocol-test"
 version = "0.64.0"
-106
 [dev-dependencies.aws-smithy-runtime]
 path = "../aws-smithy-runtime"
 features = ["test-util"]
 version = "1.12.0"
-111

↧ Expand context

 [dev-dependencies.aws-smithy-runtime-api]
 path = "../aws-smithy-runtime-api"
 features = ["test-util"]
 version = "1.13.0"
-116
 [dev-dependencies.aws-smithy-types]
 path = "../aws-smithy-types"
 features = ["http-body-1-x", "test-util"]
 version = "1.6.0"
-121
 [dev-dependencies.futures-util]
 version = "0.3.25"
 features = ["alloc"]
 default-features = false
-126
 [dev-dependencies.proptest]
 version = "1"
-129
 [dev-dependencies.serde_json]
 version = "1.0.0"

tmp-codegen-diff/aws-sdk/sdk/dynamodb/Cargo.toml

@@ -77,77 +137,137 @@

↥ Expand context

 [dependencies.regex-lite]
 version = "0.1.5"
-79
 [dependencies.tracing]
 version = "0.1"
 [dev-dependencies.approx]
 version = "0.5.1"
-84
 [dev-dependencies.aws-config]
 path = "../aws-config"
 version = "1.9.0"
-88
 [dev-dependencies.aws-credential-types]
 path = "../aws-credential-types"
 features = ["test-util"]
 version = "1.3.0"
-93
 [dev-dependencies.aws-runtime]
 path = "../aws-runtime"
 features = ["test-util"]

 version = "1.8.0"
-98
 [dev-dependencies.aws-smithy-async]
 path = "../aws-smithy-async"
 features = ["test-util"]
 version = "1.3.0"
-103
 [dev-dependencies.aws-smithy-http-client]
 path = "../aws-smithy-http-client"
 features = ["test-util", "wire-mock"]
 version = "1.2.0"
 version = "1.3.0"
-108
 [dev-dependencies.aws-smithy-protocol-test]
 path = "../aws-smithy-protocol-test"
 version = "0.64.0"
-112
 [dev-dependencies.aws-smithy-runtime]
 path = "../aws-smithy-runtime"
 features = ["test-util"]
 version = "1.12.0"
-117

↧ Expand context

 [dev-dependencies.aws-smithy-runtime-api]
 path = "../aws-smithy-runtime-api"
 features = ["test-util"]
 version = "1.13.0"
-122
 [dev-dependencies.aws-smithy-types]
 path = "../aws-smithy-types"
 features = ["http-body-1-x", "test-util"]
 version = "1.6.0"
-127
 [dev-dependencies.criterion]
 version = "0.5.0"
-130
 [dev-dependencies.futures-util]
 version = "0.3.25"
 features = ["alloc"]
 default-features = false
-135
 [dev-dependencies.proptest]
 version = "1"

tmp-codegen-diff/aws-sdk/sdk/ec2/Cargo.toml

@@ -76,76 +136,136 @@

↥ Expand context

 version = "1"
 package = "http"
-78
 [dependencies.regex-lite]
 version = "0.1.5"
-81
 [dependencies.tracing]
 version = "0.1"
 [dev-dependencies.aws-config]
 path = "../aws-config"
 version = "1.9.0"
-87
 [dev-dependencies.aws-credential-types]
 path = "../aws-credential-types"
 features = ["test-util"]
 version = "1.3.0"
-92
 [dev-dependencies.aws-runtime]
 path = "../aws-runtime"
 features = ["test-util"]

 version = "1.8.0"
-97
 [dev-dependencies.aws-smithy-async]
 path = "../aws-smithy-async"
 features = ["test-util"]
 version = "1.3.0"
-102
 [dev-dependencies.aws-smithy-http-client]
 path = "../aws-smithy-http-client"
 features = ["test-util", "wire-mock"]
 version = "1.2.0"
 version = "1.3.0"
-107
 [dev-dependencies.aws-smithy-protocol-test]
 path = "../aws-smithy-protocol-test"
 version = "0.64.0"
-111
 [dev-dependencies.aws-smithy-runtime]
 path = "../aws-smithy-runtime"
 features = ["test-util"]
 version = "1.12.0"
-116

↧ Expand context

 [dev-dependencies.aws-smithy-runtime-api]
 path = "../aws-smithy-runtime-api"
 features = ["test-util"]
 version = "1.13.0"
-121
 [dev-dependencies.aws-smithy-types]
 path = "../aws-smithy-types"
 features = ["http-body-1-x", "test-util"]
 version = "1.6.0"
-126
 [dev-dependencies.futures-util]
 version = "0.3.25"
 features = ["alloc"]
 default-features = false
-131
 [dev-dependencies.proptest]
 version = "1"
-134
 [dev-dependencies.serde_json]
 version = "1.0.0"

tmp-codegen-diff/aws-sdk/sdk/glacier/Cargo.toml

@@ -81,81 +141,141 @@

↥ Expand context

 [dependencies.regex-lite]
 version = "0.1.5"
-83
 [dependencies.ring]
 version = "0.17.5"
-86
 [dependencies.tracing]
 version = "0.1"
 [dev-dependencies.aws-config]
 path = "../aws-config"
 version = "1.9.0"
-92
 [dev-dependencies.aws-credential-types]
 path = "../aws-credential-types"
 features = ["test-util"]
 version = "1.3.0"
-97
 [dev-dependencies.aws-runtime]
 path = "../aws-runtime"
 features = ["test-util"]

 version = "1.8.0"
-102
 [dev-dependencies.aws-smithy-async]
 path = "../aws-smithy-async"
 features = ["test-util"]
 version = "1.3.0"
-107
 [dev-dependencies.aws-smithy-http-client]
 path = "../aws-smithy-http-client"
 features = ["test-util", "wire-mock"]
 version = "1.2.0"
 version = "1.3.0"
-112
 [dev-dependencies.aws-smithy-protocol-test]
 path = "../aws-smithy-protocol-test"
 version = "0.64.0"
-116
 [dev-dependencies.aws-smithy-runtime]
 path = "../aws-smithy-runtime"
 features = ["test-util"]
 version = "1.12.0"
-121

↧ Expand context

 [dev-dependencies.aws-smithy-runtime-api]
 path = "../aws-smithy-runtime-api"
 features = ["test-util"]
 version = "1.13.0"
-126
 [dev-dependencies.aws-smithy-types]
 path = "../aws-smithy-types"
 features = ["http-body-1-x", "test-util"]
 version = "1.6.0"
-131
 [dev-dependencies.futures-util]
 version = "0.3.25"
 features = ["alloc"]
 default-features = false
-136
 [dev-dependencies.pretty_assertions]
 version = "1.3.0"
-139
 [dev-dependencies.proptest]
 version = "1"

tmp-codegen-diff/aws-sdk/sdk/iam/Cargo.toml

@@ -76,76 +136,136 @@

↥ Expand context

 version = "1"
 package = "http"
-78
 [dependencies.regex-lite]
 version = "0.1.5"
-81
 [dependencies.tracing]
 version = "0.1"
 [dev-dependencies.aws-config]
 path = "../aws-config"
 version = "1.9.0"
-87
 [dev-dependencies.aws-credential-types]
 path = "../aws-credential-types"
 features = ["test-util"]
 version = "1.3.0"
-92
 [dev-dependencies.aws-runtime]
 path = "../aws-runtime"
 features = ["test-util"]

 version = "1.8.0"
-97
 [dev-dependencies.aws-smithy-async]
 path = "../aws-smithy-async"
 features = ["test-util"]
 version = "1.3.0"
-102
 [dev-dependencies.aws-smithy-http-client]
 path = "../aws-smithy-http-client"
 features = ["test-util", "wire-mock"]
 version = "1.2.0"
 version = "1.3.0"
-107
 [dev-dependencies.aws-smithy-protocol-test]
 path = "../aws-smithy-protocol-test"
 version = "0.64.0"
-111
 [dev-dependencies.aws-smithy-runtime]
 path = "../aws-smithy-runtime"
 features = ["test-util"]
 version = "1.12.0"
-116

↧ Expand context

 [dev-dependencies.aws-smithy-runtime-api]
 path = "../aws-smithy-runtime-api"
 features = ["test-util"]
 version = "1.13.0"
-121
 [dev-dependencies.aws-smithy-types]
 path = "../aws-smithy-types"
 features = ["http-body-1-x", "test-util"]
 version = "1.6.0"
-126
 [dev-dependencies.futures-util]
 version = "0.3.25"
 features = ["alloc"]
 default-features = false
-131
 [dev-dependencies.proptest]
 version = "1"
-134
 [dev-dependencies.serde_json]
 version = "1.0.0"

tmp-codegen-diff/aws-sdk/sdk/kms/Cargo.toml

@@ -71,71 +131,131 @@

↥ Expand context

 version = "1"
 package = "http"
-73
 [dependencies.regex-lite]
 version = "0.1.5"
-76
 [dependencies.tracing]
 version = "0.1"
 [dev-dependencies.aws-config]
 path = "../aws-config"
 version = "1.9.0"
-82
 [dev-dependencies.aws-credential-types]
 path = "../aws-credential-types"
 features = ["test-util"]
 version = "1.3.0"
-87
 [dev-dependencies.aws-runtime]
 path = "../aws-runtime"
 features = ["test-util"]

 version = "1.8.0"
-92
 [dev-dependencies.aws-smithy-async]
 path = "../aws-smithy-async"
 features = ["test-util"]
 version = "1.3.0"
-97
 [dev-dependencies.aws-smithy-http-client]
 path = "../aws-smithy-http-client"
 features = ["test-util", "wire-mock"]
 version = "1.2.0"
 version = "1.3.0"
-102
 [dev-dependencies.aws-smithy-protocol-test]
 path = "../aws-smithy-protocol-test"
 version = "0.64.0"
-106
 [dev-dependencies.aws-smithy-runtime]
 path = "../aws-smithy-runtime"
 features = ["test-util"]
 version = "1.12.0"
-111

↧ Expand context

 [dev-dependencies.aws-smithy-runtime-api]
 path = "../aws-smithy-runtime-api"
 features = ["test-util"]
 version = "1.13.0"
-116
 [dev-dependencies.aws-smithy-types]
 path = "../aws-smithy-types"
 features = ["http-body-1-x", "test-util"]
 version = "1.6.0"
-121
 [dev-dependencies.futures-util]
 version = "0.3.25"
 features = ["alloc"]
 default-features = false
-126
 [dev-dependencies.proptest]
 version = "1"
-129
 [dev-dependencies.serde_json]
 version = "1.0.0"

tmp-codegen-diff/aws-sdk/sdk/lambda/Cargo.toml

@@ -82,82 +142,142 @@

↥ Expand context

-82
 [dependencies.tracing]
 version = "0.1"
 [dev-dependencies.aws-config]
 path = "../aws-config"
 version = "1.9.0"
-88
 [dev-dependencies.aws-credential-types]
 path = "../aws-credential-types"
 features = ["test-util"]
 version = "1.3.0"
-93
 [dev-dependencies.aws-runtime]
 path = "../aws-runtime"
 features = ["test-util"]
 version = "1.8.0"
-98
 [dev-dependencies.aws-smithy-async]
 path = "../aws-smithy-async"
 features = ["test-util"]

 version = "1.3.0"
-103
 [dev-dependencies.aws-smithy-eventstream]
 path = "../aws-smithy-eventstream"
 features = ["test-util"]
 version = "0.61.1"
-108
 [dev-dependencies.aws-smithy-http-client]
 path = "../aws-smithy-http-client"
 features = ["test-util", "wire-mock"]
 version = "1.2.0"
 version = "1.3.0"
-113
 [dev-dependencies.aws-smithy-protocol-test]
 path = "../aws-smithy-protocol-test"
 version = "0.64.0"
-117
 [dev-dependencies.aws-smithy-runtime]
 path = "../aws-smithy-runtime"
 features = ["test-util"]
 version = "1.12.0"
-122

↧ Expand context

 [dev-dependencies.aws-smithy-runtime-api]
 path = "../aws-smithy-runtime-api"
 features = ["test-util"]
 version = "1.13.0"
-127
 [dev-dependencies.aws-smithy-types]
 path = "../aws-smithy-types"
 features = ["http-body-1-x", "test-util"]
 version = "1.6.0"
-132
 [dev-dependencies.futures-util]
 version = "0.3.25"
 features = ["alloc"]
 default-features = false
-137
 [dev-dependencies.proptest]
 version = "1"
-140
 [dev-dependencies.serde_json]
 version = "1.0.0"

Pages: 1 2 3 4 5 6 7 8

43 43	`path = "../aws-smithy-runtime"`
44 44	`features = ["client"]`
45 45	`version = "1.12.0"`

1 1	`/*`
2 2	`* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.`