Service sdk testing

build.gradle.kts

@@ -114,6 +114,7 @@ apiValidation {
             "nullability-tests",
             "paginator-tests",
             "waiter-tests",
+            "service-codegen-tests",
             "compile",
             "slf4j-1x-consumer",
             "slf4j-2x-consumer",

codegen/smithy-aws-kotlin-codegen/src/main/kotlin/software/amazon/smithy/kotlin/codegen/aws/protocols/RpcV2Cbor.kt

@@ -109,6 +109,7 @@ class RpcV2Cbor : AwsHttpBindingProtocolGenerator() {
             resolver.requestBindings(op)
         }
         val httpPayload = bindings.firstOrNull { it.location == HttpBinding.Location.PAYLOAD }
+
         if (httpPayload != null) {
             renderExplicitHttpPayloadSerializer(ctx, httpPayload, writer)
         } else {
@@ -117,9 +118,15 @@ class RpcV2Cbor : AwsHttpBindingProtocolGenerator() {
             // delegate to the generate operation body serializer function
             val sdg = structuredDataSerializer(ctx)
             val opBodySerializerFn = sdg.operationSerializer(ctx, op, documentMembers)
-            writer.write("builder.body = #T(context, input)", opBodySerializerFn)
+            if (ctx.settings.build.generateServiceProject) {
+                writer.write("response = #T(context, input)", opBodySerializerFn)
+            } else {
+                writer.write("builder.body = #T(context, input)", opBodySerializerFn)
+            }
+        }
+        if (!ctx.settings.build.generateServiceProject) {
+            renderContentTypeHeader(ctx, op, writer, resolver)
         }
-        renderContentTypeHeader(ctx, op, writer, resolver)
     }
 
     /**

codegen/smithy-kotlin-codegen-testutils/build.gradle.kts

@@ -34,15 +34,15 @@ dependencies {
 
 tasks.withType<KotlinCompile> {
     compilerOptions {
-        jvmTarget.set(JvmTarget.JVM_1_8)
-        freeCompilerArgs.add("-Xjdk-release=1.8")
+        jvmTarget.set(JvmTarget.JVM_17)
+        freeCompilerArgs.add("-Xjdk-release=17")
         freeCompilerArgs.add("-opt-in=kotlin.RequiresOptIn")
     }
 }
 
 tasks.withType<JavaCompile> {
-    sourceCompatibility = JavaVersion.VERSION_1_8.toString()
-    targetCompatibility = JavaVersion.VERSION_1_8.toString()
+    sourceCompatibility = JavaVersion.VERSION_17.toString()
+    targetCompatibility = JavaVersion.VERSION_17.toString()
 }
 
 // Reusable license copySpec

codegen/smithy-kotlin-codegen/build.gradle.kts

@@ -57,16 +57,16 @@ val generateSdkRuntimeVersion by tasks.registering {
 
 tasks.withType<KotlinCompile> {
     compilerOptions {
-        jvmTarget.set(JvmTarget.JVM_1_8)
-        freeCompilerArgs.add("-Xjdk-release=1.8")
+        jvmTarget.set(JvmTarget.JVM_17)
+        freeCompilerArgs.add("-Xjdk-release=17")
         freeCompilerArgs.add("-opt-in=kotlin.RequiresOptIn")
     }
     dependsOn(generateSdkRuntimeVersion)
 }
 
 tasks.withType<JavaCompile> {
-    sourceCompatibility = JavaVersion.VERSION_1_8.toString()
-    targetCompatibility = JavaVersion.VERSION_1_8.toString()
+    sourceCompatibility = JavaVersion.VERSION_17.toString()
+    targetCompatibility = JavaVersion.VERSION_17.toString()
 }
 
 // Reusable license copySpec

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

@@ -38,7 +38,7 @@ private fun getDefaultRuntimeVersion(): String {
 const val RUNTIME_GROUP: String = "aws.smithy.kotlin"
 val RUNTIME_VERSION: String = System.getProperty("smithy.kotlin.codegen.clientRuntimeVersion", getDefaultRuntimeVersion())
 val KOTLIN_COMPILER_VERSION: String = System.getProperty("smithy.kotlin.codegen.kotlinCompilerVersion", "2.2.0")
-val KTOR_VERSION: String = System.getProperty("smithy.kotlin.codegen.ktorVersion", "3.1.3")
+val KTOR_VERSION: String = System.getProperty("smithy.kotlin.codegen.ktorVersion", "3.2.2")
 val SERIALIZATION_PLUGIN: String = System.getProperty("smithy.kotlin.codegen.SerializationPlugin", "2.0.20")
 val KOTLINX_VERSION: String = System.getProperty("smithy.kotlin.codegen.ktorKotlinxVersion", "1.9.0")
 val KTOR_LOGGING_BACKEND_VERSION: String = System.getProperty("smithy.kotlin.codegen.ktorLoggingBackendVersion", "1.4.14")
@@ -144,8 +144,11 @@ data class KotlinDependency(
         // FIXME: version numbers should not be hardcoded, they should be setting dynamically based on the Gradle library versions
         val KTOR_SERVER_CORE = KotlinDependency(GradleConfiguration.Implementation, "io.ktor.server", "io.ktor", "ktor-server-core", KTOR_VERSION)
         val KTOR_SERVER_NETTY = KotlinDependency(GradleConfiguration.Implementation, "io.ktor.server.netty", "io.ktor", "ktor-server-netty", KTOR_VERSION)
+        val KTOR_SERVER_CIO = KotlinDependency(GradleConfiguration.Implementation, "io.ktor.server.cio", "io.ktor", "ktor-server-cio", KTOR_VERSION)
+        val KTOR_SERVER_JETTY_JAKARTA = KotlinDependency(GradleConfiguration.Implementation, "io.ktor.server.jetty.jakarta", "io.ktor", "ktor-server-jetty-jakarta", KTOR_VERSION)
         val KTOR_SERVER_HTTP = KotlinDependency(GradleConfiguration.Implementation, "io.ktor.http", "io.ktor", "ktor-http-jvm", KTOR_VERSION)
         val KTOR_SERVER_LOGGING = KotlinDependency(GradleConfiguration.Implementation, "io.ktor.server.plugins.calllogging", "io.ktor", "ktor-server-call-logging", KTOR_VERSION)
+        val KTOR_SERVER_BODY_LIMIT = KotlinDependency(GradleConfiguration.Implementation, "io.ktor.server.plugins", "io.ktor", "ktor-server-body-limit", KTOR_VERSION)
         val KTOR_LOGGING_SLF4J = KotlinDependency(GradleConfiguration.Implementation, "org.slf4j", "ch.qos.logback", "logback-classic", KTOR_LOGGING_BACKEND_VERSION)
         val KTOR_LOGGING_LOGBACK = KotlinDependency(GradleConfiguration.Implementation, "ch.qos.logback", "ch.qos.logback", "logback-classic", KTOR_LOGGING_BACKEND_VERSION)
         val KTOR_SERVER_STATUS_PAGE = KotlinDependency(GradleConfiguration.Implementation, "io.ktor.server.plugins.statuspages", "io.ktor", "ktor-server-status-pages-jvm", KTOR_VERSION)

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

@@ -497,9 +497,12 @@ object RuntimeTypes {
         val embeddedServer = symbol("embeddedServer", "engine")
         val EmbeddedServerType = symbol("EmbeddedServer", "engine")
         val ApplicationEngineFactory = symbol("ApplicationEngineFactory", "engine")
+        val connector = symbol("connector", "engine")
 
         val Application = symbol("Application", "application")
         val ApplicationCallClass = symbol("ApplicationCall", "application")
+        val ApplicationStarting = symbol("ApplicationStarting", "application")
+        val ApplicationStarted = symbol("ApplicationStarted", "application")
         val ApplicationStopping = symbol("ApplicationStopping", "application")
         val ApplicationStopped = symbol("ApplicationStopped", "application")
         val ApplicationCreateRouteScopedPlugin = symbol("createRouteScopedPlugin", "application")
@@ -536,11 +539,23 @@ object RuntimeTypes {
 
     object KtorServerNetty : RuntimeTypePackage(KotlinDependency.KTOR_SERVER_NETTY) {
         val Netty = symbol("Netty")
+        val Configuration = symbol("Configuration", "NettyApplicationEngine")
+    }
+
+    object KtorServerCio : RuntimeTypePackage(KotlinDependency.KTOR_SERVER_CIO) {
+        val CIO = symbol("CIO")
+        val Configuration = symbol("Configuration", "CIOApplicationEngine")
+    }
+
+    object KtorServerJettyJakarta : RuntimeTypePackage(KotlinDependency.KTOR_SERVER_JETTY_JAKARTA) {
+        val Jetty = symbol("Jetty")
+        val Configuration = symbol("Configuration", "JettyApplicationEngineBase")
     }
 
     object KtorServerHttp : RuntimeTypePackage(KotlinDependency.KTOR_SERVER_HTTP) {
         val ContentType = symbol("ContentType")
         val HttpStatusCode = symbol("HttpStatusCode")
+        val parseAndSortHeader = symbol("parseAndSortHeader")
         val HttpHeaders = symbol("HttpHeaders")
         val Cbor = symbol("Cbor", "ContentType.Application")
         val Json = symbol("Json", "ContentType.Application")
@@ -550,6 +565,11 @@ object RuntimeTypes {
         val CallLogging = symbol("CallLogging")
     }
 
+    object KtorServerBodyLimit : RuntimeTypePackage(KotlinDependency.KTOR_SERVER_BODY_LIMIT) {
+        val RequestBodyLimit = symbol("RequestBodyLimit", "bodylimit")
+        val PayloadTooLargeException = symbol("PayloadTooLargeException")
+    }
+
     object KtorLoggingSlf4j : RuntimeTypePackage(KotlinDependency.KTOR_LOGGING_SLF4J) {
         val Level = symbol("Level", "event")
         val LoggerFactory = symbol("LoggerFactory")
@@ -582,4 +602,8 @@ object RuntimeTypes {
     object KotlinxJsonSerde : RuntimeTypePackage(KotlinDependency.KOTLINX_JSON_SERDE) {
         val Json = symbol("Json")
     }
+
+    object Duration {
+        val seconds = "kotlin.time.Duration.Companion.seconds".toSymbol()
+    }
 }

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

@@ -182,27 +182,47 @@ abstract class HttpBindingProtocolGenerator : ProtocolGenerator {
         val serdeMeta = HttpSerdeMeta(op.isInputEventStream(ctx.model))
 
         ctx.delegator.useSymbolWriter(serializerSymbol) { writer ->
-            writer
-                .addImport(operationSerializerSymbols)
-                .write("")
-                .openBlock("internal class #T: #T.#L<#T> {", serializerSymbol, RuntimeTypes.HttpClient.Operation.HttpSerializer, serdeMeta.variantName, serializationSymbol)
-                .call {
-                    val modifier = if (serdeMeta.isStreaming) "suspend " else ""
-                    writer.openBlock(
-                        "override #Lfun serialize(context: #T, input: #T): #T {",
-                        modifier,
-                        RuntimeTypes.Core.ExecutionContext,
-                        serializationSymbol,
-                        RuntimeTypes.Http.Request.HttpRequestBuilder,
-                    )
-                        .write("val builder = #T()", RuntimeTypes.Http.Request.HttpRequestBuilder)
-                        .call {
-                            renderHttpSerialize(ctx, op, writer)
-                        }
-                        .write("return builder")
-                        .closeBlock("}")
-                }
-                .closeBlock("}")
+            // FIXME: this works only for Cbor protocol now
+            if (ctx.settings.build.generateServiceProject) {
+                writer
+                    .openBlock("internal class #T {", serializerSymbol)
+                    .call {
+                        writer.openBlock(
+                            "public fun serialize(context: #T, input: #T): ByteArray {",
+                            RuntimeTypes.Core.ExecutionContext,
+                            serializationSymbol,
+                        )
+                            .write("var response: Any")
+                            .call {
+                                renderSerializeHttpBody(ctx, op, writer)
+                            }
+                            .write("return response")
+                            .closeBlock("}")
+                    }
+                    .closeBlock("}")
+            } else {
+                writer
+                    .addImport(operationSerializerSymbols)
+                    .write("")
+                    .openBlock("internal class #T: #T.#L<#T> {", serializerSymbol, RuntimeTypes.HttpClient.Operation.HttpSerializer, serdeMeta.variantName, serializationSymbol)
+                    .call {
+                        val modifier = if (serdeMeta.isStreaming) "suspend " else ""
+                        writer.openBlock(
+                            "override #Lfun serialize(context: #T, input: #T): #T {",
+                            modifier,
+                            RuntimeTypes.Core.ExecutionContext,
+                            serializationSymbol,
+                            RuntimeTypes.Http.Request.HttpRequestBuilder,
+                        )
+                            .write("val builder = #T()", RuntimeTypes.Http.Request.HttpRequestBuilder)
+                            .call {
+                                renderHttpSerialize(ctx, op, writer)
+                            }
+                            .write("return builder")
+                            .closeBlock("}")
+                    }
+                    .closeBlock("}")
+            }
         }
     }
 

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

@@ -27,12 +27,22 @@ class CborSerializerGenerator(
         }
         val serializationShape = serializationTarget.get().let { ctx.model.expectShape(it) }
         val serializationSymbol = ctx.symbolProvider.toSymbol(serializationShape)
-
-        return op.bodySerializer(ctx.settings) { writer ->
-            addNestedDocumentSerializers(ctx, op, writer)
-            writer.withBlock("private fun #L(context: #T, input: #T): #T {", "}", op.bodySerializerName(), RuntimeTypes.Core.ExecutionContext, serializationSymbol, RuntimeTypes.Http.HttpBody) {
-                call {
-                    renderSerializeOperationBody(ctx, op, members, writer)
+        if (ctx.settings.build.generateServiceProject) {
+            return op.bodySerializer(ctx.settings) { writer ->
+                addNestedDocumentSerializers(ctx, op, writer)
+                writer.withBlock("private fun #L(context: #T, input: #T): ByteArray {", "}", op.bodySerializerName(), RuntimeTypes.Core.ExecutionContext, serializationSymbol) {
+                    call {
+                        renderSerializeOperationBody(ctx, op, members, writer)
+                    }
+                }
+            }
+        } else {
+            return op.bodySerializer(ctx.settings) { writer ->
+                addNestedDocumentSerializers(ctx, op, writer)
+                writer.withBlock("private fun #L(context: #T, input: #T): #T {", "}", op.bodySerializerName(), RuntimeTypes.Core.ExecutionContext, serializationSymbol, RuntimeTypes.Http.HttpBody) {
+                    call {
+                        renderSerializeOperationBody(ctx, op, members, writer)
+                    }
                 }
             }
         }
@@ -52,7 +62,11 @@ class CborSerializerGenerator(
         val serializationshape = ctx.model.expectShape(serializationTarget.get())
         writer.write("val serializer = #T()", RuntimeTypes.Serde.SerdeCbor.CborSerializer)
         renderSerializerBody(ctx, serializationshape, documentMembers, writer)
-        writer.write("return serializer.toHttpBody()")
+        if (ctx.settings.build.generateServiceProject) {
+            writer.write("return serializer.toByteArray()")
+        } else {
+            writer.write("return serializer.toHttpBody()")
+        }
     }
 
     private fun renderSerializerBody(