aws_sdk_dynamodb/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_dynamodb 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 invocation ID generator if one was given in config.
120 ///
121 /// 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.
122 pub fn invocation_id_generator(&self) -> ::std::option::Option<::aws_runtime::invocation_id::SharedInvocationIdGenerator> {
123 self.config.load::<::aws_runtime::invocation_id::SharedInvocationIdGenerator>().cloned()
124 }
125 /// Creates a new [service config](crate::Config) from a [shared `config`](::aws_types::sdk_config::SdkConfig).
126 pub fn new(config: &::aws_types::sdk_config::SdkConfig) -> Self {
127 Builder::from(config).build()
128 }
129 /// The signature version 4 service signing name to use in the credential scope when signing requests.
130 ///
131 /// The signing service may be overridden by the `Endpoint`, or by specifying a custom
132 /// [`SigningName`](aws_types::SigningName) during operation construction
133 pub fn signing_name(&self) -> &'static str {
134 "dynamodb"
135 }
136 /// Returns the AWS region, if it was provided.
137 pub fn region(&self) -> ::std::option::Option<&crate::config::Region> {
138 self.config.load::<crate::config::Region>()
139 }
140 /// This function was intended to be removed, and has been broken since release-2023-11-15 as it always returns a `None`. Do not use.
141 #[deprecated(
142 note = "This function was intended to be removed, and has been broken since release-2023-11-15 as it always returns a `None`. Do not use."
143 )]
144 pub fn credentials_provider(&self) -> Option<crate::config::SharedCredentialsProvider> {
145 ::std::option::Option::None
146 }
147}
148/// Builder for creating a `Config`.
149#[derive(::std::clone::Clone, ::std::fmt::Debug)]
150pub struct Builder {
151 pub(crate) config: ::aws_smithy_types::config_bag::CloneableLayer,
152 pub(crate) runtime_components: crate::config::RuntimeComponentsBuilder,
153 pub(crate) runtime_plugins: ::std::vec::Vec<crate::config::SharedRuntimePlugin>,
154 pub(crate) behavior_version: ::std::option::Option<crate::config::BehaviorVersion>,
155}
156impl ::std::default::Default for Builder {
157 fn default() -> Self {
158 Self {
159 config: ::std::default::Default::default(),
160 runtime_components: crate::config::RuntimeComponentsBuilder::new("service config"),
161 runtime_plugins: ::std::default::Default::default(),
162 behavior_version: ::std::default::Default::default(),
163 }
164 }
165}
166impl Builder {
167 ///
168 /// Constructs a config builder.
169 /// <div class="warning">
170 /// Note that a config created from this builder will not have the same safe defaults as one created by
171 /// the <a href="https://crates.io/crates/aws-config" target="_blank">aws-config</a> crate.
172 /// </div>
173 ///
174 pub fn new() -> Self {
175 Self::default()
176 }
177 /// Constructs a config builder from the given `config_bag`, setting only fields stored in the config bag,
178 /// but not those in runtime components.
179 #[allow(unused)]
180 pub(crate) fn from_config_bag(config_bag: &::aws_smithy_types::config_bag::ConfigBag) -> Self {
181 let mut builder = Self::new();
182 builder.set_stalled_stream_protection(config_bag.load::<crate::config::StalledStreamProtectionConfig>().cloned());
183 builder.set_auth_scheme_preference(config_bag.load::<::aws_smithy_runtime_api::client::auth::AuthSchemePreference>().cloned());
184 builder.set_retry_config(config_bag.load::<::aws_smithy_types::retry::RetryConfig>().cloned());
185 builder.set_timeout_config(config_bag.load::<::aws_smithy_types::timeout::TimeoutConfig>().cloned());
186 builder.set_retry_partition(config_bag.load::<::aws_smithy_runtime::client::retries::RetryPartition>().cloned());
187 builder.set_app_name(config_bag.load::<::aws_types::app_name::AppName>().cloned());
188 builder.set_account_id_endpoint_mode(config_bag.load::<::aws_types::endpoint_config::AccountIdEndpointMode>().cloned());
189 builder.set_endpoint_url(config_bag.load::<::aws_types::endpoint_config::EndpointUrl>().map(|ty| ty.0.clone()));
190 builder.set_use_dual_stack(config_bag.load::<::aws_types::endpoint_config::UseDualStack>().map(|ty| ty.0));
191 builder.set_use_fips(config_bag.load::<::aws_types::endpoint_config::UseFips>().map(|ty| ty.0));
192 builder.set_region(config_bag.load::<crate::config::Region>().cloned());
193 builder
194 }
195 /// Set the [`StalledStreamProtectionConfig`](crate::config::StalledStreamProtectionConfig)
196 /// to configure protection for stalled streams.
197 pub fn stalled_stream_protection(mut self, stalled_stream_protection_config: crate::config::StalledStreamProtectionConfig) -> Self {
198 self.set_stalled_stream_protection(::std::option::Option::Some(stalled_stream_protection_config));
199 self
200 }
201 /// Set the [`StalledStreamProtectionConfig`](crate::config::StalledStreamProtectionConfig)
202 /// to configure protection for stalled streams.
203 pub fn set_stalled_stream_protection(
204 &mut self,
205 stalled_stream_protection_config: ::std::option::Option<crate::config::StalledStreamProtectionConfig>,
206 ) -> &mut Self {
207 self.config.store_or_unset(stalled_stream_protection_config);
208 self
209 }
210 /// Sets the idempotency token provider to use for service calls that require tokens.
211 pub fn idempotency_token_provider(
212 mut self,
213 idempotency_token_provider: impl ::std::convert::Into<crate::idempotency_token::IdempotencyTokenProvider>,
214 ) -> Self {
215 self.set_idempotency_token_provider(::std::option::Option::Some(idempotency_token_provider.into()));
216 self
217 }
218 /// Sets the idempotency token provider to use for service calls that require tokens.
219 pub fn set_idempotency_token_provider(
220 &mut self,
221 idempotency_token_provider: ::std::option::Option<crate::idempotency_token::IdempotencyTokenProvider>,
222 ) -> &mut Self {
223 self.config.store_or_unset(idempotency_token_provider);
224 self
225 }
226 /// Sets the HTTP client to use when making requests.
227 ///
228 /// # Examples
229 /// ```no_run
230 /// # #[cfg(test)]
231 /// # mod tests {
232 /// # #[test]
233 /// # fn example() {
234 /// use std::time::Duration;
235 /// use aws_sdk_dynamodb::config::Config;
236 /// use aws_smithy_runtime::client::http::hyper_014::HyperClientBuilder;
237 ///
238 /// let https_connector = hyper_rustls::HttpsConnectorBuilder::new()
239 /// .with_webpki_roots()
240 /// .https_only()
241 /// .enable_http1()
242 /// .enable_http2()
243 /// .build();
244 /// let hyper_client = HyperClientBuilder::new().build(https_connector);
245 ///
246 /// // This connector can then be given to a generated service Config
247 /// let config = my_service_client::Config::builder()
248 /// .endpoint_url("https://example.com")
249 /// .http_client(hyper_client)
250 /// .build();
251 /// let client = my_service_client::Client::from_conf(config);
252 /// # }
253 /// # }
254 /// ```
255 pub fn http_client(mut self, http_client: impl crate::config::HttpClient + 'static) -> Self {
256 self.set_http_client(::std::option::Option::Some(crate::config::IntoShared::into_shared(http_client)));
257 self
258 }
259
260 /// Sets the HTTP client to use when making requests.
261 ///
262 /// # Examples
263 /// ```no_run
264 /// # #[cfg(test)]
265 /// # mod tests {
266 /// # #[test]
267 /// # fn example() {
268 /// use std::time::Duration;
269 /// use aws_sdk_dynamodb::config::{Builder, Config};
270 /// use aws_smithy_runtime::client::http::hyper_014::HyperClientBuilder;
271 ///
272 /// fn override_http_client(builder: &mut Builder) {
273 /// let https_connector = hyper_rustls::HttpsConnectorBuilder::new()
274 /// .with_webpki_roots()
275 /// .https_only()
276 /// .enable_http1()
277 /// .enable_http2()
278 /// .build();
279 /// let hyper_client = HyperClientBuilder::new().build(https_connector);
280 /// builder.set_http_client(Some(hyper_client));
281 /// }
282 ///
283 /// let mut builder = aws_sdk_dynamodb::Config::builder();
284 /// override_http_client(&mut builder);
285 /// let config = builder.build();
286 /// # }
287 /// # }
288 /// ```
289 pub fn set_http_client(&mut self, http_client: Option<crate::config::SharedHttpClient>) -> &mut Self {
290 self.runtime_components.set_http_client(http_client);
291 self
292 }
293 /// Adds an auth scheme to the builder
294 ///
295 /// If `auth_scheme` has an existing [AuthSchemeId](aws_smithy_runtime_api::client::auth::AuthSchemeId) in the runtime, the current identity
296 /// resolver and signer for that scheme will be replaced by those from `auth_scheme`.
297 ///
298 /// _Important:_ When introducing a custom auth scheme, ensure you override either
299 /// [`Self::auth_scheme_resolver`] or [`Self::set_auth_scheme_resolver`]
300 /// so that the custom auth scheme is included in the list of resolved auth scheme options.
301 /// [The default auth scheme resolver](crate::config::auth::DefaultAuthSchemeResolver) will not recognize your custom auth scheme.
302 ///
303 /// # Examples
304 /// ```no_run
305 /// # use aws_smithy_runtime_api::{
306 /// # box_error::BoxError,
307 /// # client::{
308 /// # auth::{
309 /// # AuthScheme, AuthSchemeEndpointConfig, AuthSchemeId, AuthSchemeOption,
310 /// # AuthSchemeOptionsFuture, Sign,
311 /// # },
312 /// # identity::{Identity, IdentityFuture, ResolveIdentity, SharedIdentityResolver},
313 /// # orchestrator::HttpRequest,
314 /// # runtime_components::{GetIdentityResolver, RuntimeComponents},
315 /// # },
316 /// # shared::IntoShared,
317 /// # };
318 /// # use aws_smithy_types::config_bag::ConfigBag;
319 /// // Auth scheme with customer identity resolver and signer
320 /// #[derive(Debug)]
321 /// struct CustomAuthScheme {
322 /// id: AuthSchemeId,
323 /// identity_resolver: SharedIdentityResolver,
324 /// signer: CustomSigner,
325 /// }
326 /// impl Default for CustomAuthScheme {
327 /// fn default() -> Self {
328 /// Self {
329 /// id: AuthSchemeId::new("custom"),
330 /// identity_resolver: CustomIdentityResolver.into_shared(),
331 /// signer: CustomSigner,
332 /// }
333 /// }
334 /// }
335 /// impl AuthScheme for CustomAuthScheme {
336 /// fn scheme_id(&self) -> AuthSchemeId {
337 /// self.id.clone()
338 /// }
339 /// fn identity_resolver(
340 /// &self,
341 /// _identity_resolvers: &dyn GetIdentityResolver,
342 /// ) -> Option<SharedIdentityResolver> {
343 /// Some(self.identity_resolver.clone())
344 /// }
345 /// fn signer(&self) -> &dyn Sign {
346 /// &self.signer
347 /// }
348 /// }
349 ///
350 /// #[derive(Debug, Default)]
351 /// struct CustomSigner;
352 /// impl Sign for CustomSigner {
353 /// fn sign_http_request(
354 /// &self,
355 /// _request: &mut HttpRequest,
356 /// _identity: &Identity,
357 /// _auth_scheme_endpoint_config: AuthSchemeEndpointConfig<'_>,
358 /// _runtime_components: &RuntimeComponents,
359 /// _config_bag: &ConfigBag,
360 /// ) -> Result<(), BoxError> {
361 /// // --snip--
362 /// # todo!()
363 /// }
364 /// }
365 ///
366 /// #[derive(Debug)]
367 /// struct CustomIdentityResolver;
368 /// impl ResolveIdentity for CustomIdentityResolver {
369 /// fn resolve_identity<'a>(
370 /// &'a self,
371 /// _runtime_components: &'a RuntimeComponents,
372 /// _config_bag: &'a ConfigBag,
373 /// ) -> IdentityFuture<'a> {
374 /// // --snip--
375 /// # todo!()
376 /// }
377 /// }
378 ///
379 /// // Auth scheme resolver that favors `CustomAuthScheme`
380 /// #[derive(Debug)]
381 /// struct CustomAuthSchemeResolver;
382 /// impl aws_sdk_dynamodb::config::auth::ResolveAuthScheme for CustomAuthSchemeResolver {
383 /// fn resolve_auth_scheme<'a>(
384 /// &'a self,
385 /// _params: &'a aws_sdk_dynamodb::config::auth::Params,
386 /// _cfg: &'a ConfigBag,
387 /// _runtime_components: &'a RuntimeComponents,
388 /// ) -> AuthSchemeOptionsFuture<'a> {
389 /// AuthSchemeOptionsFuture::ready(Ok(vec![AuthSchemeOption::from(AuthSchemeId::new(
390 /// "custom",
391 /// ))]))
392 /// }
393 /// }
394 ///
395 /// let config = aws_sdk_dynamodb::Config::builder()
396 /// .push_auth_scheme(CustomAuthScheme::default())
397 /// .auth_scheme_resolver(CustomAuthSchemeResolver)
398 /// // other configurations
399 /// .build();
400 /// ```
401 pub fn push_auth_scheme(mut self, auth_scheme: impl ::aws_smithy_runtime_api::client::auth::AuthScheme + 'static) -> Self {
402 self.runtime_components.push_auth_scheme(auth_scheme);
403 self
404 }
405
406 /// Set the auth scheme resolver for the builder
407 ///
408 /// # Examples
409 /// ```no_run
410 /// # use aws_smithy_runtime_api::{
411 /// # client::{
412 /// # auth::AuthSchemeOptionsFuture,
413 /// # runtime_components::RuntimeComponents,
414 /// # },
415 /// # };
416 /// # use aws_smithy_types::config_bag::ConfigBag;
417 /// #[derive(Debug)]
418 /// struct CustomAuthSchemeResolver;
419 /// impl aws_sdk_dynamodb::config::auth::ResolveAuthScheme for CustomAuthSchemeResolver {
420 /// fn resolve_auth_scheme<'a>(
421 /// &'a self,
422 /// _params: &'a aws_sdk_dynamodb::config::auth::Params,
423 /// _cfg: &'a ConfigBag,
424 /// _runtime_components: &'a RuntimeComponents,
425 /// ) -> AuthSchemeOptionsFuture<'a> {
426 /// // --snip--
427 /// # todo!()
428 /// }
429 /// }
430 ///
431 /// let config = aws_sdk_dynamodb::Config::builder()
432 /// .auth_scheme_resolver(CustomAuthSchemeResolver)
433 /// // other configurations
434 /// .build();
435 /// ```
436 pub fn auth_scheme_resolver(mut self, auth_scheme_resolver: impl crate::config::auth::ResolveAuthScheme + 'static) -> Self {
437 self.set_auth_scheme_resolver(auth_scheme_resolver);
438 self
439 }
440
441 /// Set the auth scheme resolver for the builder
442 ///
443 /// # Examples
444 /// See an example for [`Self::auth_scheme_resolver`].
445 pub fn set_auth_scheme_resolver(&mut self, auth_scheme_resolver: impl crate::config::auth::ResolveAuthScheme + 'static) -> &mut Self {
446 self.runtime_components
447 .set_auth_scheme_option_resolver(::std::option::Option::Some(auth_scheme_resolver.into_shared_resolver()));
448 self
449 }
450 /// Set the auth scheme preference for an auth scheme resolver
451 /// (typically the default auth scheme resolver).
452 ///
453 /// Each operation has a predefined order of auth schemes, as determined by the service,
454 /// for auth scheme resolution. By using the auth scheme preference, customers
455 /// can reorder the schemes resolved by the auth scheme resolver.
456 ///
457 /// The preference list is intended as a hint rather than a strict override.
458 /// Any schemes not present in the originally resolved auth schemes will be ignored.
459 ///
460 /// # Examples
461 ///
462 /// ```no_run
463 /// # use aws_smithy_runtime_api::client::auth::AuthSchemeId;
464 /// let config = aws_sdk_dynamodb::Config::builder()
465 /// .auth_scheme_preference([AuthSchemeId::from("scheme1"), AuthSchemeId::from("scheme2")])
466 /// // ...
467 /// .build();
468 /// let client = aws_sdk_dynamodb::Client::from_conf(config);
469 /// ```
470
471 pub fn auth_scheme_preference(
472 mut self,
473 preference: impl ::std::convert::Into<::aws_smithy_runtime_api::client::auth::AuthSchemePreference>,
474 ) -> Self {
475 self.set_auth_scheme_preference(::std::option::Option::Some(preference.into()));
476 self
477 }
478
479 /// Set the auth scheme preference for an auth scheme resolver
480 /// (typically the default auth scheme resolver).
481 ///
482 /// Each operation has a predefined order of auth schemes, as determined by the service,
483 /// for auth scheme resolution. By using the auth scheme preference, customers
484 /// can reorder the schemes resolved by the auth scheme resolver.
485 ///
486 /// The preference list is intended as a hint rather than a strict override.
487 /// Any schemes not present in the originally resolved auth schemes will be ignored.
488 ///
489 /// # Examples
490 ///
491 /// ```no_run
492 /// # use aws_smithy_runtime_api::client::auth::AuthSchemeId;
493 /// let config = aws_sdk_dynamodb::Config::builder()
494 /// .auth_scheme_preference([AuthSchemeId::from("scheme1"), AuthSchemeId::from("scheme2")])
495 /// // ...
496 /// .build();
497 /// let client = aws_sdk_dynamodb::Client::from_conf(config);
498 /// ```
499
500 pub fn set_auth_scheme_preference(
501 &mut self,
502 preference: ::std::option::Option<::aws_smithy_runtime_api::client::auth::AuthSchemePreference>,
503 ) -> &mut Self {
504 self.config.store_or_unset(preference);
505 self
506 }
507 /// Sets the endpoint resolver to use when making requests.
508 ///
509 ///
510 /// When unset, the client will used a generated endpoint resolver based on the endpoint resolution
511 /// rules for `aws_sdk_dynamodb`.
512 ///
513 ///
514 /// Note: setting an endpoint resolver will replace any endpoint URL that has been set.
515 /// This method accepts an endpoint resolver [specific to this service](crate::config::endpoint::ResolveEndpoint). If you want to
516 /// provide a shared endpoint resolver, use [`Self::set_endpoint_resolver`].
517 ///
518 /// # Examples
519 /// Create a custom endpoint resolver that resolves a different endpoing per-stage, e.g. staging vs. production.
520 /// ```no_run
521 /// use aws_sdk_dynamodb::config::endpoint::{ResolveEndpoint, EndpointFuture, Params, Endpoint};
522 /// #[derive(Debug)]
523 /// struct StageResolver { stage: String }
524 /// impl ResolveEndpoint for StageResolver {
525 /// fn resolve_endpoint(&self, params: &Params) -> EndpointFuture<'_> {
526 /// let stage = &self.stage;
527 /// EndpointFuture::ready(Ok(Endpoint::builder().url(format!("{stage}.myservice.com")).build()))
528 /// }
529 /// }
530 /// let resolver = StageResolver { stage: std::env::var("STAGE").unwrap() };
531 /// let config = aws_sdk_dynamodb::Config::builder().endpoint_resolver(resolver).build();
532 /// let client = aws_sdk_dynamodb::Client::from_conf(config);
533 /// ```
534 pub fn endpoint_resolver(mut self, endpoint_resolver: impl crate::config::endpoint::ResolveEndpoint + 'static) -> Self {
535 self.set_endpoint_resolver(::std::option::Option::Some(endpoint_resolver.into_shared_resolver()));
536 self
537 }
538
539 /// Sets the endpoint resolver to use when making requests.
540 ///
541 ///
542 /// When unset, the client will used a generated endpoint resolver based on the endpoint resolution
543 /// rules for `aws_sdk_dynamodb`.
544 ///
545 pub fn set_endpoint_resolver(
546 &mut self,
547 endpoint_resolver: ::std::option::Option<::aws_smithy_runtime_api::client::endpoint::SharedEndpointResolver>,
548 ) -> &mut Self {
549 self.runtime_components.set_endpoint_resolver(endpoint_resolver);
550 self
551 }
552 /// Set the retry_config for the builder
553 ///
554 /// # Examples
555 /// ```no_run
556 /// use aws_sdk_dynamodb::config::Config;
557 /// use aws_sdk_dynamodb::config::retry::RetryConfig;
558 ///
559 /// let retry_config = RetryConfig::standard().with_max_attempts(5);
560 /// let config = Config::builder().retry_config(retry_config).build();
561 /// ```
562 pub fn retry_config(mut self, retry_config: ::aws_smithy_types::retry::RetryConfig) -> Self {
563 self.set_retry_config(Some(retry_config));
564 self
565 }
566
567 /// Set the retry_config for the builder
568 ///
569 /// # Examples
570 /// ```no_run
571 /// use aws_sdk_dynamodb::config::{Builder, Config};
572 /// use aws_sdk_dynamodb::config::retry::RetryConfig;
573 ///
574 /// fn disable_retries(builder: &mut Builder) {
575 /// let retry_config = RetryConfig::standard().with_max_attempts(1);
576 /// builder.set_retry_config(Some(retry_config));
577 /// }
578 ///
579 /// let mut builder = Config::builder();
580 /// disable_retries(&mut builder);
581 /// let config = builder.build();
582 /// ```
583 pub fn set_retry_config(&mut self, retry_config: ::std::option::Option<::aws_smithy_types::retry::RetryConfig>) -> &mut Self {
584 retry_config.map(|r| self.config.store_put(r));
585 self
586 }
587 /// Set the sleep_impl for the builder
588 ///
589 /// # Examples
590 ///
591 /// ```no_run
592 /// use aws_sdk_dynamodb::config::{AsyncSleep, Config, SharedAsyncSleep, Sleep};
593 ///
594 /// #[derive(Debug)]
595 /// pub struct ForeverSleep;
596 ///
597 /// impl AsyncSleep for ForeverSleep {
598 /// fn sleep(&self, duration: std::time::Duration) -> Sleep {
599 /// Sleep::new(std::future::pending())
600 /// }
601 /// }
602 ///
603 /// let sleep_impl = SharedAsyncSleep::new(ForeverSleep);
604 /// let config = Config::builder().sleep_impl(sleep_impl).build();
605 /// ```
606 pub fn sleep_impl(mut self, sleep_impl: impl crate::config::AsyncSleep + 'static) -> Self {
607 self.set_sleep_impl(Some(::aws_smithy_runtime_api::shared::IntoShared::into_shared(sleep_impl)));
608 self
609 }
610
611 /// Set the sleep_impl for the builder
612 ///
613 /// # Examples
614 ///
615 /// ```no_run
616 /// use aws_sdk_dynamodb::config::{AsyncSleep, Builder, Config, SharedAsyncSleep, Sleep};
617 ///
618 /// #[derive(Debug)]
619 /// pub struct ForeverSleep;
620 ///
621 /// impl AsyncSleep for ForeverSleep {
622 /// fn sleep(&self, duration: std::time::Duration) -> Sleep {
623 /// Sleep::new(std::future::pending())
624 /// }
625 /// }
626 ///
627 /// fn set_never_ending_sleep_impl(builder: &mut Builder) {
628 /// let sleep_impl = SharedAsyncSleep::new(ForeverSleep);
629 /// builder.set_sleep_impl(Some(sleep_impl));
630 /// }
631 ///
632 /// let mut builder = Config::builder();
633 /// set_never_ending_sleep_impl(&mut builder);
634 /// let config = builder.build();
635 /// ```
636 pub fn set_sleep_impl(&mut self, sleep_impl: ::std::option::Option<crate::config::SharedAsyncSleep>) -> &mut Self {
637 self.runtime_components.set_sleep_impl(sleep_impl);
638 self
639 }
640 /// Set the timeout_config for the builder
641 ///
642 /// # Examples
643 ///
644 /// ```no_run
645 /// # use std::time::Duration;
646 /// use aws_sdk_dynamodb::config::Config;
647 /// use aws_sdk_dynamodb::config::timeout::TimeoutConfig;
648 ///
649 /// let timeout_config = TimeoutConfig::builder()
650 /// .operation_attempt_timeout(Duration::from_secs(1))
651 /// .build();
652 /// let config = Config::builder().timeout_config(timeout_config).build();
653 /// ```
654 pub fn timeout_config(mut self, timeout_config: ::aws_smithy_types::timeout::TimeoutConfig) -> Self {
655 self.set_timeout_config(Some(timeout_config));
656 self
657 }
658
659 /// Set the timeout_config for the builder.
660 ///
661 /// Setting this to `None` has no effect if another source of configuration has set timeouts. If you
662 /// are attempting to disable timeouts, use [`TimeoutConfig::disabled`](::aws_smithy_types::timeout::TimeoutConfig::disabled)
663 ///
664 ///
665 /// # Examples
666 ///
667 /// ```no_run
668 /// # use std::time::Duration;
669 /// use aws_sdk_dynamodb::config::{Builder, Config};
670 /// use aws_sdk_dynamodb::config::timeout::TimeoutConfig;
671 ///
672 /// fn set_request_timeout(builder: &mut Builder) {
673 /// let timeout_config = TimeoutConfig::builder()
674 /// .operation_attempt_timeout(Duration::from_secs(1))
675 /// .build();
676 /// builder.set_timeout_config(Some(timeout_config));
677 /// }
678 ///
679 /// let mut builder = Config::builder();
680 /// set_request_timeout(&mut builder);
681 /// let config = builder.build();
682 /// ```
683 pub fn set_timeout_config(&mut self, timeout_config: ::std::option::Option<::aws_smithy_types::timeout::TimeoutConfig>) -> &mut Self {
684 // passing None has no impact.
685 let Some(mut timeout_config) = timeout_config else { return self };
686
687 if let Some(base) = self.config.load::<::aws_smithy_types::timeout::TimeoutConfig>() {
688 timeout_config.take_defaults_from(base);
689 }
690 self.config.store_put(timeout_config);
691 self
692 }
693 /// Set the partition for retry-related state. When clients share a retry partition, they will
694 /// also share components such as token buckets and client rate limiters.
695 /// See the [`RetryPartition`](::aws_smithy_runtime::client::retries::RetryPartition) documentation for more details.
696 ///
697 /// # Default Behavior
698 ///
699 /// When no retry partition is explicitly set, the SDK automatically creates a default retry partition named `dynamodb`
700 /// (or `dynamodb-<region>` if a region is configured).
701 /// All DynamoDB clients without an explicit retry partition will share this default partition.
702 ///
703 /// # Notes
704 ///
705 /// - This is an advanced setting — most users won't need to modify it.
706 /// - A configured client rate limiter has no effect unless [`RetryConfig::adaptive`](::aws_smithy_types::retry::RetryConfig::adaptive) is used.
707 ///
708 /// # Examples
709 ///
710 /// Creating a custom retry partition with a token bucket:
711 /// ```no_run
712 /// use aws_sdk_dynamodb::config::Config;
713 /// use aws_sdk_dynamodb::config::retry::{RetryPartition, TokenBucket};
714 ///
715 /// let token_bucket = TokenBucket::new(10);
716 /// let config = Config::builder()
717 /// .retry_partition(RetryPartition::custom("custom")
718 /// .token_bucket(token_bucket)
719 /// .build()
720 /// )
721 /// .build();
722 /// ```
723 ///
724 /// Configuring a client rate limiter with adaptive retry mode:
725 /// ```no_run
726 /// use aws_sdk_dynamodb::config::Config;
727 /// use aws_sdk_dynamodb::config::retry::{ClientRateLimiter, RetryConfig, RetryPartition};
728 ///
729 /// let client_rate_limiter = ClientRateLimiter::new(10.0);
730 /// let config = Config::builder()
731 /// .retry_partition(RetryPartition::custom("custom")
732 /// .client_rate_limiter(client_rate_limiter)
733 /// .build()
734 /// )
735 /// .retry_config(RetryConfig::adaptive())
736 /// .build();
737 /// ```
738 pub fn retry_partition(mut self, retry_partition: ::aws_smithy_runtime::client::retries::RetryPartition) -> Self {
739 self.set_retry_partition(Some(retry_partition));
740 self
741 }
742 /// Like [`Self::retry_partition`], but takes a mutable reference to the builder and an optional `RetryPartition`
743 pub fn set_retry_partition(
744 &mut self,
745 retry_partition: ::std::option::Option<::aws_smithy_runtime::client::retries::RetryPartition>,
746 ) -> &mut Self {
747 retry_partition.map(|r| self.config.store_put(r));
748 self
749 }
750 /// Set the identity cache for auth.
751 ///
752 /// The identity cache defaults to a lazy caching implementation that will resolve
753 /// an identity when it is requested, and place it in the cache thereafter. Subsequent
754 /// requests will take the value from the cache while it is still valid. Once it expires,
755 /// the next request will result in refreshing the identity.
756 ///
757 /// This configuration allows you to disable or change the default caching mechanism.
758 /// To use a custom caching mechanism, implement the [`ResolveCachedIdentity`](crate::config::ResolveCachedIdentity)
759 /// trait and pass that implementation into this function.
760 ///
761 /// # Examples
762 ///
763 /// Disabling identity caching:
764 /// ```no_run
765 /// use aws_sdk_dynamodb::config::IdentityCache;
766 ///
767 /// let config = aws_sdk_dynamodb::Config::builder()
768 /// .identity_cache(IdentityCache::no_cache())
769 /// // ...
770 /// .build();
771 /// let client = aws_sdk_dynamodb::Client::from_conf(config);
772 /// ```
773 ///
774 /// Customizing lazy caching:
775 /// ```no_run
776 /// use aws_sdk_dynamodb::config::IdentityCache;
777 /// use std::time::Duration;
778 ///
779 /// let config = aws_sdk_dynamodb::Config::builder()
780 /// .identity_cache(
781 /// IdentityCache::lazy()
782 /// // change the load timeout to 10 seconds
783 /// .load_timeout(Duration::from_secs(10))
784 /// .build()
785 /// )
786 /// // ...
787 /// .build();
788 /// let client = aws_sdk_dynamodb::Client::from_conf(config);
789 /// ```
790 ///
791 pub fn identity_cache(mut self, identity_cache: impl crate::config::ResolveCachedIdentity + 'static) -> Self {
792 self.set_identity_cache(identity_cache);
793 self
794 }
795
796 /// Set the identity cache for auth.
797 ///
798 /// The identity cache defaults to a lazy caching implementation that will resolve
799 /// an identity when it is requested, and place it in the cache thereafter. Subsequent
800 /// requests will take the value from the cache while it is still valid. Once it expires,
801 /// the next request will result in refreshing the identity.
802 ///
803 /// This configuration allows you to disable or change the default caching mechanism.
804 /// To use a custom caching mechanism, implement the [`ResolveCachedIdentity`](crate::config::ResolveCachedIdentity)
805 /// trait and pass that implementation into this function.
806 ///
807 /// # Examples
808 ///
809 /// Disabling identity caching:
810 /// ```no_run
811 /// use aws_sdk_dynamodb::config::IdentityCache;
812 ///
813 /// let config = aws_sdk_dynamodb::Config::builder()
814 /// .identity_cache(IdentityCache::no_cache())
815 /// // ...
816 /// .build();
817 /// let client = aws_sdk_dynamodb::Client::from_conf(config);
818 /// ```
819 ///
820 /// Customizing lazy caching:
821 /// ```no_run
822 /// use aws_sdk_dynamodb::config::IdentityCache;
823 /// use std::time::Duration;
824 ///
825 /// let config = aws_sdk_dynamodb::Config::builder()
826 /// .identity_cache(
827 /// IdentityCache::lazy()
828 /// // change the load timeout to 10 seconds
829 /// .load_timeout(Duration::from_secs(10))
830 /// .build()
831 /// )
832 /// // ...
833 /// .build();
834 /// let client = aws_sdk_dynamodb::Client::from_conf(config);
835 /// ```
836 ///
837 pub fn set_identity_cache(&mut self, identity_cache: impl crate::config::ResolveCachedIdentity + 'static) -> &mut Self {
838 self.runtime_components.set_identity_cache(::std::option::Option::Some(identity_cache));
839 self
840 }
841 /// Add an [interceptor](crate::config::Intercept) that runs at specific stages of the request execution pipeline.
842 ///
843 /// Interceptors targeted at a certain stage are executed according to the pre-defined priority.
844 /// The SDK provides a default set of interceptors. An interceptor configured by this method
845 /// will run after those default interceptors.
846 ///
847 /// # Examples
848 /// ```no_run
849 /// # fn example() {
850 /// use aws_smithy_runtime_api::box_error::BoxError;
851 /// use aws_smithy_runtime_api::client::interceptors::context::BeforeTransmitInterceptorContextMut;
852 /// use aws_smithy_runtime_api::client::interceptors::Intercept;
853 /// use aws_smithy_runtime_api::client::runtime_components::RuntimeComponents;
854 /// use aws_smithy_types::config_bag::ConfigBag;
855 /// use aws_sdk_dynamodb::config::Config;
856 /// use ::http::uri::Uri;
857 ///
858 /// fn base_url() -> String {
859 /// // ...
860 /// # String::new()
861 /// }
862 ///
863 /// #[derive(Debug)]
864 /// pub struct UriModifierInterceptor;
865 /// impl Intercept for UriModifierInterceptor {
866 /// fn name(&self) -> &'static str {
867 /// "UriModifierInterceptor"
868 /// }
869 /// fn modify_before_signing(
870 /// &self,
871 /// context: &mut BeforeTransmitInterceptorContextMut<'_>,
872 /// _runtime_components: &RuntimeComponents,
873 /// _cfg: &mut ConfigBag,
874 /// ) -> Result<(), BoxError> {
875 /// let request = context.request_mut();
876 /// let uri = format!("{}{}", base_url(), request.uri());
877 /// *request.uri_mut() = uri.parse::<Uri>()?.into();
878 ///
879 /// Ok(())
880 /// }
881 /// }
882 ///
883 /// let config = Config::builder()
884 /// .interceptor(UriModifierInterceptor)
885 /// .build();
886 /// # }
887 /// ```
888 pub fn interceptor(mut self, interceptor: impl crate::config::Intercept + 'static) -> Self {
889 self.push_interceptor(crate::config::SharedInterceptor::new(interceptor));
890 self
891 }
892
893 /// Like [`Self::interceptor`], but takes a [`SharedInterceptor`](crate::config::SharedInterceptor).
894 pub fn push_interceptor(&mut self, interceptor: crate::config::SharedInterceptor) -> &mut Self {
895 self.runtime_components.push_interceptor(interceptor);
896 self
897 }
898
899 /// Set [`SharedInterceptor`](crate::config::SharedInterceptor)s for the builder.
900 pub fn set_interceptors(&mut self, interceptors: impl IntoIterator<Item = crate::config::SharedInterceptor>) -> &mut Self {
901 self.runtime_components.set_interceptors(interceptors.into_iter());
902 self
903 }
904 /// Sets the time source used for this service
905 pub fn time_source(mut self, time_source: impl ::aws_smithy_async::time::TimeSource + 'static) -> Self {
906 self.set_time_source(::std::option::Option::Some(::aws_smithy_runtime_api::shared::IntoShared::into_shared(
907 time_source,
908 )));
909 self
910 }
911 /// Sets the time source used for this service
912 pub fn set_time_source(&mut self, time_source: ::std::option::Option<::aws_smithy_async::time::SharedTimeSource>) -> &mut Self {
913 self.runtime_components.set_time_source(time_source);
914 self
915 }
916 /// Add type implementing [`ClassifyRetry`](::aws_smithy_runtime_api::client::retries::classifiers::ClassifyRetry) that will be used by the
917 /// [`RetryStrategy`](::aws_smithy_runtime_api::client::retries::RetryStrategy) to determine what responses should be retried.
918 ///
919 /// A retry classifier configured by this method will run according to its [priority](::aws_smithy_runtime_api::client::retries::classifiers::RetryClassifierPriority).
920 ///
921 /// # Examples
922 /// ```no_run
923 /// # fn example() {
924 /// use aws_smithy_runtime_api::client::interceptors::context::InterceptorContext;
925 /// use aws_smithy_runtime_api::client::orchestrator::OrchestratorError;
926 /// use aws_smithy_runtime_api::client::retries::classifiers::{
927 /// ClassifyRetry, RetryAction, RetryClassifierPriority,
928 /// };
929 /// use aws_smithy_types::error::metadata::ProvideErrorMetadata;
930 /// use aws_smithy_types::retry::ErrorKind;
931 /// use std::error::Error as StdError;
932 /// use std::marker::PhantomData;
933 /// use std::fmt;
934 /// use aws_sdk_dynamodb::config::Config;
935 /// # #[derive(Debug)]
936 /// # struct SomeOperationError {}
937 /// # impl StdError for SomeOperationError {}
938 /// # impl fmt::Display for SomeOperationError {
939 /// # fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { todo!() }
940 /// # }
941 /// # impl ProvideErrorMetadata for SomeOperationError {
942 /// # fn meta(&self) -> &aws_sdk_dynamodb::error::ErrorMetadata { todo!() }
943 /// # }
944 ///
945 /// const RETRYABLE_ERROR_CODES: &[&str] = &[
946 /// // List error codes to be retried here...
947 /// ];
948 ///
949 /// // When classifying at an operation's error type, classifiers require a generic parameter.
950 /// // When classifying the HTTP response alone, no generic is needed.
951 /// #[derive(Debug, Default)]
952 /// pub struct ExampleErrorCodeClassifier<E> {
953 /// _inner: PhantomData<E>,
954 /// }
955 ///
956 /// impl<E> ExampleErrorCodeClassifier<E> {
957 /// pub fn new() -> Self {
958 /// Self {
959 /// _inner: PhantomData,
960 /// }
961 /// }
962 /// }
963 ///
964 /// impl<E> ClassifyRetry for ExampleErrorCodeClassifier<E>
965 /// where
966 /// // Adding a trait bound for ProvideErrorMetadata allows us to inspect the error code.
967 /// E: StdError + ProvideErrorMetadata + Send + Sync + 'static,
968 /// {
969 /// fn classify_retry(&self, ctx: &InterceptorContext) -> RetryAction {
970 /// // Check for a result
971 /// let output_or_error = ctx.output_or_error();
972 /// // Check for an error
973 /// let error = match output_or_error {
974 /// Some(Ok(_)) | None => return RetryAction::NoActionIndicated,
975 /// Some(Err(err)) => err,
976 /// };
977 ///
978 /// // Downcast the generic error and extract the code
979 /// let error_code = OrchestratorError::as_operation_error(error)
980 /// .and_then(|err| err.downcast_ref::<E>())
981 /// .and_then(|err| err.code());
982 ///
983 /// // If this error's code is in our list, return an action that tells the RetryStrategy to retry this request.
984 /// if let Some(error_code) = error_code {
985 /// if RETRYABLE_ERROR_CODES.contains(&error_code) {
986 /// return RetryAction::transient_error();
987 /// }
988 /// }
989 ///
990 /// // Otherwise, return that no action is indicated i.e. that this classifier doesn't require a retry.
991 /// // Another classifier may still classify this response as retryable.
992 /// RetryAction::NoActionIndicated
993 /// }
994 ///
995 /// fn name(&self) -> &'static str { "Example Error Code Classifier" }
996 /// }
997 ///
998 /// let config = Config::builder()
999 /// .retry_classifier(ExampleErrorCodeClassifier::<SomeOperationError>::new())
1000 /// .build();
1001 /// # }
1002 /// ```
1003 pub fn retry_classifier(
1004 mut self,
1005 retry_classifier: impl ::aws_smithy_runtime_api::client::retries::classifiers::ClassifyRetry + 'static,
1006 ) -> Self {
1007 self.push_retry_classifier(::aws_smithy_runtime_api::client::retries::classifiers::SharedRetryClassifier::new(
1008 retry_classifier,
1009 ));
1010 self
1011 }
1012
1013 /// Like [`Self::retry_classifier`], but takes a [`SharedRetryClassifier`](::aws_smithy_runtime_api::client::retries::classifiers::SharedRetryClassifier).
1014 pub fn push_retry_classifier(
1015 &mut self,
1016 retry_classifier: ::aws_smithy_runtime_api::client::retries::classifiers::SharedRetryClassifier,
1017 ) -> &mut Self {
1018 self.runtime_components.push_retry_classifier(retry_classifier);
1019 self
1020 }
1021
1022 /// Set [`SharedRetryClassifier`](::aws_smithy_runtime_api::client::retries::classifiers::SharedRetryClassifier)s for the builder, replacing any that
1023 /// were previously set.
1024 pub fn set_retry_classifiers(
1025 &mut self,
1026 retry_classifiers: impl IntoIterator<Item = ::aws_smithy_runtime_api::client::retries::classifiers::SharedRetryClassifier>,
1027 ) -> &mut Self {
1028 self.runtime_components.set_retry_classifiers(retry_classifiers.into_iter());
1029 self
1030 }
1031 /// Sets the name of the app that is using the client.
1032 ///
1033 /// This _optional_ name is used to identify the application in the user agent that
1034 /// gets sent along with requests.
1035 pub fn app_name(mut self, app_name: ::aws_types::app_name::AppName) -> Self {
1036 self.set_app_name(Some(app_name));
1037 self
1038 }
1039 /// Sets the name of the app that is using the client.
1040 ///
1041 /// This _optional_ name is used to identify the application in the user agent that
1042 /// gets sent along with requests.
1043 pub fn set_app_name(&mut self, app_name: ::std::option::Option<::aws_types::app_name::AppName>) -> &mut Self {
1044 self.config.store_or_unset(app_name);
1045 self
1046 }
1047 /// Overrides the default invocation ID generator.
1048 ///
1049 /// 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.
1050 pub fn invocation_id_generator(mut self, gen: impl ::aws_runtime::invocation_id::InvocationIdGenerator + 'static) -> Self {
1051 self.set_invocation_id_generator(::std::option::Option::Some(
1052 ::aws_runtime::invocation_id::SharedInvocationIdGenerator::new(gen),
1053 ));
1054 self
1055 }
1056 /// Overrides the default invocation ID generator.
1057 ///
1058 /// 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.
1059 pub fn set_invocation_id_generator(
1060 &mut self,
1061 gen: ::std::option::Option<::aws_runtime::invocation_id::SharedInvocationIdGenerator>,
1062 ) -> &mut Self {
1063 self.config.store_or_unset(gen);
1064 self
1065 }
1066 /// The AccountId Endpoint Mode.
1067 pub fn account_id_endpoint_mode(mut self, account_id_endpoint_mode: ::aws_types::endpoint_config::AccountIdEndpointMode) -> Self {
1068 self.set_account_id_endpoint_mode(::std::option::Option::Some(account_id_endpoint_mode));
1069 self
1070 }
1071 /// The AccountId Endpoint Mode.
1072 pub fn set_account_id_endpoint_mode(
1073 &mut self,
1074 account_id_endpoint_mode: ::std::option::Option<::aws_types::endpoint_config::AccountIdEndpointMode>,
1075 ) -> &mut Self {
1076 self.config.store_or_unset(account_id_endpoint_mode);
1077 self
1078 }
1079 /// Sets the endpoint URL used to communicate with this service.
1080 ///
1081 /// Note: this is used in combination with other endpoint rules, e.g. an API that applies a host-label prefix
1082 /// will be prefixed onto this URL. To fully override the endpoint resolver, use
1083 /// [`Builder::endpoint_resolver`].
1084 pub fn endpoint_url(mut self, endpoint_url: impl Into<::std::string::String>) -> Self {
1085 self.set_endpoint_url(Some(endpoint_url.into()));
1086 self
1087 }
1088 /// Sets the endpoint URL used to communicate with this service.
1089 ///
1090 /// Note: this is used in combination with other endpoint rules, e.g. an API that applies a host-label prefix
1091 /// will be prefixed onto this URL. To fully override the endpoint resolver, use
1092 /// [`Builder::endpoint_resolver`].
1093 pub fn set_endpoint_url(&mut self, endpoint_url: Option<::std::string::String>) -> &mut Self {
1094 self.config.store_or_unset(endpoint_url.map(::aws_types::endpoint_config::EndpointUrl));
1095 self
1096 }
1097 /// When true, use the dual-stack endpoint. If the configured endpoint does not support dual-stack, dispatching the request MAY return an error.
1098 pub fn use_dual_stack(mut self, use_dual_stack: impl Into<bool>) -> Self {
1099 self.set_use_dual_stack(Some(use_dual_stack.into()));
1100 self
1101 }
1102 /// When true, use the dual-stack endpoint. If the configured endpoint does not support dual-stack, dispatching the request MAY return an error.
1103 pub fn set_use_dual_stack(&mut self, use_dual_stack: Option<bool>) -> &mut Self {
1104 self.config.store_or_unset(use_dual_stack.map(::aws_types::endpoint_config::UseDualStack));
1105 self
1106 }
1107 /// 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.
1108 pub fn use_fips(mut self, use_fips: impl Into<bool>) -> Self {
1109 self.set_use_fips(Some(use_fips.into()));
1110 self
1111 }
1112 /// 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.
1113 pub fn set_use_fips(&mut self, use_fips: Option<bool>) -> &mut Self {
1114 self.config.store_or_unset(use_fips.map(::aws_types::endpoint_config::UseFips));
1115 self
1116 }
1117 /// Sets the AWS region to use when making requests.
1118 ///
1119 /// # Examples
1120 /// ```no_run
1121 /// use aws_types::region::Region;
1122 /// use aws_sdk_dynamodb::config::{Builder, Config};
1123 ///
1124 /// let config = aws_sdk_dynamodb::Config::builder()
1125 /// .region(Region::new("us-east-1"))
1126 /// .build();
1127 /// ```
1128 pub fn region(mut self, region: impl ::std::convert::Into<::std::option::Option<crate::config::Region>>) -> Self {
1129 self.set_region(region.into());
1130 self
1131 }
1132 /// Sets the AWS region to use when making requests.
1133 pub fn set_region(&mut self, region: ::std::option::Option<crate::config::Region>) -> &mut Self {
1134 self.config.store_or_unset(region);
1135 self
1136 }
1137 /// Sets the credentials provider for this service
1138 pub fn credentials_provider(mut self, credentials_provider: impl crate::config::ProvideCredentials + 'static) -> Self {
1139 self.set_credentials_provider(::std::option::Option::Some(crate::config::SharedCredentialsProvider::new(
1140 credentials_provider,
1141 )));
1142 self
1143 }
1144 /// Sets the credentials provider for this service
1145 pub fn set_credentials_provider(&mut self, credentials_provider: ::std::option::Option<crate::config::SharedCredentialsProvider>) -> &mut Self {
1146 if let Some(credentials_provider) = credentials_provider {
1147 self.runtime_components
1148 .set_identity_resolver(::aws_runtime::auth::sigv4::SCHEME_ID, credentials_provider);
1149 }
1150 self
1151 }
1152 /// Sets the [`behavior major version`](crate::config::BehaviorVersion).
1153 ///
1154 /// Over time, new best-practice behaviors are introduced. However, these behaviors might not be backwards
1155 /// compatible. For example, a change which introduces new default timeouts or a new retry-mode for
1156 /// all operations might be the ideal behavior but could break existing applications.
1157 ///
1158 /// # Examples
1159 ///
1160 /// Set the behavior major version to `latest`. This is equivalent to enabling the `behavior-version-latest` cargo feature.
1161 /// ```no_run
1162 /// use aws_sdk_dynamodb::config::BehaviorVersion;
1163 ///
1164 /// let config = aws_sdk_dynamodb::Config::builder()
1165 /// .behavior_version(BehaviorVersion::latest())
1166 /// // ...
1167 /// .build();
1168 /// let client = aws_sdk_dynamodb::Client::from_conf(config);
1169 /// ```
1170 ///
1171 /// Customizing behavior major version:
1172 /// ```no_run
1173 /// use aws_sdk_dynamodb::config::BehaviorVersion;
1174 ///
1175 /// let config = aws_sdk_dynamodb::Config::builder()
1176 /// .behavior_version(BehaviorVersion::v2023_11_09())
1177 /// // ...
1178 /// .build();
1179 /// let client = aws_sdk_dynamodb::Client::from_conf(config);
1180 /// ```
1181 ///
1182 pub fn behavior_version(mut self, behavior_version: crate::config::BehaviorVersion) -> Self {
1183 self.set_behavior_version(Some(behavior_version));
1184 self
1185 }
1186
1187 /// Sets the [`behavior major version`](crate::config::BehaviorVersion).
1188 ///
1189 /// Over time, new best-practice behaviors are introduced. However, these behaviors might not be backwards
1190 /// compatible. For example, a change which introduces new default timeouts or a new retry-mode for
1191 /// all operations might be the ideal behavior but could break existing applications.
1192 ///
1193 /// # Examples
1194 ///
1195 /// Set the behavior major version to `latest`. This is equivalent to enabling the `behavior-version-latest` cargo feature.
1196 /// ```no_run
1197 /// use aws_sdk_dynamodb::config::BehaviorVersion;
1198 ///
1199 /// let config = aws_sdk_dynamodb::Config::builder()
1200 /// .behavior_version(BehaviorVersion::latest())
1201 /// // ...
1202 /// .build();
1203 /// let client = aws_sdk_dynamodb::Client::from_conf(config);
1204 /// ```
1205 ///
1206 /// Customizing behavior major version:
1207 /// ```no_run
1208 /// use aws_sdk_dynamodb::config::BehaviorVersion;
1209 ///
1210 /// let config = aws_sdk_dynamodb::Config::builder()
1211 /// .behavior_version(BehaviorVersion::v2023_11_09())
1212 /// // ...
1213 /// .build();
1214 /// let client = aws_sdk_dynamodb::Client::from_conf(config);
1215 /// ```
1216 ///
1217 pub fn set_behavior_version(&mut self, behavior_version: Option<crate::config::BehaviorVersion>) -> &mut Self {
1218 self.behavior_version = behavior_version;
1219 self
1220 }
1221
1222 /// Convenience method to set the latest behavior major version
1223 ///
1224 /// This is equivalent to enabling the `behavior-version-latest` Cargo feature
1225 pub fn behavior_version_latest(mut self) -> Self {
1226 self.set_behavior_version(Some(crate::config::BehaviorVersion::latest()));
1227 self
1228 }
1229 /// Adds a runtime plugin to the config.
1230 #[allow(unused)]
1231 pub(crate) fn runtime_plugin(mut self, plugin: impl crate::config::RuntimePlugin + 'static) -> Self {
1232 self.push_runtime_plugin(crate::config::SharedRuntimePlugin::new(plugin));
1233 self
1234 }
1235 /// Adds a runtime plugin to the config.
1236 #[allow(unused)]
1237 pub(crate) fn push_runtime_plugin(&mut self, plugin: crate::config::SharedRuntimePlugin) -> &mut Self {
1238 self.runtime_plugins.push(plugin);
1239 self
1240 }
1241 #[cfg(any(feature = "test-util", test))]
1242 #[allow(unused_mut)]
1243 /// Apply test defaults to the builder
1244 pub fn apply_test_defaults(&mut self) -> &mut Self {
1245 self.set_idempotency_token_provider(Some("00000000-0000-4000-8000-000000000000".into()));
1246 self.set_time_source(::std::option::Option::Some(::aws_smithy_async::time::SharedTimeSource::new(
1247 ::aws_smithy_async::time::StaticTimeSource::new(::std::time::UNIX_EPOCH + ::std::time::Duration::from_secs(1234567890)),
1248 )));
1249 self.config.store_put(::aws_runtime::user_agent::AwsUserAgent::for_tests());
1250 self.set_credentials_provider(Some(crate::config::SharedCredentialsProvider::new(
1251 ::aws_credential_types::Credentials::for_tests(),
1252 )));
1253 self.behavior_version = ::std::option::Option::Some(crate::config::BehaviorVersion::latest());
1254 self
1255 }
1256 #[cfg(any(feature = "test-util", test))]
1257 #[allow(unused_mut)]
1258 /// Apply test defaults to the builder
1259 pub fn with_test_defaults(mut self) -> Self {
1260 self.apply_test_defaults();
1261 self
1262 }
1263 /// Builds a [`Config`].
1264 #[allow(unused_mut)]
1265 pub fn build(mut self) -> Config {
1266 let mut layer = self.config;
1267 if self.runtime_components.time_source().is_none() {
1268 self.runtime_components
1269 .set_time_source(::std::option::Option::Some(::std::default::Default::default()));
1270 }
1271 layer.store_put(crate::meta::API_METADATA.clone());
1272 layer.store_put(::aws_types::SigningName::from_static("dynamodb"));
1273 layer
1274 .load::<::aws_types::region::Region>()
1275 .cloned()
1276 .map(|r| layer.store_put(::aws_types::region::SigningRegion::from(r)));
1277 Config {
1278 config: crate::config::Layer::from(layer.clone())
1279 .with_name("aws_sdk_dynamodb::config::Config")
1280 .freeze(),
1281 cloneable: layer,
1282 runtime_components: self.runtime_components,
1283 runtime_plugins: self.runtime_plugins,
1284 behavior_version: self.behavior_version,
1285 }
1286 }
1287}
1288#[derive(::std::fmt::Debug)]
1289pub(crate) struct ServiceRuntimePlugin {
1290 config: ::std::option::Option<::aws_smithy_types::config_bag::FrozenLayer>,
1291 runtime_components: ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder,
1292}
1293
1294impl ServiceRuntimePlugin {
1295 pub fn new(_service_config: crate::config::Config) -> Self {
1296 let config = {
1297 let mut cfg = ::aws_smithy_types::config_bag::Layer::new("DynamoDB_20120810");
1298 cfg.store_put(crate::idempotency_token::default_provider());
1299 cfg.store_put(::aws_smithy_runtime::client::orchestrator::AuthSchemeAndEndpointOrchestrationV2);
1300 ::std::option::Option::Some(cfg.freeze())
1301 };
1302 let mut runtime_components = ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder::new("ServiceRuntimePlugin");
1303 runtime_components.set_auth_scheme_option_resolver(::std::option::Option::Some({
1304 use crate::config::auth::ResolveAuthScheme;
1305 crate::config::auth::DefaultAuthSchemeResolver::default().into_shared_resolver()
1306 }));
1307 runtime_components.set_endpoint_resolver(::std::option::Option::Some({
1308 use crate::config::endpoint::ResolveEndpoint;
1309 crate::config::endpoint::DefaultResolver::new().into_shared_resolver()
1310 }));
1311 runtime_components.push_interceptor(::aws_smithy_runtime::client::http::connection_poisoning::ConnectionPoisoningInterceptor::new());
1312 runtime_components.push_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::HttpStatusCodeClassifier::default());
1313 runtime_components.push_interceptor(crate::sdk_feature_tracker::retry_mode::RetryModeFeatureTrackerInterceptor::new());
1314 runtime_components.push_interceptor(::aws_runtime::service_clock_skew::ServiceClockSkewInterceptor::new());
1315 runtime_components.push_interceptor(::aws_runtime::request_info::RequestInfoInterceptor::new());
1316 runtime_components.push_interceptor(::aws_runtime::user_agent::UserAgentInterceptor::new());
1317 runtime_components.push_interceptor(::aws_runtime::invocation_id::InvocationIdInterceptor::new());
1318 runtime_components.push_interceptor(::aws_runtime::recursion_detection::RecursionDetectionInterceptor::new());
1319 runtime_components.push_auth_scheme(::aws_smithy_runtime_api::client::auth::SharedAuthScheme::new(
1320 ::aws_runtime::auth::sigv4::SigV4AuthScheme::new(),
1321 ));
1322 Self { config, runtime_components }
1323 }
1324}
1325
1326impl ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin for ServiceRuntimePlugin {
1327 fn config(&self) -> ::std::option::Option<::aws_smithy_types::config_bag::FrozenLayer> {
1328 self.config.clone()
1329 }
1330
1331 fn order(&self) -> ::aws_smithy_runtime_api::client::runtime_plugin::Order {
1332 ::aws_smithy_runtime_api::client::runtime_plugin::Order::Defaults
1333 }
1334
1335 fn runtime_components(
1336 &self,
1337 _: &::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder,
1338 ) -> ::std::borrow::Cow<'_, ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder> {
1339 ::std::borrow::Cow::Borrowed(&self.runtime_components)
1340 }
1341}
1342
1343// Cross-operation shared-state singletons
1344
1345/// A plugin that enables configuration for a single operation invocation
1346///
1347/// The `config` method will return a `FrozenLayer` by storing values from `config_override`.
1348/// In the case of default values requested, they will be obtained from `client_config`.
1349#[derive(Debug)]
1350pub(crate) struct ConfigOverrideRuntimePlugin {
1351 pub(crate) config: ::aws_smithy_types::config_bag::FrozenLayer,
1352 pub(crate) components: ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder,
1353}
1354
1355impl ConfigOverrideRuntimePlugin {
1356 #[allow(dead_code)] // unused when a service does not provide any operations
1357 pub(crate) fn new(
1358 config_override: Builder,
1359 initial_config: ::aws_smithy_types::config_bag::FrozenLayer,
1360 initial_components: &::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder,
1361 ) -> Self {
1362 let mut layer = config_override.config;
1363 let mut components = config_override.runtime_components;
1364 #[allow(unused_mut)]
1365 let mut resolver =
1366 ::aws_smithy_runtime::client::config_override::Resolver::overrid(initial_config, initial_components, &mut layer, &mut components);
1367
1368 resolver
1369 .config_mut()
1370 .load::<::aws_types::region::Region>()
1371 .cloned()
1372 .map(|r| resolver.config_mut().store_put(::aws_types::region::SigningRegion::from(r)));
1373
1374 let _ = resolver;
1375 Self {
1376 config: ::aws_smithy_types::config_bag::Layer::from(layer)
1377 .with_name("aws_sdk_dynamodb::config::ConfigOverrideRuntimePlugin")
1378 .freeze(),
1379 components,
1380 }
1381 }
1382}
1383
1384impl ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin for ConfigOverrideRuntimePlugin {
1385 fn config(&self) -> ::std::option::Option<::aws_smithy_types::config_bag::FrozenLayer> {
1386 Some(self.config.clone())
1387 }
1388
1389 fn runtime_components(
1390 &self,
1391 _: &::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder,
1392 ) -> ::std::borrow::Cow<'_, ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder> {
1393 ::std::borrow::Cow::Borrowed(&self.components)
1394 }
1395}
1396
1397pub use ::aws_smithy_runtime::client::identity::IdentityCache;
1398pub use ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponents;
1399pub use ::aws_smithy_types::config_bag::ConfigBag;
1400
1401pub use ::aws_credential_types::Credentials;
1402
1403impl From<&::aws_types::sdk_config::SdkConfig> for Builder {
1404 fn from(input: &::aws_types::sdk_config::SdkConfig) -> Self {
1405 let mut builder = Builder::default();
1406 builder.set_credentials_provider(input.credentials_provider());
1407 builder = builder.region(input.region().cloned());
1408 builder.set_use_fips(input.use_fips());
1409 builder.set_use_dual_stack(input.use_dual_stack());
1410 if input.get_origin("endpoint_url").is_client_config() {
1411 builder.set_endpoint_url(input.endpoint_url().map(|s| s.to_string()));
1412 } else {
1413 builder.set_endpoint_url(
1414 input
1415 .service_config()
1416 .and_then(|conf| {
1417 conf.load_config(service_config_key("DynamoDB", "AWS_ENDPOINT_URL", "endpoint_url"))
1418 .map(|it| it.parse().unwrap())
1419 })
1420 .or_else(|| input.endpoint_url().map(|s| s.to_string())),
1421 );
1422 }
1423 builder.set_account_id_endpoint_mode(input.account_id_endpoint_mode().cloned());
1424 // resiliency
1425 builder.set_retry_config(input.retry_config().cloned());
1426 builder.set_timeout_config(input.timeout_config().cloned());
1427 builder.set_sleep_impl(input.sleep_impl());
1428
1429 builder.set_http_client(input.http_client());
1430 builder.set_time_source(input.time_source());
1431 builder.set_behavior_version(input.behavior_version());
1432 builder.set_auth_scheme_preference(input.auth_scheme_preference().cloned());
1433 // setting `None` here removes the default
1434 if let Some(config) = input.stalled_stream_protection() {
1435 builder.set_stalled_stream_protection(Some(config));
1436 }
1437
1438 if let Some(cache) = input.identity_cache() {
1439 builder.set_identity_cache(cache);
1440 }
1441 builder.set_app_name(input.app_name().cloned());
1442
1443 builder
1444 }
1445}
1446
1447impl From<&::aws_types::sdk_config::SdkConfig> for Config {
1448 fn from(sdk_config: &::aws_types::sdk_config::SdkConfig) -> Self {
1449 Builder::from(sdk_config).build()
1450 }
1451}
1452
1453pub use ::aws_types::app_name::AppName;
1454
1455#[allow(dead_code)]
1456fn service_config_key<'a>(service_id: &'a str, env: &'a str, profile: &'a str) -> aws_types::service_config::ServiceConfigKey<'a> {
1457 ::aws_types::service_config::ServiceConfigKey::builder()
1458 .service_id(service_id)
1459 .env(env)
1460 .profile(profile)
1461 .build()
1462 .expect("all field sets explicitly, can't fail")
1463}
1464
1465pub use ::aws_smithy_async::rt::sleep::Sleep;
1466
1467pub(crate) fn base_client_runtime_plugins(mut config: crate::Config) -> ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugins {
1468 let mut configured_plugins = ::std::vec::Vec::new();
1469 ::std::mem::swap(&mut config.runtime_plugins, &mut configured_plugins);
1470 #[cfg(feature = "behavior-version-latest")]
1471 {
1472 if config.behavior_version.is_none() {
1473 config.behavior_version = Some(::aws_smithy_runtime_api::client::behavior_version::BehaviorVersion::latest());
1474 }
1475 }
1476
1477 let default_retry_partition = "dynamodb";
1478 let default_retry_partition = match config.region() {
1479 Some(region) => ::std::borrow::Cow::from(format!("{default_retry_partition}-{}", region)),
1480 None => ::std::borrow::Cow::from(default_retry_partition),
1481 };
1482
1483 let scope = "aws-sdk-dynamodb";
1484
1485 let mut plugins = ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugins::new()
1486 // defaults
1487 .with_client_plugins(::aws_smithy_runtime::client::defaults::default_plugins(
1488 ::aws_smithy_runtime::client::defaults::DefaultPluginParams::new()
1489 .with_retry_partition_name(default_retry_partition)
1490 .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."))
1491 ))
1492 // user config
1493 .with_client_plugin(
1494 ::aws_smithy_runtime_api::client::runtime_plugin::StaticRuntimePlugin::new()
1495 .with_config(config.config.clone())
1496 .with_runtime_components(config.runtime_components.clone())
1497 )
1498 // codegen config
1499 .with_client_plugin(crate::config::ServiceRuntimePlugin::new(config.clone()))
1500 .with_client_plugin(::aws_smithy_runtime::client::auth::no_auth::NoAuthRuntimePlugin::new())
1501 .with_client_plugin(
1502 ::aws_smithy_runtime::client::metrics::MetricsRuntimePlugin::builder()
1503 .with_scope(scope)
1504 .with_time_source(config.runtime_components.time_source().unwrap_or_default())
1505 .build()
1506 .expect("All required fields have been set")
1507 );
1508
1509 for plugin in configured_plugins {
1510 plugins = plugins.with_client_plugin(plugin);
1511 }
1512 plugins
1513}
1514
1515pub use ::aws_smithy_types::config_bag::FrozenLayer;
1516
1517pub use ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder;
1518
1519pub use ::aws_smithy_runtime_api::client::runtime_plugin::SharedRuntimePlugin;
1520
1521pub use ::aws_smithy_runtime_api::client::behavior_version::BehaviorVersion;
1522
1523pub use ::aws_smithy_runtime_api::client::stalled_stream_protection::StalledStreamProtectionConfig;
1524
1525pub use ::aws_smithy_runtime_api::client::http::SharedHttpClient;
1526
1527pub use ::aws_smithy_async::rt::sleep::SharedAsyncSleep;
1528
1529pub use ::aws_smithy_runtime_api::client::identity::SharedIdentityCache;
1530
1531pub use ::aws_smithy_runtime_api::client::interceptors::SharedInterceptor;
1532
1533pub use ::aws_types::region::Region;
1534
1535pub use ::aws_credential_types::provider::SharedCredentialsProvider;
1536
1537pub use ::aws_smithy_runtime_api::client::http::HttpClient;
1538
1539pub use ::aws_smithy_runtime_api::shared::IntoShared;
1540
1541pub use ::aws_smithy_async::rt::sleep::AsyncSleep;
1542
1543pub use ::aws_smithy_runtime_api::client::identity::ResolveCachedIdentity;
1544
1545pub use ::aws_smithy_runtime_api::client::interceptors::Intercept;
1546
1547pub use ::aws_credential_types::provider::ProvideCredentials;
1548
1549pub use ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin;
1550
1551pub use ::aws_smithy_types::config_bag::Layer;
1552
1553/// Types needed to configure endpoint resolution.
1554pub mod endpoint;
1555
1556/// HTTP request and response types.
1557pub mod http;
1558
1559/// Types needed to implement [`Intercept`](crate::config::Intercept).
1560pub mod interceptors;
1561
1562/// Retry configuration.
1563pub mod retry;
1564
1565/// Timeout configuration.
1566pub mod timeout;
1567
1568/// Types needed to configure auth scheme resolution.
1569pub mod auth;