aws_sdk_accountaccessruntime/config.rs
1// Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
2#![allow(clippy::empty_line_after_doc_comments)]
3/// Configuration for a aws_sdk_accountaccessruntime service client.
4///
5/// Service configuration allows for customization of endpoints, region, credentials providers,
6/// and retry configuration. Generally, it is constructed automatically for you from a shared
7/// configuration loaded by the `aws-config` crate. For example:
8///
9/// ```ignore
10/// // Load a shared config from the environment
11/// let shared_config = aws_config::from_env().load().await;
12/// // The client constructor automatically converts the shared config into the service config
13/// let client = Client::new(&shared_config);
14/// ```
15///
16/// The service config can also be constructed manually using its builder.
17///
18#[derive(::std::clone::Clone, ::std::fmt::Debug)]
19pub struct Config {
20 // Both `config` and `cloneable` are the same config, but the cloneable one
21 // is kept around so that it is possible to convert back into a builder. This can be
22 // optimized in the future.
23 pub(crate) config: crate::config::FrozenLayer,
24 cloneable: ::aws_smithy_types::config_bag::CloneableLayer,
25 pub(crate) runtime_components: crate::config::RuntimeComponentsBuilder,
26 pub(crate) runtime_plugins: ::std::vec::Vec<crate::config::SharedRuntimePlugin>,
27 pub(crate) behavior_version: ::std::option::Option<crate::config::BehaviorVersion>,
28}
29impl Config {
30 ///
31 /// Constructs a config builder.
32 /// <div class="warning">
33 /// Note that a config created from this builder will not have the same safe defaults as one created by
34 /// the <a href="https://crates.io/crates/aws-config" target="_blank">aws-config</a> crate.
35 /// </div>
36 ///
37 pub fn builder() -> Builder {
38 Builder::default()
39 }
40 /// Converts this config back into a builder so that it can be tweaked.
41 pub fn to_builder(&self) -> Builder {
42 Builder {
43 config: self.cloneable.clone(),
44 runtime_components: self.runtime_components.clone(),
45 runtime_plugins: self.runtime_plugins.clone(),
46 behavior_version: self.behavior_version,
47 }
48 }
49 /// Return a reference to the stalled stream protection configuration contained in this config, if any.
50 pub fn stalled_stream_protection(&self) -> ::std::option::Option<&crate::config::StalledStreamProtectionConfig> {
51 self.config.load::<crate::config::StalledStreamProtectionConfig>()
52 }
53 /// Return the [`SharedHttpClient`](crate::config::SharedHttpClient) to use when making requests, if any.
54 pub fn http_client(&self) -> Option<crate::config::SharedHttpClient> {
55 self.runtime_components.http_client()
56 }
57 /// Return the auth schemes configured on this service config
58 pub fn auth_schemes(&self) -> impl Iterator<Item = ::aws_smithy_runtime_api::client::auth::SharedAuthScheme> + '_ {
59 self.runtime_components.auth_schemes()
60 }
61
62 /// Return the auth scheme resolver configured on this service config
63 pub fn auth_scheme_resolver(&self) -> ::std::option::Option<::aws_smithy_runtime_api::client::auth::SharedAuthSchemeOptionResolver> {
64 self.runtime_components.auth_scheme_option_resolver()
65 }
66 /// Returns the configured auth scheme preference
67 pub fn auth_scheme_preference(&self) -> ::std::option::Option<&::aws_smithy_runtime_api::client::auth::AuthSchemePreference> {
68 self.config.load::<::aws_smithy_runtime_api::client::auth::AuthSchemePreference>()
69 }
70 /// Returns the endpoint resolver.
71 pub fn endpoint_resolver(&self) -> ::aws_smithy_runtime_api::client::endpoint::SharedEndpointResolver {
72 self.runtime_components.endpoint_resolver().expect("resolver defaulted if not set")
73 }
74 /// Return a reference to the retry configuration contained in this config, if any.
75 pub fn retry_config(&self) -> ::std::option::Option<&::aws_smithy_types::retry::RetryConfig> {
76 self.config.load::<::aws_smithy_types::retry::RetryConfig>()
77 }
78
79 /// Return a cloned shared async sleep implementation from this config, if any.
80 pub fn sleep_impl(&self) -> ::std::option::Option<crate::config::SharedAsyncSleep> {
81 self.runtime_components.sleep_impl()
82 }
83
84 /// Return a reference to the timeout configuration contained in this config, if any.
85 pub fn timeout_config(&self) -> ::std::option::Option<&::aws_smithy_types::timeout::TimeoutConfig> {
86 self.config.load::<::aws_smithy_types::timeout::TimeoutConfig>()
87 }
88
89 /// Returns a reference to the retry partition contained in this config, if any.
90 ///
91 /// WARNING: This method is unstable and may be removed at any time. Do not rely on this
92 /// method for anything!
93 pub fn retry_partition(&self) -> ::std::option::Option<&::aws_smithy_runtime::client::retries::RetryPartition> {
94 self.config.load::<::aws_smithy_runtime::client::retries::RetryPartition>()
95 }
96 /// Returns the configured identity cache for auth.
97 pub fn identity_cache(&self) -> ::std::option::Option<crate::config::SharedIdentityCache> {
98 self.runtime_components.identity_cache()
99 }
100 /// Returns interceptors currently registered by the user.
101 pub fn interceptors(&self) -> impl Iterator<Item = crate::config::SharedInterceptor> + '_ {
102 self.runtime_components.interceptors()
103 }
104 /// Return time source used for this service.
105 pub fn time_source(&self) -> ::std::option::Option<::aws_smithy_async::time::SharedTimeSource> {
106 self.runtime_components.time_source()
107 }
108 /// Returns retry classifiers currently registered by the user.
109 pub fn retry_classifiers(&self) -> impl Iterator<Item = ::aws_smithy_runtime_api::client::retries::classifiers::SharedRetryClassifier> + '_ {
110 self.runtime_components.retry_classifiers()
111 }
112 /// Returns the name of the app that is using the client, if it was provided.
113 ///
114 /// This _optional_ name is used to identify the application in the user agent that
115 /// gets sent along with requests.
116 pub fn app_name(&self) -> ::std::option::Option<&::aws_types::app_name::AppName> {
117 self.config.load::<::aws_types::app_name::AppName>()
118 }
119 /// Returns the framework metadata that has been configured, if any.
120 ///
121 /// This _optional_ metadata identifies software frameworks or third-party libraries
122 /// being used with the client, rendered into the user agent as `lib/{name}/{version}`.
123 /// Entries are returned in first-seen (insertion) order, matching the order they are
124 /// rendered into the user agent.
125 pub fn framework_metadata(&self) -> ::std::vec::Vec<&::aws_types::sdk_ua_metadata::FrameworkMetadata> {
126 // `StoreAppend` loads entries newest-first; reverse to first-seen order so
127 // this getter agrees with both the user agent and `SdkConfig::framework_metadata`.
128 let mut entries: ::std::vec::Vec<&::aws_types::sdk_ua_metadata::FrameworkMetadata> =
129 self.config.load::<::aws_types::sdk_ua_metadata::FrameworkMetadata>().collect();
130 entries.reverse();
131 entries
132 }
133 /// Returns the `disable clock skew correction` setting, if it was provided.
134 pub fn disable_clock_skew_correction(&self) -> ::std::option::Option<bool> {
135 self.config
136 .load::<::aws_runtime::service_clock_skew::DisableClockSkewCorrection>()
137 .map(|it| it.is_disabled())
138 }
139 /// Returns the invocation ID generator if one was given in config.
140 ///
141 /// The invocation ID generator generates ID values for the `amz-sdk-invocation-id` header. By default, this will be a random UUID. Overriding it may be useful in tests that examine the HTTP request and need to be deterministic.
142 pub fn invocation_id_generator(&self) -> ::std::option::Option<::aws_runtime::invocation_id::SharedInvocationIdGenerator> {
143 self.config.load::<::aws_runtime::invocation_id::SharedInvocationIdGenerator>().cloned()
144 }
145 /// Creates a new [service config](crate::Config) from a [shared `config`](::aws_types::sdk_config::SdkConfig).
146 pub fn new(config: &::aws_types::sdk_config::SdkConfig) -> Self {
147 Builder::from(config).build()
148 }
149 /// Returns the AWS region, if it was provided.
150 pub fn region(&self) -> ::std::option::Option<&crate::config::Region> {
151 self.config.load::<crate::config::Region>()
152 }
153}
154/// Builder for creating a `Config`.
155#[derive(::std::clone::Clone, ::std::fmt::Debug)]
156pub struct Builder {
157 pub(crate) config: ::aws_smithy_types::config_bag::CloneableLayer,
158 pub(crate) runtime_components: crate::config::RuntimeComponentsBuilder,
159 pub(crate) runtime_plugins: ::std::vec::Vec<crate::config::SharedRuntimePlugin>,
160 pub(crate) behavior_version: ::std::option::Option<crate::config::BehaviorVersion>,
161}
162impl ::std::default::Default for Builder {
163 fn default() -> Self {
164 Self {
165 config: ::std::default::Default::default(),
166 runtime_components: crate::config::RuntimeComponentsBuilder::new("service config"),
167 runtime_plugins: ::std::default::Default::default(),
168 behavior_version: ::std::default::Default::default(),
169 }
170 }
171}
172impl Builder {
173 ///
174 /// Constructs a config builder.
175 /// <div class="warning">
176 /// Note that a config created from this builder will not have the same safe defaults as one created by
177 /// the <a href="https://crates.io/crates/aws-config" target="_blank">aws-config</a> crate.
178 /// </div>
179 ///
180 pub fn new() -> Self {
181 Self::default()
182 }
183 /// Constructs a config builder from the given `config_bag`, setting only fields stored in the config bag,
184 /// but not those in runtime components.
185 #[allow(unused)]
186 pub(crate) fn from_config_bag(config_bag: &::aws_smithy_types::config_bag::ConfigBag) -> Self {
187 let mut builder = Self::new();
188 builder.set_stalled_stream_protection(config_bag.load::<crate::config::StalledStreamProtectionConfig>().cloned());
189 builder.set_auth_scheme_preference(config_bag.load::<::aws_smithy_runtime_api::client::auth::AuthSchemePreference>().cloned());
190 builder.set_retry_config(config_bag.load::<::aws_smithy_types::retry::RetryConfig>().cloned());
191 builder.set_timeout_config(config_bag.load::<::aws_smithy_types::timeout::TimeoutConfig>().cloned());
192 builder.set_retry_partition(config_bag.load::<::aws_smithy_runtime::client::retries::RetryPartition>().cloned());
193 builder.set_app_name(config_bag.load::<::aws_types::app_name::AppName>().cloned());
194 for framework_metadata in config_bag.load::<::aws_types::sdk_ua_metadata::FrameworkMetadata>() {
195 builder.push_framework_metadata(framework_metadata.clone());
196 }
197 builder.set_disable_clock_skew_correction(
198 config_bag
199 .load::<::aws_runtime::service_clock_skew::DisableClockSkewCorrection>()
200 .map(|it| it.is_disabled()),
201 );
202 builder.set_endpoint_url(config_bag.load::<::aws_types::endpoint_config::EndpointUrl>().map(|ty| ty.0.clone()));
203 builder.set_use_fips(config_bag.load::<::aws_types::endpoint_config::UseFips>().map(|ty| ty.0));
204 builder.set_region(config_bag.load::<crate::config::Region>().cloned());
205 builder
206 }
207 /// Names operation-input members whose values are captured *and* emitted as
208 /// attributes on the client's built-in metrics (e.g. `["Bucket"]`).
209 ///
210 /// Emitting implies capture, so an emitted member is also readable in-process
211 /// via `CapturedTelemetryAttributes` on the config bag. Names are Smithy input
212 /// member names; only string-valued, non-sensitive members are eligible, and
213 /// naming any other member has no effect. Off by default.
214 ///
215 /// Prefer bounded identifiers here: an emitted member becomes a metric label, so
216 /// high-cardinality values (like object keys) fragment the metrics and inflate
217 /// cost. Use [`Self::capture_input_attributes`] for values you want to read
218 /// in-process without emitting them on the metrics.
219 pub fn emit_input_attributes(mut self, names: impl ::std::iter::IntoIterator<Item = impl ::std::convert::Into<::std::string::String>>) -> Self {
220 let mut requested = self
221 .config
222 .load::<::aws_smithy_types::telemetry::RequestedTelemetryAttributes>()
223 .cloned()
224 .unwrap_or_default();
225 requested.emit(names.into_iter().map(|n| n.into()));
226 self.config.store_put(requested);
227 self
228 }
229
230 /// Names operation-input members whose values are captured into
231 /// `CapturedTelemetryAttributes` for in-process reads (e.g. from a custom
232 /// interceptor), but are **not** emitted on the built-in metrics.
233 ///
234 /// Use this for values you need during the operation lifecycle but do not want on
235 /// the metric label set (for example, high-cardinality identifiers). Names follow
236 /// the same eligibility rules as [`Self::emit_input_attributes`]. Off by default.
237 pub fn capture_input_attributes(
238 mut self,
239 names: impl ::std::iter::IntoIterator<Item = impl ::std::convert::Into<::std::string::String>>,
240 ) -> Self {
241 let mut requested = self
242 .config
243 .load::<::aws_smithy_types::telemetry::RequestedTelemetryAttributes>()
244 .cloned()
245 .unwrap_or_default();
246 requested.capture_only(names.into_iter().map(|n| n.into()));
247 self.config.store_put(requested);
248 self
249 }
250 /// Set the [`StalledStreamProtectionConfig`](crate::config::StalledStreamProtectionConfig)
251 /// to configure protection for stalled streams.
252 pub fn stalled_stream_protection(mut self, stalled_stream_protection_config: crate::config::StalledStreamProtectionConfig) -> Self {
253 self.set_stalled_stream_protection(::std::option::Option::Some(stalled_stream_protection_config));
254 self
255 }
256 /// Set the [`StalledStreamProtectionConfig`](crate::config::StalledStreamProtectionConfig)
257 /// to configure protection for stalled streams.
258 pub fn set_stalled_stream_protection(
259 &mut self,
260 stalled_stream_protection_config: ::std::option::Option<crate::config::StalledStreamProtectionConfig>,
261 ) -> &mut Self {
262 self.config.store_or_unset(stalled_stream_protection_config);
263 self
264 }
265 /// Sets the HTTP client to use when making requests.
266 ///
267 /// # Examples
268 /// ```no_run
269 /// # #[cfg(test)]
270 /// # mod tests {
271 /// # #[test]
272 /// # fn example() {
273 /// use std::time::Duration;
274 /// use aws_sdk_accountaccessruntime::config::Config;
275 /// use aws_smithy_runtime::client::http::hyper_014::HyperClientBuilder;
276 ///
277 /// let https_connector = hyper_rustls::HttpsConnectorBuilder::new()
278 /// .with_webpki_roots()
279 /// .https_only()
280 /// .enable_http1()
281 /// .enable_http2()
282 /// .build();
283 /// let hyper_client = HyperClientBuilder::new().build(https_connector);
284 ///
285 /// // This connector can then be given to a generated service Config
286 /// let config = my_service_client::Config::builder()
287 /// .endpoint_url("https://example.com")
288 /// .http_client(hyper_client)
289 /// .build();
290 /// let client = my_service_client::Client::from_conf(config);
291 /// # }
292 /// # }
293 /// ```
294 pub fn http_client(mut self, http_client: impl crate::config::HttpClient + 'static) -> Self {
295 self.set_http_client(::std::option::Option::Some(crate::config::IntoShared::into_shared(http_client)));
296 self
297 }
298
299 /// Sets the HTTP client to use when making requests.
300 ///
301 /// # Examples
302 /// ```no_run
303 /// # #[cfg(test)]
304 /// # mod tests {
305 /// # #[test]
306 /// # fn example() {
307 /// use std::time::Duration;
308 /// use aws_sdk_accountaccessruntime::config::{Builder, Config};
309 /// use aws_smithy_runtime::client::http::hyper_014::HyperClientBuilder;
310 ///
311 /// fn override_http_client(builder: &mut Builder) {
312 /// let https_connector = hyper_rustls::HttpsConnectorBuilder::new()
313 /// .with_webpki_roots()
314 /// .https_only()
315 /// .enable_http1()
316 /// .enable_http2()
317 /// .build();
318 /// let hyper_client = HyperClientBuilder::new().build(https_connector);
319 /// builder.set_http_client(Some(hyper_client));
320 /// }
321 ///
322 /// let mut builder = aws_sdk_accountaccessruntime::Config::builder();
323 /// override_http_client(&mut builder);
324 /// let config = builder.build();
325 /// # }
326 /// # }
327 /// ```
328 pub fn set_http_client(&mut self, http_client: Option<crate::config::SharedHttpClient>) -> &mut Self {
329 self.runtime_components.set_http_client(http_client);
330 self
331 }
332 /// Sets the bearer token that will be used for HTTP bearer auth.
333 pub fn bearer_token(self, bearer_token: crate::config::Token) -> Self {
334 self.bearer_token_resolver(bearer_token)
335 }
336
337 /// Sets a bearer token provider that will be used for HTTP bearer auth.
338 pub fn bearer_token_resolver(mut self, bearer_token_resolver: impl crate::config::ResolveIdentity + 'static) -> Self {
339 self.runtime_components.set_identity_resolver(
340 ::aws_smithy_runtime_api::client::auth::http::HTTP_BEARER_AUTH_SCHEME_ID,
341 ::aws_smithy_runtime_api::shared::IntoShared::<::aws_smithy_runtime_api::client::identity::SharedIdentityResolver>::into_shared(
342 bearer_token_resolver,
343 ),
344 );
345 self
346 }
347 /// Adds an auth scheme to the builder
348 ///
349 /// If `auth_scheme` has an existing [AuthSchemeId](aws_smithy_runtime_api::client::auth::AuthSchemeId) in the runtime, the current identity
350 /// resolver and signer for that scheme will be replaced by those from `auth_scheme`.
351 ///
352 /// _Important:_ When introducing a custom auth scheme, ensure you override either
353 /// [`Self::auth_scheme_resolver`] or [`Self::set_auth_scheme_resolver`]
354 /// so that the custom auth scheme is included in the list of resolved auth scheme options.
355 /// [The default auth scheme resolver](crate::config::auth::DefaultAuthSchemeResolver) will not recognize your custom auth scheme.
356 ///
357 /// # Examples
358 /// ```no_run
359 /// # use aws_smithy_runtime_api::{
360 /// # box_error::BoxError,
361 /// # client::{
362 /// # auth::{
363 /// # AuthScheme, AuthSchemeEndpointConfig, AuthSchemeId, AuthSchemeOption,
364 /// # AuthSchemeOptionsFuture, Sign,
365 /// # },
366 /// # identity::{Identity, IdentityFuture, ResolveIdentity, SharedIdentityResolver},
367 /// # orchestrator::HttpRequest,
368 /// # runtime_components::{GetIdentityResolver, RuntimeComponents},
369 /// # },
370 /// # shared::IntoShared,
371 /// # };
372 /// # use aws_smithy_types::config_bag::ConfigBag;
373 /// // Auth scheme with customer identity resolver and signer
374 /// #[derive(Debug)]
375 /// struct CustomAuthScheme {
376 /// id: AuthSchemeId,
377 /// identity_resolver: SharedIdentityResolver,
378 /// signer: CustomSigner,
379 /// }
380 /// impl Default for CustomAuthScheme {
381 /// fn default() -> Self {
382 /// Self {
383 /// id: AuthSchemeId::new("custom"),
384 /// identity_resolver: CustomIdentityResolver.into_shared(),
385 /// signer: CustomSigner,
386 /// }
387 /// }
388 /// }
389 /// impl AuthScheme for CustomAuthScheme {
390 /// fn scheme_id(&self) -> AuthSchemeId {
391 /// self.id.clone()
392 /// }
393 /// fn identity_resolver(
394 /// &self,
395 /// _identity_resolvers: &dyn GetIdentityResolver,
396 /// ) -> Option<SharedIdentityResolver> {
397 /// Some(self.identity_resolver.clone())
398 /// }
399 /// fn signer(&self) -> &dyn Sign {
400 /// &self.signer
401 /// }
402 /// }
403 ///
404 /// #[derive(Debug, Default)]
405 /// struct CustomSigner;
406 /// impl Sign for CustomSigner {
407 /// fn sign_http_request(
408 /// &self,
409 /// _request: &mut HttpRequest,
410 /// _identity: &Identity,
411 /// _auth_scheme_endpoint_config: AuthSchemeEndpointConfig<'_>,
412 /// _runtime_components: &RuntimeComponents,
413 /// _config_bag: &ConfigBag,
414 /// ) -> Result<(), BoxError> {
415 /// // --snip--
416 /// # todo!()
417 /// }
418 /// }
419 ///
420 /// #[derive(Debug)]
421 /// struct CustomIdentityResolver;
422 /// impl ResolveIdentity for CustomIdentityResolver {
423 /// fn resolve_identity<'a>(
424 /// &'a self,
425 /// _runtime_components: &'a RuntimeComponents,
426 /// _config_bag: &'a ConfigBag,
427 /// ) -> IdentityFuture<'a> {
428 /// // --snip--
429 /// # todo!()
430 /// }
431 /// }
432 ///
433 /// // Auth scheme resolver that favors `CustomAuthScheme`
434 /// #[derive(Debug)]
435 /// struct CustomAuthSchemeResolver;
436 /// impl aws_sdk_accountaccessruntime::config::auth::ResolveAuthScheme for CustomAuthSchemeResolver {
437 /// fn resolve_auth_scheme<'a>(
438 /// &'a self,
439 /// _params: &'a aws_sdk_accountaccessruntime::config::auth::Params,
440 /// _cfg: &'a ConfigBag,
441 /// _runtime_components: &'a RuntimeComponents,
442 /// ) -> AuthSchemeOptionsFuture<'a> {
443 /// AuthSchemeOptionsFuture::ready(Ok(vec![AuthSchemeOption::from(AuthSchemeId::new(
444 /// "custom",
445 /// ))]))
446 /// }
447 /// }
448 ///
449 /// let config = aws_sdk_accountaccessruntime::Config::builder()
450 /// .push_auth_scheme(CustomAuthScheme::default())
451 /// .auth_scheme_resolver(CustomAuthSchemeResolver)
452 /// // other configurations
453 /// .build();
454 /// ```
455 pub fn push_auth_scheme(mut self, auth_scheme: impl ::aws_smithy_runtime_api::client::auth::AuthScheme + 'static) -> Self {
456 self.runtime_components.push_auth_scheme(auth_scheme);
457 self
458 }
459
460 /// Set the auth scheme resolver for the builder
461 ///
462 /// # Examples
463 /// ```no_run
464 /// # use aws_smithy_runtime_api::{
465 /// # client::{
466 /// # auth::AuthSchemeOptionsFuture,
467 /// # runtime_components::RuntimeComponents,
468 /// # },
469 /// # };
470 /// # use aws_smithy_types::config_bag::ConfigBag;
471 /// #[derive(Debug)]
472 /// struct CustomAuthSchemeResolver;
473 /// impl aws_sdk_accountaccessruntime::config::auth::ResolveAuthScheme for CustomAuthSchemeResolver {
474 /// fn resolve_auth_scheme<'a>(
475 /// &'a self,
476 /// _params: &'a aws_sdk_accountaccessruntime::config::auth::Params,
477 /// _cfg: &'a ConfigBag,
478 /// _runtime_components: &'a RuntimeComponents,
479 /// ) -> AuthSchemeOptionsFuture<'a> {
480 /// // --snip--
481 /// # todo!()
482 /// }
483 /// }
484 ///
485 /// let config = aws_sdk_accountaccessruntime::Config::builder()
486 /// .auth_scheme_resolver(CustomAuthSchemeResolver)
487 /// // other configurations
488 /// .build();
489 /// ```
490 pub fn auth_scheme_resolver(mut self, auth_scheme_resolver: impl crate::config::auth::ResolveAuthScheme + 'static) -> Self {
491 self.set_auth_scheme_resolver(auth_scheme_resolver);
492 self
493 }
494
495 /// Set the auth scheme resolver for the builder
496 ///
497 /// # Examples
498 /// See an example for [`Self::auth_scheme_resolver`].
499 pub fn set_auth_scheme_resolver(&mut self, auth_scheme_resolver: impl crate::config::auth::ResolveAuthScheme + 'static) -> &mut Self {
500 self.runtime_components
501 .set_auth_scheme_option_resolver(::std::option::Option::Some(auth_scheme_resolver.into_shared_resolver()));
502 self
503 }
504
505 /// Enable no authentication regardless of what authentication mechanisms operations support
506 ///
507 /// This adds [NoAuthScheme](aws_smithy_runtime::client::auth::no_auth::NoAuthScheme) as a fallback
508 /// and the auth scheme resolver will use it when no other auth schemes are applicable.
509 pub fn allow_no_auth(mut self) -> Self {
510 self.set_allow_no_auth();
511 self
512 }
513
514 /// Enable no authentication regardless of what authentication mechanisms operations support
515 ///
516 /// This adds [NoAuthScheme](aws_smithy_runtime::client::auth::no_auth::NoAuthScheme) as a fallback
517 /// and the auth scheme resolver will use it when no other auth schemes are applicable.
518 pub fn set_allow_no_auth(&mut self) -> &mut Self {
519 self.push_runtime_plugin(::aws_smithy_runtime::client::auth::no_auth::NoAuthRuntimePluginV2::new().into_shared());
520 self
521 }
522 /// Set the auth scheme preference for an auth scheme resolver
523 /// (typically the default auth scheme resolver).
524 ///
525 /// Each operation has a predefined order of auth schemes, as determined by the service,
526 /// for auth scheme resolution. By using the auth scheme preference, customers
527 /// can reorder the schemes resolved by the auth scheme resolver.
528 ///
529 /// The preference list is intended as a hint rather than a strict override.
530 /// Any schemes not present in the originally resolved auth schemes will be ignored.
531 ///
532 /// # Examples
533 ///
534 /// ```no_run
535 /// # use aws_smithy_runtime_api::client::auth::AuthSchemeId;
536 /// let config = aws_sdk_accountaccessruntime::Config::builder()
537 /// .auth_scheme_preference([AuthSchemeId::from("scheme1"), AuthSchemeId::from("scheme2")])
538 /// // ...
539 /// .build();
540 /// let client = aws_sdk_accountaccessruntime::Client::from_conf(config);
541 /// ```
542
543 pub fn auth_scheme_preference(
544 mut self,
545 preference: impl ::std::convert::Into<::aws_smithy_runtime_api::client::auth::AuthSchemePreference>,
546 ) -> Self {
547 self.set_auth_scheme_preference(::std::option::Option::Some(preference.into()));
548 self
549 }
550
551 /// Set the auth scheme preference for an auth scheme resolver
552 /// (typically the default auth scheme resolver).
553 ///
554 /// Each operation has a predefined order of auth schemes, as determined by the service,
555 /// for auth scheme resolution. By using the auth scheme preference, customers
556 /// can reorder the schemes resolved by the auth scheme resolver.
557 ///
558 /// The preference list is intended as a hint rather than a strict override.
559 /// Any schemes not present in the originally resolved auth schemes will be ignored.
560 ///
561 /// # Examples
562 ///
563 /// ```no_run
564 /// # use aws_smithy_runtime_api::client::auth::AuthSchemeId;
565 /// let config = aws_sdk_accountaccessruntime::Config::builder()
566 /// .auth_scheme_preference([AuthSchemeId::from("scheme1"), AuthSchemeId::from("scheme2")])
567 /// // ...
568 /// .build();
569 /// let client = aws_sdk_accountaccessruntime::Client::from_conf(config);
570 /// ```
571
572 pub fn set_auth_scheme_preference(
573 &mut self,
574 preference: ::std::option::Option<::aws_smithy_runtime_api::client::auth::AuthSchemePreference>,
575 ) -> &mut Self {
576 self.config.store_or_unset(preference);
577 self
578 }
579 /// Sets the endpoint resolver to use when making requests.
580 ///
581 ///
582 /// When unset, the client will used a generated endpoint resolver based on the endpoint resolution
583 /// rules for `aws_sdk_accountaccessruntime`.
584 ///
585 ///
586 /// Note: setting an endpoint resolver will replace any endpoint URL that has been set.
587 /// This method accepts an endpoint resolver [specific to this service](crate::config::endpoint::ResolveEndpoint). If you want to
588 /// provide a shared endpoint resolver, use [`Self::set_endpoint_resolver`].
589 ///
590 /// # Examples
591 /// Create a custom endpoint resolver that resolves a different endpoing per-stage, e.g. staging vs. production.
592 /// ```no_run
593 /// use aws_sdk_accountaccessruntime::config::endpoint::{ResolveEndpoint, EndpointFuture, Params, Endpoint};
594 /// #[derive(Debug)]
595 /// struct StageResolver { stage: String }
596 /// impl ResolveEndpoint for StageResolver {
597 /// fn resolve_endpoint(&self, params: &Params) -> EndpointFuture<'_> {
598 /// let stage = &self.stage;
599 /// EndpointFuture::ready(Ok(Endpoint::builder().url(format!("{stage}.myservice.com")).build()))
600 /// }
601 /// }
602 /// let resolver = StageResolver { stage: std::env::var("STAGE").unwrap() };
603 /// let config = aws_sdk_accountaccessruntime::Config::builder().endpoint_resolver(resolver).build();
604 /// let client = aws_sdk_accountaccessruntime::Client::from_conf(config);
605 /// ```
606 pub fn endpoint_resolver(mut self, endpoint_resolver: impl crate::config::endpoint::ResolveEndpoint + 'static) -> Self {
607 self.set_endpoint_resolver(::std::option::Option::Some(endpoint_resolver.into_shared_resolver()));
608 self
609 }
610
611 /// Sets the endpoint resolver to use when making requests.
612 ///
613 ///
614 /// When unset, the client will used a generated endpoint resolver based on the endpoint resolution
615 /// rules for `aws_sdk_accountaccessruntime`.
616 ///
617 pub fn set_endpoint_resolver(
618 &mut self,
619 endpoint_resolver: ::std::option::Option<::aws_smithy_runtime_api::client::endpoint::SharedEndpointResolver>,
620 ) -> &mut Self {
621 self.runtime_components.set_endpoint_resolver(endpoint_resolver);
622 self
623 }
624 /// Set the retry_config for the builder
625 ///
626 /// # Examples
627 /// ```no_run
628 /// use aws_sdk_accountaccessruntime::config::Config;
629 /// use aws_sdk_accountaccessruntime::config::retry::RetryConfig;
630 ///
631 /// let retry_config = RetryConfig::standard().with_max_attempts(5);
632 /// let config = Config::builder().retry_config(retry_config).build();
633 /// ```
634 ///
635 /// # Retry token bucket
636 ///
637 /// [`RetryConfig`](::aws_smithy_types::retry::RetryConfig) controls *how many* times to retry and *how long* to back
638 /// off. Retries are **also** gated by a retry token bucket (also called the retry quota) that
639 /// is shared across a [`RetryPartition`](::aws_smithy_runtime::client::retries::RetryPartition). To configure the token bucket — for
640 /// example, to set
641 /// its capacity or to give a workload its own bucket — see [`Self::retry_partition`] and
642 /// [`RetryPartition::custom`](::aws_smithy_runtime::client::retries::RetryPartition::custom).
643 pub fn retry_config(mut self, retry_config: ::aws_smithy_types::retry::RetryConfig) -> Self {
644 self.set_retry_config(Some(retry_config));
645 self
646 }
647
648 /// Set the retry_config for the builder
649 ///
650 /// # Examples
651 /// ```no_run
652 /// use aws_sdk_accountaccessruntime::config::{Builder, Config};
653 /// use aws_sdk_accountaccessruntime::config::retry::RetryConfig;
654 ///
655 /// fn disable_retries(builder: &mut Builder) {
656 /// let retry_config = RetryConfig::standard().with_max_attempts(1);
657 /// builder.set_retry_config(Some(retry_config));
658 /// }
659 ///
660 /// let mut builder = Config::builder();
661 /// disable_retries(&mut builder);
662 /// let config = builder.build();
663 /// ```
664 pub fn set_retry_config(&mut self, retry_config: ::std::option::Option<::aws_smithy_types::retry::RetryConfig>) -> &mut Self {
665 retry_config.map(|r| self.config.store_put(r));
666 self
667 }
668 /// Set the sleep_impl for the builder
669 ///
670 /// # Examples
671 ///
672 /// ```no_run
673 /// use aws_sdk_accountaccessruntime::config::{AsyncSleep, Config, SharedAsyncSleep, Sleep};
674 ///
675 /// #[derive(Debug)]
676 /// pub struct ForeverSleep;
677 ///
678 /// impl AsyncSleep for ForeverSleep {
679 /// fn sleep(&self, duration: std::time::Duration) -> Sleep {
680 /// Sleep::new(std::future::pending())
681 /// }
682 /// }
683 ///
684 /// let sleep_impl = SharedAsyncSleep::new(ForeverSleep);
685 /// let config = Config::builder().sleep_impl(sleep_impl).build();
686 /// ```
687 pub fn sleep_impl(mut self, sleep_impl: impl crate::config::AsyncSleep + 'static) -> Self {
688 self.set_sleep_impl(Some(::aws_smithy_runtime_api::shared::IntoShared::into_shared(sleep_impl)));
689 self
690 }
691
692 /// Set the sleep_impl for the builder
693 ///
694 /// # Examples
695 ///
696 /// ```no_run
697 /// use aws_sdk_accountaccessruntime::config::{AsyncSleep, Builder, Config, SharedAsyncSleep, Sleep};
698 ///
699 /// #[derive(Debug)]
700 /// pub struct ForeverSleep;
701 ///
702 /// impl AsyncSleep for ForeverSleep {
703 /// fn sleep(&self, duration: std::time::Duration) -> Sleep {
704 /// Sleep::new(std::future::pending())
705 /// }
706 /// }
707 ///
708 /// fn set_never_ending_sleep_impl(builder: &mut Builder) {
709 /// let sleep_impl = SharedAsyncSleep::new(ForeverSleep);
710 /// builder.set_sleep_impl(Some(sleep_impl));
711 /// }
712 ///
713 /// let mut builder = Config::builder();
714 /// set_never_ending_sleep_impl(&mut builder);
715 /// let config = builder.build();
716 /// ```
717 pub fn set_sleep_impl(&mut self, sleep_impl: ::std::option::Option<crate::config::SharedAsyncSleep>) -> &mut Self {
718 self.runtime_components.set_sleep_impl(sleep_impl);
719 self
720 }
721 /// Set the timeout_config for the builder
722 ///
723 /// # Examples
724 ///
725 /// ```no_run
726 /// # use std::time::Duration;
727 /// use aws_sdk_accountaccessruntime::config::Config;
728 /// use aws_sdk_accountaccessruntime::config::timeout::TimeoutConfig;
729 ///
730 /// let timeout_config = TimeoutConfig::builder()
731 /// .operation_attempt_timeout(Duration::from_secs(1))
732 /// .build();
733 /// let config = Config::builder().timeout_config(timeout_config).build();
734 /// ```
735 pub fn timeout_config(mut self, timeout_config: ::aws_smithy_types::timeout::TimeoutConfig) -> Self {
736 self.set_timeout_config(Some(timeout_config));
737 self
738 }
739
740 /// Set the timeout_config for the builder.
741 ///
742 /// Setting this to `None` has no effect if another source of configuration has set timeouts. If you
743 /// are attempting to disable timeouts, use [`TimeoutConfig::disabled`](::aws_smithy_types::timeout::TimeoutConfig::disabled)
744 ///
745 ///
746 /// # Examples
747 ///
748 /// ```no_run
749 /// # use std::time::Duration;
750 /// use aws_sdk_accountaccessruntime::config::{Builder, Config};
751 /// use aws_sdk_accountaccessruntime::config::timeout::TimeoutConfig;
752 ///
753 /// fn set_request_timeout(builder: &mut Builder) {
754 /// let timeout_config = TimeoutConfig::builder()
755 /// .operation_attempt_timeout(Duration::from_secs(1))
756 /// .build();
757 /// builder.set_timeout_config(Some(timeout_config));
758 /// }
759 ///
760 /// let mut builder = Config::builder();
761 /// set_request_timeout(&mut builder);
762 /// let config = builder.build();
763 /// ```
764 pub fn set_timeout_config(&mut self, timeout_config: ::std::option::Option<::aws_smithy_types::timeout::TimeoutConfig>) -> &mut Self {
765 // passing None has no impact.
766 let Some(mut timeout_config) = timeout_config else { return self };
767
768 if let Some(base) = self.config.load::<::aws_smithy_types::timeout::TimeoutConfig>() {
769 timeout_config.take_defaults_from(base);
770 }
771 self.config.store_put(timeout_config);
772 self
773 }
774 /// Set the partition for retry-related state. When clients share a retry partition, they will
775 /// also share components such as token buckets and client rate limiters.
776 /// See the [`RetryPartition`](::aws_smithy_runtime::client::retries::RetryPartition) documentation for more details.
777 ///
778 /// # Default Behavior
779 ///
780 /// When no retry partition is explicitly set, the SDK automatically creates a default retry partition named `accountaccessruntime`
781 /// (or `accountaccessruntime-<region>` if a region is configured).
782 /// All Account Access Runtime clients without an explicit retry partition will share this default partition.
783 ///
784 /// # Notes
785 ///
786 /// - This is an advanced setting. A common reason to set it is to size or isolate the retry
787 /// token bucket — for example, giving a high-throughput workload its own bucket. Otherwise
788 /// most users won't need to modify it.
789 /// - A configured client rate limiter has no effect unless [`RetryConfig::adaptive`](::aws_smithy_types::retry::RetryConfig::adaptive) is used.
790 ///
791 /// # Examples
792 ///
793 /// Creating a custom retry partition with a token bucket:
794 /// ```no_run
795 /// use aws_sdk_accountaccessruntime::config::Config;
796 /// use aws_sdk_accountaccessruntime::config::retry::{RetryPartition, TokenBucket};
797 ///
798 /// let token_bucket = TokenBucket::new(10);
799 /// let config = Config::builder()
800 /// .retry_partition(RetryPartition::custom("custom")
801 /// .token_bucket(token_bucket)
802 /// .build()
803 /// )
804 /// .build();
805 /// ```
806 ///
807 /// Sizing the retry token bucket (for example, for a high-throughput workload), or giving a
808 /// workload its own bucket:
809 /// ```no_run
810 /// use aws_sdk_accountaccessruntime::config::Config;
811 /// use aws_sdk_accountaccessruntime::config::retry::{RetryPartition, TokenBucket};
812 ///
813 /// let config = Config::builder()
814 /// .retry_partition(
815 /// RetryPartition::custom("high-throughput")
816 /// .token_bucket(TokenBucket::builder().capacity(5000).build())
817 /// .build(),
818 /// )
819 /// .build();
820 /// ```
821 ///
822 /// Configuring a client rate limiter with adaptive retry mode:
823 /// ```no_run
824 /// use aws_sdk_accountaccessruntime::config::Config;
825 /// use aws_sdk_accountaccessruntime::config::retry::{ClientRateLimiter, RetryConfig, RetryPartition};
826 ///
827 /// let client_rate_limiter = ClientRateLimiter::new(10.0);
828 /// let config = Config::builder()
829 /// .retry_partition(RetryPartition::custom("custom")
830 /// .client_rate_limiter(client_rate_limiter)
831 /// .build()
832 /// )
833 /// .retry_config(RetryConfig::adaptive())
834 /// .build();
835 /// ```
836 pub fn retry_partition(mut self, retry_partition: ::aws_smithy_runtime::client::retries::RetryPartition) -> Self {
837 self.set_retry_partition(Some(retry_partition));
838 self
839 }
840 /// Like [`Self::retry_partition`], but takes a mutable reference to the builder and an optional `RetryPartition`
841 pub fn set_retry_partition(
842 &mut self,
843 retry_partition: ::std::option::Option<::aws_smithy_runtime::client::retries::RetryPartition>,
844 ) -> &mut Self {
845 retry_partition.map(|r| self.config.store_put(r));
846 self
847 }
848 /// Set the identity cache for auth.
849 ///
850 /// The identity cache defaults to a lazy caching implementation that will resolve
851 /// an identity when it is requested, and place it in the cache thereafter. Subsequent
852 /// requests will take the value from the cache while it is still valid. Once it expires,
853 /// the next request will result in refreshing the identity.
854 ///
855 /// This configuration allows you to disable or change the default caching mechanism.
856 /// To use a custom caching mechanism, implement the [`ResolveCachedIdentity`](crate::config::ResolveCachedIdentity)
857 /// trait and pass that implementation into this function.
858 ///
859 /// # Examples
860 ///
861 /// Disabling identity caching:
862 /// ```no_run
863 /// use aws_sdk_accountaccessruntime::config::IdentityCache;
864 ///
865 /// let config = aws_sdk_accountaccessruntime::Config::builder()
866 /// .identity_cache(IdentityCache::no_cache())
867 /// // ...
868 /// .build();
869 /// let client = aws_sdk_accountaccessruntime::Client::from_conf(config);
870 /// ```
871 ///
872 /// Customizing lazy caching:
873 /// ```no_run
874 /// use aws_sdk_accountaccessruntime::config::IdentityCache;
875 /// use std::time::Duration;
876 ///
877 /// let config = aws_sdk_accountaccessruntime::Config::builder()
878 /// .identity_cache(
879 /// IdentityCache::lazy()
880 /// // change the load timeout to 10 seconds
881 /// .load_timeout(Duration::from_secs(10))
882 /// .build()
883 /// )
884 /// // ...
885 /// .build();
886 /// let client = aws_sdk_accountaccessruntime::Client::from_conf(config);
887 /// ```
888 ///
889 pub fn identity_cache(mut self, identity_cache: impl crate::config::ResolveCachedIdentity + 'static) -> Self {
890 self.set_identity_cache(identity_cache);
891 self
892 }
893
894 /// Set the identity cache for auth.
895 ///
896 /// The identity cache defaults to a lazy caching implementation that will resolve
897 /// an identity when it is requested, and place it in the cache thereafter. Subsequent
898 /// requests will take the value from the cache while it is still valid. Once it expires,
899 /// the next request will result in refreshing the identity.
900 ///
901 /// This configuration allows you to disable or change the default caching mechanism.
902 /// To use a custom caching mechanism, implement the [`ResolveCachedIdentity`](crate::config::ResolveCachedIdentity)
903 /// trait and pass that implementation into this function.
904 ///
905 /// # Examples
906 ///
907 /// Disabling identity caching:
908 /// ```no_run
909 /// use aws_sdk_accountaccessruntime::config::IdentityCache;
910 ///
911 /// let config = aws_sdk_accountaccessruntime::Config::builder()
912 /// .identity_cache(IdentityCache::no_cache())
913 /// // ...
914 /// .build();
915 /// let client = aws_sdk_accountaccessruntime::Client::from_conf(config);
916 /// ```
917 ///
918 /// Customizing lazy caching:
919 /// ```no_run
920 /// use aws_sdk_accountaccessruntime::config::IdentityCache;
921 /// use std::time::Duration;
922 ///
923 /// let config = aws_sdk_accountaccessruntime::Config::builder()
924 /// .identity_cache(
925 /// IdentityCache::lazy()
926 /// // change the load timeout to 10 seconds
927 /// .load_timeout(Duration::from_secs(10))
928 /// .build()
929 /// )
930 /// // ...
931 /// .build();
932 /// let client = aws_sdk_accountaccessruntime::Client::from_conf(config);
933 /// ```
934 ///
935 pub fn set_identity_cache(&mut self, identity_cache: impl crate::config::ResolveCachedIdentity + 'static) -> &mut Self {
936 self.runtime_components.set_identity_cache(::std::option::Option::Some(identity_cache));
937 self
938 }
939 /// Add an [interceptor](crate::config::Intercept) that runs at specific stages of the request execution pipeline.
940 ///
941 /// Interceptors targeted at a certain stage are executed according to the pre-defined priority.
942 /// The SDK provides a default set of interceptors. An interceptor configured by this method
943 /// will run after those default interceptors.
944 ///
945 /// # Examples
946 /// ```no_run
947 /// # fn example() {
948 /// use aws_smithy_runtime_api::box_error::BoxError;
949 /// use aws_smithy_runtime_api::client::interceptors::context::BeforeTransmitInterceptorContextMut;
950 /// use aws_smithy_runtime_api::client::interceptors::Intercept;
951 /// use aws_smithy_runtime_api::client::runtime_components::RuntimeComponents;
952 /// use aws_smithy_types::config_bag::ConfigBag;
953 /// use aws_sdk_accountaccessruntime::config::Config;
954 ///
955 /// fn base_url() -> String {
956 /// // ...
957 /// # String::new()
958 /// }
959 ///
960 /// #[derive(Debug)]
961 /// pub struct UriModifierInterceptor;
962 /// impl Intercept for UriModifierInterceptor {
963 /// fn name(&self) -> &'static str {
964 /// "UriModifierInterceptor"
965 /// }
966 /// fn modify_before_signing(
967 /// &self,
968 /// context: &mut BeforeTransmitInterceptorContextMut<'_>,
969 /// _runtime_components: &RuntimeComponents,
970 /// _cfg: &mut ConfigBag,
971 /// ) -> Result<(), BoxError> {
972 /// let request = context.request_mut();
973 /// let uri = format!("{}{}", base_url(), request.uri());
974 /// request.set_uri(uri)?;
975 ///
976 /// Ok(())
977 /// }
978 /// }
979 ///
980 /// let config = Config::builder()
981 /// .interceptor(UriModifierInterceptor)
982 /// .build();
983 /// # }
984 /// ```
985 pub fn interceptor(mut self, interceptor: impl crate::config::Intercept + 'static) -> Self {
986 self.push_interceptor(crate::config::SharedInterceptor::new(interceptor));
987 self
988 }
989
990 /// Like [`Self::interceptor`], but takes a [`SharedInterceptor`](crate::config::SharedInterceptor).
991 pub fn push_interceptor(&mut self, interceptor: crate::config::SharedInterceptor) -> &mut Self {
992 self.runtime_components.push_interceptor(interceptor);
993 self
994 }
995
996 /// Set [`SharedInterceptor`](crate::config::SharedInterceptor)s for the builder.
997 pub fn set_interceptors(&mut self, interceptors: impl IntoIterator<Item = crate::config::SharedInterceptor>) -> &mut Self {
998 self.runtime_components.set_interceptors(interceptors.into_iter());
999 self
1000 }
1001 /// Sets the time source used for this service
1002 pub fn time_source(mut self, time_source: impl ::aws_smithy_async::time::TimeSource + 'static) -> Self {
1003 self.set_time_source(::std::option::Option::Some(::aws_smithy_runtime_api::shared::IntoShared::into_shared(
1004 time_source,
1005 )));
1006 self
1007 }
1008 /// Sets the time source used for this service
1009 pub fn set_time_source(&mut self, time_source: ::std::option::Option<::aws_smithy_async::time::SharedTimeSource>) -> &mut Self {
1010 self.runtime_components.set_time_source(time_source);
1011 self
1012 }
1013 /// Add type implementing [`ClassifyRetry`](::aws_smithy_runtime_api::client::retries::classifiers::ClassifyRetry) that will be used by the
1014 /// [`RetryStrategy`](::aws_smithy_runtime_api::client::retries::RetryStrategy) to determine what responses should be retried.
1015 ///
1016 /// A retry classifier configured by this method will run according to its [priority](::aws_smithy_runtime_api::client::retries::classifiers::RetryClassifierPriority).
1017 ///
1018 /// # Examples
1019 /// ```no_run
1020 /// # fn example() {
1021 /// use aws_smithy_runtime_api::client::interceptors::context::InterceptorContext;
1022 /// use aws_smithy_runtime_api::client::orchestrator::OrchestratorError;
1023 /// use aws_smithy_runtime_api::client::retries::classifiers::{
1024 /// ClassifyRetry, RetryAction, RetryClassifierPriority,
1025 /// };
1026 /// use aws_smithy_types::error::metadata::ProvideErrorMetadata;
1027 /// use aws_smithy_types::retry::ErrorKind;
1028 /// use std::error::Error as StdError;
1029 /// use std::marker::PhantomData;
1030 /// use std::fmt;
1031 /// use aws_sdk_accountaccessruntime::config::Config;
1032 /// # #[derive(Debug)]
1033 /// # struct SomeOperationError {}
1034 /// # impl StdError for SomeOperationError {}
1035 /// # impl fmt::Display for SomeOperationError {
1036 /// # fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { todo!() }
1037 /// # }
1038 /// # impl ProvideErrorMetadata for SomeOperationError {
1039 /// # fn meta(&self) -> &aws_sdk_accountaccessruntime::error::ErrorMetadata { todo!() }
1040 /// # }
1041 ///
1042 /// const RETRYABLE_ERROR_CODES: &[&str] = &[
1043 /// // List error codes to be retried here...
1044 /// ];
1045 ///
1046 /// // When classifying at an operation's error type, classifiers require a generic parameter.
1047 /// // When classifying the HTTP response alone, no generic is needed.
1048 /// #[derive(Debug, Default)]
1049 /// pub struct ExampleErrorCodeClassifier<E> {
1050 /// _inner: PhantomData<E>,
1051 /// }
1052 ///
1053 /// impl<E> ExampleErrorCodeClassifier<E> {
1054 /// pub fn new() -> Self {
1055 /// Self {
1056 /// _inner: PhantomData,
1057 /// }
1058 /// }
1059 /// }
1060 ///
1061 /// impl<E> ClassifyRetry for ExampleErrorCodeClassifier<E>
1062 /// where
1063 /// // Adding a trait bound for ProvideErrorMetadata allows us to inspect the error code.
1064 /// E: StdError + ProvideErrorMetadata + Send + Sync + 'static,
1065 /// {
1066 /// fn classify_retry(&self, ctx: &InterceptorContext) -> RetryAction {
1067 /// // Check for a result
1068 /// let output_or_error = ctx.output_or_error();
1069 /// // Check for an error
1070 /// let error = match output_or_error {
1071 /// Some(Ok(_)) | None => return RetryAction::NoActionIndicated,
1072 /// Some(Err(err)) => err,
1073 /// };
1074 ///
1075 /// // Downcast the generic error and extract the code
1076 /// let error_code = OrchestratorError::as_operation_error(error)
1077 /// .and_then(|err| err.downcast_ref::<E>())
1078 /// .and_then(|err| err.code());
1079 ///
1080 /// // If this error's code is in our list, return an action that tells the RetryStrategy to retry this request.
1081 /// if let Some(error_code) = error_code {
1082 /// if RETRYABLE_ERROR_CODES.contains(&error_code) {
1083 /// return RetryAction::transient_error();
1084 /// }
1085 /// }
1086 ///
1087 /// // Otherwise, return that no action is indicated i.e. that this classifier doesn't require a retry.
1088 /// // Another classifier may still classify this response as retryable.
1089 /// RetryAction::NoActionIndicated
1090 /// }
1091 ///
1092 /// fn name(&self) -> &'static str { "Example Error Code Classifier" }
1093 /// }
1094 ///
1095 /// let config = Config::builder()
1096 /// .retry_classifier(ExampleErrorCodeClassifier::<SomeOperationError>::new())
1097 /// .build();
1098 /// # }
1099 /// ```
1100 pub fn retry_classifier(
1101 mut self,
1102 retry_classifier: impl ::aws_smithy_runtime_api::client::retries::classifiers::ClassifyRetry + 'static,
1103 ) -> Self {
1104 self.push_retry_classifier(::aws_smithy_runtime_api::client::retries::classifiers::SharedRetryClassifier::new(
1105 retry_classifier,
1106 ));
1107 self
1108 }
1109
1110 /// Like [`Self::retry_classifier`], but takes a [`SharedRetryClassifier`](::aws_smithy_runtime_api::client::retries::classifiers::SharedRetryClassifier).
1111 pub fn push_retry_classifier(
1112 &mut self,
1113 retry_classifier: ::aws_smithy_runtime_api::client::retries::classifiers::SharedRetryClassifier,
1114 ) -> &mut Self {
1115 self.runtime_components.push_retry_classifier(retry_classifier);
1116 self
1117 }
1118
1119 /// Set [`SharedRetryClassifier`](::aws_smithy_runtime_api::client::retries::classifiers::SharedRetryClassifier)s for the builder, replacing any that
1120 /// were previously set.
1121 pub fn set_retry_classifiers(
1122 &mut self,
1123 retry_classifiers: impl IntoIterator<Item = ::aws_smithy_runtime_api::client::retries::classifiers::SharedRetryClassifier>,
1124 ) -> &mut Self {
1125 self.runtime_components.set_retry_classifiers(retry_classifiers.into_iter());
1126 self
1127 }
1128 /// Sets the name of the app that is using the client.
1129 ///
1130 /// This _optional_ name is used to identify the application in the user agent that
1131 /// gets sent along with requests.
1132 pub fn app_name(mut self, app_name: ::aws_types::app_name::AppName) -> Self {
1133 self.set_app_name(Some(app_name));
1134 self
1135 }
1136 /// Sets the name of the app that is using the client.
1137 ///
1138 /// This _optional_ name is used to identify the application in the user agent that
1139 /// gets sent along with requests.
1140 pub fn set_app_name(&mut self, app_name: ::std::option::Option<::aws_types::app_name::AppName>) -> &mut Self {
1141 self.config.store_or_unset(app_name);
1142 self
1143 }
1144 /// Appends framework metadata to the user agent.
1145 ///
1146 /// This _optional_ metadata identifies a software framework or third-party library
1147 /// that is being used with the client. It is rendered into the user agent string
1148 /// (as `lib/{name}/{version}`) so that libraries built on top of the AWS SDK can
1149 /// self-identify in the requests they make. Multiple entries may be added; each call
1150 /// appends another entry rather than replacing previous ones.
1151 ///
1152 /// Entries are de-duplicated on `(name, version)`, rendered in first-seen order, and
1153 /// the total number of unique entries included in the user agent is capped (currently
1154 /// at 10); additional entries beyond the cap are dropped with a warning.
1155 pub fn framework_metadata(mut self, framework_metadata: ::aws_types::sdk_ua_metadata::FrameworkMetadata) -> Self {
1156 self.push_framework_metadata(framework_metadata);
1157 self
1158 }
1159 /// Appends framework metadata to the user agent.
1160 ///
1161 /// This _optional_ metadata identifies a software framework or third-party library
1162 /// that is being used with the client. It is rendered into the user agent string
1163 /// (as `lib/{name}/{version}`) so that libraries built on top of the AWS SDK can
1164 /// self-identify in the requests they make. Multiple entries may be added; each call
1165 /// appends another entry rather than replacing previous ones.
1166 pub fn push_framework_metadata(&mut self, framework_metadata: ::aws_types::sdk_ua_metadata::FrameworkMetadata) -> &mut Self {
1167 self.config.store_append(framework_metadata);
1168 self
1169 }
1170 /// Sets the access token provider for this service
1171 ///
1172 /// Note: the [`Self::bearer_token`] and [`Self::bearer_token_resolver`] methods are
1173 /// equivalent to this method, but take the [`Token`] and [`ResolveIdentity`] types
1174 /// respectively.
1175 ///
1176 /// [`Token`]: crate::config::Token
1177 /// [`ResolveIdentity`]: crate::config::ResolveIdentity
1178 pub fn token_provider(mut self, token_provider: impl crate::config::ProvideToken + 'static) -> Self {
1179 self.set_token_provider(::std::option::Option::Some(::aws_smithy_runtime_api::shared::IntoShared::<
1180 crate::config::SharedTokenProvider,
1181 >::into_shared(token_provider)));
1182 self
1183 }
1184
1185 /// Sets the access token provider for this service
1186 ///
1187 /// Note: the [`Self::bearer_token`] and [`Self::bearer_token_resolver`] methods are
1188 /// equivalent to this method, but take the [`Token`] and [`ResolveIdentity`] types
1189 /// respectively.
1190 ///
1191 /// [`Token`]: crate::config::Token
1192 /// [`ResolveIdentity`]: crate::config::ResolveIdentity
1193 pub fn set_token_provider(&mut self, token_provider: ::std::option::Option<crate::config::SharedTokenProvider>) -> &mut Self {
1194 if let Some(token_provider) = token_provider {
1195 self.runtime_components
1196 .set_identity_resolver(::aws_smithy_runtime_api::client::auth::http::HTTP_BEARER_AUTH_SCHEME_ID, token_provider);
1197 }
1198 self
1199 }
1200 /// Sets whether clock skew correction is disabled when making requests.
1201 pub fn disable_clock_skew_correction(mut self, disable_clock_skew_correction: impl ::std::convert::Into<::std::option::Option<bool>>) -> Self {
1202 self.set_disable_clock_skew_correction(disable_clock_skew_correction.into());
1203 self
1204 }
1205
1206 /// Sets whether clock skew correction is disabled when making requests.
1207 pub fn set_disable_clock_skew_correction(&mut self, disable_clock_skew_correction: ::std::option::Option<bool>) -> &mut Self {
1208 self.config
1209 .store_or_unset::<::aws_runtime::service_clock_skew::DisableClockSkewCorrection>(disable_clock_skew_correction.map(Into::into));
1210 self
1211 }
1212 /// Overrides the default invocation ID generator.
1213 ///
1214 /// The invocation ID generator generates ID values for the `amz-sdk-invocation-id` header. By default, this will be a random UUID. Overriding it may be useful in tests that examine the HTTP request and need to be deterministic.
1215 pub fn invocation_id_generator(mut self, gen: impl ::aws_runtime::invocation_id::InvocationIdGenerator + 'static) -> Self {
1216 self.set_invocation_id_generator(::std::option::Option::Some(
1217 ::aws_runtime::invocation_id::SharedInvocationIdGenerator::new(gen),
1218 ));
1219 self
1220 }
1221 /// Overrides the default invocation ID generator.
1222 ///
1223 /// The invocation ID generator generates ID values for the `amz-sdk-invocation-id` header. By default, this will be a random UUID. Overriding it may be useful in tests that examine the HTTP request and need to be deterministic.
1224 pub fn set_invocation_id_generator(
1225 &mut self,
1226 gen: ::std::option::Option<::aws_runtime::invocation_id::SharedInvocationIdGenerator>,
1227 ) -> &mut Self {
1228 self.config.store_or_unset(gen);
1229 self
1230 }
1231 /// Sets the endpoint URL used to communicate with this service.
1232 ///
1233 /// Note: this is used in combination with other endpoint rules, e.g. an API that applies a host-label prefix
1234 /// will be prefixed onto this URL. To fully override the endpoint resolver, use
1235 /// [`Builder::endpoint_resolver`].
1236 pub fn endpoint_url(mut self, endpoint_url: impl Into<::std::string::String>) -> Self {
1237 self.set_endpoint_url(Some(endpoint_url.into()));
1238 self
1239 }
1240 /// Sets the endpoint URL used to communicate with this service.
1241 ///
1242 /// Note: this is used in combination with other endpoint rules, e.g. an API that applies a host-label prefix
1243 /// will be prefixed onto this URL. To fully override the endpoint resolver, use
1244 /// [`Builder::endpoint_resolver`].
1245 pub fn set_endpoint_url(&mut self, endpoint_url: Option<::std::string::String>) -> &mut Self {
1246 self.config.store_or_unset(endpoint_url.map(::aws_types::endpoint_config::EndpointUrl));
1247 self
1248 }
1249 /// When true, send this request to the FIPS-compliant regional endpoint. If the configured endpoint does not have a FIPS compliant endpoint, dispatching the request will return an error.
1250 pub fn use_fips(mut self, use_fips: impl Into<bool>) -> Self {
1251 self.set_use_fips(Some(use_fips.into()));
1252 self
1253 }
1254 /// When true, send this request to the FIPS-compliant regional endpoint. If the configured endpoint does not have a FIPS compliant endpoint, dispatching the request will return an error.
1255 pub fn set_use_fips(&mut self, use_fips: Option<bool>) -> &mut Self {
1256 self.config.store_or_unset(use_fips.map(::aws_types::endpoint_config::UseFips));
1257 self
1258 }
1259 /// Sets the AWS region to use when making requests.
1260 ///
1261 /// # Examples
1262 /// ```no_run
1263 /// use aws_types::region::Region;
1264 /// use aws_sdk_accountaccessruntime::config::{Builder, Config};
1265 ///
1266 /// let config = aws_sdk_accountaccessruntime::Config::builder()
1267 /// .region(Region::new("us-east-1"))
1268 /// .build();
1269 /// ```
1270 pub fn region(mut self, region: impl ::std::convert::Into<::std::option::Option<crate::config::Region>>) -> Self {
1271 self.set_region(region.into());
1272 self
1273 }
1274 /// Sets the AWS region to use when making requests.
1275 pub fn set_region(&mut self, region: ::std::option::Option<crate::config::Region>) -> &mut Self {
1276 self.config.store_or_unset(region);
1277 self
1278 }
1279 /// Sets the [`behavior major version`](crate::config::BehaviorVersion).
1280 ///
1281 /// Over time, new best-practice behaviors are introduced. However, these behaviors might not be backwards
1282 /// compatible. For example, a change which introduces new default timeouts or a new retry-mode for
1283 /// all operations might be the ideal behavior but could break existing applications.
1284 ///
1285 /// # Examples
1286 ///
1287 /// Set the behavior major version to `latest`. This is equivalent to enabling the `behavior-version-latest` cargo feature.
1288 /// ```no_run
1289 /// use aws_sdk_accountaccessruntime::config::BehaviorVersion;
1290 ///
1291 /// let config = aws_sdk_accountaccessruntime::Config::builder()
1292 /// .behavior_version(BehaviorVersion::latest())
1293 /// // ...
1294 /// .build();
1295 /// let client = aws_sdk_accountaccessruntime::Client::from_conf(config);
1296 /// ```
1297 ///
1298 /// Customizing behavior major version:
1299 /// ```no_run
1300 /// use aws_sdk_accountaccessruntime::config::BehaviorVersion;
1301 ///
1302 /// let config = aws_sdk_accountaccessruntime::Config::builder()
1303 /// .behavior_version(BehaviorVersion::v2023_11_09())
1304 /// // ...
1305 /// .build();
1306 /// let client = aws_sdk_accountaccessruntime::Client::from_conf(config);
1307 /// ```
1308 ///
1309 pub fn behavior_version(mut self, behavior_version: crate::config::BehaviorVersion) -> Self {
1310 self.set_behavior_version(Some(behavior_version));
1311 self
1312 }
1313
1314 /// Sets the [`behavior major version`](crate::config::BehaviorVersion).
1315 ///
1316 /// Over time, new best-practice behaviors are introduced. However, these behaviors might not be backwards
1317 /// compatible. For example, a change which introduces new default timeouts or a new retry-mode for
1318 /// all operations might be the ideal behavior but could break existing applications.
1319 ///
1320 /// # Examples
1321 ///
1322 /// Set the behavior major version to `latest`. This is equivalent to enabling the `behavior-version-latest` cargo feature.
1323 /// ```no_run
1324 /// use aws_sdk_accountaccessruntime::config::BehaviorVersion;
1325 ///
1326 /// let config = aws_sdk_accountaccessruntime::Config::builder()
1327 /// .behavior_version(BehaviorVersion::latest())
1328 /// // ...
1329 /// .build();
1330 /// let client = aws_sdk_accountaccessruntime::Client::from_conf(config);
1331 /// ```
1332 ///
1333 /// Customizing behavior major version:
1334 /// ```no_run
1335 /// use aws_sdk_accountaccessruntime::config::BehaviorVersion;
1336 ///
1337 /// let config = aws_sdk_accountaccessruntime::Config::builder()
1338 /// .behavior_version(BehaviorVersion::v2023_11_09())
1339 /// // ...
1340 /// .build();
1341 /// let client = aws_sdk_accountaccessruntime::Client::from_conf(config);
1342 /// ```
1343 ///
1344 pub fn set_behavior_version(&mut self, behavior_version: Option<crate::config::BehaviorVersion>) -> &mut Self {
1345 self.behavior_version = behavior_version;
1346 self
1347 }
1348
1349 /// Convenience method to set the latest behavior major version
1350 ///
1351 /// This is equivalent to enabling the `behavior-version-latest` Cargo feature
1352 pub fn behavior_version_latest(mut self) -> Self {
1353 self.set_behavior_version(Some(crate::config::BehaviorVersion::latest()));
1354 self
1355 }
1356 /// Adds a runtime plugin to the config.
1357 #[allow(unused)]
1358 pub(crate) fn runtime_plugin(mut self, plugin: impl crate::config::RuntimePlugin + 'static) -> Self {
1359 self.push_runtime_plugin(crate::config::SharedRuntimePlugin::new(plugin));
1360 self
1361 }
1362 /// Adds a runtime plugin to the config.
1363 #[allow(unused)]
1364 pub(crate) fn push_runtime_plugin(&mut self, plugin: crate::config::SharedRuntimePlugin) -> &mut Self {
1365 self.runtime_plugins.push(plugin);
1366 self
1367 }
1368 #[cfg(any(feature = "test-util", test))]
1369 #[allow(unused_mut)]
1370 /// Apply test defaults to the builder. NOTE: Consider migrating to use `apply_test_defaults_v2` instead.
1371 pub fn apply_test_defaults(&mut self) -> &mut Self {
1372 self.set_time_source(::std::option::Option::Some(::aws_smithy_async::time::SharedTimeSource::new(
1373 ::aws_smithy_async::time::StaticTimeSource::new(::std::time::UNIX_EPOCH + ::std::time::Duration::from_secs(1234567890)),
1374 )));
1375 self.config.store_put(::aws_runtime::user_agent::AwsUserAgent::for_tests());
1376 self.set_token_provider(Some(crate::config::SharedTokenProvider::new(::aws_credential_types::Token::for_tests())));
1377 self.behavior_version = ::std::option::Option::Some(crate::config::BehaviorVersion::latest());
1378 self
1379 }
1380 #[cfg(any(feature = "test-util", test))]
1381 #[allow(unused_mut)]
1382 /// Apply test defaults to the builder. NOTE: Consider migrating to use `with_test_defaults_v2` instead.
1383 pub fn with_test_defaults(mut self) -> Self {
1384 self.apply_test_defaults();
1385 self
1386 }
1387 #[cfg(any(feature = "test-util", test))]
1388 #[allow(unused_mut)]
1389 /// Apply test defaults to the builder. V2 of this function sets additional test defaults such as region configuration (if applicable).
1390 pub fn apply_test_defaults_v2(&mut self) -> &mut Self {
1391 self.apply_test_defaults();
1392 if self.config.load::<crate::config::Region>().is_none() {
1393 self.set_region(::std::option::Option::Some(crate::config::Region::new("us-east-1")));
1394 }
1395 self
1396 }
1397 #[cfg(any(feature = "test-util", test))]
1398 #[allow(unused_mut)]
1399 /// Apply test defaults to the builder. V2 of this function sets additional test defaults such as region configuration (if applicable).
1400 pub fn with_test_defaults_v2(mut self) -> Self {
1401 self.apply_test_defaults_v2();
1402 self
1403 }
1404 /// Builds a [`Config`].
1405 #[allow(unused_mut)]
1406 pub fn build(mut self) -> Config {
1407 let mut layer = self.config;
1408 if self.runtime_components.time_source().is_none() {
1409 self.runtime_components
1410 .set_time_source(::std::option::Option::Some(::std::default::Default::default()));
1411 }
1412 layer.store_put(crate::meta::API_METADATA.clone());
1413 Config {
1414 config: crate::config::Layer::from(layer.clone())
1415 .with_name("aws_sdk_accountaccessruntime::config::Config")
1416 .freeze(),
1417 cloneable: layer,
1418 runtime_components: self.runtime_components,
1419 runtime_plugins: self.runtime_plugins,
1420 behavior_version: self.behavior_version,
1421 }
1422 }
1423}
1424#[derive(::std::fmt::Debug)]
1425pub(crate) struct ServiceRuntimePlugin {
1426 config: ::std::option::Option<::aws_smithy_types::config_bag::FrozenLayer>,
1427 runtime_components: ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder,
1428}
1429
1430impl ServiceRuntimePlugin {
1431 pub fn new(_service_config: crate::config::Config) -> Self {
1432 let config = {
1433 let mut cfg = ::aws_smithy_types::config_bag::Layer::new("AWSAccountAccessRuntime");
1434 cfg.store_put(::aws_smithy_runtime::client::orchestrator::AuthSchemeAndEndpointOrchestrationV2);
1435 ::std::option::Option::Some(cfg.freeze())
1436 };
1437 let mut runtime_components = ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder::new("ServiceRuntimePlugin");
1438 runtime_components.push_auth_scheme(::aws_smithy_runtime_api::client::auth::SharedAuthScheme::new(
1439 ::aws_smithy_runtime::client::auth::http::BearerAuthScheme::new(),
1440 ));
1441 runtime_components.set_auth_scheme_option_resolver(::std::option::Option::Some({
1442 use crate::config::auth::ResolveAuthScheme;
1443 crate::config::auth::DefaultAuthSchemeResolver::default().into_shared_resolver()
1444 }));
1445 runtime_components.set_endpoint_resolver(::std::option::Option::Some({
1446 use crate::config::endpoint::ResolveEndpoint;
1447 crate::config::endpoint::DefaultResolver::new().into_shared_resolver()
1448 }));
1449 runtime_components.push_interceptor(::aws_smithy_runtime_api::client::interceptors::SharedInterceptor::permanent(
1450 ::aws_smithy_runtime::client::http::connection_poisoning::ConnectionPoisoningInterceptor::new(),
1451 ));
1452 runtime_components.push_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::HttpStatusCodeClassifier::default());
1453 runtime_components.push_interceptor(::aws_smithy_runtime_api::client::interceptors::SharedInterceptor::permanent(
1454 crate::sdk_feature_tracker::retry_mode::RetryModeFeatureTrackerInterceptor::new(),
1455 ));
1456 runtime_components.push_interceptor(::aws_runtime::service_clock_skew::ServiceClockSkewInterceptor::new());
1457 runtime_components.push_interceptor(::aws_runtime::request_info::RequestInfoInterceptor::new());
1458 runtime_components.push_interceptor(::aws_runtime::user_agent::UserAgentInterceptor::new());
1459 runtime_components.push_interceptor(::aws_runtime::invocation_id::InvocationIdInterceptor::new());
1460 runtime_components.push_interceptor(::aws_smithy_runtime_api::client::interceptors::SharedInterceptor::permanent(
1461 ::aws_runtime::recursion_detection::RecursionDetectionInterceptor::new(),
1462 ));
1463 runtime_components.push_interceptor(::aws_smithy_runtime_api::client::interceptors::SharedInterceptor::permanent(
1464 crate::config::endpoint::EndpointOverrideFeatureTrackerInterceptor,
1465 ));
1466 runtime_components.push_interceptor(::aws_smithy_runtime_api::client::interceptors::SharedInterceptor::permanent(
1467 crate::observability_feature::ObservabilityFeatureTrackerInterceptor,
1468 ));
1469 Self { config, runtime_components }
1470 }
1471}
1472
1473impl ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin for ServiceRuntimePlugin {
1474 fn config(&self) -> ::std::option::Option<::aws_smithy_types::config_bag::FrozenLayer> {
1475 self.config.clone()
1476 }
1477
1478 fn order(&self) -> ::aws_smithy_runtime_api::client::runtime_plugin::Order {
1479 ::aws_smithy_runtime_api::client::runtime_plugin::Order::Defaults
1480 }
1481
1482 fn runtime_components(
1483 &self,
1484 _: &::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder,
1485 ) -> ::std::borrow::Cow<'_, ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder> {
1486 ::std::borrow::Cow::Borrowed(&self.runtime_components)
1487 }
1488}
1489
1490// Cross-operation shared-state singletons
1491
1492/// A plugin that enables configuration for a single operation invocation
1493///
1494/// The `config` method will return a `FrozenLayer` by storing values from `config_override`.
1495/// In the case of default values requested, they will be obtained from `client_config`.
1496#[derive(Debug)]
1497pub(crate) struct ConfigOverrideRuntimePlugin {
1498 pub(crate) config: ::aws_smithy_types::config_bag::FrozenLayer,
1499 pub(crate) components: ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder,
1500}
1501
1502impl ConfigOverrideRuntimePlugin {
1503 #[allow(dead_code)] // unused when a service does not provide any operations
1504 pub(crate) fn new(
1505 config_override: Builder,
1506 initial_config: ::aws_smithy_types::config_bag::FrozenLayer,
1507 initial_components: &::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder,
1508 ) -> Self {
1509 let mut layer = config_override.config;
1510 let mut components = config_override.runtime_components;
1511 #[allow(unused_mut)]
1512 let mut resolver =
1513 ::aws_smithy_runtime::client::config_override::Resolver::overrid(initial_config, initial_components, &mut layer, &mut components);
1514
1515 let _ = resolver;
1516
1517 // When the config override supplies an identity resolver for any auth scheme
1518 // known to the client or the override itself, we give this operation its own
1519 // short-lived identity cache so that new partitions don't accumulate in the
1520 // shared client cache. A lazy cache (not `no_cache`) is used so that resolved
1521 // identities are served from the short-lived identity cache on retries.
1522 //
1523 // This is skipped if the override already sets its own identity cache.
1524 if components.has_identity_resolvers() && components.identity_cache().is_none() {
1525 components.set_identity_cache(::std::option::Option::Some(
1526 ::aws_smithy_runtime::client::identity::IdentityCache::lazy().max_partitions(1).build(),
1527 ));
1528 }
1529
1530 Self {
1531 config: ::aws_smithy_types::config_bag::Layer::from(layer)
1532 .with_name("aws_sdk_accountaccessruntime::config::ConfigOverrideRuntimePlugin")
1533 .freeze(),
1534 components,
1535 }
1536 }
1537}
1538
1539impl ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin for ConfigOverrideRuntimePlugin {
1540 fn config(&self) -> ::std::option::Option<::aws_smithy_types::config_bag::FrozenLayer> {
1541 Some(self.config.clone())
1542 }
1543
1544 fn runtime_components(
1545 &self,
1546 _: &::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder,
1547 ) -> ::std::borrow::Cow<'_, ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder> {
1548 ::std::borrow::Cow::Borrowed(&self.components)
1549 }
1550}
1551
1552pub use ::aws_smithy_runtime::client::identity::IdentityCache;
1553pub use ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponents;
1554pub use ::aws_smithy_types::config_bag::ConfigBag;
1555
1556impl From<&::aws_types::sdk_config::SdkConfig> for Builder {
1557 fn from(input: &::aws_types::sdk_config::SdkConfig) -> Self {
1558 let mut builder = Builder::default();
1559 builder = builder.region(input.region().cloned());
1560 builder.set_use_fips(input.use_fips());
1561 if input.get_origin("endpoint_url").is_client_config() {
1562 builder.set_endpoint_url(input.endpoint_url().map(|s| s.to_string()));
1563 } else {
1564 builder.set_endpoint_url(
1565 input
1566 .service_config()
1567 .and_then(|conf| {
1568 conf.load_config(service_config_key("Account Access Runtime", "AWS_ENDPOINT_URL", "endpoint_url"))
1569 .map(|it| it.parse().unwrap())
1570 })
1571 .or_else(|| input.endpoint_url().map(|s| s.to_string())),
1572 );
1573 }
1574 // resiliency
1575 builder.set_retry_config(input.retry_config().cloned());
1576 builder.set_timeout_config(input.timeout_config().cloned());
1577 builder.set_sleep_impl(input.sleep_impl());
1578
1579 builder.set_http_client(input.http_client());
1580 builder.set_time_source(input.time_source());
1581 builder.set_behavior_version(input.behavior_version());
1582 builder.set_auth_scheme_preference(input.auth_scheme_preference().cloned());
1583 // setting `None` here removes the default
1584 if let Some(config) = input.stalled_stream_protection() {
1585 builder.set_stalled_stream_protection(Some(config));
1586 }
1587
1588 if let Some(cache) = input.identity_cache() {
1589 builder.set_identity_cache(cache);
1590 }
1591 builder = builder.disable_clock_skew_correction(input.disable_clock_skew_correction());
1592 builder.set_token_provider(input.token_provider());
1593 builder.set_app_name(input.app_name().cloned());
1594 for framework_metadata in input.framework_metadata() {
1595 builder.push_framework_metadata(framework_metadata.clone());
1596 }
1597
1598 builder
1599 }
1600}
1601
1602impl From<&::aws_types::sdk_config::SdkConfig> for Config {
1603 fn from(sdk_config: &::aws_types::sdk_config::SdkConfig) -> Self {
1604 Builder::from(sdk_config).build()
1605 }
1606}
1607
1608pub use ::aws_types::app_name::AppName;
1609pub use ::aws_types::sdk_ua_metadata::FrameworkMetadata;
1610
1611#[allow(dead_code)]
1612fn service_config_key<'a>(service_id: &'a str, env: &'a str, profile: &'a str) -> aws_types::service_config::ServiceConfigKey<'a> {
1613 ::aws_types::service_config::ServiceConfigKey::builder()
1614 .service_id(service_id)
1615 .env(env)
1616 .profile(profile)
1617 .build()
1618 .expect("all field sets explicitly, can't fail")
1619}
1620
1621pub use ::aws_smithy_async::rt::sleep::Sleep;
1622
1623pub(crate) fn base_client_runtime_plugins(mut config: crate::Config) -> ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugins {
1624 let mut configured_plugins = ::std::vec::Vec::new();
1625 ::std::mem::swap(&mut config.runtime_plugins, &mut configured_plugins);
1626 #[cfg(feature = "behavior-version-latest")]
1627 {
1628 if config.behavior_version.is_none() {
1629 config.behavior_version = Some(::aws_smithy_runtime_api::client::behavior_version::BehaviorVersion::latest());
1630 }
1631 }
1632
1633 let default_retry_partition = "accountaccessruntime";
1634 let default_retry_partition = match config.region() {
1635 Some(region) => ::std::borrow::Cow::from(format!("{default_retry_partition}-{region}")),
1636 None => ::std::borrow::Cow::from(default_retry_partition),
1637 };
1638
1639 let scope = "aws-sdk-accountaccessruntime";
1640
1641 #[allow(deprecated)]
1642 let mut plugins = ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugins::new()
1643 // defaults
1644 .with_client_plugins(::aws_smithy_runtime::client::defaults::default_plugins(
1645 ::aws_smithy_runtime::client::defaults::DefaultPluginParams::new()
1646 .with_retry_partition_name(default_retry_partition)
1647 .with_behavior_version(config.behavior_version.expect("Invalid client configuration: A behavior major version must be set when sending a request or constructing a client. You must set it during client construction or by enabling the `behavior-version-latest` cargo feature."))
1648 .with_is_aws_sdk(true)
1649 ))
1650 // user config
1651 .with_client_plugin(
1652 ::aws_smithy_runtime_api::client::runtime_plugin::StaticRuntimePlugin::new()
1653 .with_config(config.config.clone())
1654 .with_runtime_components(config.runtime_components.clone())
1655 )
1656 // codegen config
1657 .with_client_plugin(crate::config::ServiceRuntimePlugin::new(config.clone()))
1658 .with_client_plugin(::aws_smithy_runtime::client::auth::no_auth::NoAuthRuntimePlugin::new())
1659 .with_client_plugin(
1660 ::aws_smithy_runtime::client::metrics::MetricsRuntimePlugin::builder()
1661 .with_scope(scope)
1662 .with_time_source(config.runtime_components.time_source().unwrap_or_default())
1663 .build()
1664 .expect("All required fields have been set")
1665 );
1666
1667 for plugin in configured_plugins {
1668 plugins = plugins.with_client_plugin(plugin);
1669 }
1670 plugins
1671}
1672
1673pub use ::aws_smithy_types::config_bag::FrozenLayer;
1674
1675pub use ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder;
1676
1677pub use ::aws_smithy_runtime_api::client::runtime_plugin::SharedRuntimePlugin;
1678
1679pub use ::aws_smithy_runtime_api::client::behavior_version::BehaviorVersion;
1680
1681pub use ::aws_smithy_runtime_api::client::stalled_stream_protection::StalledStreamProtectionConfig;
1682
1683pub use ::aws_smithy_runtime_api::client::http::SharedHttpClient;
1684
1685pub use ::aws_smithy_async::rt::sleep::SharedAsyncSleep;
1686
1687pub use ::aws_smithy_runtime_api::client::identity::SharedIdentityCache;
1688
1689pub use ::aws_smithy_runtime_api::client::interceptors::SharedInterceptor;
1690
1691pub use ::aws_types::region::Region;
1692
1693pub use ::aws_smithy_runtime_api::client::http::HttpClient;
1694
1695pub use ::aws_smithy_runtime_api::shared::IntoShared;
1696
1697pub use ::aws_smithy_runtime_api::client::identity::http::Token;
1698
1699pub use ::aws_smithy_runtime_api::client::identity::ResolveIdentity;
1700
1701pub use ::aws_smithy_async::rt::sleep::AsyncSleep;
1702
1703pub use ::aws_smithy_runtime_api::client::identity::ResolveCachedIdentity;
1704
1705pub use ::aws_smithy_runtime_api::client::interceptors::Intercept;
1706
1707pub use ::aws_credential_types::provider::token::ProvideToken;
1708
1709pub use ::aws_credential_types::provider::token::SharedTokenProvider;
1710
1711pub use ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin;
1712
1713pub use ::aws_smithy_types::config_bag::Layer;
1714
1715/// Types needed to configure endpoint resolution.
1716pub mod endpoint;
1717
1718/// HTTP request and response types.
1719pub mod http;
1720
1721/// Types needed to implement [`Intercept`](crate::config::Intercept).
1722pub mod interceptors;
1723
1724/// Retry configuration.
1725///
1726/// [`RetryConfig`](crate::config::retry::RetryConfig) sets the number of retry attempts and the backoff between them. Retries are additionally bounded by a retry token bucket (a shared retry quota): [`TokenBucket`](crate::config::retry::TokenBucket) holds the tokens and [`RetryPartition`](crate::config::retry::RetryPartition) determines which clients and operations share one. To size the token bucket or give a workload its own, use [`Builder::retry_partition`](crate::config::Builder::retry_partition).
1727pub mod retry;
1728
1729/// Timeout configuration.
1730pub mod timeout;
1731
1732/// Types needed to configure auth scheme resolution.
1733pub mod auth;