Revamp errors in aws-smithy-types

aws/rust-runtime/aws-config/external-types.toml

@@ -16,8 +16,9 @@ allowed_external_types = [
    "aws_smithy_types::retry",
    "aws_smithy_types::retry::*",
    "aws_smithy_types::timeout",
-   "aws_smithy_types::timeout::config::TimeoutConfig",
-   "aws_smithy_types::timeout::error::ConfigError",
+   "aws_smithy_types::timeout::OperationTimeoutConfig",
+   "aws_smithy_types::timeout::TimeoutConfig",
+   "aws_smithy_types::timeout::TimeoutConfigBuilder",
    "aws_types::*",
    "http::response::Response",
    "http::uri::Uri",

aws/rust-runtime/aws-config/src/default_provider.rs

@@ -3,8 +3,11 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
-//! Default Provider chains for [`region`](default_provider::region), [`credentials`](default_provider::credentials),
-//! [retries](default_provider::retry_config), [timeouts](default_provider::timeout_config) and [app name](default_provider::app_name).
+//! Providers that implement the default AWS provider chain
+//!
+//! Default Provider chains for [`region`](crate::default_provider::region), [`credentials`](crate::default_provider::credentials),
+//! [retries](crate::default_provider::retry_config), [timeouts](crate::default_provider::timeout_config) and
+//! [app name](crate::default_provider::app_name).
 //!
 //! Typically, this module is used via [`load_from_env`](crate::load_from_env) or [`from_env`](crate::from_env). It should only be used directly
 //! if you need to set custom configuration options to override the default resolution chain.

aws/rust-runtime/aws-config/src/default_provider/retry_config.rs

@@ -3,11 +3,11 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
-use aws_smithy_types::retry::RetryConfig;
-
 use crate::environment::retry_config::EnvironmentVariableRetryConfigProvider;
 use crate::profile;
 use crate::provider_config::ProviderConfig;
+use aws_smithy_types::error::display::DisplayErrorContext;
+use aws_smithy_types::retry::RetryConfig;
 
 /// Default RetryConfig Provider chain
 ///
@@ -90,11 +90,11 @@ impl Builder {
         // 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.retry_config_builder() {
             Ok(retry_config_builder) => retry_config_builder,
-            Err(err) => panic!("{}", err),
+            Err(err) => panic!("{}", DisplayErrorContext(&err)),
         };
         let builder_from_profile = match self.profile_file.build().retry_config_builder().await {
             Ok(retry_config_builder) => retry_config_builder,
-            Err(err) => panic!("{}", err),
+            Err(err) => panic!("{}", DisplayErrorContext(&err)),
         };
 
         builder_from_env

aws/rust-runtime/aws-config/src/environment/mod.rs

@@ -3,6 +3,8 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
+//! Providers that load configuration from environment variables
+
 /// Load app name from the environment
 pub mod app_name;
 pub use app_name::EnvironmentVariableAppNameProvider;

aws/rust-runtime/aws-config/src/environment/retry_config.rs

@@ -3,10 +3,11 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
-use std::str::FromStr;
-
-use aws_smithy_types::retry::{RetryConfigBuilder, RetryConfigErr, RetryMode};
+use crate::retry::{
+    error::RetryConfigError, error::RetryConfigErrorKind, RetryConfigBuilder, RetryMode,
+};
 use aws_types::os_shim_internal::Env;
+use std::str::FromStr;
 
 const ENV_VAR_MAX_ATTEMPTS: &str = "AWS_MAX_ATTEMPTS";
 const ENV_VAR_RETRY_MODE: &str = "AWS_RETRY_MODE";
@@ -35,20 +36,22 @@ impl EnvironmentVariableRetryConfigProvider {
     }
 
     /// Attempt to create a new `RetryConfig` from environment variables
-    pub fn retry_config_builder(&self) -> Result<RetryConfigBuilder, RetryConfigErr> {
+    pub fn retry_config_builder(&self) -> Result<RetryConfigBuilder, RetryConfigError> {
         let max_attempts = match self.env.get(ENV_VAR_MAX_ATTEMPTS).ok() {
             Some(max_attempts) => match max_attempts.parse::<u32>() {
                 Ok(max_attempts) if max_attempts == 0 => {
-                    return Err(RetryConfigErr::MaxAttemptsMustNotBeZero {
+                    return Err(RetryConfigErrorKind::MaxAttemptsMustNotBeZero {
                         set_by: "environment variable".into(),
-                    });
+                    }
+                    .into());
                 }
                 Ok(max_attempts) => Some(max_attempts),
                 Err(source) => {
-                    return Err(RetryConfigErr::FailedToParseMaxAttempts {
+                    return Err(RetryConfigErrorKind::FailedToParseMaxAttempts {
                         set_by: "environment variable".into(),
                         source,
-                    });
+                    }
+                    .into());
                 }
             },
             None => None,
@@ -58,10 +61,11 @@ impl EnvironmentVariableRetryConfigProvider {
             Ok(retry_mode) => match RetryMode::from_str(&retry_mode) {
                 Ok(retry_mode) => Some(retry_mode),
                 Err(retry_mode_err) => {
-                    return Err(RetryConfigErr::InvalidRetryMode {
+                    return Err(RetryConfigErrorKind::InvalidRetryMode {
                         set_by: "environment variable".into(),
                         source: retry_mode_err,
-                    });
+                    }
+                    .into());
                 }
             },
             Err(_) => None,
@@ -78,10 +82,11 @@ impl EnvironmentVariableRetryConfigProvider {
 
 #[cfg(test)]
 mod test {
-    use aws_smithy_types::retry::{RetryConfig, RetryConfigErr, RetryMode};
-    use aws_types::os_shim_internal::Env;
-
     use super::{EnvironmentVariableRetryConfigProvider, ENV_VAR_MAX_ATTEMPTS, ENV_VAR_RETRY_MODE};
+    use crate::retry::{
+        error::RetryConfigError, error::RetryConfigErrorKind, RetryConfig, RetryMode,
+    };
+    use aws_types::os_shim_internal::Env;
 
     fn test_provider(vars: &[(&str, &str)]) -> EnvironmentVariableRetryConfigProvider {
         EnvironmentVariableRetryConfigProvider::new_with_env(Env::from_slice(vars))
@@ -112,7 +117,9 @@ mod test {
             test_provider(&[(ENV_VAR_MAX_ATTEMPTS, "not an integer")])
                 .retry_config_builder()
                 .unwrap_err(),
-            RetryConfigErr::FailedToParseMaxAttempts { .. }
+            RetryConfigError {
+                kind: RetryConfigErrorKind::FailedToParseMaxAttempts { .. }
+            }
         ));
     }
 
@@ -148,7 +155,9 @@ mod test {
             .unwrap_err();
         assert!(matches!(
             err,
-            RetryConfigErr::MaxAttemptsMustNotBeZero { .. }
+            RetryConfigError {
+                kind: RetryConfigErrorKind::MaxAttemptsMustNotBeZero { .. }
+            }
         ));
     }
 }

aws/rust-runtime/aws-config/src/lib.rs

@@ -11,7 +11,7 @@
     unreachable_pub
 )]
 
-//! `aws-config` provides implementations of region, credential resolution.
+//! `aws-config` provides implementations of region and credential resolution.
 //!
 //! These implementations can be used either via the default chain implementation
 //! [`from_env`]/[`ConfigLoader`] or ad-hoc individual credential and region providers.
@@ -92,9 +92,6 @@
 //! ```
 
 pub use aws_smithy_http::endpoint;
-// Re-export types from smithy-types
-pub use aws_smithy_types::retry;
-pub use aws_smithy_types::timeout;
 // Re-export types from aws-types
 pub use aws_types::{
     app_name::{AppName, InvalidAppName},
@@ -106,43 +103,28 @@ pub use loader::ConfigLoader;
 #[allow(dead_code)]
 const PKG_VERSION: &str = env!("CARGO_PKG_VERSION");
 
-/// Providers that implement the default AWS provider chain
-pub mod default_provider;
-
-/// Providers that load configuration from environment variables
-pub mod environment;
-
-/// Meta-providers that augment existing providers with new behavior
-pub mod meta;
-
-pub mod profile;
-
-pub mod sts;
-
 #[cfg(test)]
 mod test_case;
 
-pub mod web_identity_token;
-
-pub mod ecs;
-
-pub mod provider_config;
-
 mod cache;
-
-pub mod imds;
-
-mod json_credentials;
-
 mod fs_util;
-
 mod http_credential_provider;
-
-pub mod sso;
+mod json_credentials;
 
 pub mod connector;
-
 pub mod credential_process;
+pub mod default_provider;
+pub mod ecs;
+pub mod environment;
+pub mod imds;
+pub mod meta;
+pub mod profile;
+pub mod provider_config;
+pub mod retry;
+pub mod sso;
+pub mod sts;
+pub mod timeout;
+pub mod web_identity_token;
 
 /// Create an environment loader for AWS Configuration
 ///

aws/rust-runtime/aws-config/src/meta/mod.rs

@@ -3,6 +3,7 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
-pub mod region;
+//! Meta-providers that augment existing providers with new behavior
 
 pub mod credentials;
+pub mod region;

aws/rust-runtime/aws-config/src/profile/parser/parse.rs

@@ -36,7 +36,7 @@ struct Location {
 }
 
 /// An error encountered while parsing a profile
-#[derive(Debug, Clone)]
+#[derive(Debug)]
 pub struct ProfileParseError {
     /// Location where this error occurred
     location: Location,

aws/rust-runtime/aws-config/src/profile/retry_config.rs

@@ -7,8 +7,10 @@
 
 use crate::profile::profile_file::ProfileFiles;
 use crate::provider_config::ProviderConfig;
+use crate::retry::{
+    error::RetryConfigError, error::RetryConfigErrorKind, RetryConfigBuilder, RetryMode,
+};
 use aws_smithy_types::error::display::DisplayErrorContext;
-use aws_smithy_types::retry::{RetryConfigBuilder, RetryConfigErr, RetryMode};
 use aws_types::os_shim_internal::{Env, Fs};
 use std::str::FromStr;
 
@@ -101,7 +103,7 @@ impl ProfileFileRetryConfigProvider {
     }
 
     /// Attempt to create a new RetryConfigBuilder from a profile file.
-    pub async fn retry_config_builder(&self) -> Result<RetryConfigBuilder, RetryConfigErr> {
+    pub async fn retry_config_builder(&self) -> Result<RetryConfigBuilder, RetryConfigError> {
         let profile = match super::parser::load(&self.fs, &self.env, &self.profile_files).await {
             Ok(profile) => profile,
             Err(err) => {
@@ -130,16 +132,18 @@ impl ProfileFileRetryConfigProvider {
         let max_attempts = match selected_profile.get("max_attempts") {
             Some(max_attempts) => match max_attempts.parse::<u32>() {
                 Ok(max_attempts) if max_attempts == 0 => {
-                    return Err(RetryConfigErr::MaxAttemptsMustNotBeZero {
+                    return Err(RetryConfigErrorKind::MaxAttemptsMustNotBeZero {
                         set_by: "aws profile".into(),
-                    });
+                    }
+                    .into());
                 }
                 Ok(max_attempts) => Some(max_attempts),
                 Err(source) => {
-                    return Err(RetryConfigErr::FailedToParseMaxAttempts {
+                    return Err(RetryConfigErrorKind::FailedToParseMaxAttempts {
                         set_by: "aws profile".into(),
                         source,
-                    });
+                    }
+                    .into());
                 }
             },
             None => None,
@@ -149,10 +153,11 @@ impl ProfileFileRetryConfigProvider {
             Some(retry_mode) => match RetryMode::from_str(retry_mode) {
                 Ok(retry_mode) => Some(retry_mode),
                 Err(retry_mode_err) => {
-                    return Err(RetryConfigErr::InvalidRetryMode {
+                    return Err(RetryConfigErrorKind::InvalidRetryMode {
                         set_by: "aws profile".into(),
                         source: retry_mode_err,
-                    });
+                    }
+                    .into());
                 }
             },
             None => None,

aws/rust-runtime/aws-config/src/retry.rs

@@ -0,0 +1,87 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+//! Retry configuration
+
+// Re-export from aws-smithy-types
+pub use aws_smithy_types::retry::ErrorKind;
+pub use aws_smithy_types::retry::ProvideErrorKind;
+pub use aws_smithy_types::retry::RetryConfig;
+pub use aws_smithy_types::retry::RetryConfigBuilder;
+pub use aws_smithy_types::retry::RetryKind;
+pub use aws_smithy_types::retry::RetryMode;
+
+/// Errors for retry configuration
+pub mod error {
+    use std::borrow::Cow;
+    use std::fmt;
+    use std::num::ParseIntError;
+
+    // Re-export from aws-smithy-types
+    pub use aws_smithy_types::retry::RetryModeParseError;
+
+    #[derive(Debug)]
+    pub(crate) enum RetryConfigErrorKind {
+        /// The configured retry mode wasn't recognized.
+        InvalidRetryMode {
+            /// Cause of the error.
+            source: RetryModeParseError,
+            /// Where the invalid retry mode value originated from.
+            set_by: Cow<'static, str>,
+        },
+        /// Max attempts must be greater than zero.
+        MaxAttemptsMustNotBeZero {
+            /// Where the invalid max attempts value originated from.
+            set_by: Cow<'static, str>,
+        },
+        /// The max attempts value couldn't be parsed to an integer.
+        FailedToParseMaxAttempts {
+            /// Cause of the error.
+            source: ParseIntError,
+            /// Where the invalid max attempts value originated from.
+            set_by: Cow<'static, str>,
+        },
+    }
+
+    /// Failure to parse retry config from profile file or environment variable.
+    #[derive(Debug)]
+    pub struct RetryConfigError {
+        pub(crate) kind: RetryConfigErrorKind,
+    }
+
+    impl fmt::Display for RetryConfigError {
+        fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+            use RetryConfigErrorKind::*;
+            match &self.kind {
+                InvalidRetryMode { set_by, .. } => {
+                    write!(f, "invalid configuration set by {set_by}")
+                }
+                MaxAttemptsMustNotBeZero { set_by } => {
+                    write!(f, "invalid configuration set by {set_by}: It is invalid to set max attempts to 0. Unset it or set it to an integer greater than or equal to one.")
+                }
+                FailedToParseMaxAttempts { set_by, .. } => {
+                    write!(f, "failed to parse max attempts set by {set_by}",)
+                }
+            }
+        }
+    }
+
+    impl std::error::Error for RetryConfigError {
+        fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
+            use RetryConfigErrorKind::*;
+            match &self.kind {
+                InvalidRetryMode { source, .. } => Some(source),
+                FailedToParseMaxAttempts { source, .. } => Some(source),
+                MaxAttemptsMustNotBeZero { .. } => None,
+            }
+        }
+    }
+
+    impl From<RetryConfigErrorKind> for RetryConfigError {
+        fn from(kind: RetryConfigErrorKind) -> Self {
+            Self { kind }
+        }
+    }
+}