Feature: Fine-grained Timeout Configuration (#831)

**Breaking Changes**

- (aws-smithy-client): Extraneous `pub use SdkSuccess` removed from `aws_smithy_client::hyper_ext`. (smithy-rs#855)

**New this week**

- Timeouts for requests are now configurable. You can set separate timeouts for each individual request attempt and all attempts made for a request. (smithy-rs#831)

v0.29.0-alpha (November 11th, 2021)

===================================

**Breaking Changes**

Several breaking changes around `aws_smithy_types::Instant` were introduced by smithy-rs#849:

- `aws_smithy_types::Instant` from was renamed to `DateTime` to avoid confusion with the standard library's monotonically nondecreasing `Instant` type.

- `aws_smithy_types::Instant` from was renamed to `DateTime` to avoid confusion with the standard library's monotonically non-decreasing `Instant` type.

- `DateParseError` in `aws_smithy_types` has been renamed to `DateTimeParseError` to match the type that's being parsed.

- The `chrono-conversions` feature and associated functions have been moved to the `aws-smithy-types-convert` crate.

  - Calls to `Instant::from_chrono` should be changed to:

vNext (Month Day, Year)

=======================

**New this release**

- Improve docs on `aws-smithy-client` (smithy-rs#855)

**TODO Upon release**

- Update README & aws-sdk-rust CI for MSRV upgrade to 1.54

**Breaking Changes**

- (aws-smithy-client): Extraneous `pub use SdkSuccess` removed from `aws_smithy_client::hyper_ext`. (smithy-rs#855)

**New this week**

- :tada: Timeouts for requests are now configurable. You can set a timeout for each individual request attempt or for all attempts made for a request. (smithy-rs#831)

**Breaking changes**

- `RetryConfigBuilder::merge_with` has been renamed to `RetryConfigBuilder::take_unset_from`

v0.0.26-alpha (TBD)

=======================

===================================

**New this release**

- Improve docs on `aws-smithy-client` (smithy-rs#855)

**TODO Upon release**

- Update README & aws-sdk-rust CI for MSRV upgrade to 1.54

**Breaking Changes**

- (aws-smithy-client): Extraneous `pub use SdkSuccess` removed from `aws_smithy_client::hyper_ext`. (smithy-rs#855)

**Breaking Changes**

    ///

    /// # Example

    ///

    /// When running [`aws_config::from_env()`](crate::from_env()), a [`ConfigLoader`](crate::ConfigLoader)

    /// is created that will then create a [`RetryConfig`] from the default_provider. There is no

    /// need to call `default_provider` and the example below is only for illustration purposes.

    ///

    /// ```no_run

    /// # use std::error::Error;

    /// # #[tokio::main]

    /// # async fn main() -> Result<(), Box<dyn Error>> {

    /// use aws_config::default_provider::retry_config;

    /// // Creating a RetryConfig from the default_provider already happens when loading a config from_env

    /// // This is only for illustration purposes

    /// let retry_config = retry_config::default_provider().retry_config().await;

    /// let config = aws_config::from_env().retry_config(retry_config).load().await;

    ///

    /// // Load a retry config from a specific profile

    /// let retry_config = retry_config::default_provider()

    ///     .profile_name("other_profile")

    ///     .retry_config()

    ///     .await;

    /// let config = aws_config::from_env()

    ///     // Override the retry config set by the default profile

    ///     .retry_config(retry_config)

    ///     .load()

    ///     .await;

    /// // instantiate a service client:

    /// // <my_aws_service>::Client::new(&config);

    /// #     Ok(())

    }

    impl Builder {

        #[doc(hidden)]

        /// Configure the default chain

        ///

        /// Exposed for overriding the environment when unit-testing providers

                Err(err) => panic!("{}", err),

            };

            builder_from_env.merge_with(builder_from_profile).build()

            builder_from_env

                .take_unset_from(builder_from_profile)

                .build()

        }

    }

}

    }

}

/// Default timeout configuration provider chain

pub mod timeout_config {

    use aws_smithy_types::timeout::TimeoutConfig;

    use crate::environment::timeout_config::EnvironmentVariableTimeoutConfigProvider;

    use crate::profile;

    use crate::provider_config::ProviderConfig;

    /// Default [`TimeoutConfig`] Provider chain

    ///

    /// Unlike other credentials and region, [`TimeoutConfig`] has no related `TimeoutConfigProvider` trait. Instead,

    /// a builder struct is returned which has a similar API.

    ///

    /// This provider will check the following sources in order:

    /// 1. [Environment variables](EnvironmentVariableTimeoutConfigProvider)

    /// 2. [Profile file](crate::profile::timeout_config::ProfileFileTimeoutConfigProvider) (`~/.aws/config`)

    ///

    /// # Example

    ///

    /// ```no_run

    /// # use std::error::Error;

    /// # #[tokio::main]

    /// # async fn main() {

    /// use aws_config::default_provider::timeout_config;

    ///

    /// // Load a timeout config from a specific profile

    /// let timeout_config = timeout_config::default_provider()

    ///     .profile_name("other_profile")

    ///     .timeout_config()

    ///     .await;

    /// let config = aws_config::from_env()

    ///     // Override the timeout config set by the default profile

    ///     .timeout_config(timeout_config)

    ///     .load()

    ///     .await;

    /// // instantiate a service client:

    /// // <my_aws_service>::Client::new(&config);

    /// # }

    /// ```

    pub fn default_provider() -> Builder {

        Builder::default()

    }

    /// Builder for [`TimeoutConfig`] that checks the environment variables and AWS profile files for configuration

    #[derive(Default)]

    pub struct Builder {

        env_provider: EnvironmentVariableTimeoutConfigProvider,

        profile_file: profile::timeout_config::Builder,

    }

    impl Builder {

        /// Configure the default chain

        ///

        /// Exposed for overriding the environment when unit-testing providers

        pub fn configure(mut self, configuration: &ProviderConfig) -> Self {

            self.env_provider =

                EnvironmentVariableTimeoutConfigProvider::new_with_env(configuration.env());

            self.profile_file = self.profile_file.configure(configuration);

            self

        }

        /// Override the profile name used by this provider

        pub fn profile_name(mut self, name: &str) -> Self {

            self.profile_file = self.profile_file.profile_name(name);

            self

        }

        /// Attempt to create a [`TimeoutConfig`](aws_smithy_types::timeout::TimeoutConfig) from following sources in order:

        /// 1. [Environment variables](crate::environment::timeout_config::EnvironmentVariableTimeoutConfigProvider)

        /// 2. [Profile file](crate::profile::timeout_config::ProfileFileTimeoutConfigProvider)

        ///

        /// Precedence is considered on a per-field basis. If no timeout is specified, requests will never time out.

        ///

        /// # Panics

        ///

        /// This will panic if:

        /// - a timeout is set to `NaN`, a negative number, or infinity

        /// - a timeout can't be parsed as a floating point number

        pub async fn timeout_config(self) -> TimeoutConfig {

            // Both of these can return errors due to invalid config settings and we want to surface those as early as possible

            // hence, we'll panic if any config values are invalid (missing values are OK though)

            // We match this instead of unwrapping so we can print the error with the `Display` impl instead of the `Debug` impl that unwrap uses

            let builder_from_env = match self.env_provider.timeout_config() {

                Ok(timeout_config_builder) => timeout_config_builder,

                Err(err) => panic!("{}", err),

            };

            let builder_from_profile = match self.profile_file.build().timeout_config().await {

                Ok(timeout_config_builder) => timeout_config_builder,

                Err(err) => panic!("{}", err),

            };

            let conf = builder_from_env.take_unset_from(builder_from_profile);

            if conf.tls_negotiation_timeout().is_some() {

                tracing::warn!(

                    "A TLS negotiation timeout was set but that feature is currently unimplemented so the setting will be ignored. \

                    To help us prioritize support for this feature, please upvote aws-sdk-rust#151 (https://github.com/awslabs/aws-sdk-rust/issues/151)")

            }

            if conf.connect_timeout().is_some() {

                tracing::warn!(

                    "A connect timeout was set but that feature is currently unimplemented so the setting will be ignored. \

                    To help us prioritize support for this feature, please upvote aws-sdk-rust#151 (https://github.com/awslabs/aws-sdk-rust/issues/151)")

            }

            if conf.read_timeout().is_some() {

                tracing::warn!(

                    "A read timeout was set but that feature is currently unimplemented so the setting will be ignored. \

                    To help us prioritize support for this feature, please upvote aws-sdk-rust#151 (https://github.com/awslabs/aws-sdk-rust/issues/151)")

            }

            conf

        }

    }

}

/// Default credentials provider chain

pub mod credentials {

    use std::borrow::Cow;

/// Load credentials from the environment

pub mod credentials;

pub use credentials::EnvironmentVariableCredentialsProvider;

/// Load regions from the environment

pub mod region;

pub use region::EnvironmentVariableRegionProvider;

/// Load retry behavior configuration from the environment

pub mod retry_config;

pub use retry_config::EnvironmentVariableRetryConfigProvider;

/// Load timeout configuration from the environment

pub mod timeout_config;

pub use timeout_config::EnvironmentVariableTimeoutConfigProvider;

/// Load a retry_config from environment variables

///

/// This provider will check the values of `AWS_RETRY_MODE` and `AWS_MAX_ATTEMPTS`

/// in order to build a retry config. If at least one is set to a valid value,

/// construction will succeed

/// in order to build a retry config.

#[derive(Debug, Default)]

pub struct EnvironmentVariableRetryConfigProvider {

    env: Env,

}

impl EnvironmentVariableRetryConfigProvider {

    /// Create a new `EnvironmentVariableRetryConfigProvider`

    /// Create a new [`EnvironmentVariableRetryConfigProvider`]

    pub fn new() -> Self {

        EnvironmentVariableRetryConfigProvider { env: Env::real() }

    }