chore: refactor build to use custom smithy build plugin (#1168)

Author: aajtodd

aws-runtime/aws-config/build.gradle.kts

@@ -2,11 +2,13 @@
  * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
  * SPDX-License-Identifier: Apache-2.0
  */
+import aws.sdk.kotlin.gradle.codegen.dsl.generateSmithyProjections
 import aws.sdk.kotlin.gradle.codegen.dsl.smithyKotlinPlugin
+import aws.sdk.kotlin.gradle.codegen.smithyKotlinProjectionSrcDir
 import org.jetbrains.dokka.gradle.DokkaTaskPartial
 
 plugins {
-    id("aws.sdk.kotlin.codegen")
+    id("aws.sdk.kotlin.gradle.smithybuild")
 }
 
 description = "Support for AWS configuration"
@@ -69,7 +71,14 @@ kotlin {
 fun awsModelFile(name: String): String =
     rootProject.file("codegen/sdk/aws-models/$name").relativeTo(project.layout.buildDirectory.get().asFile).toString()
 
-codegen {
+val codegen by configurations.getting
+dependencies {
+    codegen(project(":codegen:aws-sdk-codegen"))
+    codegen(libs.smithy.cli)
+    codegen(libs.smithy.model)
+}
+
+smithyBuild {
     val basePackage = "aws.sdk.kotlin.runtime.auth.credentials.internal"
 
     projections {
@@ -193,9 +202,8 @@ NOTE: We need the following tasks to depend on codegen for gradle caching/up-to-
 * For Kotlin/Native, an additional dependency is introduced:
 * `compileKotlin<Platform>` (Type=KotlinNativeCompile) (e.g. compileKotlinLinuxX64)
 */
-val codegenTask = tasks.named("generateSmithyProjections")
 tasks.withType<org.jetbrains.kotlin.gradle.tasks.KotlinCompile> {
-    dependsOn(codegenTask)
+    dependsOn(tasks.generateSmithyProjections)
 
     compilerOptions {
         // generated sts/sso credential providers have quite a few warnings
@@ -204,47 +212,37 @@ tasks.withType<org.jetbrains.kotlin.gradle.tasks.KotlinCompile> {
 }
 
 tasks.withType<org.jetbrains.kotlin.gradle.tasks.KotlinNativeCompile> {
-    dependsOn(codegenTask)
+    dependsOn(tasks.generateSmithyProjections)
     compilerOptions {
         allWarningsAsErrors.set(false)
     }
 }
 
 tasks.withType<org.jetbrains.kotlin.gradle.tasks.KotlinCompileCommon> {
-    dependsOn(codegenTask)
+    dependsOn(tasks.generateSmithyProjections)
 }
 
 tasks.withType<org.gradle.jvm.tasks.Jar> {
     if (name == "jar") {
         println("Disabling $project task '$name' because it conflicts with Kotlin JAR tasks")
         enabled = false
     } else {
-        dependsOn(codegenTask)
+        dependsOn(tasks.generateSmithyProjections)
     }
 }
 
-codegen.projections.all {
+smithyBuild.projections.all {
     // add this projected source dir to the common sourceSet
-    // NOTE - build.gradle.kts is still being generated, it's NOT used though
-    // TODO - we should probably either have a postProcessing spec or a plugin setting to not generate it to avoid confusion
-    val projectedSrcDir = projectionRootDir.resolve("src/main/kotlin")
+    val projectionSrcDir = smithyBuild.smithyKotlinProjectionSrcDir(name)
     kotlin.sourceSets.commonMain {
-        println("added $projectedSrcDir to common sourceSet")
-        kotlin.srcDir(projectedSrcDir)
-    }
-}
-
-// Necessary to avoid Gradle problems identifying correct variant of aws-config. This stems from the smithy-gradle
-// plugin (used by codegen plugin) applying the Java plugin which creates these configurations.
-listOf("apiElements", "runtimeElements").forEach {
-    configurations.named(it) {
-        isCanBeConsumed = false
+        logger.info("added $projectionSrcDir to common sourceSet")
+        kotlin.srcDir(projectionSrcDir)
     }
 }
 
 // suppress internal generated clients
 tasks.named<DokkaTaskPartial>("dokkaHtmlPartial") {
-    dependsOn(codegenTask)
+    dependsOn(tasks.generateSmithyProjections)
     dokkaSourceSets.configureEach {
         perPackageOption {
             matchingRegex.set(""".*\.internal.*""")

build.gradle.kts

@@ -14,9 +14,16 @@ buildscript {
         classpath(libs.kotlinx.atomicfu.plugin)
         classpath("aws.sdk.kotlin:build-plugins") {
             version {
-                require("0.3.1")
+                require("0.3.2")
             }
         }
+
+        // FIXME - we need the ClassLoader used for Model and any traits to be the same. Unfortunately our
+        // build plugin has a transitive dependency on `smithy-model` which means our :codegen:sdk project
+        // that uses both in it's build logic won't work correctly. We "fix" this by placing them both
+        // into the root buildscript classpath and force them to share a class loader.
+        classpath(libs.smithy.model)
+        classpath(libs.smithy.aws.traits)
     }
 }
 

codegen/protocol-tests/build.gradle.kts

@@ -2,21 +2,20 @@
  * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
  * SPDX-License-Identifier: Apache-2.0
  */
+import aws.sdk.kotlin.gradle.codegen.dsl.generateSmithyProjections
 import aws.sdk.kotlin.gradle.codegen.dsl.smithyKotlinPlugin
-import software.amazon.smithy.gradle.tasks.SmithyBuild
+import aws.sdk.kotlin.gradle.codegen.smithyKotlinProjectionPath
+import aws.sdk.kotlin.gradle.codegen.smithyKotlinProjectionSrcDir
 
 plugins {
-    id("aws.sdk.kotlin.codegen")
+    kotlin("jvm") // FIXME - configuration doesn't resolve without this
+    id("aws.sdk.kotlin.gradle.smithybuild")
 }
 
 description = "Smithy protocol test suite"
 
-dependencies {
-    implementation(libs.smithy.aws.protocol.tests)
-}
-
 data class ProtocolTest(val projectionName: String, val serviceShapeId: String, val sdkId: String? = null) {
-    val packageName: String = projectionName.toLowerCase().filter { it.isLetterOrDigit() }
+    val packageName: String = projectionName.lowercase().filter { it.isLetterOrDigit() }
 }
 
 // The following section exposes Smithy protocol test suites as gradle test targets
@@ -40,9 +39,11 @@ val enabledProtocols = listOf(
     ProtocolTest("error-correction-xml", "aws.protocoltests.errorcorrection#RequiredValueXml"),
 )
 
-codegen {
+smithyBuild {
     enabledProtocols.forEach { test ->
         projections.register(test.projectionName) {
+            imports = listOf(file("model").absolutePath)
+
             transforms = listOf(
                 """
                 {
@@ -74,64 +75,79 @@ codegen {
     }
 }
 
-tasks.named<SmithyBuild>("generateSmithyProjections") {
+val codegen by configurations.getting
+dependencies {
+    codegen(project(":codegen:aws-sdk-codegen"))
+    codegen(libs.smithy.cli)
+    codegen(libs.smithy.model)
+
     // 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
+    codegen(libs.smithy.aws.protocol.tests)
+}
 
+tasks.generateSmithyProjections {
     // ensure the generated clients use the same version of the runtime as the aws aws-runtime
     val smithyKotlinRuntimeVersion = libs.versions.smithy.kotlin.runtime.version.get()
     doFirst {
         System.setProperty("smithy.kotlin.codegen.clientRuntimeVersion", smithyKotlinRuntimeVersion)
     }
 }
 
-open class ProtocolTestTask : DefaultTask() {
+abstract class ProtocolTestTask @Inject constructor(private val project: Project) : DefaultTask() {
     /**
      * The projection
      */
     @get:Input
-    var projection: aws.sdk.kotlin.gradle.codegen.dsl.SmithyProjection? = null
+    abstract val projectionName: Property<String>
+
+    /**
+     * The projection root directory
+     */
+    @get:Input
+    abstract val projectionRootDirectory: Property<String>
 
     @TaskAction
     fun runTests() {
-        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 projectionRootDir = project.file(projectionRootDirectory.get())
+        println("[$projectionName] buildDir: $projectionRootDir")
+        if (!projectionRootDir.exists()) {
+            throw GradleException("$projectionRootDir does not exist")
         }
-        val wrapper = if (System.getProperty("os.name").toLowerCase().contains("windows")) "gradlew.bat" else "gradlew"
+        val wrapper = if (System.getProperty("os.name").lowercase().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 = projection.projectionRootDir
+            workingDir = projectionRootDir
             executable = gradlew
             args = listOf("test")
         }
     }
 }
 
-val codegenTask = tasks.getByName("generateSmithyProjections")
-codegen.projections.forEach {
+smithyBuild.projections.forEach {
     val protocolName = it.name
 
     tasks.register<ProtocolTestTask>("testProtocol-$protocolName") {
-        dependsOn(codegenTask)
+        dependsOn(tasks.generateSmithyProjections)
         group = "Verification"
-        projection = it
+        projectionName.set(it.name)
+        projectionRootDirectory.set(smithyBuild.smithyKotlinProjectionPath(it.name).map { it.toString() })
     }
 
     // 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.
     val copyStaticFiles = tasks.register<Copy>("copyStaticFiles-$protocolName") {
         group = "codegen"
         from(rootProject.projectDir.resolve("services/$protocolName/common/src"))
-        into(it.projectionRootDir.resolve("src/main/kotlin/"))
+        into(smithyBuild.smithyKotlinProjectionSrcDir(it.name))
     }
 
-    codegenTask.finalizedBy(copyStaticFiles)
+    tasks.generateSmithyProjections.configure {
+        finalizedBy(copyStaticFiles)
+    }
 }
 
 tasks.register("testAllProtocols") {