build: add verifyProjectArtifacts to double check expected jars

Author: jschneidereit

.github/workflows/reusable-build-publish.yml

@@ -57,10 +57,10 @@ jobs:
         run: |
           if [[ "${{ inputs.version }}" != "" ]]; then
             echo "Version specified, running clean build with no cache for ${{ inputs.version }}"
-            gradle clean build --no-build-cache --rerun-tasks
+            gradle clean check --no-build-cache --rerun-tasks
           else
             echo "No version specified, running normal build"
-            gradle clean build
+            gradle clean check 
           fi
         env:
           RELEASE_VERSION: ${{ inputs.version }}
@@ -77,6 +77,9 @@ jobs:
           ORG_GRADLE_PROJECT_signingKey: ${{ secrets.signing_key }}
           ORG_GRADLE_PROJECT_signingPassword: ${{ secrets.signing_pass }}
         run: gradle publishAllPublicationsToMavenCentralRepository --no-scan --no-configuration-cache
+      - name: Look at files in verification
+      - if: ${{ failure() || steps.build.outcome == 'failure' || steps.publish.outcome == 'failure' }}
+        run: ls -lR verification
       - name: Upload hyper logs on failure
         if: ${{ failure() || steps.build.outcome == 'failure' || steps.publish.outcome == 'failure' }}
         uses: actions/upload-artifact@v4

.gitignore

@@ -28,3 +28,4 @@ pom.xml.bak
 .gradle
 .hyper
 .kotlin
+bin

buildSrc/src/main/kotlin/publishing-conventions.gradle.kts

@@ -1,32 +1,13 @@
 plugins {
     id("base-conventions")
+    id("version-conventions")
     signing
     `maven-publish`
     id("dev.adamko.dev-publish")
 }
 
-val revision: String by project
-
 val mavenCentralRepoName = "MavenCentral"
-
-private val ci = object {
-    private val snapshotVersion = when (System.getenv("GITHUB_RUN_NUMBER")) {
-        null -> "$revision-LOCAL"
-        else -> "$revision-SNAPSHOT"
-    }
-
-    private val releaseVersion = System.getenv("RELEASE_VERSION")?.ifBlank {
-        logger.lifecycle("env.RELEASE_VERSION not present, assuming snapshot")
-        null
-    }
-
-    val isRelease = releaseVersion != null
-
-    val resolvedVersion = releaseVersion ?: snapshotVersion
-}
-
-group = "com.salesforce.datacloud"
-version = ci.resolvedVersion
+val isRelease = !System.getenv("RELEASE_VERSION").isNullOrBlank()
 
 signing {
     val signingPassword: String? by project
@@ -37,15 +18,15 @@ signing {
     }
 
     sign(publishing.publications)
-    setRequired { ci.isRelease }
+    setRequired { isRelease }
 }
 
 gradle.taskGraph.whenReady {
     val isPublishingToMavenCentral = allTasks
         .filterIsInstance<PublishToMavenRepository>()
         .any { it.repository?.name == mavenCentralRepoName }
 
-    signing.setRequired({ isPublishingToMavenCentral || ci.isRelease })
+    signing.setRequired({ isPublishingToMavenCentral || isRelease })
 
     tasks.withType<Sign> {
         val isPublishingToMavenCentralCustom = isPublishingToMavenCentral
@@ -68,7 +49,7 @@ publishing {
             name = mavenCentralRepoName
             val releasesRepoUrl = uri("https://oss.sonatype.org/service/local/staging/deploy/maven2/")
             val snapshotsRepoUrl = uri("https://oss.sonatype.org/content/repositories/snapshots/")
-            url = if (ci.isRelease) releasesRepoUrl else snapshotsRepoUrl
+            url = if (isRelease) releasesRepoUrl else snapshotsRepoUrl
             credentials {
                 username = System.getenv("OSSRH_USERNAME")
                 password = System.getenv("OSSRH_PASSWORD")

buildSrc/src/main/kotlin/version-conventions.gradle.kts

@@ -0,0 +1,19 @@
+
+val revision: String by project
+
+private val ci = object {
+    private val snapshotVersion = when (System.getenv("GITHUB_RUN_NUMBER")) {
+        null -> "$revision-LOCAL"
+        else -> "$revision-SNAPSHOT"
+    }
+
+    private val releaseVersion = System.getenv("RELEASE_VERSION")?.ifBlank {
+        logger.lifecycle("env.RELEASE_VERSION not present, assuming snapshot")
+        null
+    }
+
+    val resolvedVersion = releaseVersion ?: snapshotVersion
+}
+
+group = "com.salesforce.datacloud"
+version = ci.resolvedVersion

settings.gradle.kts

@@ -3,3 +3,4 @@ rootProject.name = "jdbc-build"
 include(":jdbc-grpc")
 include(":jdbc-core")
 include(":jdbc")
+include(":verification")

verification/build.gradle.kts

@@ -0,0 +1,68 @@
+plugins {
+  id("base-conventions")
+  id("version-conventions")
+  id("dev.adamko.dev-publish")
+}
+
+dependencies {
+  devPublication(project(":jdbc"))
+  devPublication(project(":jdbc-core"))
+  devPublication(project(":jdbc-grpc"))
+}
+
+tasks.named("check") {
+  dependsOn("updateDevRepo")
+
+  group = "verification"
+  description = "Verifies that all subprojects produce required JAR artifacts"
+
+  var expectedVersion = "$version"
+
+  val repo = devPublish.devMavenRepo.file("maven-dev/com/salesforce/datacloud/").get().asFile
+
+  doLast {
+    val expectedPublications = setOf("jdbc", "jdbc-grpc", "jdbc-proto", "jdbc-core")
+    val shaded = setOf("jdbc")
+
+    fun hasJar(artifactId: String, version: String, classifier: String? = null): Boolean {
+      val path = "${artifactId}/${version}/${artifactId}-${version}${classifier?.let { "-$it" } ?: ""}.jar"
+      return repo.resolve(path).exists()
+    }
+
+    val failures = mutableListOf<String>()
+    val verified = mutableListOf<String>()
+
+    expectedPublications.forEach { artifactId ->
+      logger.lifecycle("Verifying artifacts for publication $artifactId:$expectedVersion...")
+
+      if (!hasJar(artifactId, expectedVersion)) {
+        failures.add("Publication '$artifactId' is missing main JAR")
+      }
+
+      if (!hasJar(artifactId, expectedVersion, "sources")) {
+        failures.add("Publication '$artifactId' is missing sources JAR")
+      }
+
+      if (!hasJar(artifactId, expectedVersion, "javadoc")) {
+        failures.add("Publication '$artifactId' is missing javadoc JAR")
+      }
+
+      if (shaded.contains(artifactId) && !hasJar(artifactId, expectedVersion, "shaded")) {
+        failures.add("Publication '$artifactId' is missing shaded JAR")
+      }
+
+      verified.add(artifactId)
+      logger.lifecycle("  Checked publication: $artifactId version $expectedVersion")
+    }
+
+    if (failures.isNotEmpty()) {
+      failures.forEach { logger.error(it) }
+      throw GradleException("Artifact verification failed. Some projects are missing required JAR files:\n" + failures.joinToString("\n"))
+    } else if (!verified.containsAll(expectedPublications)) {
+      val missing = expectedPublications - verified.toSet()
+      throw GradleException("Missing expected publication(s): $missing")
+    } else {
+      logger.lifecycle("All subprojects successfully generated required JAR artifacts.")
+    }
+  }
+}