AWS SDK

AWS SDK

rev. 6bcea292b6197a62fef0adf12ff1604d4bc257ce

Files changed:

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

@@ -13,13 +77,77 @@
   33     33   
   34     34   
[dependencies]
   35     35   
bytes = "1.1.0"
   36     36   
http = "1"
   37     37   
url = "2.5.4"
   38     38   
fastrand = "2.3.0"
   39     39   
   40     40   
[dependencies.aws-credential-types]
   41     41   
path = "../aws-credential-types"
   42     42   
features = ["test-util"]
   43         -
version = "1.2.4"
          43  +
version = "1.2.5"
   44     44   
   45     45   
[dependencies.aws-runtime]
   46     46   
path = "../aws-runtime"
   47         -
version = "1.5.9"
          47  +
version = "1.5.10"
   48     48   
   49     49   
[dependencies.aws-sdk-sts]
   50     50   
path = "../sts"
   51     51   
default-features = false
   52     52   
version = "0.0.0-local"
   53     53   
   54     54   
[dependencies.aws-smithy-async]
   55     55   
path = "../aws-smithy-async"
   56     56   
version = "1.2.5"
   57     57

tmp-codegen-diff/aws-sdk/sdk/aws-credential-types/Cargo.toml

@@ -1,1 +34,34 @@
    1      1   
# Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
    2      2   
[package]
    3      3   
name = "aws-credential-types"
    4         -
version = "1.2.4"
           4  +
version = "1.2.5"
    5      5   
authors = ["AWS Rust SDK Team <aws-sdk-rust@amazon.com>"]
    6      6   
description = "Types for AWS SDK credentials."
    7      7   
edition = "2021"
    8      8   
license = "Apache-2.0"
    9      9   
repository = "https://github.com/smithy-lang/smithy-rs"
   10     10   
[package.metadata.docs.rs]
   11     11   
all-features = true
   12     12   
targets = ["x86_64-unknown-linux-gnu"]
   13     13   
cargo-args = ["-Zunstable-options", "-Zrustdoc-scrape-examples"]
   14     14   
rustdoc-args = ["--cfg", "docsrs"]

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

@@ -0,1 +0,52 @@
           1  +
/*
           2  +
 * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
           3  +
 * SPDX-License-Identifier: Apache-2.0
           4  +
 */
           5  +
           6  +
use aws_smithy_types::config_bag::{Storable, StoreAppend};
           7  +
           8  +
/// IDs for the credential related features that may be used in the AWS SDK
           9  +
#[non_exhaustive]
          10  +
#[derive(Clone, Debug, Eq, PartialEq)]
          11  +
pub enum AwsCredentialFeature {
          12  +
    /// An operation called using credentials resolved from code, cli parameters, session object, or client instance
          13  +
    CredentialsCode,
          14  +
    /// An operation called using credentials resolved from environment variables
          15  +
    CredentialsEnvVars,
          16  +
    /// An operation called using credentials resolved from environment variables for assuming a role with STS using a web identity token
          17  +
    CredentialsEnvVarsStsWebIdToken,
          18  +
    /// An operation called using credentials resolved from STS using assume role
          19  +
    CredentialsStsAssumeRole,
          20  +
    /// An operation called using credentials resolved from STS using assume role with SAML
          21  +
    CredentialsStsAssumeRoleSaml,
          22  +
    /// An operation called using credentials resolved from STS using assume role with web identity
          23  +
    CredentialsStsAssumeRoleWebId,
          24  +
    /// An operation called using credentials resolved from STS using a federation token
          25  +
    CredentialsStsFederationToken,
          26  +
    /// An operation called using credentials resolved from STS using a session token
          27  +
    CredentialsStsSessionToken,
          28  +
    /// An operation called using credentials resolved from a config file(s) profile with static credentials
          29  +
    CredentialsProfile,
          30  +
    /// An operation called using credentials resolved from a source profile in a config file(s) profile
          31  +
    CredentialsProfileSourceProfile,
          32  +
    /// An operation called using credentials resolved from a named provider in a config file(s) profile
          33  +
    CredentialsProfileNamedProvider,
          34  +
    /// An operation called using credentials resolved from configuration for assuming a role with STS using web identity token in a config file(s) profile
          35  +
    CredentialsProfileStsWebIdToken,
          36  +
    /// An operation called using credentials resolved from an SSO session in a config file(s) profile
          37  +
    CredentialsProfileSso,
          38  +
    /// An operation called using credentials resolved from an SSO session
          39  +
    CredentialsSso,
          40  +
    /// An operation called using credentials resolved from a process in a config file(s) profile
          41  +
    CredentialsProfileProcess,
          42  +
    /// An operation called using credentials resolved from a process
          43  +
    CredentialsProcess,
          44  +
    /// An operation called using credentials resolved from an HTTP endpoint
          45  +
    CredentialsHttp,
          46  +
    /// An operation called using credentials resolved from the instance metadata service (IMDS)
          47  +
    CredentialsImds,
          48  +
}
          49  +
          50  +
impl Storable for AwsCredentialFeature {
          51  +
    type Storer = StoreAppend<Self>;
          52  +
}

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

@@ -1,1 +55,82 @@
    1      1   
/*
    2      2   
 * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
    3      3   
 * SPDX-License-Identifier: Apache-2.0
    4      4   
 */
    5      5   
           6  +
use aws_smithy_types::config_bag::Layer;
    6      7   
use aws_smithy_types::date_time::Format;
           8  +
use aws_smithy_types::type_erasure::TypeErasedBox;
           9  +
use std::any::{Any, TypeId};
          10  +
use std::collections::HashMap;
    7     11   
use std::fmt;
    8     12   
use std::fmt::{Debug, Formatter};
    9     13   
use std::sync::Arc;
   10     14   
use std::time::{SystemTime, UNIX_EPOCH};
   11     15   
use zeroize::Zeroizing;
   12     16   
   13     17   
use aws_smithy_runtime_api::client::identity::Identity;
   14     18   
   15     19   
use crate::attributes::AccountId;
          20  +
use crate::credential_feature::AwsCredentialFeature;
   16     21   
   17     22   
/// AWS SDK Credentials
   18     23   
///
   19     24   
/// An opaque struct representing credentials that may be used in an AWS SDK, modeled on
   20     25   
/// the [CRT credentials implementation](https://github.com/awslabs/aws-c-auth/blob/main/source/credentials.c).
   21     26   
///
   22     27   
/// When `Credentials` is dropped, its contents are zeroed in memory. Credentials uses an interior Arc to ensure
   23     28   
/// that even when cloned, credentials don't exist in multiple memory locations.
   24         -
#[derive(Clone, Eq, PartialEq)]
   25         -
pub struct Credentials(Arc<Inner>);
          29  +
pub struct Credentials(Arc<Inner>, HashMap<TypeId, TypeErasedBox>);
          30  +
          31  +
impl Clone for Credentials {
          32  +
    fn clone(&self) -> Self {
          33  +
        let mut new_map = HashMap::with_capacity(self.1.len());
          34  +
        for (k, v) in &self.1 {
          35  +
            new_map.insert(
          36  +
                *k,
          37  +
                v.try_clone()
          38  +
                    .expect("values are guaranteed to implement `Clone` via `set_property`"),
          39  +
            );
          40  +
        }
          41  +
        Self(self.0.clone(), new_map)
          42  +
    }
          43  +
}
          44  +
          45  +
impl PartialEq for Credentials {
          46  +
    #[inline] // specified in the output of cargo expand of the original `#[derive(PartialEq)]`
          47  +
    fn eq(&self, other: &Credentials) -> bool {
          48  +
        self.0 == other.0
          49  +
    }
          50  +
}
          51  +
          52  +
impl Eq for Credentials {}
   26     53   
   27     54   
#[derive(Clone, Eq, PartialEq)]
   28     55   
struct Inner {
   29     56   
    access_key_id: Zeroizing<String>,
   30     57   
    secret_access_key: Zeroizing<String>,
   31     58   
    session_token: Zeroizing<Option<String>>,
   32     59   
   33     60   
    /// Credential Expiry
   34     61   
    ///
   35     62   
    /// A SystemTime at which the credentials should no longer be used because they have expired.
@@ -66,93 +133,163 @@
   86    113   
    ///
   87    114   
    /// This is intended to be used from a custom credentials provider implementation.
   88    115   
    /// It is __NOT__ secure to hardcode credentials into your application.
   89    116   
    pub fn new(
   90    117   
        access_key_id: impl Into<String>,
   91    118   
        secret_access_key: impl Into<String>,
   92    119   
        session_token: Option<String>,
   93    120   
        expires_after: Option<SystemTime>,
   94    121   
        provider_name: &'static str,
   95    122   
    ) -> Self {
   96         -
        Credentials(Arc::new(Inner {
   97         -
            access_key_id: Zeroizing::new(access_key_id.into()),
   98         -
            secret_access_key: Zeroizing::new(secret_access_key.into()),
   99         -
            session_token: Zeroizing::new(session_token),
  100         -
            expires_after,
  101         -
            account_id: None,
  102         -
            provider_name,
  103         -
        }))
         123  +
        Credentials(
         124  +
            Arc::new(Inner {
         125  +
                access_key_id: Zeroizing::new(access_key_id.into()),
         126  +
                secret_access_key: Zeroizing::new(secret_access_key.into()),
         127  +
                session_token: Zeroizing::new(session_token),
         128  +
                expires_after,
         129  +
                account_id: None,
         130  +
                provider_name,
         131  +
            }),
         132  +
            HashMap::new(),
         133  +
        )
  104    134   
    }
  105    135   
  106    136   
    /// Creates `Credentials` from hardcoded access key, secret key, and session token.
  107    137   
    ///
  108    138   
    /// _Note: In general, you should prefer to use the credential providers that come
  109    139   
    /// with the AWS SDK to get credentials. It is __NOT__ secure to hardcode credentials
  110    140   
    /// into your application. If you're writing a custom credentials provider, then
  111    141   
    /// use [`Credentials::new`] instead of this._
  112    142   
    ///
  113    143   
    /// This function requires the `hardcoded-credentials` feature to be enabled.
@@ -161,191 +220,286 @@
  181    211   
  182    212   
    /// Returns the account ID.
  183    213   
    pub fn account_id(&self) -> Option<&AccountId> {
  184    214   
        self.0.account_id.as_ref()
  185    215   
    }
  186    216   
  187    217   
    /// Returns the session token.
  188    218   
    pub fn session_token(&self) -> Option<&str> {
  189    219   
        self.0.session_token.as_deref()
  190    220   
    }
         221  +
         222  +
    /// Set arbitrary property for `Credentials`
         223  +
    #[doc(hidden)]
         224  +
    pub fn set_property<T: Any + Clone + Debug + Send + Sync + 'static>(&mut self, prop: T) {
         225  +
        self.1
         226  +
            .insert(TypeId::of::<T>(), TypeErasedBox::new_with_clone(prop));
         227  +
    }
         228  +
         229  +
    /// Returns arbitrary property associated with this `Credentials`.
         230  +
    #[doc(hidden)]
         231  +
    pub fn get_property<T: Any + Debug + Send + Sync + 'static>(&self) -> Option<&T> {
         232  +
        self.1
         233  +
            .get(&TypeId::of::<T>())
         234  +
            .and_then(|b| b.downcast_ref())
         235  +
    }
         236  +
         237  +
    /// Attempts to retrieve a mutable reference to property of a given type `T`.
         238  +
    #[doc(hidden)]
         239  +
    pub fn get_property_mut<T: Any + Debug + Send + Sync + 'static>(&mut self) -> Option<&mut T> {
         240  +
        self.1
         241  +
            .get_mut(&TypeId::of::<T>())
         242  +
            .and_then(|b| b.downcast_mut())
         243  +
    }
         244  +
         245  +
    /// Returns a mutable reference to `T` if it is stored in the property, otherwise returns the
         246  +
    /// [`Default`] implementation of `T`.
         247  +
    #[doc(hidden)]
         248  +
    pub fn get_property_mut_or_default<T: Any + Clone + Debug + Default + Send + Sync + 'static>(
         249  +
        &mut self,
         250  +
    ) -> &mut T {
         251  +
        self.1
         252  +
            .entry(TypeId::of::<T>())
         253  +
            .or_insert_with(|| TypeErasedBox::new_with_clone(T::default()))
         254  +
            .downcast_mut()
         255  +
            .expect("typechecked")
         256  +
    }
  191    257   
}
  192    258   
  193    259   
/// Builder for [`Credentials`]
  194    260   
///
  195    261   
/// Similar to [`Credentials::new`], the use of the builder is intended for a custom credentials provider implementation.
  196    262   
/// It is __NOT__ secure to hardcode credentials into your application.
  197    263   
#[derive(Default, Clone)]
  198    264   
#[allow(missing_debug_implementations)] // for security reasons, and we can add manual `impl Debug` just like `Credentials`, if needed.
  199    265   
pub struct CredentialsBuilder {
  200    266   
    access_key_id: Option<Zeroizing<String>>,
@@ -232,298 +362,485 @@
  252    318   
    }
  253    319   
  254    320   
    /// Set provider name for the builder.
  255    321   
    pub fn provider_name(mut self, provider_name: &'static str) -> Self {
  256    322   
        self.provider_name = Some(provider_name);
  257    323   
        self
  258    324   
    }
  259    325   
  260    326   
    /// Build [`Credentials`] from the builder.
  261    327   
    pub fn build(self) -> Credentials {
  262         -
        Credentials(Arc::new(Inner {
  263         -
            access_key_id: self
  264         -
                .access_key_id
  265         -
                .expect("required field `access_key_id` missing"),
  266         -
            secret_access_key: self
  267         -
                .secret_access_key
  268         -
                .expect("required field `secret_access_key` missing"),
  269         -
            session_token: self.session_token,
  270         -
            expires_after: self.expires_after,
  271         -
            account_id: self.account_id,
  272         -
            provider_name: self
  273         -
                .provider_name
  274         -
                .expect("required field `provider_name` missing"),
  275         -
        }))
         328  +
        Credentials(
         329  +
            Arc::new(Inner {
         330  +
                access_key_id: self
         331  +
                    .access_key_id
         332  +
                    .expect("required field `access_key_id` missing"),
         333  +
                secret_access_key: self
         334  +
                    .secret_access_key
         335  +
                    .expect("required field `secret_access_key` missing"),
         336  +
                session_token: self.session_token,
         337  +
                expires_after: self.expires_after,
         338  +
                account_id: self.account_id,
         339  +
                provider_name: self
         340  +
                    .provider_name
         341  +
                    .expect("required field `provider_name` missing"),
         342  +
            }),
         343  +
            HashMap::new(),
         344  +
        )
  276    345   
    }
  277    346   
}
  278    347   
  279    348   
#[cfg(feature = "test-util")]
  280    349   
impl Credentials {
  281    350   
    /// Creates a test `Credentials` with no session token.
  282    351   
    pub fn for_tests() -> Self {
  283    352   
        Self::new(
  284    353   
            "ANOTREAL",
  285    354   
            "notrealrnrELgWzOk3IfjzDKtFBhDby",
  286    355   
            None,
  287    356   
            None,
  288    357   
            "test",
  289    358   
        )
  290    359   
    }
  291    360   
  292    361   
    /// Creates a test `Credentials` that include a session token.
  293    362   
    pub fn for_tests_with_session_token() -> Self {
  294    363   
        Self::new(
  295    364   
            "ANOTREAL",
  296    365   
            "notrealrnrELgWzOk3IfjzDKtFBhDby",
  297    366   
            Some("notarealsessiontoken".to_string()),
  298    367   
            None,
  299    368   
            "test",
  300    369   
        )
  301    370   
    }
  302    371   
}
  303    372   
  304    373   
#[cfg(feature = "test-util")]
  305    374   
impl CredentialsBuilder {
  306    375   
    /// Creates a test `CredentialsBuilder` with the required fields:
  307    376   
    /// `access_key_id`, `secret_access_key`, and `provider_name`.
  308    377   
    pub fn for_tests() -> Self {
  309    378   
        CredentialsBuilder::default()
  310    379   
            .access_key_id("ANOTREAL")
  311    380   
            .secret_access_key("notrealrnrELgWzOk3IfjzDKtFBhDby")
  312    381   
            .provider_name("test")
  313    382   
    }
  314    383   
}
  315    384   
  316    385   
impl From<Credentials> for Identity {
  317    386   
    fn from(val: Credentials) -> Self {
  318    387   
        let expiry = val.expiry();
  319    388   
        let mut builder = if let Some(account_id) = val.account_id() {
  320         -
            Identity::builder().property(account_id.clone()).data(val)
         389  +
            Identity::builder().property(account_id.clone())
  321    390   
        } else {
  322         -
            Identity::builder().data(val)
         391  +
            Identity::builder()
  323    392   
        };
         393  +
  324    394   
        builder.set_expiration(expiry);
  325         -
        builder.build().expect("set required fields")
         395  +
         396  +
        if let Some(features) = val.get_property::<Vec<AwsCredentialFeature>>().cloned() {
         397  +
            let mut layer = Layer::new("IdentityResolutionFeatureIdTracking");
         398  +
            for feat in features {
         399  +
                layer.store_append(feat);
         400  +
            }
         401  +
            builder.set_property(layer.freeze());
         402  +
        }
         403  +
         404  +
        builder.data(val).build().expect("set required fields")
  326    405   
    }
  327    406   
}
  328    407   
  329    408   
#[cfg(test)]
  330    409   
mod test {
  331    410   
    use crate::Credentials;
  332    411   
    use std::time::{Duration, UNIX_EPOCH};
  333    412   
         413  +
    #[cfg(feature = "test-util")]
         414  +
    use crate::credential_feature::AwsCredentialFeature;
         415  +
  334    416   
    #[test]
  335    417   
    fn debug_impl() {
  336    418   
        let creds = Credentials::new(
  337    419   
            "akid",
  338    420   
            "secret",
  339    421   
            Some("token".into()),
  340    422   
            Some(UNIX_EPOCH + Duration::from_secs(1234567890)),
  341    423   
            "debug tester",
  342    424   
        );
  343    425   
        assert_eq!(
  344    426   
            format!("{:?}", creds),
  345    427   
            r#"Credentials { provider_name: "debug tester", access_key_id: "akid", secret_access_key: "** redacted **", expires_after: "2009-02-13T23:31:30Z" }"#
  346    428   
        );
  347    429   
  348    430   
        // with account ID
  349    431   
        let creds = Credentials::builder()
  350    432   
            .access_key_id("akid")
  351    433   
            .secret_access_key("secret")
  352    434   
            .session_token("token")
  353    435   
            .expiry(UNIX_EPOCH + Duration::from_secs(1234567890))
  354    436   
            .account_id("012345678901")
  355    437   
            .provider_name("debug tester")
  356    438   
            .build();
  357    439   
        assert_eq!(
  358    440   
            format!("{:?}", creds),
  359    441   
            r#"Credentials { provider_name: "debug tester", access_key_id: "akid", secret_access_key: "** redacted **", expires_after: "2009-02-13T23:31:30Z", account_id: "012345678901" }"#
  360    442   
        );
  361    443   
    }
         444  +
         445  +
    #[cfg(feature = "test-util")]
         446  +
    #[test]
         447  +
    fn equality_ignores_properties() {
         448  +
        #[derive(Clone, Debug)]
         449  +
        struct Foo;
         450  +
        let mut creds1 = Credentials::for_tests_with_session_token();
         451  +
        creds1.set_property(AwsCredentialFeature::CredentialsCode);
         452  +
         453  +
        let mut creds2 = Credentials::for_tests_with_session_token();
         454  +
        creds2.set_property(Foo);
         455  +
         456  +
        assert_eq!(creds1, creds2)
         457  +
    }
         458  +
         459  +
    #[cfg(feature = "test-util")]
         460  +
    #[test]
         461  +
    fn identity_inherits_feature_properties() {
         462  +
        use aws_smithy_runtime_api::client::identity::Identity;
         463  +
        use aws_smithy_types::config_bag::FrozenLayer;
         464  +
         465  +
        let mut creds = Credentials::for_tests_with_session_token();
         466  +
        let mut feature_props = vec![
         467  +
            AwsCredentialFeature::CredentialsCode,
         468  +
            AwsCredentialFeature::CredentialsStsSessionToken,
         469  +
        ];
         470  +
        creds.set_property(feature_props.clone());
         471  +
         472  +
        let identity = Identity::from(creds);
         473  +
         474  +
        let maybe_props = identity
         475  +
            .property::<FrozenLayer>()
         476  +
            .unwrap()
         477  +
            .load::<AwsCredentialFeature>()
         478  +
            .cloned()
         479  +
            .collect::<Vec<AwsCredentialFeature>>();
         480  +
         481  +
        // The props get reversed when being popped out of the StoreAppend
         482  +
        feature_props.reverse();
         483  +
        assert_eq!(maybe_props, feature_props)
         484  +
    }
  362    485   
}

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

@@ -1,1 +37,39 @@
   14     14   
#![allow(clippy::derive_partial_eq_without_eq)]
   15     15   
#![warn(
   16     16   
    missing_debug_implementations,
   17     17   
    missing_docs,
   18     18   
    rust_2018_idioms,
   19     19   
    rustdoc::missing_crate_level_docs,
   20     20   
    unreachable_pub
   21     21   
)]
   22     22   
   23     23   
pub mod attributes;
          24  +
#[doc(hidden)]
          25  +
pub mod credential_feature;
   24     26   
pub mod credential_fn;
   25     27   
mod credentials_impl;
   26     28   
pub mod provider;
   27     29   
pub mod token_fn;
   28     30   
   29     31   
pub use credentials_impl::{Credentials, CredentialsBuilder};
   30     32   
   31     33   
/// AWS Access Token
   32     34   
///
   33     35   
/// This access token type is used to authenticate to AWS services that use HTTP Bearer

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

@@ -1,1 +0,18 @@
    8      8   
license = "Apache-2.0"
    9      9   
repository = "https://github.com/smithy-lang/smithy-rs"
   10     10   
[package.metadata.docs.rs]
   11     11   
all-features = true
   12     12   
targets = ["x86_64-unknown-linux-gnu"]
   13     13   
cargo-args = ["-Zunstable-options", "-Zrustdoc-scrape-examples"]
   14     14   
rustdoc-args = ["--cfg", "docsrs"]
   15     15   
[dependencies.aws-runtime]
   16     16   
path = "../aws-runtime"
   17     17   
features = ["http-02x"]
   18         -
version = "1.5.9"
          18  +
version = "1.5.10"

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

@@ -1,1 +65,65 @@
    1      1   
# Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
    2      2   
[package]
    3      3   
name = "aws-runtime"
    4         -
version = "1.5.9"
           4  +
version = "1.5.10"
    5      5   
authors = ["AWS Rust SDK Team <aws-sdk-rust@amazon.com>"]
    6      6   
description = "Runtime support code for the AWS SDK. This crate isn't intended to be used directly."
    7      7   
edition = "2021"
    8      8   
license = "Apache-2.0"
    9      9   
repository = "https://github.com/smithy-lang/smithy-rs"
   10     10   
[package.metadata.docs.rs]
   11     11   
all-features = true
   12     12   
targets = ["x86_64-unknown-linux-gnu"]
   13     13   
cargo-args = ["-Zunstable-options", "-Zrustdoc-scrape-examples"]
   14     14   
rustdoc-args = ["--cfg", "docsrs"]
   15     15   
   16     16   
[package.metadata.smithy-rs-release-tooling]
   17     17   
stable = true
   18     18   
   19     19   
[features]
   20     20   
event-stream = ["dep:aws-smithy-eventstream", "aws-sigv4/sign-eventstream"]
   21     21   
http-02x = []
   22     22   
http-1x = ["dep:http-1x", "dep:http-body-1x"]
   23     23   
test-util = ["dep:regex-lite"]
   24     24   
sigv4a = ["aws-sigv4/sigv4a"]
   25     25   
   26     26   
[dependencies]
   27     27   
bytes = "1.10.0"
   28     28   
fastrand = "2.3.0"
   29     29   
percent-encoding = "2.3.1"
   30     30   
pin-project-lite = "0.2.14"
   31     31   
tracing = "0.1.40"
   32     32   
   33     33   
[dependencies.aws-credential-types]
   34     34   
path = "../aws-credential-types"
   35         -
version = "1.2.4"
          35  +
version = "1.2.5"
   36     36   
   37     37   
[dependencies.aws-sigv4]
   38     38   
path = "../aws-sigv4"
   39     39   
features = ["http0-compat"]
   40     40   
version = "1.3.3"
   41     41   
   42     42   
[dependencies.aws-smithy-async]
   43     43   
path = "../aws-smithy-async"
   44     44   
version = "1.2.5"
   45     45
@@ -79,79 +139,139 @@
   99     99   
arbitrary = "1.3"
  100    100   
bytes-utils = "0.1.2"
  101    101   
convert_case = "0.6.0"
  102    102   
proptest = "1.2"
  103    103   
serde_json = "1"
  104    104   
tracing-test = "0.2.4"
  105    105   
  106    106   
[dev-dependencies.aws-credential-types]
  107    107   
path = "../aws-credential-types"
  108    108   
features = ["test-util"]
  109         -
version = "1.2.4"
         109  +
version = "1.2.5"
  110    110   
  111    111   
[dev-dependencies.aws-smithy-async]
  112    112   
path = "../aws-smithy-async"
  113    113   
features = ["test-util"]
  114    114   
version = "1.2.5"
  115    115   
  116    116   
[dev-dependencies.aws-smithy-protocol-test]
  117    117   
path = "../aws-smithy-protocol-test"
  118    118   
version = "0.63.4"
  119    119

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

@@ -1,1 +18,21 @@
    1      1   
/*
    2      2   
 * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
    3      3   
 * SPDX-License-Identifier: Apache-2.0
    4      4   
 */
    5      5   
           6  +
/// Note: This code originally lived in the `aws-runtime` crate. It was moved here to avoid circular dependencies
           7  +
/// This module is re-exported in `aws-runtime`, and so even though this is a pre-1.0 crate, this module should not
           8  +
/// have any breaking changes
    6      9   
use aws_smithy_types::config_bag::{Storable, StoreAppend};
    7     10   
    8     11   
/// IDs for the features that may be used in the AWS SDK
    9     12   
#[non_exhaustive]
   10     13   
#[derive(Clone, Debug, Eq, PartialEq)]
   11     14   
pub enum AwsSdkFeature {
   12     15   
    /// Indicates that an operation was called by the S3 Transfer Manager
   13     16   
    S3Transfer,
   14     17   
}
   15     18

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

@@ -1,1 +40,41 @@
    1      1   
/*
    2      2   
 * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
    3      3   
 * SPDX-License-Identifier: Apache-2.0
    4      4   
 */
    5      5   
    6      6   
use std::borrow::Cow;
    7      7   
use std::fmt;
    8      8   
    9      9   
use http_02x::header::{HeaderName, HeaderValue, InvalidHeaderValue, USER_AGENT};
   10     10   
          11  +
use aws_credential_types::credential_feature::AwsCredentialFeature;
   11     12   
use aws_smithy_runtime::client::sdk_feature::SmithySdkFeature;
   12     13   
use aws_smithy_runtime_api::box_error::BoxError;
   13     14   
use aws_smithy_runtime_api::client::http::HttpClient;
   14     15   
use aws_smithy_runtime_api::client::interceptors::context::{
   15     16   
    BeforeTransmitInterceptorContextMut, BeforeTransmitInterceptorContextRef,
   16     17   
};
   17     18   
use aws_smithy_runtime_api::client::interceptors::Intercept;
   18     19   
use aws_smithy_runtime_api::client::runtime_components::RuntimeComponents;
   19     20   
use aws_smithy_types::config_bag::ConfigBag;
   20     21   
use aws_types::app_name::AppName;
@@ -119,120 +178,186 @@
  139    140   
                .map(|m| ua.add_business_metric(m));
  140    141   
        }
  141    142   
  142    143   
        let aws_sdk_features = cfg.load::<AwsSdkFeature>();
  143    144   
        for aws_sdk_feature in aws_sdk_features {
  144    145   
            aws_sdk_feature
  145    146   
                .provide_business_metric()
  146    147   
                .map(|m| ua.add_business_metric(m));
  147    148   
        }
  148    149   
         150  +
        let aws_credential_features = cfg.load::<AwsCredentialFeature>();
         151  +
        for aws_credential_feature in aws_credential_features {
         152  +
            aws_credential_feature
         153  +
                .provide_business_metric()
         154  +
                .map(|m| ua.add_business_metric(m));
         155  +
        }
         156  +
  149    157   
        let maybe_connector_metadata = runtime_components
  150    158   
            .http_client()
  151    159   
            .and_then(|c| c.connector_metadata());
  152    160   
        if let Some(connector_metadata) = maybe_connector_metadata {
  153    161   
            let am = AdditionalMetadata::new(Cow::Owned(connector_metadata.to_string()))?;
  154    162   
            ua.add_additional_metadata(am);
  155    163   
        }
  156    164   
  157    165   
        let headers = context.request_mut().headers_mut();
  158    166   
        let (user_agent, x_amz_user_agent) = header_values(&ua)?;

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

@@ -1,1 +36,37 @@
    1      1   
/*
    2      2   
 * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
    3      3   
 * SPDX-License-Identifier: Apache-2.0
    4      4   
 */
    5      5   
    6      6   
use crate::sdk_feature::AwsSdkFeature;
           7  +
use aws_credential_types::credential_feature::AwsCredentialFeature;
    7      8   
use aws_smithy_runtime::client::sdk_feature::SmithySdkFeature;
    8      9   
use std::borrow::Cow;
    9     10   
use std::collections::HashMap;
   10     11   
use std::fmt;
   11     12   
use std::sync::LazyLock;
   12     13   
   13     14   
const MAX_COMMA_SEPARATED_METRICS_VALUES_LENGTH: usize = 1024;
   14     15   
#[allow(dead_code)]
   15     16   
const MAX_METRICS_ID_NUMBER: usize = 350;
   16     17
@@ -109,110 +225,294 @@
  129    130   
    Sigv4aSigning,
  130    131   
    ResolvedAccountId,
  131    132   
    FlexibleChecksumsReqCrc32,
  132    133   
    FlexibleChecksumsReqCrc32c,
  133    134   
    FlexibleChecksumsReqCrc64,
  134    135   
    FlexibleChecksumsReqSha1,
  135    136   
    FlexibleChecksumsReqSha256,
  136    137   
    FlexibleChecksumsReqWhenSupported,
  137    138   
    FlexibleChecksumsReqWhenRequired,
  138    139   
    FlexibleChecksumsResWhenSupported,
  139         -
    FlexibleChecksumsResWhenRequired
         140  +
    FlexibleChecksumsResWhenRequired,
         141  +
    DdbMapper,
         142  +
    CredentialsCode,
         143  +
    CredentialsJvmSystemProperties,
         144  +
    CredentialsEnvVars,
         145  +
    CredentialsEnvVarsStsWebIdToken,
         146  +
    CredentialsStsAssumeRole,
         147  +
    CredentialsStsAssumeRoleSaml,
         148  +
    CredentialsStsAssumeRoleWebId,
         149  +
    CredentialsStsFederationToken,
         150  +
    CredentialsStsSessionToken,
         151  +
    CredentialsProfile,
         152  +
    CredentialsProfileSourceProfile,
         153  +
    CredentialsProfileNamedProvider,
         154  +
    CredentialsProfileStsWebIdToken,
         155  +
    CredentialsProfileSso,
         156  +
    CredentialsSso,
         157  +
    CredentialsProfileSsoLegacy,
         158  +
    CredentialsSsoLegacy,
         159  +
    CredentialsProfileProcess,
         160  +
    CredentialsProcess,
         161  +
    CredentialsBoto2ConfigFile,
         162  +
    CredentialsAwsSdkStore,
         163  +
    CredentialsHttp,
         164  +
    CredentialsImds
  140    165   
);
  141    166   
  142    167   
pub(crate) trait ProvideBusinessMetric {
  143    168   
    fn provide_business_metric(&self) -> Option<BusinessMetric>;
  144    169   
}
  145    170   
  146    171   
impl ProvideBusinessMetric for SmithySdkFeature {
  147    172   
    fn provide_business_metric(&self) -> Option<BusinessMetric> {
  148    173   
        use SmithySdkFeature::*;
  149    174   
        match self {
  150    175   
            Waiter => Some(BusinessMetric::Waiter),
  151    176   
            Paginator => Some(BusinessMetric::Paginator),
  152    177   
            GzipRequestCompression => Some(BusinessMetric::GzipRequestCompression),
  153    178   
            ProtocolRpcV2Cbor => Some(BusinessMetric::ProtocolRpcV2Cbor),
  154    179   
            RetryModeStandard => Some(BusinessMetric::RetryModeStandard),
  155    180   
            RetryModeAdaptive => Some(BusinessMetric::RetryModeAdaptive),
  156    181   
            FlexibleChecksumsReqCrc32 => Some(BusinessMetric::FlexibleChecksumsReqCrc32),
  157    182   
            FlexibleChecksumsReqCrc32c => Some(BusinessMetric::FlexibleChecksumsReqCrc32c),
  158    183   
            FlexibleChecksumsReqCrc64 => Some(BusinessMetric::FlexibleChecksumsReqCrc64),
  159    184   
            FlexibleChecksumsReqSha1 => Some(BusinessMetric::FlexibleChecksumsReqSha1),
  160    185   
            FlexibleChecksumsReqSha256 => Some(BusinessMetric::FlexibleChecksumsReqSha256),
  161    186   
            FlexibleChecksumsReqWhenSupported => {
  162    187   
                Some(BusinessMetric::FlexibleChecksumsReqWhenSupported)
  163    188   
            }
  164    189   
            FlexibleChecksumsReqWhenRequired => {
  165    190   
                Some(BusinessMetric::FlexibleChecksumsReqWhenRequired)
  166    191   
            }
  167    192   
            FlexibleChecksumsResWhenSupported => {
  168    193   
                Some(BusinessMetric::FlexibleChecksumsResWhenSupported)
  169    194   
            }
  170    195   
            FlexibleChecksumsResWhenRequired => {
  171    196   
                Some(BusinessMetric::FlexibleChecksumsResWhenRequired)
  172    197   
            }
  173    198   
            otherwise => {
  174    199   
                // This may occur if a customer upgrades only the `aws-smithy-runtime-api` crate
  175    200   
                // while continuing to use an outdated version of an SDK crate or the `aws-runtime`
  176    201   
                // crate.
  177    202   
                tracing::warn!(
  178    203   
                    "Attempted to provide `BusinessMetric` for `{otherwise:?}`, which is not recognized in the current version of the `aws-runtime` crate. \
  179    204   
                    Consider upgrading to the latest version to ensure that all tracked features are properly reported in your metrics."
  180    205   
                );
  181    206   
                None
  182    207   
            }
  183    208   
        }
  184    209   
    }
  185    210   
}
  186    211   
  187    212   
impl ProvideBusinessMetric for AwsSdkFeature {
  188    213   
    fn provide_business_metric(&self) -> Option<BusinessMetric> {
  189    214   
        use AwsSdkFeature::*;
  190    215   
        match self {
  191    216   
            S3Transfer => Some(BusinessMetric::S3Transfer),
  192    217   
        }
  193    218   
    }
  194    219   
}
  195    220   
         221  +
impl ProvideBusinessMetric for AwsCredentialFeature {
         222  +
    fn provide_business_metric(&self) -> Option<BusinessMetric> {
         223  +
        use AwsCredentialFeature::*;
         224  +
        match self {
         225  +
            CredentialsCode => Some(BusinessMetric::CredentialsCode),
         226  +
            CredentialsEnvVars => Some(BusinessMetric::CredentialsEnvVars),
         227  +
            CredentialsEnvVarsStsWebIdToken => {
         228  +
                Some(BusinessMetric::CredentialsEnvVarsStsWebIdToken)
         229  +
            }
         230  +
            CredentialsStsAssumeRole => Some(BusinessMetric::CredentialsStsAssumeRole),
         231  +
            CredentialsStsAssumeRoleSaml => Some(BusinessMetric::CredentialsStsAssumeRoleSaml),
         232  +
            CredentialsStsAssumeRoleWebId => Some(BusinessMetric::CredentialsStsAssumeRoleWebId),
         233  +
            CredentialsStsFederationToken => Some(BusinessMetric::CredentialsStsFederationToken),
         234  +
            CredentialsStsSessionToken => Some(BusinessMetric::CredentialsStsSessionToken),
         235  +
            CredentialsProfile => Some(BusinessMetric::CredentialsProfile),
         236  +
            CredentialsProfileSourceProfile => {
         237  +
                Some(BusinessMetric::CredentialsProfileSourceProfile)
         238  +
            }
         239  +
            CredentialsProfileNamedProvider => {
         240  +
                Some(BusinessMetric::CredentialsProfileNamedProvider)
         241  +
            }
         242  +
            CredentialsProfileStsWebIdToken => {
         243  +
                Some(BusinessMetric::CredentialsProfileStsWebIdToken)
         244  +
            }
         245  +
            CredentialsProfileSso => Some(BusinessMetric::CredentialsProfileSso),
         246  +
            CredentialsSso => Some(BusinessMetric::CredentialsSso),
         247  +
            CredentialsProfileProcess => Some(BusinessMetric::CredentialsProfileProcess),
         248  +
            CredentialsProcess => Some(BusinessMetric::CredentialsProcess),
         249  +
            CredentialsHttp => Some(BusinessMetric::CredentialsHttp),
         250  +
            CredentialsImds => Some(BusinessMetric::CredentialsImds),
         251  +
            otherwise => {
         252  +
                // This may occur if a customer upgrades only the `aws-smithy-runtime-api` crate
         253  +
                // while continuing to use an outdated version of an SDK crate or the `aws-credential-types`
         254  +
                // crate.
         255  +
                tracing::warn!(
         256  +
                    "Attempted to provide `BusinessMetric` for `{otherwise:?}`, which is not recognized in the current version of the `aws-runtime` crate. \
         257  +
                    Consider upgrading to the latest version to ensure that all tracked features are properly reported in your metrics."
         258  +
                );
         259  +
                None
         260  +
            }
         261  +
        }
         262  +
    }
         263  +
}
         264  +
  196    265   
#[derive(Clone, Debug, Default)]
  197    266   
pub(super) struct BusinessMetrics(Vec<BusinessMetric>);
  198    267   
  199    268   
impl BusinessMetrics {
  200    269   
    pub(super) fn push(&mut self, metric: BusinessMetric) {
  201    270   
        self.0.push(metric);
  202    271   
    }
  203    272   
  204    273   
    pub(super) fn is_empty(&self) -> bool {
  205    274   
        self.0.is_empty()
@@ -270,339 +330,424 @@
  290    359   
  "SIGV4A_SIGNING": "S",
  291    360   
  "RESOLVED_ACCOUNT_ID": "T",
  292    361   
  "FLEXIBLE_CHECKSUMS_REQ_CRC32" : "U",
  293    362   
  "FLEXIBLE_CHECKSUMS_REQ_CRC32C" : "V",
  294    363   
  "FLEXIBLE_CHECKSUMS_REQ_CRC64" : "W",
  295    364   
  "FLEXIBLE_CHECKSUMS_REQ_SHA1" : "X",
  296    365   
  "FLEXIBLE_CHECKSUMS_REQ_SHA256" : "Y",
  297    366   
  "FLEXIBLE_CHECKSUMS_REQ_WHEN_SUPPORTED" : "Z",
  298    367   
  "FLEXIBLE_CHECKSUMS_REQ_WHEN_REQUIRED" : "a",
  299    368   
  "FLEXIBLE_CHECKSUMS_RES_WHEN_SUPPORTED" : "b",
  300         -
  "FLEXIBLE_CHECKSUMS_RES_WHEN_REQUIRED" : "c"
         369  +
  "FLEXIBLE_CHECKSUMS_RES_WHEN_REQUIRED" : "c",
         370  +
  "DDB_MAPPER" : "d",
         371  +
  "CREDENTIALS_CODE" : "e",
         372  +
  "CREDENTIALS_JVM_SYSTEM_PROPERTIES" : "f",
         373  +
  "CREDENTIALS_ENV_VARS" : "g",
         374  +
  "CREDENTIALS_ENV_VARS_STS_WEB_ID_TOKEN" : "h",
         375  +
  "CREDENTIALS_STS_ASSUME_ROLE" : "i",
         376  +
  "CREDENTIALS_STS_ASSUME_ROLE_SAML" : "j",
         377  +
  "CREDENTIALS_STS_ASSUME_ROLE_WEB_ID" : "k",
         378  +
  "CREDENTIALS_STS_FEDERATION_TOKEN" : "l",
         379  +
  "CREDENTIALS_STS_SESSION_TOKEN" : "m",
         380  +
  "CREDENTIALS_PROFILE" : "n",
         381  +
  "CREDENTIALS_PROFILE_SOURCE_PROFILE" : "o",
         382  +
  "CREDENTIALS_PROFILE_NAMED_PROVIDER" : "p",
         383  +
  "CREDENTIALS_PROFILE_STS_WEB_ID_TOKEN" : "q",
         384  +
  "CREDENTIALS_PROFILE_SSO" : "r",
         385  +
  "CREDENTIALS_SSO" : "s",
         386  +
  "CREDENTIALS_PROFILE_SSO_LEGACY" : "t",
         387  +
  "CREDENTIALS_SSO_LEGACY" : "u",
         388  +
  "CREDENTIALS_PROFILE_PROCESS" : "v",
         389  +
  "CREDENTIALS_PROCESS" : "w",
         390  +
  "CREDENTIALS_BOTO2_CONFIG_FILE" : "x",
         391  +
  "CREDENTIALS_AWS_SDK_STORE" : "y",
         392  +
  "CREDENTIALS_HTTP" : "z",
         393  +
  "CREDENTIALS_IMDS" : "0"
         394  +
  301    395   
}
  302    396   
        "#;
  303    397   
  304    398   
        let expected: HashMap<&str, &str> = serde_json::from_str(EXPECTED).unwrap();
  305    399   
        assert_eq!(expected.len(), FEATURE_ID_TO_METRIC_VALUE.len());
  306    400   
  307    401   
        for (feature_id, metric_value) in &*FEATURE_ID_TO_METRIC_VALUE {
  308    402   
            let expected = expected.get(format!("{feature_id}").as_str());
  309    403   
            assert_eq!(
  310    404   
                expected.unwrap_or_else(|| panic!("Expected {feature_id} to have value `{metric_value}` but it was `{expected:?}` instead.")),

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

@@ -17,17 +77,77 @@
   37     37   
[dependencies]
   38     38   
bytes = "1.10.0"
   39     39   
hex = "0.4.3"
   40     40   
hmac = "0.12"
   41     41   
sha2 = "0.10"
   42     42   
time = "0.3.5"
   43     43   
tracing = "0.1.40"
   44     44   
   45     45   
[dependencies.aws-credential-types]
   46     46   
path = "../aws-credential-types"
   47         -
version = "1.2.4"
          47  +
version = "1.2.5"
   48     48   
   49     49   
[dependencies.aws-smithy-eventstream]
   50     50   
path = "../aws-smithy-eventstream"
   51     51   
optional = true
   52     52   
version = "0.60.10"
   53     53   
   54     54   
[dependencies.aws-smithy-http]
   55     55   
path = "../aws-smithy-http"
   56     56   
version = "0.62.2"
   57     57
@@ -89,89 +130,130 @@
  109    109   
pretty_assertions = "1.3"
  110    110   
proptest = "1.2"
  111    111   
serde = "1.0.180"
  112    112   
serde_derive = "1.0.180"
  113    113   
serde_json = "1.0.104"
  114    114   
criterion = "0.5"
  115    115   
  116    116   
[dev-dependencies.aws-credential-types]
  117    117   
path = "../aws-credential-types"
  118    118   
features = ["test-util", "hardcoded-credentials"]
  119         -
version = "1.2.4"
         119  +
version = "1.2.5"
  120    120   
  121    121   
[dev-dependencies.aws-smithy-runtime-api]
  122    122   
path = "../aws-smithy-runtime-api"
  123    123   
features = ["client", "test-util"]
  124    124   
version = "1.8.4"
  125    125   
  126    126   
[dev-dependencies.time]
  127    127   
version = "0.3.5"
  128    128   
features = ["parsing"]
  129    129   
[target."cfg(not(any(target_arch = \"powerpc\", target_arch = \"powerpc64\")))".dev-dependencies]

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

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

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

@@ -1,1 +48,48 @@
    8      8   
use aws_smithy_runtime_api::box_error::BoxError;
    9      9   
use aws_smithy_runtime_api::client::auth::{
   10     10   
    AuthScheme, AuthSchemeEndpointConfig, AuthSchemeId, AuthSchemeOption,
   11     11   
    AuthSchemeOptionResolverParams, AuthSchemePreference, ResolveAuthSchemeOptions,
   12     12   
};
   13     13   
use aws_smithy_runtime_api::client::endpoint::{EndpointResolverParams, ResolveEndpoint};
   14     14   
use aws_smithy_runtime_api::client::identity::{Identity, ResolveIdentity};
   15     15   
use aws_smithy_runtime_api::client::identity::{IdentityCacheLocation, ResolveCachedIdentity};
   16     16   
use aws_smithy_runtime_api::client::interceptors::context::InterceptorContext;
   17     17   
use aws_smithy_runtime_api::client::runtime_components::RuntimeComponents;
   18         -
use aws_smithy_types::config_bag::{ConfigBag, Storable, StoreReplace};
          18  +
use aws_smithy_types::config_bag::{ConfigBag, FrozenLayer, Storable, StoreReplace};
   19     19   
use aws_smithy_types::endpoint::Endpoint;
   20     20   
use aws_smithy_types::Document;
   21     21   
use std::borrow::Cow;
   22     22   
use std::collections::HashMap;
   23     23   
use std::error::Error as StdError;
   24     24   
use std::fmt;
   25     25   
use tracing::trace;
   26     26   
   27     27   
#[derive(Debug)]
   28     28   
struct NoMatchingAuthSchemeError(ExploredList);
@@ -135,135 +194,199 @@
  155    155   
                            IdentityCache::no_cache()
  156    156   
                        };
  157    157   
                        // Apply properties from the selected auth scheme option
  158    158   
                        if let Some(properties) = auth_scheme_option.properties() {
  159    159   
                            cfg.push_shared_layer(properties);
  160    160   
                        }
  161    161   
                        let identity = identity_cache
  162    162   
                            .resolve_cached_identity(identity_resolver, runtime_components, cfg)
  163    163   
                            .await?;
  164    164   
                        trace!(identity = ?identity, "resolved identity");
         165  +
                        // Extract the FrozenLayer placed in the Identity property bag by the From<Credentials> impl.
         166  +
                        // This layer contains feature data for the user agent and potentially other metadata.
         167  +
                        if let Some(layer) = identity.property::<FrozenLayer>().cloned() {
         168  +
                            cfg.push_shared_layer(layer);
         169  +
                        }
  165    170   
                        return Ok((scheme_id.clone(), identity, endpoint));
  166    171   
                    }
  167    172   
                    Err(AuthOrchestrationError::MissingEndpointConfig) => {
  168    173   
                        explored.push(scheme_id.clone(), ExploreResult::MissingEndpointConfig);
  169    174   
                        continue;
  170    175   
                    }
  171    176   
                    Err(AuthOrchestrationError::FailedToResolveEndpoint(source)) => {
  172    177   
                        // Some negative endpoint tests expect an endpoint resolution error,
  173    178   
                        // so we need to return it to satisfy them.
  174    179   
                        return Err(source);

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

@@ -1,1 +59,59 @@
   19     19   
normal = ["aws-smithy-runtime", "hyper-rustls"]
   20     20   
   21     21   
[features]
   22     22   
examples = ["dep:hyper-rustls", "aws-smithy-runtime/client", "aws-smithy-runtime/connector-hyper-0-14-x", "aws-smithy-runtime/tls-rustls"]
   23     23   
   24     24   
[dependencies]
   25     25   
tracing = "0.1.40"
   26     26   
   27     27   
[dependencies.aws-credential-types]
   28     28   
path = "../aws-credential-types"
   29         -
version = "1.2.4"
          29  +
version = "1.2.5"
   30     30   
   31     31   
[dependencies.aws-smithy-async]
   32     32   
path = "../aws-smithy-async"
   33     33   
version = "1.2.5"
   34     34   
   35     35   
[dependencies.aws-smithy-types]
   36     36   
path = "../aws-smithy-types"
   37     37   
version = "1.3.2"
   38     38   
   39     39   
[dependencies.aws-smithy-runtime]

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

@@ -1,1 +95,95 @@
    9      9   
repository = "https://github.com/awslabs/aws-sdk-rust"
   10     10   
rust-version = "1.86.0"
   11     11   
readme = "README.md"
   12     12   
[package.metadata.smithy]
   13     13   
codegen-version = "ci"
   14     14   
[package.metadata.docs.rs]
   15     15   
all-features = true
   16     16   
targets = ["x86_64-unknown-linux-gnu"]
   17     17   
[dependencies.aws-credential-types]
   18     18   
path = "../aws-credential-types"
   19         -
version = "1.2.4"
          19  +
version = "1.2.5"
   20     20   
   21     21   
[dependencies.aws-runtime]
   22     22   
path = "../aws-runtime"
   23     23   
features = ["event-stream"]
   24         -
version = "1.5.9"
          24  +
version = "1.5.10"
   25     25   
   26     26   
[dependencies.aws-smithy-async]
   27     27   
path = "../aws-smithy-async"
   28     28   
version = "1.2.5"
   29     29   
   30     30   
[dependencies.aws-smithy-eventstream]
   31     31   
path = "../aws-smithy-eventstream"
   32     32   
version = "0.60.10"
   33     33   
   34     34   
[dependencies.aws-smithy-http]
   35     35   
path = "../aws-smithy-http"
   36     36   
features = ["event-stream"]
   37     37   
version = "0.62.2"
   38     38   
   39     39   
[dependencies.aws-smithy-json]
   40     40   
path = "../aws-smithy-json"
   41     41   
version = "0.61.4"
   42     42   
   43     43   
[dependencies.aws-smithy-runtime]
   44     44   
path = "../aws-smithy-runtime"
   45     45   
features = ["client"]
   46     46   
version = "1.8.5"
   47     47   
   48     48   
[dependencies.aws-smithy-runtime-api]
   49     49   
path = "../aws-smithy-runtime-api"
   50     50   
features = ["client", "http-02x"]
   51     51   
version = "1.8.4"
   52     52   
   53     53   
[dependencies.aws-smithy-types]
   54     54   
path = "../aws-smithy-types"
   55     55   
version = "1.3.2"
   56     56   
   57     57   
[dependencies.aws-types]
   58     58   
path = "../aws-types"
   59     59   
version = "1.3.8"
   60     60   
   61     61   
[dependencies.bytes]
   62     62   
version = "1.4.0"
   63     63   
   64     64   
[dependencies.fastrand]
   65     65   
version = "2.0.0"
   66     66   
   67     67   
[dependencies.http]
   68     68   
version = "0.2.9"
   69     69   
   70     70   
[dependencies.regex-lite]
   71     71   
version = "0.1.5"
   72     72   
   73     73   
[dependencies.tracing]
   74     74   
version = "0.1"
   75     75   
[dev-dependencies.aws-config]
   76     76   
path = "../aws-config"
   77     77   
version = "1.8.3"
   78     78   
   79     79   
[dev-dependencies.aws-credential-types]
   80     80   
path = "../aws-credential-types"
   81     81   
features = ["test-util"]
   82         -
version = "1.2.4"
          82  +
version = "1.2.5"
   83     83   
   84     84   
[dev-dependencies.tokio]
   85     85   
version = "1.23.1"
   86     86   
features = ["macros", "test-util", "rt-multi-thread"]
   87     87   
   88     88   
[features]
   89     89   
behavior-version-latest = []
   90     90   
rustls = ["aws-smithy-runtime/tls-rustls"]
   91     91   
default-https-client = ["aws-smithy-runtime/default-https-client"]
   92     92   
rt-tokio = ["aws-smithy-async/rt-tokio", "aws-smithy-types/rt-tokio"]