#[derive(::std::clone::Clone, ::std::fmt::Debug)]
pub struct Config {
pub(crate) config: ::aws_smithy_types::config_bag::FrozenLayer,
cloneable: ::aws_smithy_types::config_bag::CloneableLayer,
pub(crate) runtime_components: ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder,
pub(crate) runtime_plugins: ::std::vec::Vec<::aws_smithy_runtime_api::client::runtime_plugin::SharedRuntimePlugin>,
}
impl Config {
pub fn builder() -> Builder {
Builder::default()
}
pub fn to_builder(&self) -> Builder {
Builder {
config: self.cloneable.clone(),
runtime_components: self.runtime_components.clone(),
runtime_plugins: self.runtime_plugins.clone(),
}
}
pub fn idempotency_token_provider(&self) -> crate::idempotency_token::IdempotencyTokenProvider {
self.config
.load::<crate::idempotency_token::IdempotencyTokenProvider>()
.expect("the idempotency provider should be set")
.clone()
}
pub fn http_connector(&self) -> Option<::aws_smithy_runtime_api::client::connectors::SharedHttpConnector> {
self.runtime_components.http_connector()
}
pub fn endpoint_resolver(&self) -> ::aws_smithy_runtime_api::client::endpoint::SharedEndpointResolver {
self.runtime_components.endpoint_resolver().expect("resolver defaulted if not set")
}
pub fn retry_config(&self) -> ::std::option::Option<&::aws_smithy_types::retry::RetryConfig> {
self.config.load::<::aws_smithy_types::retry::RetryConfig>()
}
pub fn sleep_impl(&self) -> ::std::option::Option<::aws_smithy_async::rt::sleep::SharedAsyncSleep> {
self.runtime_components.sleep_impl()
}
pub fn timeout_config(&self) -> ::std::option::Option<&::aws_smithy_types::timeout::TimeoutConfig> {
self.config.load::<::aws_smithy_types::timeout::TimeoutConfig>()
}
#[doc(hidden)]
pub fn retry_partition(&self) -> ::std::option::Option<&::aws_smithy_runtime::client::retries::RetryPartition> {
self.config.load::<::aws_smithy_runtime::client::retries::RetryPartition>()
}
pub fn interceptors(&self) -> impl Iterator<Item = ::aws_smithy_runtime_api::client::interceptors::SharedInterceptor> + '_ {
self.runtime_components.interceptors()
}
pub fn time_source(&self) -> ::std::option::Option<::aws_smithy_async::time::SharedTimeSource> {
self.runtime_components.time_source()
}
pub fn app_name(&self) -> ::std::option::Option<&::aws_types::app_name::AppName> {
self.config.load::<::aws_types::app_name::AppName>()
}
pub fn invocation_id_generator(&self) -> ::std::option::Option<::aws_runtime::invocation_id::SharedInvocationIdGenerator> {
self.config.load::<::aws_runtime::invocation_id::SharedInvocationIdGenerator>().cloned()
}
pub fn new(config: &::aws_types::sdk_config::SdkConfig) -> Self {
Builder::from(config).build()
}
pub fn signing_service(&self) -> &'static str {
"connect"
}
pub fn region(&self) -> ::std::option::Option<&::aws_types::region::Region> {
self.config.load::<::aws_types::region::Region>()
}
pub fn credentials_cache(&self) -> ::std::option::Option<::aws_credential_types::cache::SharedCredentialsCache> {
self.config.load::<::aws_credential_types::cache::SharedCredentialsCache>().cloned()
}
}
#[derive(::std::clone::Clone, ::std::fmt::Debug)]
pub struct Builder {
pub(crate) config: ::aws_smithy_types::config_bag::CloneableLayer,
pub(crate) runtime_components: ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder,
pub(crate) runtime_plugins: ::std::vec::Vec<::aws_smithy_runtime_api::client::runtime_plugin::SharedRuntimePlugin>,
}
impl ::std::default::Default for Builder {
fn default() -> Self {
Self {
config: ::std::default::Default::default(),
runtime_components: ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder::new("service config"),
runtime_plugins: ::std::default::Default::default(),
}
}
}
impl Builder {
pub fn new() -> Self {
Self::default()
}
pub fn idempotency_token_provider(
mut self,
idempotency_token_provider: impl ::std::convert::Into<crate::idempotency_token::IdempotencyTokenProvider>,
) -> Self {
self.set_idempotency_token_provider(::std::option::Option::Some(idempotency_token_provider.into()));
self
}
pub fn set_idempotency_token_provider(
&mut self,
idempotency_token_provider: ::std::option::Option<crate::idempotency_token::IdempotencyTokenProvider>,
) -> &mut Self {
self.config.store_or_unset(idempotency_token_provider);
self
}
pub fn http_connector(mut self, http_connector: impl Into<::aws_smithy_client::http_connector::HttpConnector>) -> Self {
self.set_http_connector(::std::option::Option::Some(http_connector));
self
}
pub fn set_http_connector(&mut self, http_connector: Option<impl Into<::aws_smithy_client::http_connector::HttpConnector>>) -> &mut Self {
http_connector.map(|c| self.config.store_put(c.into()));
self
}
pub fn endpoint_resolver(
mut self,
endpoint_resolver: impl ::aws_smithy_http::endpoint::ResolveEndpoint<crate::config::endpoint::Params> + 'static,
) -> Self {
self.set_endpoint_resolver(::std::option::Option::Some(::aws_smithy_http::endpoint::SharedEndpointResolver::new(
endpoint_resolver,
)));
self
}
pub fn set_endpoint_resolver(
&mut self,
endpoint_resolver: ::std::option::Option<::aws_smithy_http::endpoint::SharedEndpointResolver<crate::config::endpoint::Params>>,
) -> &mut Self {
self.config.store_or_unset(endpoint_resolver);
self
}
pub fn retry_config(mut self, retry_config: ::aws_smithy_types::retry::RetryConfig) -> Self {
self.set_retry_config(Some(retry_config));
self
}
pub fn set_retry_config(&mut self, retry_config: ::std::option::Option<::aws_smithy_types::retry::RetryConfig>) -> &mut Self {
retry_config.map(|r| self.config.store_put(r));
self
}
pub fn sleep_impl(mut self, sleep_impl: ::aws_smithy_async::rt::sleep::SharedAsyncSleep) -> Self {
self.set_sleep_impl(Some(sleep_impl));
self
}
pub fn set_sleep_impl(&mut self, sleep_impl: ::std::option::Option<::aws_smithy_async::rt::sleep::SharedAsyncSleep>) -> &mut Self {
self.runtime_components.set_sleep_impl(sleep_impl);
self
}
pub fn timeout_config(mut self, timeout_config: ::aws_smithy_types::timeout::TimeoutConfig) -> Self {
self.set_timeout_config(Some(timeout_config));
self
}
pub fn set_timeout_config(&mut self, timeout_config: ::std::option::Option<::aws_smithy_types::timeout::TimeoutConfig>) -> &mut Self {
timeout_config.map(|t| self.config.store_put(t));
self
}
#[doc(hidden)]
pub fn retry_partition(mut self, retry_partition: ::aws_smithy_runtime::client::retries::RetryPartition) -> Self {
self.set_retry_partition(Some(retry_partition));
self
}
#[doc(hidden)]
pub fn set_retry_partition(
&mut self,
retry_partition: ::std::option::Option<::aws_smithy_runtime::client::retries::RetryPartition>,
) -> &mut Self {
retry_partition.map(|r| self.config.store_put(r));
self
}
pub fn interceptor(mut self, interceptor: impl ::aws_smithy_runtime_api::client::interceptors::Interceptor + 'static) -> Self {
self.push_interceptor(::aws_smithy_runtime_api::client::interceptors::SharedInterceptor::new(interceptor));
self
}
pub fn push_interceptor(&mut self, interceptor: ::aws_smithy_runtime_api::client::interceptors::SharedInterceptor) -> &mut Self {
self.runtime_components.push_interceptor(interceptor);
self
}
pub fn set_interceptors(
&mut self,
interceptors: impl IntoIterator<Item = ::aws_smithy_runtime_api::client::interceptors::SharedInterceptor>,
) -> &mut Self {
self.runtime_components.set_interceptors(interceptors.into_iter());
self
}
pub fn time_source(mut self, time_source: impl ::std::convert::Into<::aws_smithy_async::time::SharedTimeSource>) -> Self {
self.set_time_source(::std::option::Option::Some(time_source.into()));
self
}
pub fn set_time_source(&mut self, time_source: ::std::option::Option<::aws_smithy_async::time::SharedTimeSource>) -> &mut Self {
self.runtime_components.set_time_source(time_source);
self
}
pub fn app_name(mut self, app_name: ::aws_types::app_name::AppName) -> Self {
self.set_app_name(Some(app_name));
self
}
pub fn set_app_name(&mut self, app_name: ::std::option::Option<::aws_types::app_name::AppName>) -> &mut Self {
self.config.store_or_unset(app_name);
self
}
pub fn invocation_id_generator(mut self, gen: impl ::aws_runtime::invocation_id::InvocationIdGenerator + 'static) -> Self {
self.set_invocation_id_generator(::std::option::Option::Some(
::aws_runtime::invocation_id::SharedInvocationIdGenerator::new(gen),
));
self
}
pub fn set_invocation_id_generator(
&mut self,
gen: ::std::option::Option<::aws_runtime::invocation_id::SharedInvocationIdGenerator>,
) -> &mut Self {
self.config.store_or_unset(gen);
self
}
pub fn endpoint_url(mut self, endpoint_url: impl Into<::std::string::String>) -> Self {
self.set_endpoint_url(Some(endpoint_url.into()));
self
}
pub fn set_endpoint_url(&mut self, endpoint_url: Option<::std::string::String>) -> &mut Self {
self.config.store_or_unset(endpoint_url.map(::aws_types::endpoint_config::EndpointUrl));
self
}
pub fn use_dual_stack(mut self, use_dual_stack: impl Into<bool>) -> Self {
self.set_use_dual_stack(Some(use_dual_stack.into()));
self
}
pub fn set_use_dual_stack(&mut self, use_dual_stack: Option<bool>) -> &mut Self {
self.config.store_or_unset(use_dual_stack.map(::aws_types::endpoint_config::UseDualStack));
self
}
pub fn use_fips(mut self, use_fips: impl Into<bool>) -> Self {
self.set_use_fips(Some(use_fips.into()));
self
}
pub fn set_use_fips(&mut self, use_fips: Option<bool>) -> &mut Self {
self.config.store_or_unset(use_fips.map(::aws_types::endpoint_config::UseFips));
self
}
pub fn region(mut self, region: impl ::std::convert::Into<::std::option::Option<::aws_types::region::Region>>) -> Self {
self.set_region(region.into());
self
}
pub fn set_region(&mut self, region: ::std::option::Option<::aws_types::region::Region>) -> &mut Self {
self.config.store_or_unset(region);
self
}
pub fn credentials_provider(mut self, credentials_provider: impl ::aws_credential_types::provider::ProvideCredentials + 'static) -> Self {
self.set_credentials_provider(::std::option::Option::Some(
::aws_credential_types::provider::SharedCredentialsProvider::new(credentials_provider),
));
self
}
pub fn set_credentials_provider(
&mut self,
credentials_provider: ::std::option::Option<::aws_credential_types::provider::SharedCredentialsProvider>,
) -> &mut Self {
self.config.store_or_unset(credentials_provider);
self
}
pub fn credentials_cache(mut self, credentials_cache: ::aws_credential_types::cache::CredentialsCache) -> Self {
self.set_credentials_cache(::std::option::Option::Some(credentials_cache));
self
}
pub fn set_credentials_cache(&mut self, credentials_cache: ::std::option::Option<::aws_credential_types::cache::CredentialsCache>) -> &mut Self {
self.config.store_or_unset(credentials_cache);
self
}
#[allow(unused)]
pub(crate) fn runtime_plugin(mut self, plugin: impl ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin + 'static) -> Self {
self.push_runtime_plugin(::aws_smithy_runtime_api::client::runtime_plugin::SharedRuntimePlugin::new(plugin));
self
}
#[allow(unused)]
pub(crate) fn push_runtime_plugin(&mut self, plugin: ::aws_smithy_runtime_api::client::runtime_plugin::SharedRuntimePlugin) -> &mut Self {
self.runtime_plugins.push(plugin);
self
}
#[cfg(any(feature = "test-util", test))]
#[allow(unused_mut)]
pub fn set_test_defaults(&mut self) -> &mut Self {
self.set_idempotency_token_provider(Some("00000000-0000-4000-8000-000000000000".into()));
self.set_time_source(::std::option::Option::Some(::aws_smithy_async::time::SharedTimeSource::new(
::aws_smithy_async::time::StaticTimeSource::new(::std::time::UNIX_EPOCH + ::std::time::Duration::from_secs(1234567890)),
)));
self.set_credentials_provider(Some(::aws_credential_types::provider::SharedCredentialsProvider::new(
::aws_credential_types::Credentials::for_tests(),
)));
self
}
#[cfg(any(feature = "test-util", test))]
#[allow(unused_mut)]
pub fn with_test_defaults(mut self) -> Self {
self.set_test_defaults();
self
}
#[allow(unused_mut)]
pub fn build(mut self) -> Config {
let mut layer = self.config;
let mut resolver = ::aws_smithy_runtime::client::config_override::Resolver::initial(&mut layer, &mut self.runtime_components);
if !resolver.is_set::<crate::idempotency_token::IdempotencyTokenProvider>() {
resolver.config_mut().store_put(crate::idempotency_token::default_provider());
}
crate::config::set_connector(&mut resolver);
crate::config::set_endpoint_resolver(&mut resolver);
if layer.load::<::aws_smithy_types::retry::RetryConfig>().is_none() {
layer.store_put(::aws_smithy_types::retry::RetryConfig::disabled());
}
let retry_config = layer
.load::<::aws_smithy_types::retry::RetryConfig>()
.expect("set to default above")
.clone();
if layer.load::<::aws_smithy_runtime::client::retries::RetryPartition>().is_none() {
layer.store_put(::aws_smithy_runtime::client::retries::RetryPartition::new("connect"));
}
let retry_partition = layer
.load::<::aws_smithy_runtime::client::retries::RetryPartition>()
.expect("set to default above")
.clone();
if retry_config.has_retry() {
::tracing::debug!("using retry strategy with partition '{}'", retry_partition);
}
if retry_config.mode() == ::aws_smithy_types::retry::RetryMode::Adaptive {
if let ::std::option::Option::Some(time_source) = self.runtime_components.time_source() {
let seconds_since_unix_epoch = time_source
.now()
.duration_since(::std::time::SystemTime::UNIX_EPOCH)
.expect("the present takes place after the UNIX_EPOCH")
.as_secs_f64();
let client_rate_limiter_partition = ::aws_smithy_runtime::client::retries::ClientRateLimiterPartition::new(retry_partition.clone());
let client_rate_limiter = CLIENT_RATE_LIMITER.get_or_init(client_rate_limiter_partition, || {
::aws_smithy_runtime::client::retries::ClientRateLimiter::new(seconds_since_unix_epoch)
});
layer.store_put(client_rate_limiter);
}
}
let token_bucket_partition = ::aws_smithy_runtime::client::retries::TokenBucketPartition::new(retry_partition);
let token_bucket = TOKEN_BUCKET.get_or_init(token_bucket_partition, ::aws_smithy_runtime::client::retries::TokenBucket::default);
layer.store_put(token_bucket);
if layer.load::<::aws_smithy_types::timeout::TimeoutConfig>().is_none() {
layer.store_put(::aws_smithy_types::timeout::TimeoutConfig::disabled());
}
self.runtime_components.set_retry_strategy(::std::option::Option::Some(
::aws_smithy_runtime_api::client::retries::SharedRetryStrategy::new(
::aws_smithy_runtime::client::retries::strategy::StandardRetryStrategy::new(&retry_config),
),
));
if self.runtime_components.time_source().is_none() {
self.runtime_components
.set_time_source(::std::option::Option::Some(::std::default::Default::default()));
}
layer.store_put(crate::meta::API_METADATA.clone());
layer.store_put(::aws_types::SigningService::from_static("connect"));
layer
.load::<::aws_types::region::Region>()
.cloned()
.map(|r| layer.store_put(::aws_types::region::SigningRegion::from(r)));
if let Some(credentials_provider) = layer.load::<::aws_credential_types::provider::SharedCredentialsProvider>().cloned() {
let cache_config = layer.load::<::aws_credential_types::cache::CredentialsCache>().cloned().unwrap_or_else({
let sleep = self.runtime_components.sleep_impl();
|| match sleep {
Some(sleep) => ::aws_credential_types::cache::CredentialsCache::lazy_builder()
.sleep(sleep)
.into_credentials_cache(),
None => ::aws_credential_types::cache::CredentialsCache::lazy(),
}
});
let shared_credentials_cache = cache_config.create_cache(credentials_provider);
layer.store_put(shared_credentials_cache);
}
Config {
config: ::aws_smithy_types::config_bag::Layer::from(layer.clone())
.with_name("aws_sdk_connect::config::Config")
.freeze(),
cloneable: layer,
runtime_components: self.runtime_components,
runtime_plugins: self.runtime_plugins,
}
}
}
#[derive(::std::fmt::Debug)]
pub(crate) struct ServiceRuntimePlugin {
config: ::std::option::Option<::aws_smithy_types::config_bag::FrozenLayer>,
runtime_components: ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder,
}
impl ServiceRuntimePlugin {
pub fn new(_service_config: crate::config::Config) -> Self {
let config = { None };
let mut runtime_components = ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder::new("ServiceRuntimePlugin");
runtime_components.push_interceptor(::aws_smithy_runtime_api::client::interceptors::SharedInterceptor::new(
::aws_smithy_runtime::client::connectors::connection_poisoning::ConnectionPoisoningInterceptor::new(),
) as _);
runtime_components.push_interceptor(::aws_smithy_runtime_api::client::interceptors::SharedInterceptor::new(
::aws_runtime::service_clock_skew::ServiceClockSkewInterceptor::new(),
) as _);
runtime_components.push_interceptor(::aws_smithy_runtime_api::client::interceptors::SharedInterceptor::new(
::aws_runtime::request_info::RequestInfoInterceptor::new(),
) as _);
runtime_components.push_interceptor(::aws_smithy_runtime_api::client::interceptors::SharedInterceptor::new(
::aws_runtime::user_agent::UserAgentInterceptor::new(),
) as _);
runtime_components.push_interceptor(::aws_smithy_runtime_api::client::interceptors::SharedInterceptor::new(
::aws_runtime::invocation_id::InvocationIdInterceptor::new(),
) as _);
runtime_components.push_interceptor(::aws_smithy_runtime_api::client::interceptors::SharedInterceptor::new(
::aws_runtime::recursion_detection::RecursionDetectionInterceptor::new(),
) as _);
runtime_components.push_auth_scheme(::aws_smithy_runtime_api::client::auth::SharedAuthScheme::new(
::aws_runtime::auth::sigv4::SigV4AuthScheme::new(),
));
if let Some(credentials_cache) = _service_config.credentials_cache() {
runtime_components.push_identity_resolver(
::aws_runtime::auth::sigv4::SCHEME_ID,
::aws_smithy_runtime_api::client::identity::SharedIdentityResolver::new(
::aws_runtime::identity::credentials::CredentialsIdentityResolver::new(credentials_cache),
),
);
}
Self { config, runtime_components }
}
}
impl ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin for ServiceRuntimePlugin {
fn config(&self) -> ::std::option::Option<::aws_smithy_types::config_bag::FrozenLayer> {
self.config.clone()
}
fn runtime_components(&self) -> ::std::borrow::Cow<'_, ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder> {
::std::borrow::Cow::Borrowed(&self.runtime_components)
}
}
static TOKEN_BUCKET: ::aws_smithy_runtime::static_partition_map::StaticPartitionMap<
::aws_smithy_runtime::client::retries::TokenBucketPartition,
::aws_smithy_runtime::client::retries::TokenBucket,
> = ::aws_smithy_runtime::static_partition_map::StaticPartitionMap::new();
static CLIENT_RATE_LIMITER: ::aws_smithy_runtime::static_partition_map::StaticPartitionMap<
::aws_smithy_runtime::client::retries::ClientRateLimiterPartition,
::aws_smithy_runtime::client::retries::ClientRateLimiter,
> = ::aws_smithy_runtime::static_partition_map::StaticPartitionMap::new();
#[derive(Debug)]
pub(crate) struct ConfigOverrideRuntimePlugin {
pub(crate) config: ::aws_smithy_types::config_bag::FrozenLayer,
pub(crate) components: ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder,
}
impl ConfigOverrideRuntimePlugin {
pub(crate) fn new(
config_override: Builder,
initial_config: ::aws_smithy_types::config_bag::FrozenLayer,
initial_components: &::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder,
) -> Self {
let mut layer = config_override.config;
let mut components = config_override.runtime_components;
let mut resolver =
::aws_smithy_runtime::client::config_override::Resolver::overrid(initial_config, initial_components, &mut layer, &mut components);
crate::config::set_connector(&mut resolver);
crate::config::set_endpoint_resolver(&mut resolver);
match (
resolver.config_mut().load::<::aws_credential_types::cache::CredentialsCache>().cloned(),
resolver
.config_mut()
.load::<::aws_credential_types::provider::SharedCredentialsProvider>()
.cloned(),
) {
(::std::option::Option::None, ::std::option::Option::None) => {}
(::std::option::Option::None, _) => {
panic!("also specify `.credentials_cache` when overriding credentials provider for the operation");
}
(_, ::std::option::Option::None) => {
panic!("also specify `.credentials_provider` when overriding credentials cache for the operation");
}
(::std::option::Option::Some(credentials_cache), ::std::option::Option::Some(credentials_provider)) => {
resolver.config_mut().store_put(credentials_cache.create_cache(credentials_provider));
}
}
let _ = resolver;
Self {
config: ::aws_smithy_types::config_bag::Layer::from(layer)
.with_name("aws_sdk_connect::config::ConfigOverrideRuntimePlugin")
.freeze(),
components,
}
}
}
impl ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin for ConfigOverrideRuntimePlugin {
fn config(&self) -> ::std::option::Option<::aws_smithy_types::config_bag::FrozenLayer> {
Some(self.config.clone())
}
fn runtime_components(&self) -> ::std::borrow::Cow<'_, ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder> {
::std::borrow::Cow::Borrowed(&self.components)
}
}
pub use ::aws_smithy_runtime_api::client::interceptors::Interceptor;
pub use ::aws_smithy_runtime_api::client::interceptors::SharedInterceptor;
pub use ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponents;
pub use ::aws_smithy_types::config_bag::ConfigBag;
pub use ::aws_credential_types::Credentials;
pub use ::aws_types::region::Region;
impl From<&::aws_types::sdk_config::SdkConfig> for Builder {
fn from(input: &::aws_types::sdk_config::SdkConfig) -> Self {
let mut builder = Builder::default();
builder.set_credentials_cache(input.credentials_cache().cloned());
builder.set_credentials_provider(input.credentials_provider());
builder = builder.region(input.region().cloned());
builder.set_use_fips(input.use_fips());
builder.set_use_dual_stack(input.use_dual_stack());
builder.set_endpoint_url(input.endpoint_url().map(|s| s.to_string()));
builder.set_retry_config(input.retry_config().cloned());
builder.set_timeout_config(input.timeout_config().cloned());
builder.set_sleep_impl(input.sleep_impl());
builder.set_http_connector(input.http_connector().cloned());
builder.set_time_source(input.time_source());
builder.set_app_name(input.app_name().cloned());
builder
}
}
impl From<&::aws_types::sdk_config::SdkConfig> for Config {
fn from(sdk_config: &::aws_types::sdk_config::SdkConfig) -> Self {
Builder::from(sdk_config).build()
}
}
pub use ::aws_types::app_name::AppName;
pub use ::aws_smithy_async::rt::sleep::{AsyncSleep, SharedAsyncSleep, Sleep};
pub(crate) fn base_client_runtime_plugins(mut config: crate::Config) -> ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugins {
let mut configured_plugins = ::std::vec::Vec::new();
::std::mem::swap(&mut config.runtime_plugins, &mut configured_plugins);
let mut plugins = ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugins::new()
.with_client_plugin(
::aws_smithy_runtime_api::client::runtime_plugin::StaticRuntimePlugin::new()
.with_config(config.config.clone())
.with_runtime_components(config.runtime_components.clone()),
)
.with_client_plugin(crate::config::ServiceRuntimePlugin::new(config))
.with_client_plugin(::aws_smithy_runtime::client::auth::no_auth::NoAuthRuntimePlugin::new());
for plugin in configured_plugins {
plugins = plugins.with_client_plugin(plugin);
}
plugins
}
fn set_connector(resolver: &mut ::aws_smithy_runtime::client::config_override::Resolver<'_>) {
let must_set_connector = resolver.is_initial()
|| resolver.is_latest_set::<::aws_smithy_client::http_connector::HttpConnector>()
|| resolver.latest_sleep_impl().is_some()
|| resolver.is_latest_set::<::aws_smithy_types::timeout::TimeoutConfig>();
if must_set_connector {
let sleep_impl = resolver.sleep_impl();
let timeout_config = resolver
.resolve_config::<::aws_smithy_types::timeout::TimeoutConfig>()
.cloned()
.unwrap_or_else(::aws_smithy_types::timeout::TimeoutConfig::disabled);
let connector_settings = ::aws_smithy_client::http_connector::ConnectorSettings::from_timeout_config(&timeout_config);
let http_connector = resolver.resolve_config::<::aws_smithy_client::http_connector::HttpConnector>();
let connector = http_connector
.and_then(|c| c.connector(&connector_settings, sleep_impl.clone()))
.or_else(|| crate::config::default_connector(&connector_settings, sleep_impl))
.map(|c| {
::aws_smithy_runtime_api::client::connectors::SharedHttpConnector::new(
::aws_smithy_runtime::client::connectors::adapter::DynConnectorAdapter::new(c),
)
});
resolver.runtime_components_mut().set_http_connector(connector);
}
}
fn set_endpoint_resolver(resolver: &mut ::aws_smithy_runtime::client::config_override::Resolver<'_>) {
let endpoint_resolver = if resolver.is_initial() {
Some(
resolver
.resolve_config::<::aws_smithy_http::endpoint::SharedEndpointResolver<crate::config::endpoint::Params>>()
.cloned()
.unwrap_or_else(|| ::aws_smithy_http::endpoint::SharedEndpointResolver::new(crate::config::endpoint::DefaultResolver::new())),
)
} else if resolver.is_latest_set::<::aws_smithy_http::endpoint::SharedEndpointResolver<crate::config::endpoint::Params>>() {
resolver
.resolve_config::<::aws_smithy_http::endpoint::SharedEndpointResolver<crate::config::endpoint::Params>>()
.cloned()
} else {
None
};
if let Some(endpoint_resolver) = endpoint_resolver {
let shared = ::aws_smithy_runtime_api::client::endpoint::SharedEndpointResolver::new(
::aws_smithy_runtime::client::orchestrator::endpoints::DefaultEndpointResolver::<crate::config::endpoint::Params>::new(endpoint_resolver),
);
resolver
.runtime_components_mut()
.set_endpoint_resolver(::std::option::Option::Some(shared));
}
}
pub mod endpoint;
pub mod interceptors;
pub mod retry;
pub mod timeout;
#[cfg(feature = "rustls")]
fn default_connector(
connector_settings: &::aws_smithy_client::http_connector::ConnectorSettings,
sleep_impl: ::std::option::Option<::aws_smithy_async::rt::sleep::SharedAsyncSleep>,
) -> ::std::option::Option<::aws_smithy_client::erase::DynConnector> {
::aws_smithy_client::conns::default_connector(connector_settings, sleep_impl)
}
#[cfg(not(feature = "rustls"))]
fn default_connector(
_connector_settings: &::aws_smithy_client::http_connector::ConnectorSettings,
_sleep_impl: ::std::option::Option<::aws_smithy_async::rt::sleep::SharedAsyncSleep>,
) -> ::std::option::Option<::aws_smithy_client::erase::DynConnector> {
::std::option::Option::None
}