feat: add configurable retry policy to clients (#797)

Author: ianbotsf

.changes/fbd99a2c-dd01-4b42-8c9a-55d2bf8e42fe.json

@@ -0,0 +1,5 @@
+{
+    "id": "fbd99a2c-dd01-4b42-8c9a-55d2bf8e42fe",
+    "type": "feature",
+    "description": "Add configuration for retry policy on clients"
+}

codegen/smithy-kotlin-codegen/src/main/kotlin/software/amazon/smithy/kotlin/codegen/core/RuntimeTypes.kt

@@ -137,6 +137,7 @@ object RuntimeTypes {
                 val OutputAcceptor = symbol("OutputAcceptor")
                 val RetryDirective = symbol("RetryDirective")
                 val RetryErrorType = symbol("RetryErrorType")
+                val RetryPolicy = symbol("RetryPolicy")
                 val StandardRetryPolicy = symbol("StandardRetryPolicy")
                 val SuccessAcceptor = symbol("SuccessAcceptor")
             }

codegen/smithy-kotlin-codegen/src/main/kotlin/software/amazon/smithy/kotlin/codegen/rendering/ServiceClientConfigGenerator.kt

@@ -49,6 +49,7 @@ class ServiceClientConfigGenerator(
             add(RuntimeConfigProperty.IdempotencyTokenProvider)
         }
 
+        add(RuntimeConfigProperty.RetryPolicy)
         add(RuntimeConfigProperty.RetryStrategy)
         add(RuntimeConfigProperty.Tracer)
 
@@ -98,16 +99,20 @@ class ServiceClientConfigGenerator(
     fun render(ctx: CodegenContext, writer: KotlinWriter) = render(ctx, emptyList(), writer)
 
     override fun render(ctx: CodegenContext, props: Collection<ConfigProperty>, writer: KotlinWriter) {
-        val allProps = props.toMutableList()
+        val allPropsByName = props.byName().toMutableMap()
         if (detectDefaultProps) {
+            val defaultPropsByName = detectDefaultProps(ctx, serviceShape).byName()
             // register auto detected properties
-            allProps.addAll(detectDefaultProps(ctx, serviceShape))
+            allPropsByName.putAll(defaultPropsByName)
         }
 
         // register properties from integrations
-        val integrationProps = ctx.integrations.flatMap { it.additionalServiceConfigProps(ctx) }
-        allProps.addAll(integrationProps)
-        super.render(ctx, allProps, writer)
+        ctx
+            .integrations
+            .map { it.additionalServiceConfigProps(ctx).byName() }
+            .forEach(allPropsByName::putAll)
+
+        super.render(ctx, allPropsByName.values.toList(), writer)
     }
 
     override fun renderBuilderBuildMethod(writer: KotlinWriter) {
@@ -116,3 +121,5 @@ class ServiceClientConfigGenerator(
         writer.write("override fun build(): #configClass.name:L = #configClass.name:L(this)")
     }
 }
+
+private fun Collection<ConfigProperty>.byName(): Map<String, ConfigProperty> = associateBy(ConfigProperty::propertyName)

codegen/smithy-kotlin-codegen/src/main/kotlin/software/amazon/smithy/kotlin/codegen/rendering/util/ConfigProperty.kt

@@ -169,6 +169,19 @@ class ConfigProperty private constructor(builder: Builder) {
             builtInProperty(name, builtInSymbol("String", defaultValue), documentation, baseClass)
     }
 
+    fun toBuilder(): Builder = Builder().apply {
+        symbol = this@ConfigProperty.symbol
+        builderSymbol = this@ConfigProperty.builderSymbol.takeUnless { it == this@ConfigProperty.symbol }
+        toBuilderExpression = this@ConfigProperty.toBuilderExpression
+        name = this@ConfigProperty.propertyName
+        documentation = this@ConfigProperty.documentation
+        baseClass = this@ConfigProperty.baseClass
+        builderBaseClass = this@ConfigProperty.builderBaseClass
+        propertyType = this@ConfigProperty.propertyType
+        additionalImports = this@ConfigProperty.additionalImports
+        order = this@ConfigProperty.order
+    }
+
     class Builder {
         var symbol: Symbol? = null
         var builderSymbol: Symbol? = null

codegen/smithy-kotlin-codegen/src/main/kotlin/software/amazon/smithy/kotlin/codegen/rendering/util/RuntimeConfigProperty.kt

@@ -6,6 +6,7 @@
 package software.amazon.smithy.kotlin.codegen.rendering.util
 
 import software.amazon.smithy.codegen.core.CodegenException
+import software.amazon.smithy.codegen.core.SymbolReference
 import software.amazon.smithy.kotlin.codegen.core.RuntimeTypes
 import software.amazon.smithy.kotlin.codegen.lang.KotlinTypes
 import software.amazon.smithy.kotlin.codegen.model.buildSymbol
@@ -52,6 +53,26 @@ object RuntimeConfigProperty {
         """.trimIndent()
     }
 
+    val RetryPolicy = ConfigProperty {
+        symbol = buildSymbol {
+            name = "RetryPolicy<Any?>"
+            reference(RuntimeTypes.Core.Retries.Policy.RetryPolicy, SymbolReference.ContextOption.USE)
+        }
+        name = "retryPolicy"
+        documentation = """
+            The policy to use for evaluating operation results and determining whether/how to retry.
+        """.trimIndent()
+
+        propertyType = ConfigPropertyType.RequiredWithDefault("StandardRetryPolicy.Default")
+        baseClass = RuntimeTypes.SmithyClient.SdkClientConfig
+        builderBaseClass = buildSymbol {
+            name = "${baseClass!!.name}.Builder<Config>"
+            namespace = baseClass!!.namespace
+        }
+
+        additionalImports = listOf(RuntimeTypes.Core.Retries.Policy.StandardRetryPolicy)
+    }
+
     val RetryStrategy = ConfigProperty {
         symbol = RuntimeTypes.Core.Retries.RetryStrategy
         name = "retryStrategy"

codegen/smithy-kotlin-codegen/src/test/kotlin/software/amazon/smithy/kotlin/codegen/rendering/ServiceClientConfigGeneratorTest.kt

@@ -15,6 +15,7 @@ import software.amazon.smithy.kotlin.codegen.loadModelFromResource
 import software.amazon.smithy.kotlin.codegen.model.*
 import software.amazon.smithy.kotlin.codegen.rendering.util.ConfigProperty
 import software.amazon.smithy.kotlin.codegen.rendering.util.ConfigPropertyType
+import software.amazon.smithy.kotlin.codegen.rendering.util.RuntimeConfigProperty
 import software.amazon.smithy.kotlin.codegen.test.*
 import software.amazon.smithy.model.Model
 import software.amazon.smithy.model.shapes.ServiceShape
@@ -50,6 +51,7 @@ public class Config private constructor(builder: Builder) : HttpClientConfig, Id
     public val endpointProvider: EndpointProvider = requireNotNull(builder.endpointProvider) { "endpointProvider is a required configuration property" }
     override val idempotencyTokenProvider: IdempotencyTokenProvider = builder.idempotencyTokenProvider ?: IdempotencyTokenProvider.Default
     override val interceptors: kotlin.collections.List<aws.smithy.kotlin.runtime.http.interceptors.HttpInterceptor> = builder.interceptors
+    override val retryPolicy: RetryPolicy<Any?> = builder.retryPolicy ?: StandardRetryPolicy.Default
     override val retryStrategy: RetryStrategy = builder.retryStrategy ?: StandardRetryStrategy()
     override val sdkLogMode: SdkLogMode = builder.sdkLogMode
     override val tracer: Tracer = builder.tracer ?: DefaultTracer(LoggingTraceProbe, "${TestModelDefault.SERVICE_NAME}")
@@ -84,6 +86,11 @@ public class Config private constructor(builder: Builder) : HttpClientConfig, Id
          */
         override var interceptors: kotlin.collections.MutableList<aws.smithy.kotlin.runtime.http.interceptors.HttpInterceptor> = kotlin.collections.mutableListOf()
 
+        /**
+         * The policy to use for evaluating operation results and determining whether/how to retry.
+         */
+        override var retryPolicy: RetryPolicy<Any?>? = null
+
         /**
          * The [RetryStrategy] implementation to use for service calls. All API calls will be wrapped by the
          * strategy.
@@ -202,6 +209,95 @@ public class Config private constructor(builder: Builder) {
         contents.shouldContain(expectedProps)
     }
 
+    @Test
+    fun `it overrides props by name`() {
+        val model = getModel()
+        val serviceShape = model.expectShape<ServiceShape>(TestModelDefault.SERVICE_SHAPE_ID)
+
+        val testCtx = model.newTestContext()
+        val writer = createWriter()
+        val customIntegration = object : KotlinIntegration {
+            private val overriddenLogMode = RuntimeConfigProperty.SdkLogMode.toBuilder().apply {
+                symbol = symbol!!.toBuilder().apply {
+                    defaultValue("SdkLogMode.LogRequest") // replaces SdkLogMode.Default
+                }.build()
+            }.build()
+
+            override fun additionalServiceConfigProps(ctx: CodegenContext): List<ConfigProperty> = listOf(
+                ConfigProperty.Int("customProp"),
+                overriddenLogMode,
+            )
+        }
+
+        val renderingCtx = testCtx.toRenderingContext(writer, serviceShape)
+            .copy(integrations = listOf(customIntegration))
+
+        ServiceClientConfigGenerator(serviceShape, detectDefaultProps = true).render(renderingCtx, renderingCtx.writer)
+        val contents = writer.toString()
+
+        val expectedBuilderProps = """
+        /**
+         * Override the default HTTP client engine used to make SDK requests (e.g. configure proxy behavior, timeouts, concurrency, etc).
+         * NOTE: The caller is responsible for managing the lifetime of the engine when set. The SDK
+         * client will not close it when the client is closed.
+         */
+        override var httpClientEngine: HttpClientEngine? = null
+
+        public var customProp: Int? = null
+
+        /**
+         * The endpoint provider used to determine where to make service requests.
+         */
+        public var endpointProvider: EndpointProvider? = null
+
+        /**
+         * Override the default idempotency token generator. SDK clients will generate tokens for members
+         * that represent idempotent tokens when not explicitly set by the caller using this generator.
+         */
+        override var idempotencyTokenProvider: IdempotencyTokenProvider? = null
+
+        /**
+         * Add an [aws.smithy.kotlin.runtime.client.Interceptor] that will have access to read and modify
+         * the request and response objects as they are processed by the SDK.
+         * Interceptors added using this method are executed in the order they are configured and are always
+         * later than any added automatically by the SDK.
+         */
+        override var interceptors: kotlin.collections.MutableList<aws.smithy.kotlin.runtime.http.interceptors.HttpInterceptor> = kotlin.collections.mutableListOf()
+
+        /**
+         * The policy to use for evaluating operation results and determining whether/how to retry.
+         */
+        override var retryPolicy: RetryPolicy<Any?>? = null
+
+        /**
+         * The [RetryStrategy] implementation to use for service calls. All API calls will be wrapped by the
+         * strategy.
+         */
+        override var retryStrategy: RetryStrategy? = null
+
+        /**
+         * Configure events that will be logged. By default clients will not output
+         * raw requests or responses. Use this setting to opt-in to additional debug logging.
+         *
+         * This can be used to configure logging of requests, responses, retries, etc of SDK clients.
+         *
+         * **NOTE**: Logging of raw requests or responses may leak sensitive information! It may also have
+         * performance considerations when dumping the request/response body. This is primarily a tool for
+         * debug purposes.
+         */
+        override var sdkLogMode: SdkLogMode = SdkLogMode.LogRequest
+
+        /**
+         * The tracer that is responsible for creating trace spans and wiring them up to a tracing backend (e.g.,
+         * a trace probe). By default, this will create a standard tracer that uses the service name for the root
+         * trace span and delegates to a logging trace probe (i.e.,
+         * `DefaultTracer(LoggingTraceProbe, "<service-name>")`).
+         */
+        override var tracer: Tracer? = null
+"""
+        contents.shouldContain(expectedBuilderProps)
+    }
+
     @Test
     fun `it finds idempotency token via resources`() {
         val model = """

runtime/smithy-client/common/src/aws/smithy/kotlin/runtime/client/SdkClientConfig.kt

@@ -5,6 +5,7 @@
 package aws.smithy.kotlin.runtime.client
 
 import aws.smithy.kotlin.runtime.retries.RetryStrategy
+import aws.smithy.kotlin.runtime.retries.policy.RetryPolicy
 import aws.smithy.kotlin.runtime.util.Buildable
 
 /**
@@ -24,6 +25,11 @@ public interface SdkClientConfig {
     public val sdkLogMode: SdkLogMode
         get() = SdkLogMode.Default
 
+    /**
+     * The policy to use for evaluating operation results and determining whether/how to retry.
+     */
+    public val retryPolicy: RetryPolicy<Any?>
+
     /**
      * The [RetryStrategy] the client will use to retry failed operations.
      */
@@ -47,6 +53,11 @@ public interface SdkClientConfig {
          */
         public var sdkLogMode: SdkLogMode
 
+        /**
+         * The policy to use for evaluating operation results and determining whether/how to retry.
+         */
+        public var retryPolicy: RetryPolicy<Any?>?
+
         /**
          * Configure the [RetryStrategy] the client will use to retry failed operations.
          */