AWS SDK

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

@@ -154,154 +213,237 @@

     if let Some(retry_config) = cfg.load::<RetryConfig>() {
         if retry_config.has_retry() && components.sleep_impl().is_none() {
             Err("An async sleep implementation is required for retry to work. Please provide a `sleep_impl` on \
                  the config, or disable timeouts.".into())
         } else {
             Ok(())
-160
+        }
     } else {
         Err(
             "The default retry config was removed, and no other config was put in its place."
                 .into(),
-165
+        )
-166
+    }
-167
+}
-168
 /// Runtime plugin that sets the default timeout config (no timeouts).
 pub fn default_timeout_config_plugin() -> Option<SharedRuntimePlugin> {
     Some(
         default_plugin("default_timeout_config_plugin", |components| {
             components.with_config_validator(SharedConfigValidator::base_client_config_fn(

                 validate_timeout_config,
             ))
         })
         .with_config(layer("default_timeout_config", |layer| {
             layer.store_put(TimeoutConfig::disabled());
         }))
         .into_shared(),
-181
+    )
-182
+}
-183
 /// Runtime plugin that sets the default timeout config (no timeouts).
 pub fn default_timeout_config_plugin_v2() -> Option<SharedRuntimePlugin> {
     Some(
         default_plugin("default_timeout_config_plugin", |components| {
             components.with_config_validator(SharedConfigValidator::base_client_config_fn(
                 validate_timeout_config,
             ))
         })
         .with_config(layer("default_timeout_config", |layer| {
             let timeout_config = if default_sleep_impl_plugin().is_some() {
                 TimeoutConfig::builder()
                     .connect_timeout(Duration::from_millis(3100))
                     .disable_operation_attempt_timeout()
                     .disable_operation_timeout()
                     .build()
             } else {
                 TimeoutConfig::disabled()
             };
             layer.store_put(timeout_config);
         }))
         .into_shared(),
-+
+    )
-+
+}
-+
 fn validate_timeout_config(
     components: &RuntimeComponentsBuilder,
     cfg: &ConfigBag,
 ) -> Result<(), BoxError> {
     if let Some(timeout_config) = cfg.load::<TimeoutConfig>() {
         if timeout_config.has_timeouts() && components.sleep_impl().is_none() {
             Err("An async sleep implementation is required for timeouts to work. Please provide a `sleep_impl` on \
                  the config, or disable timeouts.".into())
         } else {
             Ok(())

↧ Expand context

-218
+        }
     } else {
         Err(
             "The default timeout config was removed, and no other config was put in its place."
                 .into(),
-223
+        )
-224
+    }
-225
+}
-226
 /// Runtime plugin that registers the default identity cache implementation.
 pub fn default_identity_cache_plugin() -> Option<SharedRuntimePlugin> {
     Some(
         default_plugin("default_identity_cache_plugin", |components| {
             components.with_identity_cache(Some(IdentityCache::lazy().build()))
         })
         .into_shared(),
-234
+    )
-235
+}
-236
 /// Runtime plugin that sets the default stalled stream protection config.

@@ -300,324 +360,384 @@

↥ Expand context

     pub fn with_retry_partition_name(mut self, name: impl Into<Cow<'static, str>>) -> Self {
         self.retry_partition_name = Some(name.into());
         self
-327
+    }
-328
     /// Sets the behavior major version.
     pub fn with_behavior_version(mut self, version: BehaviorVersion) -> Self {
         self.behavior_version = Some(version);
         self
-333
+    }
-334
+}
-335
 /// All default plugins.
 pub fn default_plugins(
     params: DefaultPluginParams,
 ) -> impl IntoIterator<Item = SharedRuntimePlugin> {
     let behavior_version = params
         .behavior_version
         .unwrap_or_else(BehaviorVersion::latest);
-343

-344
+    [
         default_http_client_plugin_v2(behavior_version),
         default_identity_cache_plugin(),
         default_retry_config_plugin(
             params
                 .retry_partition_name
                 .expect("retry_partition_name is required"),
         ),
         default_sleep_impl_plugin(),
         default_time_source_plugin(),
         default_timeout_config_plugin(),
         default_timeout_config_plugin_v2(),
         enforce_content_length_runtime_plugin(),
         default_stalled_stream_protection_config_plugin_v2(behavior_version),
-357
+    ]
     .into_iter()
     .flatten()
     .collect::<Vec<SharedRuntimePlugin>>()
-361
+}
-362
 #[cfg(test)]
 mod tests {

↧ Expand context

     use super::*;
     use aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugins;
-367
     fn test_plugin_params(version: BehaviorVersion) -> DefaultPluginParams {
         DefaultPluginParams::new()
             .with_behavior_version(version)
             .with_retry_partition_name("dontcare")
-372
+    }
     fn config_for(plugins: impl IntoIterator<Item = SharedRuntimePlugin>) -> ConfigBag {
         let mut config = ConfigBag::base();
         let plugins = RuntimePlugins::new().with_client_plugins(plugins);
         plugins.apply_client_configuration(&mut config).unwrap();
         config
-378
+    }
-379
     #[test]
     #[allow(deprecated)]
     fn v2024_03_28_stalled_stream_protection_difference() {
         let latest = config_for(default_plugins(test_plugin_params(
             BehaviorVersion::latest(),

tmp-codegen-diff/aws-sdk/sdk/s3/tests/timeouts.rs

@@ -139,139 +207,277 @@

↥ Expand context

-139
+        )
         .endpoint_url(format!("http://{server_addr}"))
         .build();
     let client = Client::from_conf(config);
-143
     if let Ok(result) = timeout(
         Duration::from_millis(1000),
         client.get_object().bucket("test").key("test").send(),
-147
+    )
     .await
-149
+    {
         match result {
             Ok(_) => panic!("should not have succeeded"),
             Err(err) => {
                 let message = format!("{}", DisplayErrorContext(&err));
                 let expected = "timeout: HTTP read timeout occurred after 300ms";
                 assert!(
                     message.contains(expected),
                     "expected '{message}' to contain '{expected}'"
                 );

-159
+            }
-160
+        }
     } else {
         panic!("the client didn't timeout");
-163
+    }
-164
     server_shutdown.send(()).unwrap();
     server_handle.await.unwrap();
-167
+}
-168
 #[tokio::test]
 async fn test_connect_timeout() {
     let config = Config::builder()
 async fn run_connect_timeout_test(timeout_config: Option<TimeoutConfig>, expected_timeout_ms: u64) {
     let mut config_builder = Config::builder()
         .with_test_defaults()
         .region(Region::new("us-east-1"))
         .timeout_config(
         .endpoint_url("http://172.255.255.0:18104");
-+
     if let Some(tc) = timeout_config {
         config_builder = config_builder.timeout_config(tc);
-+
+    }
-+
     let client = Client::from_conf(config_builder.build());
-+
     if let Ok(result) = timeout(
         Duration::from_millis(expected_timeout_ms + 1000),
         client.get_object().bucket("test").key("test").send(),
-+
+    )
     .await
-+
+    {
         match result {
             Ok(_) => panic!("should not have succeeded"),
             Err(err) => {
                 let message = format!("{}", DisplayErrorContext(&err));
                 let expected =
                     "timeout: client error (Connect): HTTP connect timeout occurred after";
                 assert!(
                     message.contains(expected),
                     "expected '{message}' to contain '{expected}'"
                 );
-+
+            }
-+
+        }
     } else {
         panic!("the client didn't timeout");
-+
+    }
-+
+}
-+
 #[tokio::test]
 async fn test_connect_timeout_explicit() {
     run_connect_timeout_test(
         Some(
             TimeoutConfig::builder()
                 .connect_timeout(Duration::from_millis(300))
                 .build(),
--
+        )
         .endpoint_url(
             // Emulate a connect timeout error by hitting an unroutable IP
             "http://172.255.255.0:18104",
--
+        )
         ),
 ,
-+
+    )
     .await;
-+
+}
-+
 #[tokio::test]
 async fn test_connect_timeout_default() {
     run_connect_timeout_test(None, 3100).await;
-+
+}
-+
 #[tokio::test]
 async fn test_connect_timeout_disabled() {
     let config = Config::builder()
         .with_test_defaults()
         .region(Region::new("us-east-1"))
         .timeout_config(TimeoutConfig::disabled())
         .endpoint_url("http://172.255.255.0:18104")
         .build();
     let client = Client::from_conf(config);
-231
     if let Err(_) = timeout(
         Duration::from_secs(5),
         client.get_object().bucket("test").key("test").send(),
-+
+    )
     .await
-+
+    {
         // Expected: the operation should not complete within 5 seconds when timeout is disabled
     } else {
         panic!("operation completed unexpectedly when timeout was disabled");
-+
+    }
-+
+}
-+
 // this behavior is surprising—I would have expected this to fail, but it seems like the default
 // runtime plugin always is providing a sleep impl. In any case, this pattern does not seem to exist
 // in real life
 #[tokio::test]
 async fn test_connect_timeout_with_sleep_impl_none() {
     let mut builder = Config::builder()
         .with_test_defaults()
         .region(Region::new("us-east-1"))
         .endpoint_url("http://172.255.255.0:18104");
     builder.set_sleep_impl(None);
     let client = Client::from_conf(builder.build());
-+
     if let Ok(result) = timeout(
         Duration::from_millis(1000),
         Duration::from_millis(4100),
         client.get_object().bucket("test").key("test").send(),
-259
+    )
     .await
-261
+    {
         match result {
             Ok(_) => panic!("should not have succeeded"),
             Err(err) => {
                 let message = format!("{}", DisplayErrorContext(&err));
                 let expected =
                     "timeout: client error (Connect): HTTP connect timeout occurred after 300ms";
                     "timeout: client error (Connect): HTTP connect timeout occurred after";
                 assert!(
                     message.contains(expected),
                     "expected '{message}' to contain '{expected}'"
                 );
-272
+            }
-273
+        }
     } else {
         panic!("the client didn't timeout");
-276
+    }
-277
+}

AWS SDK

Files changed:

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

tmp-codegen-diff/aws-sdk/sdk/s3/tests/timeouts.rs