[smithy-rs] Add skeleton for supporting operation level config (#2589)

## Motivation and Context
This PR adds skeleton code for supporting operation level config behind
`enableNewSmithyRuntime`.

## Description
The approach is described in
smithy-lang/smithy-rs#2527, where fluent builders
now have a new method, `config_override`, that takes a service config
builder. The builder implements the `RuntimePlugin` trait and once
`TODO(RuntimePlugins)` is implemented, allows itself to put field values
into a config bag within `send_v2`.

## Testing
Added a line of code to an ignored test in `sra_test`, which, however,
does check compilation.

----

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

---------

Co-authored-by: Yuki Saito <awsaito@amazon.com>
Co-authored-by: John DiSanti <jdisanti@amazon.com>

Author: 2 people

sdk/accessanalyzer/src/config.rs

@@ -98,7 +98,7 @@ impl Config {
                     }
 }
 /// Builder for creating a `Config`.
-#[derive(Default)]pub struct Builder {
+#[derive(Clone, Debug, Default)]pub struct Builder {
     make_token: Option<crate::idempotency_token::IdempotencyTokenProvider>,
     endpoint_resolver: Option<std::sync::Arc<dyn aws_smithy_http::endpoint::ResolveEndpoint<crate::endpoint::Params>>>,
     retry_config: Option<aws_smithy_types::retry::RetryConfig>,

sdk/accessanalyzer/src/idempotency_token.rs

@@ -38,10 +38,12 @@ pub(crate) fn uuid_v4(input: u128) -> String {
 /// for testing, two options are available:
 /// 1. Utilize the From<&'static str>` implementation to hard code an idempotency token
 /// 2. Seed the token provider with [`IdempotencyTokenProvider::with_seed`](IdempotencyTokenProvider::with_seed)
+#[derive(Debug)]
 pub struct IdempotencyTokenProvider {
     inner: Inner,
 }
 
+#[derive(Debug)]
 enum Inner {
     Static(&'static str),
     Random(Mutex<fastrand::Rng>),

sdk/accessanalyzer/src/operation/apply_archive_rule/builders.rs

@@ -8,16 +8,17 @@ pub use crate::operation::apply_archive_rule::_apply_archive_rule_input::ApplyAr
 /// <p>Retroactively applies the archive rule to existing findings that meet the archive rule criteria.</p>
 #[derive(std::clone::Clone, std::fmt::Debug)]
 pub struct ApplyArchiveRuleFluentBuilder {
-                handle: std::sync::Arc<crate::client::Handle>,
-                inner: crate::operation::apply_archive_rule::builders::ApplyArchiveRuleInputBuilder
-            }
+    handle: std::sync::Arc<crate::client::Handle>,
+                    inner: crate::operation::apply_archive_rule::builders::ApplyArchiveRuleInputBuilder,
+}
 impl ApplyArchiveRuleFluentBuilder  {
     /// Creates a new `ApplyArchiveRule`.
-                    pub(crate) fn new(handle: std::sync::Arc<crate::client::Handle>) -> Self {
-                        Self { handle, inner: Default::default() }
-                    }
-    
-                    /// Consume this builder, creating a customizable operation that can be modified before being
+    pub(crate) fn new(handle: std::sync::Arc<crate::client::Handle>) -> Self {
+        Self {
+            handle, inner: Default::default(),
+        }
+    }
+    /// Consume this builder, creating a customizable operation that can be modified before being
                     /// sent. The operation's inner [http::Request] can be modified as well.
                     pub async fn customize(self) -> std::result::Result<
                         crate::client::customize::CustomizableOperation<crate::operation::apply_archive_rule::ApplyArchiveRule, aws_http::retry::AwsResponseRetryClassifier,>,

sdk/accessanalyzer/src/operation/cancel_policy_generation/builders.rs

@@ -8,16 +8,17 @@ pub use crate::operation::cancel_policy_generation::_cancel_policy_generation_in
 /// <p>Cancels the requested policy generation.</p>
 #[derive(std::clone::Clone, std::fmt::Debug)]
 pub struct CancelPolicyGenerationFluentBuilder {
-                handle: std::sync::Arc<crate::client::Handle>,
-                inner: crate::operation::cancel_policy_generation::builders::CancelPolicyGenerationInputBuilder
-            }
+    handle: std::sync::Arc<crate::client::Handle>,
+                    inner: crate::operation::cancel_policy_generation::builders::CancelPolicyGenerationInputBuilder,
+}
 impl CancelPolicyGenerationFluentBuilder  {
     /// Creates a new `CancelPolicyGeneration`.
-                    pub(crate) fn new(handle: std::sync::Arc<crate::client::Handle>) -> Self {
-                        Self { handle, inner: Default::default() }
-                    }
-    
-                    /// Consume this builder, creating a customizable operation that can be modified before being
+    pub(crate) fn new(handle: std::sync::Arc<crate::client::Handle>) -> Self {
+        Self {
+            handle, inner: Default::default(),
+        }
+    }
+    /// Consume this builder, creating a customizable operation that can be modified before being
                     /// sent. The operation's inner [http::Request] can be modified as well.
                     pub async fn customize(self) -> std::result::Result<
                         crate::client::customize::CustomizableOperation<crate::operation::cancel_policy_generation::CancelPolicyGeneration, aws_http::retry::AwsResponseRetryClassifier,>,

sdk/accessanalyzer/src/operation/create_access_preview/builders.rs

@@ -8,16 +8,17 @@ pub use crate::operation::create_access_preview::_create_access_preview_input::C
 /// <p>Creates an access preview that allows you to preview IAM Access Analyzer findings for your resource before deploying resource permissions.</p>
 #[derive(std::clone::Clone, std::fmt::Debug)]
 pub struct CreateAccessPreviewFluentBuilder {
-                handle: std::sync::Arc<crate::client::Handle>,
-                inner: crate::operation::create_access_preview::builders::CreateAccessPreviewInputBuilder
-            }
+    handle: std::sync::Arc<crate::client::Handle>,
+                    inner: crate::operation::create_access_preview::builders::CreateAccessPreviewInputBuilder,
+}
 impl CreateAccessPreviewFluentBuilder  {
     /// Creates a new `CreateAccessPreview`.
-                    pub(crate) fn new(handle: std::sync::Arc<crate::client::Handle>) -> Self {
-                        Self { handle, inner: Default::default() }
-                    }
-    
-                    /// Consume this builder, creating a customizable operation that can be modified before being
+    pub(crate) fn new(handle: std::sync::Arc<crate::client::Handle>) -> Self {
+        Self {
+            handle, inner: Default::default(),
+        }
+    }
+    /// Consume this builder, creating a customizable operation that can be modified before being
                     /// sent. The operation's inner [http::Request] can be modified as well.
                     pub async fn customize(self) -> std::result::Result<
                         crate::client::customize::CustomizableOperation<crate::operation::create_access_preview::CreateAccessPreview, aws_http::retry::AwsResponseRetryClassifier,>,

sdk/accessanalyzer/src/operation/create_analyzer/builders.rs

@@ -8,16 +8,17 @@ pub use crate::operation::create_analyzer::_create_analyzer_input::CreateAnalyze
 /// <p>Creates an analyzer for your account.</p>
 #[derive(std::clone::Clone, std::fmt::Debug)]
 pub struct CreateAnalyzerFluentBuilder {
-                handle: std::sync::Arc<crate::client::Handle>,
-                inner: crate::operation::create_analyzer::builders::CreateAnalyzerInputBuilder
-            }
+    handle: std::sync::Arc<crate::client::Handle>,
+                    inner: crate::operation::create_analyzer::builders::CreateAnalyzerInputBuilder,
+}
 impl CreateAnalyzerFluentBuilder  {
     /// Creates a new `CreateAnalyzer`.
-                    pub(crate) fn new(handle: std::sync::Arc<crate::client::Handle>) -> Self {
-                        Self { handle, inner: Default::default() }
-                    }
-    
-                    /// Consume this builder, creating a customizable operation that can be modified before being
+    pub(crate) fn new(handle: std::sync::Arc<crate::client::Handle>) -> Self {
+        Self {
+            handle, inner: Default::default(),
+        }
+    }
+    /// Consume this builder, creating a customizable operation that can be modified before being
                     /// sent. The operation's inner [http::Request] can be modified as well.
                     pub async fn customize(self) -> std::result::Result<
                         crate::client::customize::CustomizableOperation<crate::operation::create_analyzer::CreateAnalyzer, aws_http::retry::AwsResponseRetryClassifier,>,

sdk/accessanalyzer/src/operation/create_archive_rule/builders.rs

@@ -9,16 +9,17 @@ pub use crate::operation::create_archive_rule::_create_archive_rule_input::Creat
 /// <p>To learn about filter keys that you can use to create an archive rule, see <a href="https://docs.aws.amazon.com/IAM/latest/UserGuide/access-analyzer-reference-filter-keys.html">IAM Access Analyzer filter keys</a> in the <b>IAM User Guide</b>.</p>
 #[derive(std::clone::Clone, std::fmt::Debug)]
 pub struct CreateArchiveRuleFluentBuilder {
-                handle: std::sync::Arc<crate::client::Handle>,
-                inner: crate::operation::create_archive_rule::builders::CreateArchiveRuleInputBuilder
-            }
+    handle: std::sync::Arc<crate::client::Handle>,
+                    inner: crate::operation::create_archive_rule::builders::CreateArchiveRuleInputBuilder,
+}
 impl CreateArchiveRuleFluentBuilder  {
     /// Creates a new `CreateArchiveRule`.
-                    pub(crate) fn new(handle: std::sync::Arc<crate::client::Handle>) -> Self {
-                        Self { handle, inner: Default::default() }
-                    }
-    
-                    /// Consume this builder, creating a customizable operation that can be modified before being
+    pub(crate) fn new(handle: std::sync::Arc<crate::client::Handle>) -> Self {
+        Self {
+            handle, inner: Default::default(),
+        }
+    }
+    /// Consume this builder, creating a customizable operation that can be modified before being
                     /// sent. The operation's inner [http::Request] can be modified as well.
                     pub async fn customize(self) -> std::result::Result<
                         crate::client::customize::CustomizableOperation<crate::operation::create_archive_rule::CreateArchiveRule, aws_http::retry::AwsResponseRetryClassifier,>,

sdk/accessanalyzer/src/operation/delete_analyzer/builders.rs

@@ -8,16 +8,17 @@ pub use crate::operation::delete_analyzer::_delete_analyzer_input::DeleteAnalyze
 /// <p>Deletes the specified analyzer. When you delete an analyzer, IAM Access Analyzer is disabled for the account or organization in the current or specific Region. All findings that were generated by the analyzer are deleted. You cannot undo this action.</p>
 #[derive(std::clone::Clone, std::fmt::Debug)]
 pub struct DeleteAnalyzerFluentBuilder {
-                handle: std::sync::Arc<crate::client::Handle>,
-                inner: crate::operation::delete_analyzer::builders::DeleteAnalyzerInputBuilder
-            }
+    handle: std::sync::Arc<crate::client::Handle>,
+                    inner: crate::operation::delete_analyzer::builders::DeleteAnalyzerInputBuilder,
+}
 impl DeleteAnalyzerFluentBuilder  {
     /// Creates a new `DeleteAnalyzer`.
-                    pub(crate) fn new(handle: std::sync::Arc<crate::client::Handle>) -> Self {
-                        Self { handle, inner: Default::default() }
-                    }
-    
-                    /// Consume this builder, creating a customizable operation that can be modified before being
+    pub(crate) fn new(handle: std::sync::Arc<crate::client::Handle>) -> Self {
+        Self {
+            handle, inner: Default::default(),
+        }
+    }
+    /// Consume this builder, creating a customizable operation that can be modified before being
                     /// sent. The operation's inner [http::Request] can be modified as well.
                     pub async fn customize(self) -> std::result::Result<
                         crate::client::customize::CustomizableOperation<crate::operation::delete_analyzer::DeleteAnalyzer, aws_http::retry::AwsResponseRetryClassifier,>,

sdk/accessanalyzer/src/operation/delete_archive_rule/builders.rs

@@ -8,16 +8,17 @@ pub use crate::operation::delete_archive_rule::_delete_archive_rule_input::Delet
 /// <p>Deletes the specified archive rule.</p>
 #[derive(std::clone::Clone, std::fmt::Debug)]
 pub struct DeleteArchiveRuleFluentBuilder {
-                handle: std::sync::Arc<crate::client::Handle>,
-                inner: crate::operation::delete_archive_rule::builders::DeleteArchiveRuleInputBuilder
-            }
+    handle: std::sync::Arc<crate::client::Handle>,
+                    inner: crate::operation::delete_archive_rule::builders::DeleteArchiveRuleInputBuilder,
+}
 impl DeleteArchiveRuleFluentBuilder  {
     /// Creates a new `DeleteArchiveRule`.
-                    pub(crate) fn new(handle: std::sync::Arc<crate::client::Handle>) -> Self {
-                        Self { handle, inner: Default::default() }
-                    }
-    
-                    /// Consume this builder, creating a customizable operation that can be modified before being
+    pub(crate) fn new(handle: std::sync::Arc<crate::client::Handle>) -> Self {
+        Self {
+            handle, inner: Default::default(),
+        }
+    }
+    /// Consume this builder, creating a customizable operation that can be modified before being
                     /// sent. The operation's inner [http::Request] can be modified as well.
                     pub async fn customize(self) -> std::result::Result<
                         crate::client::customize::CustomizableOperation<crate::operation::delete_archive_rule::DeleteArchiveRule, aws_http::retry::AwsResponseRetryClassifier,>,

sdk/accessanalyzer/src/operation/get_access_preview/builders.rs

@@ -8,16 +8,17 @@ pub use crate::operation::get_access_preview::_get_access_preview_input::GetAcce
 /// <p>Retrieves information about an access preview for the specified analyzer.</p>
 #[derive(std::clone::Clone, std::fmt::Debug)]
 pub struct GetAccessPreviewFluentBuilder {
-                handle: std::sync::Arc<crate::client::Handle>,
-                inner: crate::operation::get_access_preview::builders::GetAccessPreviewInputBuilder
-            }
+    handle: std::sync::Arc<crate::client::Handle>,
+                    inner: crate::operation::get_access_preview::builders::GetAccessPreviewInputBuilder,
+}
 impl GetAccessPreviewFluentBuilder  {
     /// Creates a new `GetAccessPreview`.
-                    pub(crate) fn new(handle: std::sync::Arc<crate::client::Handle>) -> Self {
-                        Self { handle, inner: Default::default() }
-                    }
-    
-                    /// Consume this builder, creating a customizable operation that can be modified before being
+    pub(crate) fn new(handle: std::sync::Arc<crate::client::Handle>) -> Self {
+        Self {
+            handle, inner: Default::default(),
+        }
+    }
+    /// Consume this builder, creating a customizable operation that can be modified before being
                     /// sent. The operation's inner [http::Request] can be modified as well.
                     pub async fn customize(self) -> std::result::Result<
                         crate::client::customize::CustomizableOperation<crate::operation::get_access_preview::GetAccessPreview, aws_http::retry::AwsResponseRetryClassifier,>,