AWS SDK

rev. ba98f30b52e51c6e715b0ae469e7a2e988c27d9a

Files changed:

tmp-codegen-diff/aws-sdk/sdk/aws-credential-types/src/credentials_impl.rs

@@ -1,1 +166,133 @@

 /*
  * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
  * SPDX-License-Identifier: Apache-2.0
  */
-5
 use aws_smithy_types::config_bag::Layer;
 use aws_smithy_types::date_time::Format;
 use aws_smithy_types::type_erasure::TypeErasedBox;
 use std::any::{Any, TypeId};
 use std::collections::HashMap;
 use std::fmt;
 use std::fmt::{Debug, Formatter};
 use std::sync::Arc;
 use std::time::{SystemTime, UNIX_EPOCH};
 use zeroize::Zeroizing;
-12
 use aws_smithy_runtime_api::client::identity::Identity;
-14
 use crate::attributes::AccountId;
 use crate::credential_feature::AwsCredentialFeature;
-16
 /// AWS SDK Credentials
 ///
 /// An opaque struct representing credentials that may be used in an AWS SDK, modeled on
 /// the [CRT credentials implementation](https://github.com/awslabs/aws-c-auth/blob/main/source/credentials.c).
 ///
 /// When `Credentials` is dropped, its contents are zeroed in memory. Credentials uses an interior Arc to ensure
 /// that even when cloned, credentials don't exist in multiple memory locations.
 pub struct Credentials(Arc<Inner>, HashMap<TypeId, TypeErasedBox>);
--
 impl Clone for Credentials {
     fn clone(&self) -> Self {
         let mut new_map = HashMap::with_capacity(self.1.len());
         for (k, v) in &self.1 {
             new_map.insert(
                 *k,
                 v.try_clone()
                     .expect("values are guaranteed to implement `Clone` via `set_property`"),
             );
--
+        }
         Self(self.0.clone(), new_map)
--
+    }
--
+}
--
 impl PartialEq for Credentials {
     #[inline] // specified in the output of cargo expand of the original `#[derive(PartialEq)]`
     fn eq(&self, other: &Credentials) -> bool {
         self.0 == other.0
--
+    }
--
+}
--
 impl Eq for Credentials {}
 #[derive(Clone, Eq, PartialEq)]
 pub struct Credentials(Arc<Inner>);
-26
 #[derive(Clone, Eq, PartialEq)]
 struct Inner {
     access_key_id: Zeroizing<String>,
     secret_access_key: Zeroizing<String>,
     session_token: Zeroizing<Option<String>>,
-32
     /// Credential Expiry
     ///
     /// A SystemTime at which the credentials should no longer be used because they have expired.
     /// The primary purpose of this value is to allow credentials to communicate to the caching
     /// provider when they need to be refreshed.
     ///
     /// If these credentials never expire, this value will be set to `None`
     expires_after: Option<SystemTime>,
-41
     // Optional piece of data to support account-based endpoints.
     // https://docs.aws.amazon.com/sdkref/latest/guide/feature-account-endpoints.html
     account_id: Option<AccountId>,
-45
     provider_name: &'static str,
-47
+}
-48
 impl Debug for Credentials {
     fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
         let mut creds = f.debug_struct("Credentials");
         creds
             .field("provider_name", &self.0.provider_name)
             .field("access_key_id", &self.0.access_key_id.as_str())
             .field("secret_access_key", &"** redacted **");
         if let Some(expiry) = self.expiry() {
             if let Some(formatted) = expiry.duration_since(UNIX_EPOCH).ok().and_then(|dur| {
                 aws_smithy_types::DateTime::from_secs(dur.as_secs() as _)
                     .fmt(Format::DateTime)
                     .ok()
             }) {
                 creds.field("expires_after", &formatted);
             } else {
                 creds.field("expires_after", &expiry);
-65
+            }
         } else {
             creds.field("expires_after", &"never");
-68
+        }
         if let Some(account_id) = &self.0.account_id {
             creds.field("account_id", &account_id.as_str());
-71
+        }
         for (i, prop) in self.1.values().enumerate() {
             creds.field(&format!("property_{i}"), prop);
--
+        }
         creds.finish()
-73
+    }
-74
+}
-75
 #[cfg(feature = "hardcoded-credentials")]
 const STATIC_CREDENTIALS: &str = "Static";
-78
 impl Credentials {
     /// Returns builder for `Credentials`.
     pub fn builder() -> CredentialsBuilder {
         CredentialsBuilder::default()
-83
+    }
-84
     /// Creates `Credentials`.
     ///
     /// This is intended to be used from a custom credentials provider implementation.
     /// It is __NOT__ secure to hardcode credentials into your application.
     pub fn new(
         access_key_id: impl Into<String>,
         secret_access_key: impl Into<String>,
         session_token: Option<String>,
         expires_after: Option<SystemTime>,
         provider_name: &'static str,
     ) -> Self {
         Credentials(
             Arc::new(Inner {
                 access_key_id: Zeroizing::new(access_key_id.into()),
                 secret_access_key: Zeroizing::new(secret_access_key.into()),
                 session_token: Zeroizing::new(session_token),
                 expires_after,
                 account_id: None,
                 provider_name,
             }),
             HashMap::new(),
--
+        )
         Credentials(Arc::new(Inner {
             access_key_id: Zeroizing::new(access_key_id.into()),
             secret_access_key: Zeroizing::new(secret_access_key.into()),
             session_token: Zeroizing::new(session_token),
             expires_after,
             account_id: None,
             provider_name,
         }))
-104
+    }
-105
     /// Creates `Credentials` from hardcoded access key, secret key, and session token.
     ///
     /// _Note: In general, you should prefer to use the credential providers that come
     /// with the AWS SDK to get credentials. It is __NOT__ secure to hardcode credentials
     /// into your application. If you're writing a custom credentials provider, then
     /// use [`Credentials::new`] instead of this._
     ///
     /// This function requires the `hardcoded-credentials` feature to be enabled.

↧ Expand context

     ///
     /// [`Credentials`] implement
     /// [`ProvideCredentials`](crate::provider::ProvideCredentials) directly, so no custom provider
     /// implementation is required when wiring these up to a client:
     /// ```rust
     /// use aws_credential_types::Credentials;
     /// # mod service {
     /// #     use aws_credential_types::provider::ProvideCredentials;
     /// #     pub struct Config;
     /// #     impl Config {
     /// #        pub fn builder() -> Self {
     /// #            Config
     /// #        }
     /// #        pub fn credentials_provider(self, provider: impl ProvideCredentials + 'static) -> Self {
     /// #            self
     /// #        }
     /// #        pub fn build(self) -> Config { Config }
     /// #     }
     /// #     pub struct Client;
     /// #     impl Client {

@@ -194,161 +289,220 @@

↥ Expand context

-161
     /// Returns the access key ID.
     pub fn access_key_id(&self) -> &str {
         &self.0.access_key_id
-165
+    }
-166
     /// Returns the secret access key.
     pub fn secret_access_key(&self) -> &str {
         &self.0.secret_access_key
-170
+    }
-171
     /// Returns the time when the credentials will expire.
     pub fn expiry(&self) -> Option<SystemTime> {
         self.0.expires_after
-175
+    }
-176
     /// Returns a mutable reference to the time when the credentials will expire.
     pub fn expiry_mut(&mut self) -> &mut Option<SystemTime> {
         &mut Arc::make_mut(&mut self.0).expires_after
-180
+    }

-181
     /// Returns the account ID.
     pub fn account_id(&self) -> Option<&AccountId> {
         self.0.account_id.as_ref()
-185
+    }
-186
     /// Returns the session token.
     pub fn session_token(&self) -> Option<&str> {
         self.0.session_token.as_deref()
-190
+    }
--
     /// Set arbitrary property for `Credentials`
     #[doc(hidden)]
     pub fn set_property<T: Any + Clone + Debug + Send + Sync + 'static>(&mut self, prop: T) {
         self.1
             .insert(TypeId::of::<T>(), TypeErasedBox::new_with_clone(prop));
--
+    }
--
     /// Returns arbitrary property associated with this `Credentials`.
     #[doc(hidden)]
     pub fn get_property<T: Any + Debug + Send + Sync + 'static>(&self) -> Option<&T> {
         self.1
             .get(&TypeId::of::<T>())
             .and_then(|b| b.downcast_ref())
--
+    }
--
     /// Attempts to retrieve a mutable reference to property of a given type `T`.
     #[doc(hidden)]
     pub fn get_property_mut<T: Any + Debug + Send + Sync + 'static>(&mut self) -> Option<&mut T> {
         self.1
             .get_mut(&TypeId::of::<T>())
             .and_then(|b| b.downcast_mut())
--
+    }
--
     /// Returns a mutable reference to `T` if it is stored in the property, otherwise returns the
     /// [`Default`] implementation of `T`.
     #[doc(hidden)]
     pub fn get_property_mut_or_default<T: Any + Clone + Debug + Default + Send + Sync + 'static>(
         &mut self,
     ) -> &mut T {
         self.1
             .entry(TypeId::of::<T>())
             .or_insert_with(|| TypeErasedBox::new_with_clone(T::default()))
             .downcast_mut()
             .expect("typechecked")
--
+    }
-191
+}
-192
 /// Builder for [`Credentials`]
 ///
 /// Similar to [`Credentials::new`], the use of the builder is intended for a custom credentials provider implementation.
 /// It is __NOT__ secure to hardcode credentials into your application.
 #[derive(Default, Clone)]
 #[allow(missing_debug_implementations)] // for security reasons, and we can add manual `impl Debug` just like `Credentials`, if needed.
 pub struct CredentialsBuilder {
     access_key_id: Option<Zeroizing<String>>,

↧ Expand context

     secret_access_key: Option<Zeroizing<String>>,
     session_token: Zeroizing<Option<String>>,
     expires_after: Option<SystemTime>,
     account_id: Option<AccountId>,
     provider_name: Option<&'static str>,
-206
+}
-207
 impl CredentialsBuilder {
     /// Set access key id for the builder.
     pub fn access_key_id(mut self, access_key_id: impl Into<String>) -> Self {
         self.access_key_id = Some(Zeroizing::new(access_key_id.into()));
         self
-213
+    }
-214
     /// Set secret access key for the builder.
     pub fn secret_access_key(mut self, secret_access_key: impl Into<String>) -> Self {
         self.secret_access_key = Some(Zeroizing::new(secret_access_key.into()));
         self
-219
+    }
-220

@@ -301,232 +488,362 @@

↥ Expand context

     /// Set expiry for the builder.
     pub fn expiry(mut self, expiry: SystemTime) -> Self {
         self.set_expiry(Some(expiry));
         self
-236
+    }
-237
     /// Set expiry for the builder.
     pub fn set_expiry(&mut self, expiry: Option<SystemTime>) {
         self.expires_after = expiry;
-241
+    }
-242
     /// Set account ID for the builder.
     pub fn account_id(mut self, account_id: impl Into<AccountId>) -> Self {
         self.set_account_id(Some(account_id.into()));
         self
-247
+    }
-248
     /// Set account ID for the builder.
     pub fn set_account_id(&mut self, account_id: Option<AccountId>) {
         self.account_id = account_id;

-252
+    }
-253
     /// Set provider name for the builder.
     pub fn provider_name(mut self, provider_name: &'static str) -> Self {
         self.provider_name = Some(provider_name);
         self
-258
+    }
-259
     /// Build [`Credentials`] from the builder.
     pub fn build(self) -> Credentials {
         Credentials(
             Arc::new(Inner {
                 access_key_id: self
                     .access_key_id
                     .expect("required field `access_key_id` missing"),
                 secret_access_key: self
                     .secret_access_key
                     .expect("required field `secret_access_key` missing"),
                 session_token: self.session_token,
                 expires_after: self.expires_after,
                 account_id: self.account_id,
                 provider_name: self
                     .provider_name
                     .expect("required field `provider_name` missing"),
             }),
             HashMap::new(),
--
+        )
         Credentials(Arc::new(Inner {
             access_key_id: self
                 .access_key_id
                 .expect("required field `access_key_id` missing"),
             secret_access_key: self
                 .secret_access_key
                 .expect("required field `secret_access_key` missing"),
             session_token: self.session_token,
             expires_after: self.expires_after,
             account_id: self.account_id,
             provider_name: self
                 .provider_name
                 .expect("required field `provider_name` missing"),
         }))
-276
+    }
-277
+}
-278
 #[cfg(feature = "test-util")]
 impl Credentials {
     /// Creates a test `Credentials` with no session token.
     pub fn for_tests() -> Self {
         Self::new(
             "ANOTREAL",
             "notrealrnrELgWzOk3IfjzDKtFBhDby",
             None,
             None,
             "test",
-289
+        )
-290
+    }
-291
     /// Creates a test `Credentials` that include a session token.
     pub fn for_tests_with_session_token() -> Self {
         Self::new(
             "ANOTREAL",
             "notrealrnrELgWzOk3IfjzDKtFBhDby",
             Some("notarealsessiontoken".to_string()),
             None,
             "test",
-300
+        )
-301
+    }
-302
+}
-303
 #[cfg(feature = "test-util")]
 impl CredentialsBuilder {
     /// Creates a test `CredentialsBuilder` with the required fields:
     /// `access_key_id`, `secret_access_key`, and `provider_name`.
     pub fn for_tests() -> Self {
         CredentialsBuilder::default()
             .access_key_id("ANOTREAL")
             .secret_access_key("notrealrnrELgWzOk3IfjzDKtFBhDby")
             .provider_name("test")
-313
+    }
-314
+}
-315
 impl From<Credentials> for Identity {
     fn from(val: Credentials) -> Self {
         let expiry = val.expiry();
         let mut builder = if let Some(account_id) = val.account_id() {
             Identity::builder().property(account_id.clone())
             Identity::builder().property(account_id.clone()).data(val)
         } else {
             Identity::builder()
             Identity::builder().data(val)
         };
--
         builder.set_expiration(expiry);
--
         if let Some(features) = val.get_property::<Vec<AwsCredentialFeature>>().cloned() {
             let mut layer = Layer::new("IdentityResolutionFeatureIdTracking");
             for feat in features {
                 layer.store_append(feat);
--
+            }
             builder.set_property(layer.freeze());
--
+        }
--
         builder.data(val).build().expect("set required fields")
         builder.build().expect("set required fields")
-326
+    }
-327
+}
-328
 #[cfg(test)]
 mod test {
     use crate::Credentials;
     use std::time::{Duration, UNIX_EPOCH};
-333
     #[cfg(feature = "test-util")]
     use crate::credential_feature::AwsCredentialFeature;
--
     #[test]
     fn debug_impl() {
         let creds = Credentials::new(
             "akid",
             "secret",
             Some("token".into()),
             Some(UNIX_EPOCH + Duration::from_secs(1234567890)),
             "debug tester",
         );
         assert_eq!(
             format!("{:?}", creds),
             r#"Credentials { provider_name: "debug tester", access_key_id: "akid", secret_access_key: "** redacted **", expires_after: "2009-02-13T23:31:30Z" }"#
         );
-347
         // with account ID
         let creds = Credentials::builder()
             .access_key_id("akid")
             .secret_access_key("secret")
             .session_token("token")
             .expiry(UNIX_EPOCH + Duration::from_secs(1234567890))
             .account_id("012345678901")
             .provider_name("debug tester")
             .build();
         assert_eq!(
             format!("{:?}", creds),
             r#"Credentials { provider_name: "debug tester", access_key_id: "akid", secret_access_key: "** redacted **", expires_after: "2009-02-13T23:31:30Z", account_id: "012345678901" }"#
         );
-361
+    }
--
     #[cfg(feature = "test-util")]
     #[test]
     fn equality_ignores_properties() {
         #[derive(Clone, Debug)]
         struct Foo;
         let mut creds1 = Credentials::for_tests_with_session_token();
         creds1.set_property(AwsCredentialFeature::CredentialsCode);
--
         let mut creds2 = Credentials::for_tests_with_session_token();
         creds2.set_property(Foo);
--
         assert_eq!(creds1, creds2)
--
+    }
--
     #[cfg(feature = "test-util")]
     #[test]
     fn identity_inherits_feature_properties() {
         use aws_smithy_runtime_api::client::identity::Identity;
         use aws_smithy_types::config_bag::FrozenLayer;
--
         let mut creds = Credentials::for_tests_with_session_token();
         let mut feature_props = vec![
             AwsCredentialFeature::CredentialsCode,
             AwsCredentialFeature::CredentialsStsSessionToken,
         ];
         creds.set_property(feature_props.clone());
--
         let identity = Identity::from(creds);
--
         let maybe_props = identity
             .property::<FrozenLayer>()
             .unwrap()
             .load::<AwsCredentialFeature>()
             .cloned()
             .collect::<Vec<AwsCredentialFeature>>();
--
         // The props get reversed when being popped out of the StoreAppend
         feature_props.reverse();
         assert_eq!(maybe_props, feature_props)
--
+    }
-362
+}

tmp-codegen-diff/aws-sdk/sdk/aws-credential-types/src/lib.rs

@@ -1,1 +39,37 @@

↥ Expand context

 /*
  * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
  * SPDX-License-Identifier: Apache-2.0
  */
-5
 /* Automatically managed default lints */
 #![cfg_attr(docsrs, feature(doc_auto_cfg))]
 /* End of automatically managed default lints */
 //! `aws-credential-types` provides types concerned with AWS SDK credentials including:
 //! * Traits for credentials providers and for credentials caching
 //! * An opaque struct representing credentials
 //! * Concrete implementations of credentials caching
-13

 #![allow(clippy::derive_partial_eq_without_eq)]
 #![warn(
     missing_debug_implementations,
     missing_docs,
     rust_2018_idioms,
     rustdoc::missing_crate_level_docs,
     unreachable_pub
 )]
-22
 pub mod attributes;
 #[doc(hidden)]
 pub mod credential_feature;
 pub mod credential_fn;
 mod credentials_impl;
 pub mod provider;
 pub mod token_fn;
-28
 pub use credentials_impl::{Credentials, CredentialsBuilder};
-30
 /// AWS Access Token
 ///
 /// This access token type is used to authenticate to AWS services that use HTTP Bearer

↧ Expand context

 /// Auth with an AWS Builder ID such as CodeCatalyst.
 ///
 /// For more details on tokens, see: <https://oauth.net/2/access-tokens>
 pub type Token = aws_smithy_runtime_api::client::identity::http::Token;

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

@@ -1,1 +0,18 @@

↥ Expand context

 # Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
 [package]
 name = "aws-http"
 version = "0.60.6"
 authors = ["AWS Rust SDK Team <aws-sdk-rust@amazon.com>", "Russell Cohen <rcoh@amazon.com>"]
 description = "This crate is no longer used by the AWS SDK and is deprecated."
 edition = "2021"

 license = "Apache-2.0"
 repository = "https://github.com/smithy-lang/smithy-rs"
 [package.metadata.docs.rs]
 all-features = true
 targets = ["x86_64-unknown-linux-gnu"]
 cargo-args = ["-Zunstable-options", "-Zrustdoc-scrape-examples"]
 rustdoc-args = ["--cfg", "docsrs"]
 [dependencies.aws-runtime]
 path = "../aws-runtime"
 features = ["http-02x"]
 version = "1.5.10"
 version = "1.5.9"

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

@@ -1,1 +144,144 @@

 # Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
 [package]
 name = "aws-runtime"
 version = "1.5.10"
 version = "1.5.9"
 authors = ["AWS Rust SDK Team <aws-sdk-rust@amazon.com>"]
 description = "Runtime support code for the AWS SDK. This crate isn't intended to be used directly."
 edition = "2021"
 license = "Apache-2.0"
 repository = "https://github.com/smithy-lang/smithy-rs"
 [package.metadata.docs.rs]
 all-features = true
 targets = ["x86_64-unknown-linux-gnu"]
 cargo-args = ["-Zunstable-options", "-Zrustdoc-scrape-examples"]
 rustdoc-args = ["--cfg", "docsrs"]
-15
 [package.metadata.smithy-rs-release-tooling]
 stable = true
-18
 [features]
 event-stream = ["dep:aws-smithy-eventstream", "aws-sigv4/sign-eventstream"]
 http-02x = []
 http-1x = ["dep:http-1x", "dep:http-body-1x"]
 test-util = ["dep:regex-lite"]
 sigv4a = ["aws-sigv4/sigv4a"]
-25
 [dependencies]
 bytes = "1.10.0"
 fastrand = "2.3.0"
 percent-encoding = "2.3.1"
 pin-project-lite = "0.2.14"
 tracing = "0.1.40"
-32
 [dependencies.aws-credential-types]
 path = "../aws-credential-types"
 version = "1.2.5"
 version = "1.2.4"
-36
 [dependencies.aws-sigv4]
 path = "../aws-sigv4"
 features = ["http0-compat"]
 version = "1.3.4"
-41
 [dependencies.aws-smithy-async]
 path = "../aws-smithy-async"
 version = "1.2.5"
-45
 [dependencies.aws-smithy-eventstream]
 path = "../aws-smithy-eventstream"
 optional = true
 version = "0.60.10"
-50
 [dependencies.aws-smithy-http]
 path = "../aws-smithy-http"
 version = "0.62.3"
-54
 [dependencies.aws-smithy-runtime]
 path = "../aws-smithy-runtime"
 features = ["client"]
 version = "1.8.6"
 version = "1.8.5"
-59
 [dependencies.aws-smithy-runtime-api]
 path = "../aws-smithy-runtime-api"
 features = ["client"]
 version = "1.8.7"
 version = "1.8.5"
-64
 [dependencies.aws-smithy-types]
 path = "../aws-smithy-types"
 version = "1.3.2"
-68
 [dependencies.aws-types]
 path = "../aws-types"
 version = "1.3.8"
-72
 [dependencies.http-02x]
 package = "http"
 version = "0.2.9"
-76
 [dependencies.http-body-04x]
 package = "http-body"
 version = "0.4.5"
-80
 [dependencies.http-1x]
 package = "http"
 version = "1.1.0"
 optional = true
-85
 [dependencies.http-body-1x]
 package = "http-body"
 version = "1.0.0"
 optional = true
-90
 [dependencies.regex-lite]
 version = "0.1.5"
 optional = true
-94
 [dependencies.uuid]
 version = "1"
-97
 [dev-dependencies]
 arbitrary = "1.3"
 bytes-utils = "0.1.2"
 convert_case = "0.6.0"
 proptest = "1.2"
 serde_json = "1"
 tracing-test = "0.2.4"
-105
 [dev-dependencies.aws-credential-types]
 path = "../aws-credential-types"
 features = ["test-util"]
 version = "1.2.5"
 version = "1.2.4"
-110
 [dev-dependencies.aws-smithy-async]
 path = "../aws-smithy-async"
 features = ["test-util"]
 version = "1.2.5"
-115
 [dev-dependencies.aws-smithy-protocol-test]
 path = "../aws-smithy-protocol-test"
 version = "0.63.4"
-119
 [dev-dependencies.aws-smithy-runtime-api]
 path = "../aws-smithy-runtime-api"
 features = ["test-util"]
 version = "1.8.7"
 version = "1.8.5"
-124
 [dev-dependencies.aws-smithy-types]
 path = "../aws-smithy-types"
 features = ["test-util"]
 version = "1.3.2"
-129
 [dev-dependencies.futures-util]
 version = "0.3.29"
 default-features = false
-133

↧ Expand context

 [dev-dependencies.serde]
 version = "1"
 features = ["derive"]
-137
 [dev-dependencies.tokio]
 version = "1.23.1"
 features = ["macros", "rt", "time"]
-141
 [dev-dependencies.tracing-subscriber]
 version = "0.3.17"
 features = ["env-filter"]

tmp-codegen-diff/aws-sdk/sdk/aws-runtime/src/sdk_feature.rs

@@ -1,1 +25,18 @@

 /*
  * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
  * SPDX-License-Identifier: Apache-2.0
  */
-5
 /// Note: This code originally lived in the `aws-runtime` crate. It was moved here to avoid circular dependencies
 /// This module is re-exported in `aws-runtime`, and so even though this is a pre-1.0 crate, this module should not
 /// have any breaking changes
 use aws_smithy_types::config_bag::{Storable, StoreAppend};
-7
 /// IDs for the features that may be used in the AWS SDK
 #[non_exhaustive]
 #[derive(Clone, Debug, Eq, PartialEq)]
 pub enum AwsSdkFeature {
     /// Indicates that an operation was called by the S3 Transfer Manager
     S3Transfer,
     /// Calling an SSO-OIDC operation as part of the SSO login flow, when using the OAuth2.0 device code grant
     SsoLoginDevice,
     /// Calling an SSO-OIDC operation as part of the SSO login flow, when using the OAuth2.0 authorization code grant
     SsoLoginAuth,
-14
+}
-15
 impl Storable for AwsSdkFeature {
     type Storer = StoreAppend<Self>;
-18
+}

tmp-codegen-diff/aws-sdk/sdk/aws-runtime/src/user_agent/interceptor.rs

@@ -1,1 +41,40 @@

 /*
  * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
  * SPDX-License-Identifier: Apache-2.0
  */
-5
 use std::borrow::Cow;
 use std::fmt;
-8
 use http_02x::header::{HeaderName, HeaderValue, InvalidHeaderValue, USER_AGENT};
-10
 use aws_credential_types::credential_feature::AwsCredentialFeature;
 use aws_smithy_runtime::client::sdk_feature::SmithySdkFeature;
 use aws_smithy_runtime_api::box_error::BoxError;
 use aws_smithy_runtime_api::client::http::HttpClient;
 use aws_smithy_runtime_api::client::interceptors::context::{
     BeforeTransmitInterceptorContextMut, BeforeTransmitInterceptorContextRef,
 };
 use aws_smithy_runtime_api::client::interceptors::Intercept;
 use aws_smithy_runtime_api::client::runtime_components::RuntimeComponents;
 use aws_smithy_types::config_bag::ConfigBag;
 use aws_types::app_name::AppName;

↧ Expand context

 use aws_types::os_shim_internal::Env;
-22
 use crate::sdk_feature::AwsSdkFeature;
 use crate::user_agent::metrics::ProvideBusinessMetric;
 use crate::user_agent::{AdditionalMetadata, ApiMetadata, AwsUserAgent, InvalidMetadataValue};
-26
 #[allow(clippy::declare_interior_mutable_const)] // we will never mutate this
 const X_AMZ_USER_AGENT: HeaderName = HeaderName::from_static("x-amz-user-agent");
-29
 #[derive(Debug)]
 enum UserAgentInterceptorError {
     MissingApiMetadata,
     InvalidHeaderValue(InvalidHeaderValue),
     InvalidMetadataValue(InvalidMetadataValue),
-35
+}
-36
 impl std::error::Error for UserAgentInterceptorError {
     fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
         match self {
             Self::InvalidHeaderValue(source) => Some(source),

@@ -120,119 +186,178 @@

↥ Expand context

         cfg.interceptor_state().store_put(ua);
-120
         Ok(())
-122
+    }
-123
     fn modify_before_signing(
         &self,
         context: &mut BeforeTransmitInterceptorContextMut<'_>,
         runtime_components: &RuntimeComponents,
         cfg: &mut ConfigBag,
     ) -> Result<(), BoxError> {
         let mut ua = cfg
             .load::<AwsUserAgent>()
             .expect("`AwsUserAgent should have been created in `read_before_execution`")
             .clone();
-134
         let smithy_sdk_features = cfg.load::<SmithySdkFeature>();
         for smithy_sdk_feature in smithy_sdk_features {
             smithy_sdk_feature
                 .provide_business_metric()

                 .map(|m| ua.add_business_metric(m));
-140
+        }
-141
         let aws_sdk_features = cfg.load::<AwsSdkFeature>();
         for aws_sdk_feature in aws_sdk_features {
             aws_sdk_feature
                 .provide_business_metric()
                 .map(|m| ua.add_business_metric(m));
-147
+        }
-148
         let aws_credential_features = cfg.load::<AwsCredentialFeature>();
         for aws_credential_feature in aws_credential_features {
             aws_credential_feature
                 .provide_business_metric()
                 .map(|m| ua.add_business_metric(m));
--
+        }
--
         let maybe_connector_metadata = runtime_components
             .http_client()
             .and_then(|c| c.connector_metadata());
         if let Some(connector_metadata) = maybe_connector_metadata {
             let am = AdditionalMetadata::new(Cow::Owned(connector_metadata.to_string()))?;
             ua.add_additional_metadata(am);
-155
+        }
-156
         let headers = context.request_mut().headers_mut();
         let (user_agent, x_amz_user_agent) = header_values(&ua)?;

↧ Expand context

         headers.append(USER_AGENT, user_agent);
         headers.append(X_AMZ_USER_AGENT, x_amz_user_agent);
         Ok(())
-162
+    }
-163
+}
-164
 #[cfg(test)]
 mod tests {
     use super::*;
     use aws_smithy_runtime_api::client::interceptors::context::{Input, InterceptorContext};
     use aws_smithy_runtime_api::client::interceptors::Intercept;
     use aws_smithy_runtime_api::client::orchestrator::HttpRequest;
     use aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder;
     use aws_smithy_types::config_bag::{ConfigBag, Layer};
     use aws_smithy_types::error::display::DisplayErrorContext;
-174
     fn expect_header<'a>(context: &'a InterceptorContext, header_name: &str) -> &'a str {
         context
             .request()
             .expect("request is set")

tmp-codegen-diff/aws-sdk/sdk/aws-runtime/src/user_agent/metrics.rs

@@ -1,1 +37,36 @@

 /*
  * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
  * SPDX-License-Identifier: Apache-2.0
  */
-5
 use crate::sdk_feature::AwsSdkFeature;
 use aws_credential_types::credential_feature::AwsCredentialFeature;
 use aws_smithy_runtime::client::sdk_feature::SmithySdkFeature;
 use std::borrow::Cow;
 use std::collections::HashMap;
 use std::fmt;
 use std::sync::LazyLock;
-12
 const MAX_COMMA_SEPARATED_METRICS_VALUES_LENGTH: usize = 1024;
 #[allow(dead_code)]
 const MAX_METRICS_ID_NUMBER: usize = 350;
-16

↧ Expand context

 macro_rules! iterable_enum {
     ($docs:tt, $enum_name:ident, $( $variant:ident ),*) => {
         #[derive(Clone, Debug, Eq, Hash, PartialEq)]
         #[non_exhaustive]
         #[doc = $docs]
         #[allow(missing_docs)] // for variants, not for the Enum itself
         pub enum $enum_name {
             $( $variant ),*
-25
+        }
-26
         #[allow(dead_code)]
         impl $enum_name {
             pub(crate) fn iter() -> impl Iterator<Item = &'static $enum_name> {
                 const VARIANTS: &[$enum_name] = &[
                     $( $enum_name::$variant ),*
                 ];
                 VARIANTS.iter()
-34
+            }
-35
+        }
     };

@@ -110,109 +296,221 @@

↥ Expand context

     "Enumerates human readable identifiers for the features tracked by metrics",
     BusinessMetric,
     ResourceModel,
     Waiter,
     Paginator,
     RetryModeLegacy,
     RetryModeStandard,
     RetryModeAdaptive,
     S3Transfer,
     S3CryptoV1n,
     S3CryptoV2,
     S3ExpressBucket,
     S3AccessGrants,
     GzipRequestCompression,
     ProtocolRpcV2Cbor,
     EndpointOverride,
     AccountIdEndpoint,
     AccountIdModePreferred,
     AccountIdModeDisabled,
     AccountIdModeRequired,

     Sigv4aSigning,
     ResolvedAccountId,
     FlexibleChecksumsReqCrc32,
     FlexibleChecksumsReqCrc32c,
     FlexibleChecksumsReqCrc64,
     FlexibleChecksumsReqSha1,
     FlexibleChecksumsReqSha256,
     FlexibleChecksumsReqWhenSupported,
     FlexibleChecksumsReqWhenRequired,
     FlexibleChecksumsResWhenSupported,
     FlexibleChecksumsResWhenRequired,
     DdbMapper,
     CredentialsCode,
     CredentialsJvmSystemProperties,
     CredentialsEnvVars,
     CredentialsEnvVarsStsWebIdToken,
     CredentialsStsAssumeRole,
     CredentialsStsAssumeRoleSaml,
     CredentialsStsAssumeRoleWebId,
     CredentialsStsFederationToken,
     CredentialsStsSessionToken,
     CredentialsProfile,
     CredentialsProfileSourceProfile,
     CredentialsProfileNamedProvider,
     CredentialsProfileStsWebIdToken,
     CredentialsProfileSso,
     CredentialsSso,
     CredentialsProfileSsoLegacy,
     CredentialsSsoLegacy,
     CredentialsProfileProcess,
     CredentialsProcess,
     CredentialsBoto2ConfigFile,
     CredentialsAwsSdkStore,
     CredentialsHttp,
     CredentialsImds,
     SsoLoginDevice,
     SsoLoginAuth,
     BearerServiceEnvVars
     FlexibleChecksumsResWhenRequired
 );
-141
 pub(crate) trait ProvideBusinessMetric {
     fn provide_business_metric(&self) -> Option<BusinessMetric>;
-144
+}
-145
 impl ProvideBusinessMetric for SmithySdkFeature {
     fn provide_business_metric(&self) -> Option<BusinessMetric> {
         use SmithySdkFeature::*;
         match self {
             Waiter => Some(BusinessMetric::Waiter),
             Paginator => Some(BusinessMetric::Paginator),
             GzipRequestCompression => Some(BusinessMetric::GzipRequestCompression),
             ProtocolRpcV2Cbor => Some(BusinessMetric::ProtocolRpcV2Cbor),
             RetryModeStandard => Some(BusinessMetric::RetryModeStandard),
             RetryModeAdaptive => Some(BusinessMetric::RetryModeAdaptive),
             FlexibleChecksumsReqCrc32 => Some(BusinessMetric::FlexibleChecksumsReqCrc32),
             FlexibleChecksumsReqCrc32c => Some(BusinessMetric::FlexibleChecksumsReqCrc32c),
             FlexibleChecksumsReqCrc64 => Some(BusinessMetric::FlexibleChecksumsReqCrc64),
             FlexibleChecksumsReqSha1 => Some(BusinessMetric::FlexibleChecksumsReqSha1),
             FlexibleChecksumsReqSha256 => Some(BusinessMetric::FlexibleChecksumsReqSha256),
             FlexibleChecksumsReqWhenSupported => {
                 Some(BusinessMetric::FlexibleChecksumsReqWhenSupported)
-163
+            }
             FlexibleChecksumsReqWhenRequired => {
                 Some(BusinessMetric::FlexibleChecksumsReqWhenRequired)
-166
+            }
             FlexibleChecksumsResWhenSupported => {
                 Some(BusinessMetric::FlexibleChecksumsResWhenSupported)
-169
+            }
             FlexibleChecksumsResWhenRequired => {
                 Some(BusinessMetric::FlexibleChecksumsResWhenRequired)
-172
+            }
             otherwise => {
                 // This may occur if a customer upgrades only the `aws-smithy-runtime-api` crate
                 // while continuing to use an outdated version of an SDK crate or the `aws-runtime`
                 // crate.
                 tracing::warn!(
                     "Attempted to provide `BusinessMetric` for `{otherwise:?}`, which is not recognized in the current version of the `aws-runtime` crate. \
                     Consider upgrading to the latest version to ensure that all tracked features are properly reported in your metrics."
                 );
                 None
-182
+            }
-183
+        }
-184
+    }
-185
+}
-186
 impl ProvideBusinessMetric for AwsSdkFeature {
     fn provide_business_metric(&self) -> Option<BusinessMetric> {
         use AwsSdkFeature::*;
         match self {
             S3Transfer => Some(BusinessMetric::S3Transfer),
             SsoLoginDevice => Some(BusinessMetric::SsoLoginDevice),
             SsoLoginAuth => Some(BusinessMetric::SsoLoginAuth),
--
+        }
--
+    }
--
+}
--
 impl ProvideBusinessMetric for AwsCredentialFeature {
     fn provide_business_metric(&self) -> Option<BusinessMetric> {
         use AwsCredentialFeature::*;
         match self {
             CredentialsCode => Some(BusinessMetric::CredentialsCode),
             CredentialsEnvVars => Some(BusinessMetric::CredentialsEnvVars),
             CredentialsEnvVarsStsWebIdToken => {
                 Some(BusinessMetric::CredentialsEnvVarsStsWebIdToken)
--
+            }
             CredentialsStsAssumeRole => Some(BusinessMetric::CredentialsStsAssumeRole),
             CredentialsStsAssumeRoleSaml => Some(BusinessMetric::CredentialsStsAssumeRoleSaml),
             CredentialsStsAssumeRoleWebId => Some(BusinessMetric::CredentialsStsAssumeRoleWebId),
             CredentialsStsFederationToken => Some(BusinessMetric::CredentialsStsFederationToken),
             CredentialsStsSessionToken => Some(BusinessMetric::CredentialsStsSessionToken),
             CredentialsProfile => Some(BusinessMetric::CredentialsProfile),
             CredentialsProfileSourceProfile => {
                 Some(BusinessMetric::CredentialsProfileSourceProfile)
--
+            }
             CredentialsProfileNamedProvider => {
                 Some(BusinessMetric::CredentialsProfileNamedProvider)
--
+            }
             CredentialsProfileStsWebIdToken => {
                 Some(BusinessMetric::CredentialsProfileStsWebIdToken)
--
+            }
             CredentialsProfileSso => Some(BusinessMetric::CredentialsProfileSso),
             CredentialsSso => Some(BusinessMetric::CredentialsSso),
             CredentialsProfileProcess => Some(BusinessMetric::CredentialsProfileProcess),
             CredentialsProcess => Some(BusinessMetric::CredentialsProcess),
             CredentialsHttp => Some(BusinessMetric::CredentialsHttp),
             CredentialsImds => Some(BusinessMetric::CredentialsImds),
             BearerServiceEnvVars => Some(BusinessMetric::BearerServiceEnvVars),
             otherwise => {
                 // This may occur if a customer upgrades only the `aws-smithy-runtime-api` crate
                 // while continuing to use an outdated version of an SDK crate or the `aws-credential-types`
                 // crate.
                 tracing::warn!(
                     "Attempted to provide `BusinessMetric` for `{otherwise:?}`, which is not recognized in the current version of the `aws-runtime` crate. \
                     Consider upgrading to the latest version to ensure that all tracked features are properly reported in your metrics."
                 );
                 None
--
+            }
-192
+        }
-193
+    }
-194
+}
-195
 #[derive(Clone, Debug, Default)]
 pub(super) struct BusinessMetrics(Vec<BusinessMetric>);
-198
 impl BusinessMetrics {
     pub(super) fn push(&mut self, metric: BusinessMetric) {
         self.0.push(metric);

↧ Expand context

-202
+    }
-203
     pub(super) fn is_empty(&self) -> bool {
         self.0.is_empty()
-206
+    }
-207
+}
-208
 fn drop_unfinished_metrics_to_fit(csv: &str, max_len: usize) -> Cow<'_, str> {
     if csv.len() <= max_len {
         Cow::Borrowed(csv)
     } else {
         let truncated = &csv[..max_len];
         if let Some(pos) = truncated.rfind(',') {
             Cow::Owned(truncated[..pos].to_owned())
         } else {
             Cow::Owned(truncated.to_owned())
-218
+        }
-219
+    }
-220
+}
-221

@@ -315,240 +375,332 @@

↥ Expand context

         );
-241
         write!(f, "m/{}", metrics_values)
-243
+    }
-244
+}
 #[cfg(test)]
 mod tests {
     use crate::user_agent::metrics::{
         drop_unfinished_metrics_to_fit, Base64Iterator, FEATURE_ID_TO_METRIC_VALUE,
         MAX_METRICS_ID_NUMBER,
     };
     use crate::user_agent::BusinessMetric;
     use convert_case::{Boundary, Case, Casing};
     use std::collections::HashMap;
     use std::fmt::{Display, Formatter};
-255
     impl Display for BusinessMetric {
         fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
             f.write_str(
                 &format!("{:?}", self)

                     .as_str()
                     .from_case(Case::Pascal)
                     .with_boundaries(&[Boundary::DigitUpper, Boundary::LowerUpper])
                     .to_case(Case::ScreamingSnake),
-264
+            )
-265
+        }
-266
+    }
-267
     #[test]
     fn feature_id_to_metric_value() {
         const EXPECTED: &str = include_str!("test_data/feature_id_to_metric_value.json");
         const EXPECTED: &str = r#"
-+
+{
   "RESOURCE_MODEL": "A",
   "WAITER": "B",
   "PAGINATOR": "C",
   "RETRY_MODE_LEGACY": "D",
   "RETRY_MODE_STANDARD": "E",
   "RETRY_MODE_ADAPTIVE": "F",
   "S3_TRANSFER": "G",
   "S3_CRYPTO_V1N": "H",
   "S3_CRYPTO_V2": "I",
   "S3_EXPRESS_BUCKET": "J",
   "S3_ACCESS_GRANTS": "K",
   "GZIP_REQUEST_COMPRESSION": "L",
   "PROTOCOL_RPC_V2_CBOR": "M",
   "ENDPOINT_OVERRIDE": "N",
   "ACCOUNT_ID_ENDPOINT": "O",
   "ACCOUNT_ID_MODE_PREFERRED": "P",
   "ACCOUNT_ID_MODE_DISABLED": "Q",
   "ACCOUNT_ID_MODE_REQUIRED": "R",
   "SIGV4A_SIGNING": "S",
   "RESOLVED_ACCOUNT_ID": "T",
   "FLEXIBLE_CHECKSUMS_REQ_CRC32" : "U",
   "FLEXIBLE_CHECKSUMS_REQ_CRC32C" : "V",
   "FLEXIBLE_CHECKSUMS_REQ_CRC64" : "W",
   "FLEXIBLE_CHECKSUMS_REQ_SHA1" : "X",
   "FLEXIBLE_CHECKSUMS_REQ_SHA256" : "Y",
   "FLEXIBLE_CHECKSUMS_REQ_WHEN_SUPPORTED" : "Z",
   "FLEXIBLE_CHECKSUMS_REQ_WHEN_REQUIRED" : "a",
   "FLEXIBLE_CHECKSUMS_RES_WHEN_SUPPORTED" : "b",
   "FLEXIBLE_CHECKSUMS_RES_WHEN_REQUIRED" : "c"
-+
+}
         "#;
-303
         let expected: HashMap<&str, &str> = serde_json::from_str(EXPECTED).unwrap();
         assert_eq!(expected.len(), FEATURE_ID_TO_METRIC_VALUE.len());
-306
         for (feature_id, metric_value) in &*FEATURE_ID_TO_METRIC_VALUE {
             let expected = expected.get(format!("{feature_id}").as_str());
             assert_eq!(
                 expected.unwrap_or_else(|| panic!("Expected {feature_id} to have value `{metric_value}` but it was `{expected:?}` instead.")),
                 metric_value,
             );

↧ Expand context

-313
+        }
-314
+    }
-315
     #[test]
     fn test_base64_iter() {
         // 350 is the max number of metric IDs we support for now
         let ids: Vec<String> = Base64Iterator::new().take(MAX_METRICS_ID_NUMBER).collect();
         assert_eq!("A", ids[0]);
         assert_eq!("Z", ids[25]);
         assert_eq!("a", ids[26]);
         assert_eq!("z", ids[51]);
         assert_eq!("0", ids[52]);
         assert_eq!("9", ids[61]);
         assert_eq!("+", ids[62]);
         assert_eq!("-", ids[63]);
         assert_eq!("AA", ids[64]);
         assert_eq!("AB", ids[65]);
         assert_eq!("A-", ids[127]);
         assert_eq!("BA", ids[128]);
         assert_eq!("Ed", ids[349]);

tmp-codegen-diff/aws-sdk/sdk/aws-runtime/src/user_agent/test_data/feature_id_to_metric_value.json

@@ -1,0 +58,0 @@

--
+{
   "RESOURCE_MODEL": "A",
   "WAITER": "B",
   "PAGINATOR": "C",
   "RETRY_MODE_LEGACY": "D",
   "RETRY_MODE_STANDARD": "E",
   "RETRY_MODE_ADAPTIVE": "F",
   "S3_TRANSFER": "G",
   "S3_CRYPTO_V1N": "H",
   "S3_CRYPTO_V2": "I",
   "S3_EXPRESS_BUCKET": "J",
   "S3_ACCESS_GRANTS": "K",
   "GZIP_REQUEST_COMPRESSION": "L",
   "PROTOCOL_RPC_V2_CBOR": "M",
   "ENDPOINT_OVERRIDE": "N",
   "ACCOUNT_ID_ENDPOINT": "O",
   "ACCOUNT_ID_MODE_PREFERRED": "P",
   "ACCOUNT_ID_MODE_DISABLED": "Q",
   "ACCOUNT_ID_MODE_REQUIRED": "R",
   "SIGV4A_SIGNING": "S",
   "RESOLVED_ACCOUNT_ID": "T",
   "FLEXIBLE_CHECKSUMS_REQ_CRC32": "U",
   "FLEXIBLE_CHECKSUMS_REQ_CRC32C": "V",
   "FLEXIBLE_CHECKSUMS_REQ_CRC64": "W",
   "FLEXIBLE_CHECKSUMS_REQ_SHA1": "X",
   "FLEXIBLE_CHECKSUMS_REQ_SHA256": "Y",
   "FLEXIBLE_CHECKSUMS_REQ_WHEN_SUPPORTED": "Z",
   "FLEXIBLE_CHECKSUMS_REQ_WHEN_REQUIRED": "a",
   "FLEXIBLE_CHECKSUMS_RES_WHEN_SUPPORTED": "b",
   "FLEXIBLE_CHECKSUMS_RES_WHEN_REQUIRED": "c",
   "DDB_MAPPER": "d",
   "CREDENTIALS_CODE": "e",
   "CREDENTIALS_JVM_SYSTEM_PROPERTIES": "f",
   "CREDENTIALS_ENV_VARS": "g",
   "CREDENTIALS_ENV_VARS_STS_WEB_ID_TOKEN": "h",
   "CREDENTIALS_STS_ASSUME_ROLE": "i",
   "CREDENTIALS_STS_ASSUME_ROLE_SAML": "j",
   "CREDENTIALS_STS_ASSUME_ROLE_WEB_ID": "k",
   "CREDENTIALS_STS_FEDERATION_TOKEN": "l",
   "CREDENTIALS_STS_SESSION_TOKEN": "m",
   "CREDENTIALS_PROFILE": "n",
   "CREDENTIALS_PROFILE_SOURCE_PROFILE": "o",
   "CREDENTIALS_PROFILE_NAMED_PROVIDER": "p",
   "CREDENTIALS_PROFILE_STS_WEB_ID_TOKEN": "q",
   "CREDENTIALS_PROFILE_SSO": "r",
   "CREDENTIALS_SSO": "s",
   "CREDENTIALS_PROFILE_SSO_LEGACY": "t",
   "CREDENTIALS_SSO_LEGACY": "u",
   "CREDENTIALS_PROFILE_PROCESS": "v",
   "CREDENTIALS_PROCESS": "w",
   "CREDENTIALS_BOTO2_CONFIG_FILE": "x",
   "CREDENTIALS_AWS_SDK_STORE": "y",
   "CREDENTIALS_HTTP": "z",
   "CREDENTIALS_IMDS": "0",
   "SSO_LOGIN_DEVICE": "1",
   "SSO_LOGIN_AUTH": "2",
   "BEARER_SERVICE_ENV_VARS": "3"
--
+}

tmp-codegen-diff/aws-sdk/sdk/aws-runtime/src/user_agent/test_util.rs

@@ -1,1 +92,70 @@

↥ Expand context

 /*
  * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
  * SPDX-License-Identifier: Apache-2.0
  */

-5
 //! Utilities for testing the User-Agent header
-7
 use regex_lite::Regex;
 use std::sync::LazyLock;
-10
 // regular expression pattern for base64 numeric values
 #[allow(dead_code)]
 static RE: LazyLock<Regex> = LazyLock::new(|| Regex::new(r"m/([A-Za-z0-9+/=_,-]+)").unwrap());
-14
 /// Helper function to check metric values in user agent
 fn check_ua_metric_values(user_agent: &str, values: &[&str], should_contain: bool) {
 /// Asserts `user_agent` contains all metric values `values`
 ///
 /// Refer to the end of the parent module file `user_agent.rs` for the complete ABNF specification
 /// of `business-metrics`.
 pub fn assert_ua_contains_metric_values(user_agent: &str, values: &[&str]) {
     match extract_ua_values(user_agent) {
         Some(metrics) => {
             let mut problematic_values = vec![];
             let mut missed = vec![];
-23
             for value in values.iter() {
                 let contains = metrics.contains(value);
                 if (should_contain && !contains) || (!should_contain && contains) {
                     problematic_values.push(value);
--
+                }
--
+            }
--
             if !problematic_values.is_empty() {
                 if should_contain {
                     panic!("metric values {problematic_values:?} not found in `{user_agent}`");
                 } else {
                     panic!(
                         "metric values {problematic_values:?} unexpectedly found in `{user_agent}`"
                     );
                 if !metrics.contains(value) {
                     missed.push(value);
-27
+                }
-28
+            }
             assert!(
                 missed.is_empty(),
                 "{}",
                 format!("metric values {missed:?} not found in `{user_agent}`")
             );
-34
+        }
         None => {
             if should_contain {
                 panic!("the pattern for business-metrics `m/(metric_id) *(comma metric_id)` not found in `{user_agent}`");
--
+            }
             // For "does not contain", no metrics pattern means the assertion passes
             panic!("{}", format!("the pattern for business-metrics `m/(metric_id) *(comma metric_id)` not found in `{user_agent}`"))
-37
+        }
-38
+    }
-39
+}
-40
 /// Asserts `user_agent` contains all metric values `values`
 ///
 /// Refer to the end of the parent module file `user_agent.rs` for the complete ABNF specification
 /// of `business-metrics`.
 pub fn assert_ua_contains_metric_values(user_agent: &str, values: &[&str]) {
     check_ua_metric_values(user_agent, values, true);
--
+}
--
 /// Asserts `user_agent` does NOT contain any of the metric values `values`
 ///
 /// Refer to the end of the parent module file `user_agent.rs` for the complete ABNF specification
 /// of `business-metrics`.
 pub fn assert_ua_does_not_contain_metric_values(user_agent: &str, values: &[&str]) {
     check_ua_metric_values(user_agent, values, false);
--
+}
--
 /// Extract the metric values from the `user_agent` string
 pub fn extract_ua_values(user_agent: &str) -> Option<Vec<&str>> {
     RE.find(user_agent).map(|matched| {
         matched
             .as_str()
             .strip_prefix("m/")
             .expect("prefix `m/` is guaranteed to exist by regex match")
             .split(',')
             .collect()
     })

↧ Expand context

-51
+}
-52
 #[cfg(test)]
 mod tests {
     use super::*;
-56
     #[test]
     fn test_assert_ua_contains_metric_values() {
         assert_ua_contains_metric_values("m/A", &[]);
         assert_ua_contains_metric_values("m/A", &["A"]);
         assert_ua_contains_metric_values(" m/A", &["A"]);
         assert_ua_contains_metric_values("m/A ", &["A"]);
         assert_ua_contains_metric_values(" m/A ", &["A"]);
         assert_ua_contains_metric_values("m/A,B", &["B"]);
         assert_ua_contains_metric_values("m/A,B", &["A", "B"]);
         assert_ua_contains_metric_values("m/A,B", &["B", "A"]);
         assert_ua_contains_metric_values("m/A,B,C", &["B"]);
         assert_ua_contains_metric_values("m/A,B,C", &["B", "C"]);
         assert_ua_contains_metric_values("m/A,B,C", &["A", "B", "C"]);
         assert_ua_contains_metric_values("m/A,B,C,AA", &["AA"]);

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

@@ -17,17 +130,130 @@

↥ Expand context

 exclude = ["aws-sig-v4-test-suite/*"]
 license = "Apache-2.0"
 repository = "https://github.com/smithy-lang/smithy-rs"
 [package.metadata.docs.rs]
 all-features = true
 targets = ["x86_64-unknown-linux-gnu"]
 cargo-args = ["-Zunstable-options", "-Zrustdoc-scrape-examples"]
 rustdoc-args = ["--cfg", "docsrs"]
-25
 [package.metadata.smithy-rs-release-tooling]
 stable = true
-28
 [features]
 default = ["sign-http", "http1"]
 http0-compat = ["dep:http0"]
 http1 = ["dep:http"]
 sign-http = ["dep:http0", "dep:percent-encoding", "dep:form_urlencoded"]
 sign-eventstream = ["dep:aws-smithy-eventstream"]
 sigv4a = ["dep:p256", "dep:crypto-bigint", "dep:subtle", "dep:zeroize", "dep:ring"]
-36

 [dependencies]
 bytes = "1.10.0"
 hex = "0.4.3"
 hmac = "0.12"
 sha2 = "0.10"
 time = "0.3.5"
 tracing = "0.1.40"
-44
 [dependencies.aws-credential-types]
 path = "../aws-credential-types"
 version = "1.2.5"
 version = "1.2.4"
-48
 [dependencies.aws-smithy-eventstream]
 path = "../aws-smithy-eventstream"
 optional = true
 version = "0.60.10"
-53
 [dependencies.aws-smithy-http]
 path = "../aws-smithy-http"
 version = "0.62.3"
-57
 [dependencies.aws-smithy-runtime-api]
 path = "../aws-smithy-runtime-api"
 features = ["client"]
 version = "1.8.7"
 version = "1.8.5"
-62
 [dependencies.aws-smithy-types]
 path = "../aws-smithy-types"
 version = "1.3.2"
-66
 [dependencies.form_urlencoded]
 version = "1.2.1"
 optional = true
-70
 [dependencies.http0]
 version = "0.2.9"
 optional = true
 package = "http"
-75
 [dependencies.http]
 version = "1.1.0"
 optional = true
-79
 [dependencies.p256]
 version = "0.11"
 features = ["ecdsa"]
 optional = true
-84
 [dependencies.percent-encoding]
 version = "2.3.1"
 optional = true
-88
 [dependencies.ring]
 version = "0.17.5"
 optional = true
-92
 [dependencies.crypto-bigint]
 version = "0.5.4"
 optional = true
-96
 [dependencies.subtle]
 version = "2.5.0"
 optional = true
-100
 [dependencies.zeroize]
 version = "^1.7.0"
 optional = true
-104
 [dev-dependencies]
 bytes = "1"
 hex-literal = "0.4.1"
 httparse = "1.10.1"
 pretty_assertions = "1.3"
 proptest = "1.2"
 serde = "1.0.180"
 serde_derive = "1.0.180"
 serde_json = "1.0.104"
 criterion = "0.5"
-115
 [dev-dependencies.aws-credential-types]
 path = "../aws-credential-types"
 features = ["test-util", "hardcoded-credentials"]
 version = "1.2.5"
 version = "1.2.4"
-120
 [dev-dependencies.aws-smithy-runtime-api]
 path = "../aws-smithy-runtime-api"
 features = ["client", "test-util"]
 version = "1.8.7"
 version = "1.8.5"
-125
 [dev-dependencies.time]
 version = "0.3.5"
 features = ["parsing"]
 [target."cfg(not(any(target_arch = \"powerpc\", target_arch = \"powerpc64\")))".dev-dependencies]
 ring = "0.17.5"

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

@@ -1,1 +34,34 @@

 # Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
 [package]
 name = "aws-smithy-checksums"
 version = "0.63.6"
 version = "0.63.5"
 authors = ["AWS Rust SDK Team <aws-sdk-rust@amazon.com>", "Zelda Hessler <zhessler@amazon.com>"]
 description = "Checksum calculation and verification callbacks"
 edition = "2021"
 license = "Apache-2.0"
 repository = "https://github.com/smithy-lang/smithy-rs"
 [package.metadata.docs.rs]
 all-features = true
 targets = ["x86_64-unknown-linux-gnu"]
 cargo-args = ["-Zunstable-options", "-Zrustdoc-scrape-examples"]
 rustdoc-args = ["--cfg", "docsrs"]

↧ Expand context

-15
 [dependencies]
 bytes = "1.10.0"
 crc-fast = "1.3.0"
 hex = "0.4.3"
 http = "0.2.9"
 http-body = "0.4.5"
 md-5 = "0.10"
 pin-project-lite = "0.2.14"
 sha1 = "0.10"
 sha2 = "0.10"
 tracing = "0.1.40"
-27
 [dependencies.aws-smithy-http]
 path = "../aws-smithy-http"
 version = "0.62.3"
-31
 [dependencies.aws-smithy-types]
 path = "../aws-smithy-types"
 version = "1.3.2"

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

@@ -3,3 +63,63 @@

↥ Expand context

 name = "aws-smithy-compression"
 version = "0.0.4"
 authors = ["AWS Rust SDK Team <aws-sdk-rust@amazon.com>", "Zelda Hessler <zhessler@amazon.com>"]
 description = "Request compression for smithy clients."
 edition = "2021"
 license = "Apache-2.0"
 repository = "https://github.com/smithy-lang/smithy-rs"
 [package.metadata.docs.rs]
 all-features = true
 targets = ["x86_64-unknown-linux-gnu"]
 cargo-args = ["-Zunstable-options", "-Zrustdoc-scrape-examples"]
 rustdoc-args = ["--cfg", "docsrs"]
-15
 [features]
 http-body-0-4-x = ["dep:http-body-0-4", "dep:http-0-2", "aws-smithy-types/http-body-0-4-x"]
 http-body-1-x = ["dep:http-body-1-0", "dep:http-1-0", "dep:http-body-util", "aws-smithy-types/http-body-1-x"]
-19
 [dependencies]
 bytes = "1.10.0"
 flate2 = "1.0.30"

 futures-util = "0.3"
 pin-project-lite = "0.2.14"
 tracing = "0.1.40"
-26
 [dependencies.aws-smithy-types]
 path = "../aws-smithy-types"
 version = "1.3.2"
-30
 [dependencies.aws-smithy-runtime-api]
 path = "../aws-smithy-runtime-api"
 version = "1.8.7"
 version = "1.8.5"
-34
 [dependencies.http-0-2]
 package = "http"
 version = "0.2.9"
 optional = true
-39
 [dependencies.http-1-0]
 package = "http"
 version = "1"
 optional = true

↧ Expand context

-44
 [dependencies.http-body-0-4]
 package = "http-body"
 version = "0.4.5"
 optional = true
-49
 [dependencies.http-body-1-0]
 package = "http-body"
 version = "1"
 optional = true
-54
 [dependencies.http-body-util]
 version = "0.1.2"
 optional = true
-58
 [dev-dependencies]
 bytes-utils = "0.1.2"
 pretty_assertions = "1.3"
-62
 [dev-dependencies.tokio]

tmp-codegen-diff/aws-sdk/sdk/aws-smithy-http-client/Cargo.toml

@@ -32,32 +92,92 @@

↥ Expand context

 [package.metadata.docs.rs]
 all-features = false
 features = ["default-client ", "wire-mock", "test-util", "rustls-ring", "rustls-aws-lc"]
 targets = ["x86_64-unknown-linux-gnu"]
 cargo-args = ["-Zunstable-options", "-Zrustdoc-scrape-examples"]
 rustdoc-args = ["--cfg", "docsrs"]
-38
 [features]
 hyper-014 = ["aws-smithy-runtime-api/http-02x", "aws-smithy-types/http-body-0-4-x", "dep:http-02x", "dep:http-body-04x", "dep:hyper-0-14", "dep:h2-0-3"]
 default-client = ["aws-smithy-runtime-api/http-1x", "aws-smithy-types/http-body-1-x", "dep:hyper", "dep:hyper-util", "hyper-util?/client-legacy", "dep:http-1x", "dep:tower", "dep:rustls-pki-types", "dep:rustls-native-certs"]
 wire-mock = ["test-util", "default-client", "hyper-util?/server", "hyper-util?/server-auto", "hyper-util?/service", "hyper-util?/server-graceful", "tokio/macros", "dep:http-body-util"]
 test-util = ["dep:aws-smithy-protocol-test", "dep:serde", "dep:serde_json", "dep:indexmap", "dep:bytes", "dep:http-1x", "aws-smithy-runtime-api/http-1x", "dep:http-body-1x", "aws-smithy-types/http-body-1-x", "tokio/rt"]
 legacy-test-util = ["test-util", "dep:http-02x", "aws-smithy-runtime-api/http-02x", "aws-smithy-types/http-body-0-4-x"]
 legacy-rustls-ring = ["dep:legacy-hyper-rustls", "dep:legacy-rustls", "hyper-014"]
 rustls-ring = ["dep:rustls", "rustls?/ring", "dep:hyper-rustls", "default-client"]
 rustls-aws-lc = ["dep:rustls", "rustls?/aws_lc_rs", "dep:hyper-rustls", "default-client"]
 rustls-aws-lc-fips = ["dep:rustls", "rustls?/fips", "dep:hyper-rustls", "default-client"]
 s2n-tls = ["dep:s2n-tls", "dep:s2n-tls-hyper", "default-client"]
-50
 [dependencies]

 pin-project-lite = "0.2.14"
 tracing = "0.1.40"
-54
 [dependencies.aws-smithy-async]
 path = "../aws-smithy-async"
 version = "1.2.5"
-58
 [dependencies.aws-smithy-runtime-api]
 path = "../aws-smithy-runtime-api"
 features = ["client"]
 version = "1.8.7"
 version = "1.8.5"
-63
 [dependencies.aws-smithy-types]
 path = "../aws-smithy-types"
 version = "1.3.2"
-67
 [dependencies.aws-smithy-protocol-test]
 path = "../aws-smithy-protocol-test"
 optional = true
 version = "0.63.4"
-72

↧ Expand context

 [dependencies.h2]
 version = "0.4.2"
 default-features = false
-76
 [dependencies.tokio]
 version = "1.40"
 features = []
-80
 [dependencies.hyper]
 version = "1.6.0"
 features = ["client", "http1", "http2"]
 optional = true
-85
 [dependencies.hyper-util]
 version = "0.1.10"
 features = ["http1", "http2"]
 optional = true
-90
 [dependencies.http-1x]
 package = "http"

@@ -171,171 +221,221 @@

↥ Expand context

 version = "1.0.210"
 features = ["derive"]
 optional = true
-174
 [dependencies.serde_json]
 version = "1.0.128"
 features = ["preserve_order"]
 optional = true
-179
 [dependencies.indexmap]
 version = "2.6.0"
 features = ["serde"]
 optional = true
-184
 [dependencies.http-body-util]
 version = "0.1.2"
 optional = true
-188
 [dev-dependencies]
 rustls-pemfile = "2.2.0"

 tokio-rustls = "0.26.1"
-192
 [dev-dependencies.aws-smithy-async]
 path = "../aws-smithy-async"
 features = ["rt-tokio", "test-util"]
 version = "1.2.5"
-197
 [dev-dependencies.aws-smithy-runtime-api]
 path = "../aws-smithy-runtime-api"
 features = ["test-util"]
 version = "1.8.7"
 version = "1.8.5"
-202
 [dev-dependencies.aws-smithy-types]
 path = "../aws-smithy-types"
 features = ["http-body-0-4-x", "test-util"]
 version = "1.3.2"
-207
 [dev-dependencies.http-body-util]
 version = "0.1.2"
-210
 [dev-dependencies.hyper-util]

↧ Expand context

 version = "0.1.7"
 features = ["full"]
-214
 [dev-dependencies.rustls-pki-types]
 version = "1.11.0"
 features = ["std"]
-218
 [dev-dependencies.tokio]
 version = "1"
 features = ["macros", "rt", "rt-multi-thread", "test-util", "full"]

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

@@ -7,7 +67,67 @@

↥ Expand context

 edition = "2021"
 license = "Apache-2.0"
 repository = "https://github.com/smithy-lang/smithy-rs"
 [package.metadata.docs.rs]
 all-features = true
 targets = ["x86_64-unknown-linux-gnu"]
 cargo-args = ["-Zunstable-options", "-Zrustdoc-scrape-examples"]
 rustdoc-args = ["--cfg", "docsrs"]
-15
 [features]
 event-stream = ["aws-smithy-eventstream"]
 rt-tokio = ["aws-smithy-types/rt-tokio"]
-19
 [dependencies]
 bytes = "1.10.0"
 bytes-utils = "0.1"
 percent-encoding = "2.3.1"
 pin-project-lite = "0.2.14"
 pin-utils = "0.1.0"
 tracing = "0.1.40"

 futures-core = "0.3.31"
-28
 [dependencies.aws-smithy-eventstream]
 path = "../aws-smithy-eventstream"
 optional = true
 version = "0.60.10"
-33
 [dependencies.aws-smithy-runtime-api]
 path = "../aws-smithy-runtime-api"
 features = ["client", "http-02x"]
 version = "1.8.7"
 version = "1.8.5"
-38
 [dependencies.aws-smithy-types]
 path = "../aws-smithy-types"
 features = ["byte-stream-poll-next", "http-body-0-4-x"]
 version = "1.3.2"
-43
 [dependencies.http-02x]
 package = "http"
 version = "0.2.9"
-47

↧ Expand context

 [dependencies.http-1x]
 package = "http"
 version = "1"
-51
 [dependencies.http-body-04x]
 package = "http-body"
 version = "0.4.5"
-55
 [dev-dependencies]
 async-stream = "0.3"
 proptest = "1"
-59
 [dev-dependencies.futures-util]
 version = "0.3.29"
 default-features = false
-63
 [dev-dependencies.hyper]
 version = "0.14.26"
 features = ["stream"]
-67

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

@@ -1,1 +29,29 @@

↥ Expand context

 # Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
 [[example]]
 name = "s3-getobject-mocks"
 doc-scrape-examples = true
-5
 [package]
 name = "aws-smithy-mocks-experimental"
 version = "0.2.4"
 authors = ["AWS Rust SDK Team <aws-sdk-rust@amazon.com>"]
 description = "Experimental testing utilities for smithy-rs generated clients"
 edition = "2021"
 license = "Apache-2.0"
 repository = "https://github.com/smithy-lang/smithy-rs"
 [package.metadata.docs.rs]
 all-features = true

 targets = ["x86_64-unknown-linux-gnu"]
 cargo-args = ["-Zunstable-options", "-Zrustdoc-scrape-examples"]
 rustdoc-args = ["--cfg", "docsrs"]
 [dependencies.aws-smithy-types]
 path = "../aws-smithy-types"
 version = "1.3.2"
-22
 [dependencies.aws-smithy-runtime-api]
 path = "../aws-smithy-runtime-api"
 features = ["client", "http-02x"]
 version = "1.8.7"
 version = "1.8.5"
 [dev-dependencies.tokio]
 version = "1"
 features = ["full"]

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

@@ -1,1 +0,44 @@

↥ Expand context

 # Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
 [package]
 name = "aws-smithy-mocks"
 version = "0.1.1"
 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"
 [package.metadata.docs.rs]
 all-features = true
 targets = ["x86_64-unknown-linux-gnu"]
 cargo-args = ["-Zunstable-options", "-Zrustdoc-scrape-examples"]
 rustdoc-args = ["--cfg", "docsrs"]
-15

 [dependencies]
 http = "1"
-18
 [dependencies.aws-smithy-types]
 path = "../aws-smithy-types"
 version = "1.3.2"
-22
 [dependencies.aws-smithy-runtime-api]
 path = "../aws-smithy-runtime-api"
 features = ["client", "http-1x"]
 version = "1.8.7"
 version = "1.8.5"
-27
 [dependencies.aws-smithy-http-client]
 path = "../aws-smithy-http-client"
 features = ["test-util"]
 version = "1.0.6"
 [dev-dependencies.tokio]
 version = "1"
 features = ["full"]
-35
 [dev-dependencies.aws-smithy-async]
 path = "../aws-smithy-async"
 features = ["rt-tokio"]
 version = "1.2.5"
-40
 [dev-dependencies.aws-smithy-runtime]
 path = "../aws-smithy-runtime"
 features = ["client"]
 version = "1.8.6"
 version = "1.8.5"

Pages: 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30