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