Fix native Smithy client retry and retry response errors

CHANGELOG.next.toml

@@ -186,3 +186,21 @@ message = "Smithy IDL v2 mixins are now supported"
 references = ["smithy-rs#1680"]
 meta = { "breaking" = false, "tada" = false, "bug" = false, "target" = "all"}
 author = "ogudavid"
+
+[[smithy-rs]]
+message = "Generated clients now retry transient errors without replacing the retry policy."
+references = ["smithy-rs#1715", "smithy-rs#1717"]
+meta = { "breaking" = false, "tada" = false, "bug" = true, "target" = "client" }
+author = "jdisanti"
+
+[[smithy-rs]]
+message = "`ClassifyResponse` is no longer implemented for the unit type."
+references = ["smithy-rs#1715", "smithy-rs#1717"]
+meta = { "breaking" = true, "tada" = false, "bug" = false, "target" = "client" }
+author = "jdisanti"
+
+[[aws-sdk-rust]]
+message = "The `SdkError::ResponseError`, typically caused by a connection terminating before the full response is received, is now treated as a transient failure and retried."
+references = ["aws-sdk-rust#303", "smithy-rs#1717"]
+meta = { "breaking" = false, "tada" = false, "bug" = true }
+author = "jdisanti"

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

@@ -5,21 +5,10 @@
 //! AWS-specific retry logic
 
 use aws_smithy_http::result::SdkError;
-use aws_smithy_http::retry::ClassifyResponse;
+use aws_smithy_http::retry::{ClassifyResponse, DefaultResponseClassifier};
 use aws_smithy_types::retry::{ErrorKind, ProvideErrorKind, RetryKind};
 use std::time::Duration;
 
-/// A retry policy that models AWS error codes as outlined in the SEP
-///
-/// In order of priority:
-/// 1. The `x-amz-retry-after` header is checked
-/// 2. The modeled error retry mode is checked
-/// 3. The code is checked against a predetermined list of throttling errors & transient error codes
-/// 4. The status code is checked against a predetermined list of status codes
-#[non_exhaustive]
-#[derive(Clone, Debug)]
-pub struct AwsErrorRetryPolicy;
-
 const TRANSIENT_ERROR_STATUS_CODES: &[u16] = &[500, 502, 503, 504];
 const THROTTLING_ERRORS: &[&str] = &[
  "Throttling",
@@ -39,41 +28,38 @@ const THROTTLING_ERRORS: &[&str] = &[
 ];
 const TRANSIENT_ERRORS: &[&str] = &["RequestTimeout", "RequestTimeoutException"];
 
-impl AwsErrorRetryPolicy {
- /// Create an `AwsErrorRetryPolicy` with the default set of known error & status codes
+/// Implementation of [`ClassifyResponse`] that models AWS error codes.
+///
+/// In order of priority:
+/// 1. The `x-amz-retry-after` header is checked
+/// 2. The modeled error retry mode is checked
+/// 3. The code is checked against a predetermined list of throttling errors & transient error codes
+/// 4. The status code is checked against a predetermined list of status codes
+#[non_exhaustive]
+#[derive(Clone, Debug)]
+pub struct AwsResponseClassifier;
+
+impl AwsResponseClassifier {
+ /// Create an `AwsResponseClassifier` with the default set of known error & status codes
  pub fn new() -> Self {
- AwsErrorRetryPolicy
+ AwsResponseClassifier
  }
 }
 
-impl Default for AwsErrorRetryPolicy {
+impl Default for AwsResponseClassifier {
  fn default() -> Self {
  Self::new()
  }
 }
 
-impl<T, E> ClassifyResponse<T, SdkError<E>> for AwsErrorRetryPolicy
+impl<T, E> ClassifyResponse<T, SdkError<E>> for AwsResponseClassifier
 where
  E: ProvideErrorKind,
 {
- fn classify(&self, err: Result<&T, &SdkError<E>>) -> RetryKind {
- let (err, response) = match err {
- Ok(_) => return RetryKind::Unnecessary,
- Err(SdkError::ServiceError { err, raw }) => (err, raw),
- Err(SdkError::TimeoutError(_err)) => {
- return RetryKind::Error(ErrorKind::TransientError)
- }
-
- Err(SdkError::DispatchFailure(err)) => {
- return if err.is_timeout() || err.is_io() {
- RetryKind::Error(ErrorKind::TransientError)
- } else if let Some(ek) = err.is_other() {
- RetryKind::Error(ek)
- } else {
- RetryKind::UnretryableFailure
- };
- }
- Err(_) => return RetryKind::UnretryableFailure,
+ fn classify(&self, result: Result<&T, &SdkError<E>>) -> RetryKind {
+ let (err, response) = match DefaultResponseClassifier::try_extract_err_response(result) {
+ Ok(extracted) => extracted,
+ Err(retry_kind) => return retry_kind,
  };
  if let Some(retry_after_delay) = response
  .http()
@@ -105,15 +91,23 @@ where
 
 #[cfg(test)]
 mod test {
- use crate::retry::AwsErrorRetryPolicy;
+ use crate::retry::AwsResponseClassifier;
  use aws_smithy_http::body::SdkBody;
  use aws_smithy_http::operation;
  use aws_smithy_http::result::{SdkError, SdkSuccess};
  use aws_smithy_http::retry::ClassifyResponse;
  use aws_smithy_types::retry::{ErrorKind, ProvideErrorKind, RetryKind};
+ use std::fmt;
  use std::time::Duration;
 
+ #[derive(Debug)]
  struct UnmodeledError;
+ impl fmt::Display for UnmodeledError {
+ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+ write!(f, "UnmodeledError")
+ }
+ }
+ impl std::error::Error for UnmodeledError {}
 
  struct CodedError {
  code: &'static str,
@@ -151,7 +145,7 @@ mod test {
 
  #[test]
  fn not_an_error() {
- let policy = AwsErrorRetryPolicy::new();
+ let policy = AwsResponseClassifier::new();
  let test_response = http::Response::new("OK");
  assert_eq!(
  policy.classify(make_err(UnmodeledError, test_response).as_ref()),
@@ -161,7 +155,7 @@ mod test {
 
  #[test]
  fn classify_by_response_status() {
- let policy = AwsErrorRetryPolicy::new();
+ let policy = AwsResponseClassifier::new();
  let test_resp = http::Response::builder()
  .status(500)
  .body("error!")
@@ -174,7 +168,7 @@ mod test {
 
  #[test]
  fn classify_by_response_status_not_retryable() {
- let policy = AwsErrorRetryPolicy::new();
+ let policy = AwsResponseClassifier::new();
  let test_resp = http::Response::builder()
  .status(408)
  .body("error!")
@@ -188,7 +182,7 @@ mod test {
  #[test]
  fn classify_by_error_code() {
  let test_response = http::Response::new("OK");
- let policy = AwsErrorRetryPolicy::new();
+ let policy = AwsResponseClassifier::new();
 
  assert_eq!(
  policy.classify(make_err(CodedError { code: "Throttling" }, test_response).as_ref()),
@@ -214,7 +208,7 @@ mod test {
  fn classify_generic() {
  let err = aws_smithy_types::Error::builder().code("SlowDown").build();
  let test_response = http::Response::new("OK");
- let policy = AwsErrorRetryPolicy::new();
+ let policy = AwsResponseClassifier::new();
  assert_eq!(
  policy.classify(make_err(err, test_response).as_ref()),
  RetryKind::Error(ErrorKind::ThrottlingError)
@@ -236,7 +230,7 @@ mod test {
  }
  }
 
- let policy = AwsErrorRetryPolicy::new();
+ let policy = AwsResponseClassifier::new();
 
  assert_eq!(
  policy.classify(make_err(ModeledRetries, test_response).as_ref()),
@@ -246,7 +240,7 @@ mod test {
 
  #[test]
  fn test_retry_after_header() {
- let policy = AwsErrorRetryPolicy::new();
+ let policy = AwsResponseClassifier::new();
  let test_response = http::Response::builder()
  .header("x-amz-retry-after", "5000")
  .body("retry later")
@@ -258,9 +252,26 @@ mod test {
  );
  }
 
+ #[test]
+ fn classify_response_error() {
+ let policy = AwsResponseClassifier::new();
+ assert_eq!(
+ policy.classify(
+ Result::<SdkSuccess<()>, SdkError<UnmodeledError>>::Err(SdkError::ResponseError {
+ err: Box::new(UnmodeledError),
+ raw: operation::Response::new(
+ http::Response::new("OK").map(|b| SdkBody::from(b))
+ ),
+ })
+ .as_ref()
+ ),
+ RetryKind::Error(ErrorKind::TransientError)
+ );
+ }
+
  #[test]
  fn test_timeout_error() {
- let policy = AwsErrorRetryPolicy::new();
+ let policy = AwsResponseClassifier::new();
  let err: Result<(), SdkError<UnmodeledError>> = Err(SdkError::TimeoutError("blah".into()));
  assert_eq!(
  policy.classify(err.as_ref()),

aws/rust-runtime/aws-inlineable/tests/middleware_e2e_test.rs

@@ -15,7 +15,7 @@ use http::{self, Uri};
 
 use aws_endpoint::partition::endpoint::{Protocol, SignatureVersion};
 use aws_endpoint::{EndpointShim, Params};
-use aws_http::retry::AwsErrorRetryPolicy;
+use aws_http::retry::AwsResponseClassifier;
 use aws_http::user_agent::AwsUserAgent;
 use aws_inlineable::middleware::DefaultMiddleware;
 use aws_sig_auth::signer::OperationSigningConfig;
@@ -75,7 +75,7 @@ impl ParseHttpResponse for TestOperationParser {
  }
 }
 
-fn test_operation() -> Operation<TestOperationParser, AwsErrorRetryPolicy> {
+fn test_operation() -> Operation<TestOperationParser, AwsResponseClassifier> {
  let req = operation::Request::new(
  http::Request::builder()
  .uri("https://test-service.test-region.amazonaws.com/")
@@ -110,7 +110,7 @@ fn test_operation() -> Operation<TestOperationParser, AwsErrorRetryPolicy> {
  Result::<_, Infallible>::Ok(req)
  })
  .unwrap();
- Operation::new(req, TestOperationParser).with_retry_policy(AwsErrorRetryPolicy::new())
+ Operation::new(req, TestOperationParser).with_retry_policy(AwsResponseClassifier::new())
 }
 
 #[cfg(any(feature = "native-tls", feature = "rustls"))]

aws/sdk-codegen/src/main/kotlin/software/amazon/smithy/rustsdk/AwsFluentClientDecorator.kt

@@ -98,7 +98,7 @@ class AwsFluentClientDecorator : RustCodegenDecorator<ClientCodegenContext> {
  AwsPresignedFluentBuilderMethod(runtimeConfig),
  AwsFluentClientDocs(codegenContext),
  ),
- retryPolicy = runtimeConfig.awsHttp().asType().member("retry::AwsErrorRetryPolicy").writable,
+ retryPolicy = runtimeConfig.awsHttp().asType().member("retry::AwsResponseClassifier").writable,
  ).render(rustCrate)
  rustCrate.withModule(FluentClientGenerator.customizableOperationModule) { writer ->
  renderCustomizableOperationSendMethod(runtimeConfig, generics, writer)

aws/sdk-codegen/src/main/kotlin/software/amazon/smithy/rustsdk/RetryPolicyDecorator.kt

@@ -34,7 +34,7 @@ class RetryPolicyDecorator : RustCodegenDecorator<ClientCodegenContext> {
 }
 
 class RetryPolicyFeature(private val runtimeConfig: RuntimeConfig) : OperationCustomization() {
- override fun retryType(): RuntimeType = runtimeConfig.awsHttp().asType().member("retry::AwsErrorRetryPolicy")
+ override fun retryType(): RuntimeType = runtimeConfig.awsHttp().asType().member("retry::AwsResponseClassifier")
  override fun section(section: OperationSection) = when (section) {
  is OperationSection.FinalizeOperation -> writable {
  rust(

aws/sdk/integration-tests/dynamodb/tests/movies.rs

@@ -5,7 +5,7 @@
 
 use aws_sdk_dynamodb as dynamodb;
 
-use aws_http::retry::AwsErrorRetryPolicy;
+use aws_http::retry::AwsResponseClassifier;
 use aws_sdk_dynamodb::input::CreateTableInput;
 use aws_smithy_client::test_connection::TestConnection;
 use aws_smithy_http::body::SdkBody;
@@ -155,7 +155,7 @@ where
 async fn wait_for_ready_table(
  table_name: &str,
  conf: &Config,
-) -> Operation<DescribeTable, WaitForReadyTable<AwsErrorRetryPolicy>> {
+) -> Operation<DescribeTable, WaitForReadyTable<AwsResponseClassifier>> {
  let operation = DescribeTableInput::builder()
  .table_name(table_name)
  .build()

aws/sdk/integration-tests/kms/tests/sensitive-it.rs

@@ -3,7 +3,7 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
-use aws_http::retry::AwsErrorRetryPolicy;
+use aws_http::retry::AwsResponseClassifier;
 use aws_sdk_kms as kms;
 use aws_smithy_http::body::SdkBody;
 use aws_smithy_http::operation::{self, Parts};
@@ -65,7 +65,7 @@ fn types_are_debug() {
  assert_debug::<kms::client::fluent_builders::CreateAlias>();
 }
 
-async fn create_alias_op() -> Parts<CreateAlias, AwsErrorRetryPolicy> {
+async fn create_alias_op() -> Parts<CreateAlias, AwsResponseClassifier> {
  let conf = kms::Config::builder().build();
  let (_, parts) = CreateAlias::builder()
  .build()

codegen-client/src/main/kotlin/software/amazon/smithy/rust/codegen/smithy/generators/client/FluentClientGenerator.kt

@@ -67,7 +67,8 @@ class FluentClientGenerator(
  client = CargoDependency.SmithyClient(codegenContext.runtimeConfig).asType(),
  ),
  private val customizations: List<FluentClientCustomization> = emptyList(),
- private val retryPolicy: Writable = RustType.Unit.writable,
+ private val retryPolicy: Writable = CargoDependency.SmithyHttp(codegenContext.runtimeConfig).asType()
+ .member("retry::DefaultResponseClassifier").writable,
 ) {
  companion object {
  fun clientOperationFnName(operationShape: OperationShape, symbolProvider: RustSymbolProvider): String =

codegen-client/src/main/kotlin/software/amazon/smithy/rust/codegen/smithy/generators/protocol/MakeOperationGenerator.kt

@@ -10,7 +10,6 @@ import software.amazon.smithy.model.shapes.BlobShape
 import software.amazon.smithy.model.shapes.OperationShape
 import software.amazon.smithy.rust.codegen.rustlang.Attribute
 import software.amazon.smithy.rust.codegen.rustlang.CargoDependency
-import software.amazon.smithy.rust.codegen.rustlang.RustType
 import software.amazon.smithy.rust.codegen.rustlang.RustWriter
 import software.amazon.smithy.rust.codegen.rustlang.asType
 import software.amazon.smithy.rust.codegen.rustlang.docs
@@ -48,6 +47,8 @@ open class MakeOperationGenerator(
  protected val runtimeConfig = coreCodegenContext.runtimeConfig
  protected val symbolProvider = coreCodegenContext.symbolProvider
  protected val httpBindingResolver = protocol.httpBindingResolver
+ private val defaultClassifier = CargoDependency.SmithyHttp(runtimeConfig)
+ .asType().member("retry::DefaultResponseClassifier")
 
  private val sdkId =
  coreCodegenContext.serviceShape.getTrait<ServiceTrait>()?.sdkId?.lowercase()?.replace(" ", "")
@@ -152,7 +153,7 @@ open class MakeOperationGenerator(
  writer.format(symbolProvider.toSymbol(shape))
 
  private fun buildOperationTypeRetry(writer: RustWriter, customizations: List<OperationCustomization>): String =
- (customizations.firstNotNullOfOrNull { it.retryType() } ?: RustType.Unit).let { writer.format(it) }
+ (customizations.firstNotNullOfOrNull { it.retryType() } ?: defaultClassifier).let { writer.format(it) }
 
  private fun needsContentLength(operationShape: OperationShape): Boolean {
  return protocol.httpBindingResolver.requestBindings(operationShape)

rust-runtime/aws-smithy-client/src/static_tests.rs

@@ -7,6 +7,7 @@
 
 use crate::{Builder, Error, Operation, ParseHttpResponse, ProvideErrorKind};
 use aws_smithy_http::operation;
+use aws_smithy_http::retry::DefaultResponseClassifier;
 
 #[derive(Debug)]
 #[non_exhaustive]
@@ -40,7 +41,7 @@ impl ParseHttpResponse for TestOperation {
  unreachable!("only used for static tests")
  }
 }
-pub type ValidTestOperation = Operation<TestOperation, ()>;
+pub type ValidTestOperation = Operation<TestOperation, DefaultResponseClassifier>;
 
 // Statically check that a standard retry can actually be used to build a Client.
 #[allow(dead_code)]

rust-runtime/aws-smithy-http-tower/src/lib.rs

@@ -62,6 +62,7 @@ mod tests {
  use aws_smithy_http::operation::{Operation, Request};
  use aws_smithy_http::response::ParseStrictResponse;
  use aws_smithy_http::result::ConnectorError;
+ use aws_smithy_http::retry::DefaultResponseClassifier;
  use bytes::Bytes;
  use http::Response;
  use std::convert::{Infallible, TryInto};
@@ -102,7 +103,10 @@ mod tests {
  });
 
  let mut svc = ServiceBuilder::new()
- .layer(ParseResponseLayer::<TestParseResponse, ()>::new())
+ .layer(ParseResponseLayer::<
+ TestParseResponse,
+ DefaultResponseClassifier,
+ >::new())
  .layer(MapRequestLayer::for_mapper(AddHeader))
  .layer(DispatchLayer)
  .service(http_layer);

rust-runtime/aws-smithy-http/src/operation.rs

@@ -5,6 +5,7 @@
 
 use crate::body::SdkBody;
 use crate::property_bag::{PropertyBag, SharedPropertyBag};
+use crate::retry::DefaultResponseClassifier;
 use aws_smithy_types::date_time::DateTimeFormatError;
 use http::uri::InvalidUri;
 use std::borrow::Cow;
@@ -232,12 +233,12 @@ impl<H, R> Operation<H, R> {
 }
 
 impl<H> Operation<H, ()> {
- pub fn new(request: Request, response_handler: H) -> Self {
+ pub fn new(request: Request, response_handler: H) -> Operation<H, DefaultResponseClassifier> {
  Operation {
  request,
  parts: Parts {
  response_handler,
- retry_policy: (),
+ retry_policy: DefaultResponseClassifier::new(),
  metadata: None,
  },
  }