Merge branch 'main' into smithy-1.27

CHANGELOG.next.toml

@@ -49,30 +49,6 @@ references = ["smithy-rs#1784", "smithy-rs#2074"]
 meta = { "breaking" = true, "tada" = true, "bug" = false }
 author = "rcoh"
 
-[[smithy-rs]]
-message = "In 0.52, `@length`-constrained collection shapes whose members are not constrained made the server code generator crash. This has been fixed."
-references = ["smithy-rs#2103"]
-meta = { "breaking" = false, "tada" = false, "bug" = true, "target" = "server" }
-author = "david-perez"
-
-[[smithy-rs]]
-message = "The Rust client codegen plugin is now called `rust-client-codegen` instead of `rust-codegen`. Be sure to update your `smithy-build.json` files to refer to the correct plugin name."
-references = ["smithy-rs#2099"]
-meta = { "breaking" = true, "tada" = false, "bug" = false, "target" = "client" }
-author = "jdisanti"
-
-[[smithy-rs]]
-message = "Client codegen plugins need to define a service named `software.amazon.smithy.rust.codegen.client.smithy.customize.ClientCodegenDecorator` (this is the new file name for the plugin definition in `resources/META-INF/services`)."
-references = ["smithy-rs#2099"]
-meta = { "breaking" = true, "tada" = false, "bug" = false, "target" = "client" }
-author = "jdisanti"
-
-[[smithy-rs]]
-message = "Server codegen plugins need to define a service named `software.amazon.smithy.rust.codegen.server.smithy.customize.ServerCodegenDecorator` (this is the new file name for the plugin definition in `resources/META-INF/services`)."
-references = ["smithy-rs#2099"]
-meta = { "breaking" = true, "tada" = false, "bug" = false, "target" = "server" }
-author = "jdisanti"
-
 [[aws-sdk-rust]]
 message = """
 Move types for AWS SDK credentials to a separate crate.
@@ -82,18 +58,6 @@ references = ["smithy-rs#2108"]
 meta = { "breaking" = true, "tada" = false, "bug" = false }
 author = "ysaito1001"
 
-[[smithy-rs]]
-message = "Servers support the `@default` trait: models can specify default values. Default values will be automatically supplied when not manually set."
-references = ["smithy-rs#1879"]
-meta = { "breaking" = false, "tada" = false, "bug" = false, "target" = "server" }
-author = "82marbag"
-
-[[smithy-rs]]
-message = "The constraint `@length` on non-streaming blob shapes is supported."
-references = ["smithy-rs#2131"]
-meta = { "breaking" = false, "tada" = false, "bug" = false, "target" = "server" }
-author = "82marbag"
-
 [[aws-sdk-rust]]
 references = ["smithy-rs#2152"]
 meta = { "breaking" = false, "tada" = false, "bug" = false }
@@ -137,24 +101,12 @@ let sdk_config = aws_config::from_env()
 /// ```
 """
 
-[[smithy-rs]]
-message = "Fix bug where string default values were not supported for endpoint parameters"
-references = ["smithy-rs#2150"]
-meta = { "breaking" = false, "tada" = false, "bug" = true, "target" = "client" }
-author = "rcoh"
-
 [[aws-sdk-rust]]
 references = ["smithy-rs#2162"]
 meta = { "breaking" = true, "tada" = false, "bug" = false }
 message = "`aws_config::profile::retry_config` && `aws_config::environment::retry_config` have been removed. Use `aws_config::default_provider::retry_config` instead."
 author = "rcoh"
 
-[[smithy-rs]]
-references = ["smithy-rs#2170", "aws-sdk-rust#706"]
-meta = { "breaking" = false, "tada" = false, "bug" = true }
-message = "Remove the webpki-roots feature from `hyper-rustls`"
-author = "rcoh"
-
 [[aws-sdk-rust]]
 references = ["smithy-rs#2168"]
 meta = { "breaking" = false, "tada" = true, "bug" = false }
@@ -203,7 +155,6 @@ After:
 ```rust
 use aws_credential_types::cache::CredentialsCache;
 use aws_types::provider::ProvideCredentials;
-use std::sync::Arc;
 
 fn make_provider() -> impl ProvideCredentials {
     // --snip--
@@ -212,7 +163,7 @@ fn make_provider() -> impl ProvideCredentials {
 // Wrapping a result of `make_provider` in `LazyCredentialsCache` is done automatically.
 let sdk_config = aws_config::from_env()
     .credentials_cache(CredentialsCache::lazy()) // This line can be omitted because it is on by default.
-    .credentials_provider(Arc::new(make_provider()))
+    .credentials_provider(make_provider())
     .load()
     .await;
 
@@ -249,7 +200,6 @@ After:
 ```rust
 use aws_credential_types::cache::CredentialsCache;
 use aws_types::provider::ProvideCredentials;
-use std::sync::Arc;
 use std::time::Duration;
 
 fn make_provider() -> impl ProvideCredentials {
@@ -262,7 +212,7 @@ let sdk_config = aws_config::from_env()
             .load_timeout(Duration::from_secs(60)) // Configures timeout.
             .into_credentials_cache(),
     )
-    .credentials_provider(Arc::new(make_provider()))
+    .credentials_provider(make_provider())
     .load()
     .await;
 
@@ -301,7 +251,6 @@ After:
 ```rust
 use aws_config::default_provider::credentials::default_provider;
 use aws_credential_types::cache::CredentialsCache;
-use std::sync::Arc;
 use std::time::Duration;
 
 // Previously used methods no longer exist on the builder for `DefaultCredentialsChain`.
@@ -314,7 +263,7 @@ let sdk_config = aws_config::from_env()
             .default_credential_expiration(Duration::from_secs(20 * 60))
             .into_credentials_cache(),
     )
-    .credentials_provider(Arc::new(credentials_provider))
+    .credentials_provider(credentials_provider)
     .load()
     .await;
 
@@ -323,13 +272,13 @@ let client = aws_sdk_s3::Client::new(&sdk_config);
 
 </details>
 """
-references = ["smithy-rs#2122"]
+references = ["smithy-rs#2122", "smithy-rs#2227"]
 meta = { "breaking" = true, "tada" = false, "bug" = false }
 author = "ysaito1001"
 
 [[aws-sdk-rust]]
 message = """
-The introduction of `CredentialsCache` comes with an accompanying type `SharedCredentialsCache`. This replaces `SharedCredentialsProvider` and as a result, `aws_http::auth:set_provider` has been updated to `aws_http::auth::set_credentials_cache`.
+The introduction of `CredentialsCache` comes with an accompanying type `SharedCredentialsCache`, which we will store in the property bag instead of a `SharedCredentialsProvider`. As a result, `aws_http::auth:set_provider` has been updated to `aws_http::auth::set_credentials_cache`.
 
 Before:
 ```rust
@@ -351,22 +300,34 @@ After:
 ```rust
 use aws_credential_types::Credentials;
 use aws_credential_types::cache::{CredentialsCache, SharedCredentialsCache};
+use aws_credential_types::provider::SharedCredentialsProvider;
 use aws_http::auth::set_credentials_cache;
 use aws_smithy_http::body::SdkBody;
 use aws_smithy_http::operation;
-use std::sync::Arc;
 
 let mut req = operation::Request::new(http::Request::new(SdkBody::from("some body")));
 let credentials = Credentials::new("example", "example", None, None, "my_provider_name");
 let credentials_cache = CredentialsCache::lazy_builder()
     .into_credentials_cache()
-    .create_cache(Arc::new(credentials));
+    .create_cache(SharedCredentialsProvider::new(credentials));
 set_credentials_cache(
     &mut req.properties_mut(),
     SharedCredentialsCache::new(credentials_cache),
 );
 ```
 """
-references = ["smithy-rs#2122"]
+references = ["smithy-rs#2122", "smithy-rs#2227"]
 meta = { "breaking" = true, "tada" = false, "bug" = false }
 author = "ysaito1001"
+
+[[smithy-rs]]
+message = "`aws_smithy_types::date_time::DateTime`, `aws_smithy_types::Blob` now implement the `Eq` and `Hash` traits"
+references = ["smithy-rs#2223"]
+meta = { "breaking" = false, "tada" = false, "bug" = false, "target" = "all"}
+author = "david-perez"
+
+[[smithy-rs]]
+message = "Code-generated types for server SDKs now implement the `Eq` and `Hash` traits when possible"
+references = ["smithy-rs#2223"]
+meta = { "breaking" = false, "tada" = false, "bug" = false, "target" = "server"}
+author = "david-perez"

aws/rust-runtime/aws-config/external-types.toml

@@ -6,6 +6,7 @@ allowed_external_types = [
    "aws_credential_types::cache::CredentialsCache",
    "aws_credential_types::provider::ProvideCredentials",
    "aws_credential_types::provider::Result",
+   "aws_credential_types::provider::SharedCredentialsProvider",
    "aws_sdk_sts::model::PolicyDescriptorType",
    "aws_smithy_async::rt::sleep::AsyncSleep",
    "aws_smithy_client::bounds::SmithyConnector",

aws/rust-runtime/aws-config/src/lib.rs

@@ -151,7 +151,7 @@ mod loader {
     use std::sync::Arc;
 
     use aws_credential_types::cache::CredentialsCache;
-    use aws_credential_types::provider::ProvideCredentials;
+    use aws_credential_types::provider::{ProvideCredentials, SharedCredentialsProvider};
     use aws_smithy_async::rt::sleep::{default_async_sleep, AsyncSleep};
     use aws_smithy_client::http_connector::{ConnectorSettings, HttpConnector};
     use aws_smithy_types::retry::RetryConfig;
@@ -179,7 +179,7 @@ mod loader {
     pub struct ConfigLoader {
         app_name: Option<AppName>,
         credentials_cache: Option<CredentialsCache>,
-        credentials_provider: Option<Arc<dyn ProvideCredentials>>,
+        credentials_provider: Option<SharedCredentialsProvider>,
         endpoint_resolver: Option<Arc<dyn ResolveAwsEndpoint>>,
         endpoint_url: Option<String>,
         region: Option<Box<dyn ProvideRegion>>,
@@ -326,22 +326,21 @@ mod loader {
         /// Override the credentials provider but load the default value for region:
         /// ```no_run
         /// # use aws_credential_types::Credentials;
-        /// # use std::sync::Arc;
         /// # fn create_my_credential_provider() -> Credentials {
         /// #     Credentials::new("example", "example", None, None, "example")
         /// # }
         /// # async fn create_config() {
         /// let config = aws_config::from_env()
-        ///     .credentials_provider(Arc::new(create_my_credential_provider()))
+        ///     .credentials_provider(create_my_credential_provider())
         ///     .load()
         ///     .await;
         /// # }
         /// ```
         pub fn credentials_provider(
             mut self,
-            credentials_provider: Arc<dyn ProvideCredentials>,
+            credentials_provider: impl ProvideCredentials + 'static,
         ) -> Self {
-            self.credentials_provider = Some(credentials_provider);
+            self.credentials_provider = Some(SharedCredentialsProvider::new(credentials_provider));
             self
         }
 
@@ -600,7 +599,7 @@ mod loader {
             } else {
                 let mut builder = credentials::DefaultCredentialsChain::builder().configure(conf);
                 builder.set_region(region.clone());
-                Arc::new(builder.build().await)
+                SharedCredentialsProvider::new(builder.build().await)
             };
 
             let endpoint_resolver = self.endpoint_resolver;

aws/rust-runtime/aws-credential-types/src/cache.rs

@@ -11,7 +11,7 @@ mod lazy_caching;
 pub use expiring_cache::ExpiringCache;
 pub use lazy_caching::Builder as LazyBuilder;
 
-use crate::provider::{future, ProvideCredentials};
+use crate::provider::{future, SharedCredentialsProvider};
 use std::sync::Arc;
 
 /// Asynchronous Cached Credentials Provider
@@ -24,13 +24,13 @@ pub trait ProvideCachedCredentials: Send + Sync + std::fmt::Debug {
 
 /// Credentials cache wrapper that may be shared
 ///
-/// Newtype wrapper around ProvideCachedCredentials that implements Clone using an internal
-/// Arc.
+/// Newtype wrapper around `ProvideCachedCredentials` that implements `Clone` using an internal
+/// `Arc`.
 #[derive(Clone, Debug)]
 pub struct SharedCredentialsCache(Arc<dyn ProvideCachedCredentials>);
 
 impl SharedCredentialsCache {
-    /// Create a new `SharedCredentialsCache` from `ProvideCredentialsCache`
+    /// Create a new `SharedCredentialsCache` from `ProvideCachedCredentials`
     ///
     /// The given `cache` will be wrapped in an internal `Arc`. If your
     /// cache is already in an `Arc`, use `SharedCredentialsCache::from(cache)` instead.
@@ -73,11 +73,11 @@ pub(crate) enum Inner {
 /// use aws_credential_types::Credentials;
 /// use aws_credential_types::cache::CredentialsCache;
 /// use aws_credential_types::credential_fn::provide_credentials_fn;
-/// use std::sync::Arc;
+/// use aws_credential_types::provider::SharedCredentialsProvider;
 ///
 /// let credentials_cache = CredentialsCache::lazy_builder()
 ///     .into_credentials_cache()
-///     .create_cache(Arc::new(provide_credentials_fn(|| async {
+///     .create_cache(SharedCredentialsProvider::new(provide_credentials_fn(|| async {
 ///         // An async process to retrieve credentials would go here:
 ///         Ok(Credentials::new(
 ///             "example",
@@ -105,7 +105,7 @@ impl CredentialsCache {
     }
 
     /// Creates a [`SharedCredentialsCache`] wrapping a concrete caching implementation.
-    pub fn create_cache(self, provider: Arc<dyn ProvideCredentials>) -> SharedCredentialsCache {
+    pub fn create_cache(self, provider: SharedCredentialsProvider) -> SharedCredentialsCache {
         match self.inner {
             Inner::Lazy(builder) => SharedCredentialsCache::new(builder.build(provider)),
         }