Unverified Commit fbeaab9d authored by John DiSanti's avatar John DiSanti Committed by GitHub
Browse files

Remove `get`/`put` methods from `ConfigBag` and `Layer` (#2807) 

This PR removes the non-storable `get`/`put` methods from `ConfigBag`
and `Layer`.

----

_By submitting this pull request, I confirm that you can use, modify,
copy, and redistribute this contribution, under the terms of your
choice._
parent bb8e19a4

aws/rust-runtime/aws-http/src/user_agent.rs

+9 −0
Original line number Diff line number Diff line
@@ -5,6 +5,7 @@ 


use aws_smithy_http::middleware::MapRequest;

use aws_smithy_http::operation::Request;

use aws_smithy_types::config_bag::{Storable, StoreReplace};

use aws_types::app_name::AppName;

use aws_types::build_metadata::{OsFamily, BUILD_METADATA};

use aws_types::os_shim_internal::Env;
@@ -211,6 +212,10 @@ impl AwsUserAgent { 
    }

}



impl Storable for AwsUserAgent {

    type Storer = StoreReplace<Self>;

}



#[derive(Clone, Copy, Debug)]

struct SdkMetadata {

    name: &'static str,
@@ -246,6 +251,10 @@ impl fmt::Display for ApiMetadata { 
    }

}



impl Storable for ApiMetadata {

    type Storer = StoreReplace<Self>;

}



/// Error for when an user agent metadata doesn't meet character requirements.

///

/// Metadata may only have alphanumeric characters and any of these characters:

aws/rust-runtime/aws-inlineable/src/glacier_interceptors.rs

+3 −3
Original line number Diff line number Diff line
@@ -130,18 +130,18 @@ impl Interceptor for GlacierTreeHashHeaderInterceptor { 
        context: &mut BeforeTransmitInterceptorContextMut<'_>,

        cfg: &mut ConfigBag,

    ) -> Result<(), BoxError> {

        let maybe_loaded_body = cfg.get::<LoadedRequestBody>();

        let maybe_loaded_body = cfg.load::<LoadedRequestBody>();

        if let Some(LoadedRequestBody::Loaded(body)) = maybe_loaded_body {

            let content_sha256 = add_checksum_treehash(context.request_mut(), body)?;



            // Override the signing payload with this precomputed hash

            let mut signing_config = cfg

                .get::<SigV4OperationSigningConfig>()

                .load::<SigV4OperationSigningConfig>()

                .ok_or("SigV4OperationSigningConfig not found")?

                .clone();

            signing_config.signing_options.payload_override =

                Some(SignableBody::Precomputed(content_sha256));

            cfg.interceptor_state().put(signing_config);

            cfg.interceptor_state().store_put(signing_config);

        } else {

            return Err(

                "the request body wasn't loaded into memory before the retry loop, \

aws/rust-runtime/aws-inlineable/src/http_request_checksum.rs

+2 −5
Original line number Diff line number Diff line
@@ -132,13 +132,10 @@ fn add_checksum_for_request_body( 
        // Body is streaming: wrap the body so it will emit a checksum as a trailer.

        None => {

            tracing::debug!("applying {checksum_algorithm:?} of the request body as a trailer");

            if let Some(mut signing_config) = cfg.get::<SigV4OperationSigningConfig>().cloned() {

            if let Some(mut signing_config) = cfg.load::<SigV4OperationSigningConfig>().cloned() {

                signing_config.signing_options.payload_override =

                    Some(SignableBody::StreamingUnsignedPayloadTrailer);



                let mut layer = Layer::new("http_body_checksum_sigv4_payload_override");

                layer.put(signing_config);

                cfg.push_layer(layer);

                cfg.interceptor_state().store_put(signing_config);

            }

            wrap_streaming_request_body_in_checksum_calculating_body(request, checksum_algorithm)?;

        }

aws/rust-runtime/aws-inlineable/src/presigning_interceptors.rs

+13 −11
Original line number Diff line number Diff line
@@ -22,6 +22,7 @@ use aws_smithy_runtime_api::client::interceptors::{ 
    disable_interceptor, Interceptor, InterceptorRegistrar, SharedInterceptor,

};

use aws_smithy_runtime_api::client::orchestrator::ConfigBagAccessors;

use aws_smithy_runtime_api::client::retries::DynRetryStrategy;

use aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin;

use aws_smithy_types::config_bag::{ConfigBag, FrozenLayer, Layer};
@@ -48,7 +49,8 @@ impl Interceptor for SigV4PresigningInterceptor { 
        _context: &mut BeforeSerializationInterceptorContextMut<'_>,

        cfg: &mut ConfigBag,

    ) -> Result<(), BoxError> {

        cfg.interceptor_state().put::<HeaderSerializationSettings>(

        cfg.interceptor_state()

            .store_put::<HeaderSerializationSettings>(

                HeaderSerializationSettings::new()

                    .omit_default_content_length()

                    .omit_default_content_type(),
@@ -65,12 +67,12 @@ impl Interceptor for SigV4PresigningInterceptor { 
        _context: &mut BeforeTransmitInterceptorContextMut<'_>,

        cfg: &mut ConfigBag,

    ) -> Result<(), BoxError> {

        if let Some(mut config) = cfg.get::<SigV4OperationSigningConfig>().cloned() {

        if let Some(mut config) = cfg.load::<SigV4OperationSigningConfig>().cloned() {

            config.signing_options.expires_in = Some(self.config.expires());

            config.signing_options.signature_type = HttpSignatureType::HttpRequestQueryParams;

            config.signing_options.payload_override = Some(self.payload_override.clone());

            cfg.interceptor_state()

                .put::<SigV4OperationSigningConfig>(config);

                .store_put::<SigV4OperationSigningConfig>(config);

            Ok(())

        } else {

            Err(
@@ -101,10 +103,10 @@ impl SigV4PresigningRuntimePlugin { 
impl RuntimePlugin for SigV4PresigningRuntimePlugin {

    fn config(&self) -> Option<FrozenLayer> {

        let mut layer = Layer::new("Presigning");

        layer.set_retry_strategy(NeverRetryStrategy::new());

        layer.put(disable_interceptor::<InvocationIdInterceptor>("presigning"));

        layer.put(disable_interceptor::<RequestInfoInterceptor>("presigning"));

        layer.put(disable_interceptor::<UserAgentInterceptor>("presigning"));

        layer.set_retry_strategy(DynRetryStrategy::new(NeverRetryStrategy::new()));

        layer.store_put(disable_interceptor::<InvocationIdInterceptor>("presigning"));

        layer.store_put(disable_interceptor::<RequestInfoInterceptor>("presigning"));

        layer.store_put(disable_interceptor::<UserAgentInterceptor>("presigning"));

        Some(layer.freeze())

    }

aws/rust-runtime/aws-runtime/src/auth/sigv4.rs

+11 −7
Original line number Diff line number Diff line
@@ -14,7 +14,7 @@ use aws_smithy_runtime_api::client::auth::{ 
};

use aws_smithy_runtime_api::client::identity::{Identity, IdentityResolver, IdentityResolvers};

use aws_smithy_runtime_api::client::orchestrator::{ConfigBagAccessors, HttpRequest};

use aws_smithy_types::config_bag::ConfigBag;

use aws_smithy_types::config_bag::{ConfigBag, Storable, StoreReplace};

use aws_smithy_types::Document;

use aws_types::region::{Region, SigningRegion};

use aws_types::SigningService;
@@ -169,6 +169,10 @@ pub struct SigV4OperationSigningConfig { 
    pub signing_options: SigningOptions,

}



impl Storable for SigV4OperationSigningConfig {

    type Storer = StoreReplace<Self>;

}



/// SigV4 HTTP request signer.

#[derive(Debug, Default)]

pub struct SigV4HttpRequestSigner;
@@ -253,11 +257,11 @@ impl SigV4HttpRequestSigner { 
        config_bag: &'a ConfigBag,

    ) -> Result<Cow<'a, SigV4OperationSigningConfig>, SigV4SigningError> {

        let operation_config = config_bag

            .get::<SigV4OperationSigningConfig>()

            .load::<SigV4OperationSigningConfig>()

            .ok_or(SigV4SigningError::MissingOperationSigningConfig)?;



        let signing_region = config_bag.get::<SigningRegion>();

        let signing_service = config_bag.get::<SigningService>();

        let signing_region = config_bag.load::<SigningRegion>();

        let signing_service = config_bag.load::<SigningService>();



        let EndpointAuthSchemeConfig {

            signing_region_override,
@@ -365,7 +369,7 @@ impl HttpRequestSigner for SigV4HttpRequestSigner { 
            use aws_smithy_eventstream::frame::DeferredSignerSender;

            use event_stream::SigV4MessageSigner;



            if let Some(signer_sender) = config_bag.get::<DeferredSignerSender>() {

            if let Some(signer_sender) = config_bag.load::<DeferredSignerSender>() {

                let time_source = config_bag.request_time().unwrap_or_default();

                signer_sender

                    .send(Box::new(SigV4MessageSigner::new(
@@ -559,7 +563,7 @@ mod tests { 
    #[test]

    fn endpoint_config_overrides_region_and_service() {

        let mut layer = Layer::new("test");

        layer.put(SigV4OperationSigningConfig {

        layer.store_put(SigV4OperationSigningConfig {

            region: Some(SigningRegion::from(Region::new("override-this-region"))),

            service: Some(SigningService::from_static("override-this-service")),

            signing_options: Default::default(),
@@ -597,7 +601,7 @@ mod tests { 
    #[test]

    fn endpoint_config_supports_fallback_when_region_or_service_are_unset() {

        let mut layer = Layer::new("test");

        layer.put(SigV4OperationSigningConfig {

        layer.store_put(SigV4OperationSigningConfig {

            region: Some(SigningRegion::from(Region::new("us-east-1"))),

            service: Some(SigningService::from_static("qldb")),

            signing_options: Default::default(),