refactor: remove middleware Feature concept (#536)

Author: aajtodd

runtime/io/common/src/aws/smithy/kotlin/runtime/io/middleware/ModifyRequest.kt

@@ -0,0 +1,25 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+package aws.smithy.kotlin.runtime.io.middleware
+
+import aws.smithy.kotlin.runtime.io.Handler
+
+/**
+ * A transform that only modifies the input type
+ */
+interface ModifyRequest<Request> {
+    suspend fun modifyRequest(req: Request): Request
+}
+
+/**
+ * Adapter for [ModifyRequest] to implement middleware
+ */
+internal class ModifyRequestMiddleware<Request, Response>(
+    private val transform: ModifyRequest<Request>
+) : Middleware<Request, Response> {
+    override suspend fun <H : Handler<Request, Response>> handle(request: Request, next: H): Response =
+        next.call(transform.modifyRequest(request))
+}

runtime/io/common/src/aws/smithy/kotlin/runtime/io/middleware/ModifyResponse.kt

@@ -0,0 +1,27 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+package aws.smithy.kotlin.runtime.io.middleware
+
+import aws.smithy.kotlin.runtime.io.Handler
+
+/**
+ * A transform that only modifies the output type
+ */
+interface ModifyResponse<Response> {
+    suspend fun modifyResponse(resp: Response): Response
+}
+
+/**
+ * Adapter for [ModifyResponse] to implement middleware
+ */
+internal class ModifyResponseMiddleware<Request, Response>(
+    private val transform: ModifyResponse<Response>
+) : Middleware<Request, Response> {
+    override suspend fun <H : Handler<Request, Response>> handle(request: Request, next: H): Response {
+        val resp = next.call(request)
+        return transform.modifyResponse(resp)
+    }
+}

runtime/io/common/src/aws/smithy/kotlin/runtime/io/middleware/Phase.kt

@@ -20,23 +20,37 @@ class Phase<Request, Response> : Middleware<Request, Response> {
         Before, After
     }
 
-    private val middlewares = mutableListOf<Middleware<Request, Response>>()
+    private val middlewares = ArrayDeque<Middleware<Request, Response>>()
 
     /**
      * Insert [interceptor] in a specific order into the set of interceptors for this phase
      */
     fun intercept(order: Order = Order.After, interceptor: suspend (req: Request, next: Handler<Request, Response>) -> Response) {
         val wrapped = MiddlewareLambda(interceptor)
-        register(order, wrapped)
+        register(wrapped, order)
+    }
+
+    /**
+     * Insert a [transform] that only modifies the request of this phase
+     */
+    fun register(transform: ModifyRequest<Request>, order: Order = Order.After) {
+        register(ModifyRequestMiddleware(transform), order)
+    }
+
+    /**
+     * Insert a [transform] that only modifies the response of this phase
+     */
+    fun register(transform: ModifyResponse<Response>, order: Order = Order.After) {
+        register(ModifyResponseMiddleware(transform), order)
     }
 
     /**
      * Register a middleware in a specific order
      */
-    fun register(order: Order, middleware: Middleware<Request, Response>) {
+    fun register(middleware: Middleware<Request, Response>, order: Order = Order.After) {
         when (order) {
-            Order.Before -> middlewares.add(0, middleware)
-            Order.After -> middlewares.add(middleware)
+            Order.Before -> middlewares.addFirst(middleware)
+            Order.After -> middlewares.addLast(middleware)
         }
     }
 

runtime/protocol/http/common/src/aws/smithy/kotlin/runtime/http/Feature.kt

@@ -6,8 +6,11 @@ package aws.smithy.kotlin.runtime.http.middleware
 
 import aws.smithy.kotlin.runtime.SdkBaseException
 import aws.smithy.kotlin.runtime.http.*
-import aws.smithy.kotlin.runtime.http.operation.SdkHttpOperation
+import aws.smithy.kotlin.runtime.http.operation.ReceiveMiddleware
+import aws.smithy.kotlin.runtime.http.operation.SdkHttpRequest
 import aws.smithy.kotlin.runtime.http.request.HttpRequest
+import aws.smithy.kotlin.runtime.http.response.HttpCall
+import aws.smithy.kotlin.runtime.io.Handler
 
 /**
  * Generic HTTP service exception
@@ -51,29 +54,22 @@ class HttpResponseException : SdkBaseException {
  * so all we can do is throw a generic exception with the code and let the user figure out what modeled error it was
  * using whatever matching mechanism they want.
  */
-class DefaultValidateResponse : Feature {
-    companion object Feature : HttpClientFeatureFactory<DefaultValidateResponse, DefaultValidateResponse> {
-        override val key: FeatureKey<DefaultValidateResponse> = FeatureKey("DefaultValidateResponse")
-        override fun create(block: DefaultValidateResponse.() -> Unit): DefaultValidateResponse =
-            DefaultValidateResponse().apply(block)
-    }
-
-    override fun <I, O> install(operation: SdkHttpOperation<I, O>) {
-        operation.execution.receive.intercept { req, next ->
-            val call = next.call(req)
-            if (call.response.status.isSuccess()) {
-                return@intercept call
-            }
+class DefaultValidateResponse : ReceiveMiddleware {
 
-            val message = "received unsuccessful HTTP call.response: ${call.response.status}"
-            val httpException = HttpResponseException(message).apply {
-                statusCode = call.response.status
-                headers = call.response.headers
-                body = call.response.body.readAll()
-                request = call.request
-            }
+    override suspend fun <H : Handler<SdkHttpRequest, HttpCall>> handle(request: SdkHttpRequest, next: H): HttpCall {
+        val call = next.call(request)
+        if (call.response.status.isSuccess()) {
+            return call
+        }
 
-            throw httpException
+        val message = "received unsuccessful HTTP call.response: ${call.response.status}"
+        val httpException = HttpResponseException(message).apply {
+            statusCode = call.response.status
+            headers = call.response.headers
+            body = call.response.body.readAll()
+            this.request = call.request
         }
+
+        throw httpException
     }
 }

runtime/protocol/http/common/src/aws/smithy/kotlin/runtime/http/middleware/DefaultValidateResponse.kt

@@ -5,11 +5,8 @@
 
 package aws.smithy.kotlin.runtime.http.middleware
 
-import aws.smithy.kotlin.runtime.http.Feature
-import aws.smithy.kotlin.runtime.http.FeatureKey
 import aws.smithy.kotlin.runtime.http.HttpBody
-import aws.smithy.kotlin.runtime.http.HttpClientFeatureFactory
-import aws.smithy.kotlin.runtime.http.operation.SdkHttpOperation
+import aws.smithy.kotlin.runtime.http.operation.*
 import aws.smithy.kotlin.runtime.http.request.header
 import aws.smithy.kotlin.runtime.util.InternalApi
 import aws.smithy.kotlin.runtime.util.encodeBase64String
@@ -22,23 +19,15 @@ import aws.smithy.kotlin.runtime.util.md5
  *   - https://datatracker.ietf.org/doc/html/rfc1864.html
  */
 @InternalApi
-class Md5Checksum : Feature {
+class Md5Checksum : ModifyRequestMiddleware {
 
-    companion object Feature : HttpClientFeatureFactory<Md5Checksum, Md5Checksum> {
-        override val key: FeatureKey<Md5Checksum> = FeatureKey("Md5Checksum")
-        override fun create(block: Md5Checksum.() -> Unit): Md5Checksum =
-            Md5Checksum().apply(block)
-    }
-
-    override fun <I, O> install(operation: SdkHttpOperation<I, O>) {
-        operation.execution.mutate.intercept { req, next ->
-            val checksum = when (val body = req.subject.body) {
-                is HttpBody.Bytes -> body.bytes().md5().encodeBase64String()
-                else -> null
-            }
-
-            checksum?.let { req.subject.header("Content-MD5", it) }
-            next.call(req)
+    override suspend fun modifyRequest(req: SdkHttpRequest): SdkHttpRequest {
+        val checksum = when (val body = req.subject.body) {
+            is HttpBody.Bytes -> body.bytes().md5().encodeBase64String()
+            else -> null
         }
+
+        checksum?.let { req.subject.header("Content-MD5", it) }
+        return req
     }
 }

runtime/protocol/http/common/src/aws/smithy/kotlin/runtime/http/middleware/Md5Checksum.kt

@@ -6,16 +6,28 @@
 package aws.smithy.kotlin.runtime.http.middleware
 
 import aws.smithy.kotlin.runtime.http.*
-import aws.smithy.kotlin.runtime.http.operation.SdkHttpOperation
+import aws.smithy.kotlin.runtime.http.operation.*
+import aws.smithy.kotlin.runtime.util.InternalApi
 
 /**
  * HTTP middleware feature that allows mutation of in-flight request headers
  */
-class MutateHeaders : Feature {
+@InternalApi
+class MutateHeaders(
+    override: Map<String, String> = emptyMap(),
+    append: Map<String, String> = emptyMap(),
+    setMissing: Map<String, String> = emptyMap(),
+) : ModifyRequestMiddleware {
     private val overrides = HeadersBuilder()
     private val additional = HeadersBuilder()
     private val conditionallySet = HeadersBuilder()
 
+    init {
+        override.forEach { (key, value) -> set(key, value) }
+        append.forEach { (key, value) -> append(key, value) }
+        setMissing.forEach { (key, value) -> setIfMissing(key, value) }
+    }
+
     /**
      * Set a header in the request, overriding any existing key of the same name
      */
@@ -33,29 +45,21 @@ class MutateHeaders : Feature {
      */
     fun setIfMissing(name: String, value: String) = conditionallySet.append(name, value)
 
-    companion object Feature : HttpClientFeatureFactory<MutateHeaders, MutateHeaders> {
-        override val key: FeatureKey<MutateHeaders> = FeatureKey("AddHeaders")
-        override fun create(block: MutateHeaders.() -> Unit): MutateHeaders =
-            MutateHeaders().apply(block)
-    }
+    override suspend fun modifyRequest(req: SdkHttpRequest): SdkHttpRequest {
+        additional.entries().forEach { (key, values) ->
+            req.subject.headers.appendAll(key, values)
+        }
 
-    override fun <I, O> install(operation: SdkHttpOperation<I, O>) {
-        operation.execution.mutate.intercept { req, next ->
-            additional.entries().forEach { (key, values) ->
-                req.subject.headers.appendAll(key, values)
-            }
+        overrides.entries().forEach { (key, values) ->
+            req.subject.headers[key] = values.last()
+        }
 
-            overrides.entries().forEach { (key, values) ->
+        conditionallySet.entries().forEach { (key, values) ->
+            if (!req.subject.headers.contains(key)) {
                 req.subject.headers[key] = values.last()
             }
-
-            conditionallySet.entries().forEach { (key, values) ->
-                if (!req.subject.headers.contains(key)) {
-                    req.subject.headers[key] = values.last()
-                }
-            }
-
-            next.call(req)
         }
+
+        return req
     }
 }

runtime/protocol/http/common/src/aws/smithy/kotlin/runtime/http/middleware/MutateHeaders.kt

@@ -5,44 +5,23 @@
 
 package aws.smithy.kotlin.runtime.http.middleware
 
-import aws.smithy.kotlin.runtime.http.*
 import aws.smithy.kotlin.runtime.http.operation.*
 import aws.smithy.kotlin.runtime.util.InternalApi
 
 /**
- *  Http feature for resolving the service endpoint.
+ *  Http middleware for resolving the service endpoint.
  */
 @InternalApi
-public class ResolveEndpoint(
-    config: Config
-) : Feature {
-
-    private val resolver: EndpointResolver = requireNotNull(config.resolver) { "EndpointResolver must not be null" }
-
-    public class Config {
-        /**
-         * The resolver to use
-         */
-        public var resolver: EndpointResolver? = null
-    }
-
-    public companion object Feature : HttpClientFeatureFactory<Config, ResolveEndpoint> {
-        override val key: FeatureKey<ResolveEndpoint> = FeatureKey("ResolveEndpoint")
-
-        override fun create(block: Config.() -> Unit): ResolveEndpoint {
-            val config = Config().apply(block)
-            return ResolveEndpoint(config)
-        }
-    }
-
-    override fun <I, O> install(operation: SdkHttpOperation<I, O>) {
-        operation.execution.mutate.intercept { req, next ->
-            val endpoint = resolver.resolve()
-            setRequestEndpoint(req, endpoint)
-            val logger = req.context.getLogger("ResolveEndpoint")
-            logger.debug { "resolved endpoint: $endpoint" }
-            next.call(req)
-        }
+class ResolveEndpoint(
+    private val resolver: EndpointResolver
+) : ModifyRequestMiddleware {
+
+    override suspend fun modifyRequest(req: SdkHttpRequest): SdkHttpRequest {
+        val endpoint = resolver.resolve()
+        setRequestEndpoint(req, endpoint)
+        val logger = req.context.getLogger("ResolveEndpoint")
+        logger.debug { "resolved endpoint: $endpoint" }
+        return req
     }
 }