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._

Author: jdisanti

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

@@ -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

@@ -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

@@ -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

@@ -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,11 +49,12 @@ impl Interceptor for SigV4PresigningInterceptor {
         _context: &mut BeforeSerializationInterceptorContextMut<'_>,
         cfg: &mut ConfigBag,
     ) -> Result<(), BoxError> {
-        cfg.interceptor_state().put::<HeaderSerializationSettings>(
-            HeaderSerializationSettings::new()
-                .omit_default_content_length()
-                .omit_default_content_type(),
-        );
+        cfg.interceptor_state()
+            .store_put::<HeaderSerializationSettings>(
+                HeaderSerializationSettings::new()
+                    .omit_default_content_length()
+                    .omit_default_content_type(),
+            );
         cfg.interceptor_state()
             .set_request_time(SharedTimeSource::new(StaticTimeSource::new(
                 self.config.start_time(),
@@ -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

@@ -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(),

aws/rust-runtime/aws-runtime/src/invocation_id.rs

@@ -6,7 +6,7 @@
 use aws_smithy_runtime_api::box_error::BoxError;
 use aws_smithy_runtime_api::client::interceptors::context::BeforeTransmitInterceptorContextMut;
 use aws_smithy_runtime_api::client::interceptors::Interceptor;
-use aws_smithy_types::config_bag::ConfigBag;
+use aws_smithy_types::config_bag::{ConfigBag, Storable, StoreReplace};
 use http::{HeaderName, HeaderValue};
 use std::fmt::Debug;
 use uuid::Uuid;
@@ -24,6 +24,27 @@ pub trait InvocationIdGenerator: Debug + Send + Sync {
     fn generate(&self) -> Result<Option<InvocationId>, BoxError>;
 }
 
+/// Dynamic dispatch implementation of [`InvocationIdGenerator`]
+#[derive(Debug)]
+pub struct DynInvocationIdGenerator(Box<dyn InvocationIdGenerator>);
+
+impl DynInvocationIdGenerator {
+    /// Creates a new [`DynInvocationIdGenerator`].
+    pub fn new(gen: impl InvocationIdGenerator + 'static) -> Self {
+        Self(Box::new(gen))
+    }
+}
+
+impl InvocationIdGenerator for DynInvocationIdGenerator {
+    fn generate(&self) -> Result<Option<InvocationId>, BoxError> {
+        self.0.generate()
+    }
+}
+
+impl Storable for DynInvocationIdGenerator {
+    type Storer = StoreReplace<Self>;
+}
+
 /// This interceptor generates a UUID and attaches it to all request attempts made as part of this operation.
 #[non_exhaustive]
 #[derive(Debug, Default)]
@@ -43,12 +64,12 @@ impl Interceptor for InvocationIdInterceptor {
         cfg: &mut ConfigBag,
     ) -> Result<(), BoxError> {
         let id = cfg
-            .get::<Box<dyn InvocationIdGenerator>>()
+            .load::<DynInvocationIdGenerator>()
             .map(|gen| gen.generate())
             .transpose()?
             .flatten();
         cfg.interceptor_state()
-            .put::<InvocationId>(id.unwrap_or_default());
+            .store_put::<InvocationId>(id.unwrap_or_default());
 
         Ok(())
     }
@@ -60,7 +81,7 @@ impl Interceptor for InvocationIdInterceptor {
     ) -> Result<(), BoxError> {
         let headers = ctx.request_mut().headers_mut();
         let id = cfg
-            .get::<InvocationId>()
+            .load::<InvocationId>()
             .ok_or("Expected an InvocationId in the ConfigBag but none was present")?;
         headers.append(AMZ_SDK_INVOCATION_ID, id.0.clone());
         Ok(())
@@ -90,6 +111,10 @@ impl Default for InvocationId {
     }
 }
 
+impl Storable for InvocationId {
+    type Storer = StoreReplace<Self>;
+}
+
 #[cfg(feature = "test-util")]
 mod test_util {
     use super::*;
@@ -188,7 +213,7 @@ mod tests {
             .modify_before_transmit(&mut ctx, &mut cfg)
             .unwrap();
 
-        let expected = cfg.get::<InvocationId>().expect("invocation ID was set");
+        let expected = cfg.load::<InvocationId>().expect("invocation ID was set");
         let header = expect_header(&ctx, "amz-sdk-invocation-id");
         assert_eq!(expected.0, header, "the invocation ID in the config bag must match the invocation ID in the request header");
         // UUID should include 32 chars and 4 dashes

aws/rust-runtime/aws-runtime/src/request_info.rs

@@ -43,7 +43,7 @@ impl RequestInfoInterceptor {
         cfg: &ConfigBag,
     ) -> Option<(Cow<'static, str>, Cow<'static, str>)> {
         let request_attempts = cfg
-            .get::<RequestAttempts>()
+            .load::<RequestAttempts>()
             .map(|r_a| r_a.attempts())
             .unwrap_or(0);
         let request_attempts = request_attempts.to_string();
@@ -54,7 +54,7 @@ impl RequestInfoInterceptor {
         &self,
         cfg: &ConfigBag,
     ) -> Option<(Cow<'static, str>, Cow<'static, str>)> {
-        if let Some(retry_config) = cfg.get::<RetryConfig>() {
+        if let Some(retry_config) = cfg.load::<RetryConfig>() {
             let max_attempts = retry_config.max_attempts().to_string();
             Some((Cow::Borrowed("max"), Cow::Owned(max_attempts)))
         } else {
@@ -63,9 +63,9 @@ impl RequestInfoInterceptor {
     }
 
     fn build_ttl_pair(&self, cfg: &ConfigBag) -> Option<(Cow<'static, str>, Cow<'static, str>)> {
-        let timeout_config = cfg.get::<TimeoutConfig>()?;
+        let timeout_config = cfg.load::<TimeoutConfig>()?;
         let socket_read = timeout_config.read_timeout()?;
-        let estimated_skew: Duration = cfg.get::<ServiceClockSkew>().cloned()?.into();
+        let estimated_skew: Duration = cfg.load::<ServiceClockSkew>().cloned()?.into();
         let current_time = SystemTime::now();
         let ttl = current_time.checked_add(socket_read + estimated_skew)?;
         let mut timestamp = DateTime::from(ttl);
@@ -191,8 +191,8 @@ mod tests {
         context.set_request(http::Request::builder().body(SdkBody::empty()).unwrap());
 
         let mut layer = Layer::new("test");
-        layer.put(RetryConfig::standard());
-        layer.put(
+        layer.store_put(RetryConfig::standard());
+        layer.store_put(
             TimeoutConfig::builder()
                 .read_timeout(Duration::from_secs(30))
                 .build(),

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

@@ -77,19 +77,19 @@ impl Interceptor for UserAgentInterceptor {
         cfg: &mut ConfigBag,
     ) -> Result<(), BoxError> {
         let api_metadata = cfg
-            .get::<ApiMetadata>()
+            .load::<ApiMetadata>()
             .ok_or(UserAgentInterceptorError::MissingApiMetadata)?;
 
         // Allow for overriding the user agent by an earlier interceptor (so, for example,
         // tests can use `AwsUserAgent::for_tests()`) by attempting to grab one out of the
         // config bag before creating one.
         let ua: Cow<'_, AwsUserAgent> = cfg
-            .get::<AwsUserAgent>()
+            .load::<AwsUserAgent>()
             .map(Cow::Borrowed)
             .unwrap_or_else(|| {
                 let mut ua = AwsUserAgent::new_from_environment(Env::real(), api_metadata.clone());
 
-                let maybe_app_name = cfg.get::<AppName>();
+                let maybe_app_name = cfg.load::<AppName>();
                 if let Some(app_name) = maybe_app_name {
                     ua.set_app_name(app_name.clone());
                 }
@@ -139,8 +139,8 @@ mod tests {
         let mut context = context();
 
         let mut layer = Layer::new("test");
-        layer.put(AwsUserAgent::for_tests());
-        layer.put(ApiMetadata::new("unused", "unused"));
+        layer.store_put(AwsUserAgent::for_tests());
+        layer.store_put(ApiMetadata::new("unused", "unused"));
         let mut cfg = ConfigBag::of_layers(vec![layer]);
 
         let interceptor = UserAgentInterceptor::new();
@@ -165,7 +165,7 @@ mod tests {
 
         let api_metadata = ApiMetadata::new("some-service", "some-version");
         let mut layer = Layer::new("test");
-        layer.put(api_metadata.clone());
+        layer.store_put(api_metadata.clone());
         let mut config = ConfigBag::of_layers(vec![layer]);
 
         let interceptor = UserAgentInterceptor::new();
@@ -195,8 +195,8 @@ mod tests {
 
         let api_metadata = ApiMetadata::new("some-service", "some-version");
         let mut layer = Layer::new("test");
-        layer.put(api_metadata);
-        layer.put(AppName::new("my_awesome_app").unwrap());
+        layer.store_put(api_metadata);
+        layer.store_put(AppName::new("my_awesome_app").unwrap());
         let mut config = ConfigBag::of_layers(vec![layer]);
 
         let interceptor = UserAgentInterceptor::new();

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

@@ -25,6 +25,7 @@ pub mod sdk_config;
 pub use aws_smithy_client::http_connector;
 pub use sdk_config::SdkConfig;
 
+use aws_smithy_types::config_bag::{Storable, StoreReplace};
 use std::borrow::Cow;
 
 /// The name of the service used to sign this request
@@ -56,3 +57,7 @@ impl From<&'static str> for SigningService {
         Self::from_static(service)
     }
 }
+
+impl Storable for SigningService {
+    type Storer = StoreReplace<Self>;
+}

aws/rust-runtime/aws-types/src/region.rs

@@ -82,3 +82,7 @@ impl SigningRegion {
         SigningRegion(Cow::Borrowed(region))
     }
 }
+
+impl Storable for SigningRegion {
+    type Storer = StoreReplace<Self>;
+}