chore: abstract codegen logic into a plugin

build.gradle.kts

@@ -149,6 +149,7 @@ val lintPaths = listOf(
     "aws-runtime/**/*.kt",
     "examples/**/*.kt",
     "dokka-aws/**/*.kt",
+    "gradle/sdk-plugins/src/**/*.kt",
     "services/**/*.kt",
     "!services/*/generated-src/**/*.kt"
 )

codegen/protocol-tests/build.gradle.kts

@@ -2,28 +2,25 @@
  * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
  * SPDX-License-Identifier: Apache-2.0.
  */
+import aws.sdk.kotlin.gradle.codegen.dsl.smithyKotlinPlugin
 import software.amazon.smithy.gradle.tasks.SmithyBuild
 
 plugins {
-    id("software.amazon.smithy")
+    id("aws.sdk.kotlin.codegen")
 }
 
 description = "Smithy protocol test suite"
 
-buildscript {
-    val smithyVersion: String by project
-    dependencies {
-        classpath("software.amazon.smithy:smithy-cli:$smithyVersion")
-    }
-}
-
-
 val smithyVersion: String by project
 dependencies {
     implementation("software.amazon.smithy:smithy-aws-protocol-tests:$smithyVersion")
-    implementation(project(":codegen:smithy-aws-kotlin-codegen"))
 }
 
+data class ProtocolTest(val projectionName: String, val serviceShapeId: String, val sdkId: String? = null) {
+    val packageName: String = projectionName.toLowerCase().filter { it.isLetterOrDigit() }
+}
+
+
 // The following section exposes Smithy protocol test suites as gradle test targets
 // for the configured protocols in [enabledProtocols].
 val enabledProtocols = listOf(
@@ -41,157 +38,96 @@ val enabledProtocols = listOf(
     ProtocolTest("machinelearning", "com.amazonaws.machinelearning#AmazonML_20141212", sdkId = "Machine Learning"),
 )
 
-// This project doesn't produce a JAR.
-tasks["jar"].enabled = false
-
-// Run the SmithyBuild task manually since this project needs the built JAR
-// from smithy-aws-kotlin-codegen.
-tasks["smithyBuildJar"].enabled = false
-
-task("generateSmithyBuild") {
-    group = "codegen"
-    description = "generate smithy-build.json"
-    val buildFile = projectDir.resolve("smithy-build.json")
-    doFirst {
-        buildFile.writeText(generateSmithyBuild(enabledProtocols))
+codegen {
+    enabledProtocols.forEach { test ->
+        projections.register(test.projectionName) {
+            transforms = listOf(
+                """
+                {
+                  "name": "includeServices",
+                  "args": {
+                    "services": ["${test.serviceShapeId}"]
+                  }
+                }
+                """
+            )
+
+            smithyKotlinPlugin {
+                serviceShapeId = test.serviceShapeId
+                packageName = "aws.sdk.kotlin.services.${test.packageName}"
+                packageVersion = "1.0"
+                sdkId = test.sdkId
+                buildSettings {
+                    generateFullProject = true
+                    optInAnnotations = listOf(
+                        "aws.smithy.kotlin.runtime.util.InternalApi",
+                        "aws.sdk.kotlin.runtime.InternalSdkApi"
+                    )
+                }
+            }
+        }
     }
-    outputs.file(buildFile)
 }
 
-// Remove generated model file for clean
-tasks["clean"].doFirst {
-    delete("smithy-build.json")
-}
+tasks.named<SmithyBuild>("generateSmithyProjections") {
+    // NOTE: The protocol tests are published to maven as a jar, this ensures that
+    // the aws-protocol-tests dependency is found when generating code such that the `includeServices` transform
+    // actually works
+    addCompileClasspath = true
 
-tasks.create<SmithyBuild>("generateSdk") {
-    group = "codegen"
     // ensure the generated clients use the same version of the runtime as the aws aws-runtime
     val smithyKotlinVersion: String by project
     doFirst {
         System.setProperty("smithy.kotlin.codegen.clientRuntimeVersion", smithyKotlinVersion)
     }
-    addRuntimeClasspath = true
-    dependsOn(tasks["generateSmithyBuild"])
-    inputs.file(projectDir.resolve("smithy-build.json"))
-    // ensure smithy-aws-kotlin-codegen is up to date
-    inputs.files(configurations.compileClasspath)
-}
-
-// force rebuild every time while developing
-tasks["generateSdk"].outputs.upToDateWhen { false }
-
-data class ProtocolTest(val projectionName: String, val serviceShapeId: String, val sdkId: String? = null) {
-    val packageName: String
-        get() = projectionName.toLowerCase().filter { it.isLetterOrDigit() }
-}
-
-
-// Generates a smithy-build.json file by creating a new projection.
-// The generated smithy-build.json file is not committed to git since
-// it's rebuilt each time codegen is performed.
-fun generateSmithyBuild(tests: List<ProtocolTest>): String {
-    val projections = tests.joinToString(",") { test ->
-        val sdkIdEntry = test.sdkId?.let { """"sdkId": "$it",""" } ?: ""
-        """
-        "${test.projectionName}": {
-          "transforms": [
-            {
-              "name": "includeServices",
-              "args": {
-                "services": [
-                  "${test.serviceShapeId}"
-                ]
-              }
-            }
-          ],
-          "plugins": {
-            "kotlin-codegen": {
-              "service": "${test.serviceShapeId}",
-              "package": {
-                "name": "aws.sdk.kotlin.services.${test.packageName}",
-                "version": "1.0"
-              },
-              $sdkIdEntry
-              "build": {
-                "rootProject": true,
-                "optInAnnotations": [
-                  "aws.smithy.kotlin.runtime.util.InternalApi",
-                  "aws.sdk.kotlin.runtime.InternalSdkApi"
-                ]
-              }
-            }
-          }
-        }
-        """
-    }
-    return """
-    {
-        "version": "1.0",
-        "projections": {
-            $projections
-        }
-    }
-    """.trimIndent()
 }
 
 open class ProtocolTestTask : DefaultTask() {
     /**
-     * The protocol name
+     * The projection
      */
     @get:Input
-    var protocol: String = ""
+    var projection: aws.sdk.kotlin.gradle.codegen.dsl.SmithyProjection? = null
 
-    /**
-     * The plugin name to use
-     */
-    @get:Input
-    var plugin: String = ""
-
-    /**
-     * The build directory for the task
-     */
-    val generatedBuildDir: File
-        @OutputDirectory
-        get() = project.buildDir.resolve("smithyprojections/${project.name}/$protocol/$plugin")
 
     @TaskAction
     fun runTests() {
-        require(protocol.isNotEmpty()) { "protocol name must be specified" }
-        require(plugin.isNotEmpty()) { "plugin name must be specified" }
-
-        println("[$protocol] buildDir: $generatedBuildDir")
-        if (!generatedBuildDir.exists()) {
-            throw GradleException("$generatedBuildDir does not exist")
+        val projection = requireNotNull(projection) { "projection is required task input" }
+        println("[${projection.name}] buildDir: ${projection.projectionRootDir}")
+        if (!projection.projectionRootDir.exists()) {
+            throw GradleException("${projection.projectionRootDir} does not exist")
         }
         val wrapper = if (System.getProperty("os.name").toLowerCase().contains("windows")) "gradlew.bat" else "gradlew"
         val gradlew = project.rootProject.file(wrapper).absolutePath
 
         // NOTE - this still requires us to publish to maven local.
         project.exec {
-            workingDir = generatedBuildDir
+            workingDir = projection.projectionRootDir
             executable = gradlew
             args = listOf("test")
         }
     }
 }
 
-enabledProtocols.forEach {
-    val protocolName = it.projectionName
+val codegenTask = tasks.getByName("generateSmithyProjections")
+codegen.projections.forEach {
+    val protocolName = it.name
 
-    val protocolTestTask = tasks.register<ProtocolTestTask>("testProtocol-$protocolName") {
-        dependsOn(tasks["generateSdk"])
+    tasks.register<ProtocolTestTask>("testProtocol-$protocolName") {
+        dependsOn(codegenTask)
         group = "Verification"
-        protocol = protocolName
-        plugin = "kotlin-codegen"
-    }.get()
+        projection = it
+    }
 
     // FIXME This is a hack to work around how protocol tests aren't in the actual service model and thus codegen
     // separately from service customizations.
-    tasks.create<Copy>("copyStaticFiles-$protocolName") {
+    val copyStaticFiles = tasks.register<Copy>("copyStaticFiles-$protocolName") {
+        group = "codegen"
         from(rootProject.projectDir.resolve("services/$protocolName/common/src"))
-        into(protocolTestTask.generatedBuildDir.resolve("src/main/kotlin/"))
-        tasks["generateSdk"].finalizedBy(this)
+        into(it.projectionRootDir.resolve("src/main/kotlin/"))
     }
+
+    codegenTask.finalizedBy(copyStaticFiles)
 }
 
 tasks.register("testAllProtocols") {