Update jvm artifact deployment for new maven central portal (#838)

chippmann · piiertho · web-flow · commit 5e6be50e511d · 2025-08-14T11:55:56.000+02:00
* Setup deployment plugin for the new maven plugin portal

---------

Co-authored-by: Pierre-Thomas Meisels &lt;meisels27@yahoo.fr&gt;
diff --git a/.github/workflows/deploy_jvm.yml b/.github/workflows/deploy_jvm.yml
@@ -13,10 +13,10 @@ on:
         type: string
 
 env:
-  GODOT_KOTLIN_GPG_PRIVATE_KEY_ASCII: ${{ secrets.GODOT_KOTLIN_GPG_PRIVATE_KEY_ASCII }}
-  GODOT_KOTLIN_GPG_KEY_PASSPHRASE: ${{ secrets.GODOT_KOTLIN_GPG_KEY_PASSPHRASE }}
-  GODOT_KOTLIN_MAVEN_CENTRAL_TOKEN_USERNAME: ${{ secrets.GODOT_KOTLIN_MAVEN_CENTRAL_TOKEN_USERNAME }}
-  GODOT_KOTLIN_MAVEN_CENTRAL_TOKEN_PASSWORD: ${{ secrets.GODOT_KOTLIN_MAVEN_CENTRAL_TOKEN_PASSWORD }}
+  ORG_GRADLE_PROJECT_signingInMemoryKey: ${{ secrets.UTOPIA_RISE_GPG_PRIVATE_KEY_ASCII }}
+  ORG_GRADLE_PROJECT_signingInMemoryKeyPassword: ${{ secrets.UTOPIA_RISE_GPG_KEY_PASSPHRASE }}
+  ORG_GRADLE_PROJECT_mavenCentralUsername: ${{ secrets.UTOPIA_RISE_MAVEN_CENTRAL_PORTAL_TOKEN_USERNAME }}
+  ORG_GRADLE_PROJECT_mavenCentralPassword: ${{ secrets.UTOPIA_RISE_MAVEN_CENTRAL_PORTAL_TOKEN_PASSWORD }}
   GRADLE_PUBLISH_KEY: ${{ secrets.GRADLE_PUBLISH_KEY }}
   GRADLE_PUBLISH_SECRET: ${{ secrets.GRADLE_PUBLISH_SECRET }}
   GODOT_KOTLIN_INTELLIJ_PLUGIN_PUBLISH: ${{secrets.GODOT_KOTLIN_INTELLIJ_PLUGIN_PUBLISH }}
diff --git a/kt/build-logic/convention/build.gradle.kts b/kt/build-logic/convention/build.gradle.kts
@@ -12,6 +12,7 @@ kotlin {
 dependencies {
     compileOnly(kotlin("gradle-plugin", version = libs.versions.kotlin.get()))
     implementation(libs.grgit)
+    implementation(libs.maven.publish)
 }
 
 gradlePlugin {
diff --git a/kt/build-logic/convention/src/main/kotlin/publish/PublishToMavenCentralPlugin.kt b/kt/build-logic/convention/src/main/kotlin/publish/PublishToMavenCentralPlugin.kt
@@ -1,83 +1,45 @@
+
 package publish
 
+import com.vanniktech.maven.publish.MavenPublishBaseExtension
+import com.vanniktech.maven.publish.MavenPublishPlugin
+import com.vanniktech.maven.publish.SonatypeHost
 import org.gradle.api.Plugin
 import org.gradle.api.Project
-import org.gradle.api.plugins.JavaPluginExtension
 import org.gradle.api.publish.PublishingExtension
 import org.gradle.api.publish.maven.MavenPublication
-import org.gradle.api.tasks.SourceSetContainer
-import org.gradle.jvm.tasks.Jar
 import org.gradle.plugins.signing.Sign
-import org.gradle.plugins.signing.SigningExtension
 
+@Suppress("unused") // false positive
 class PublishToMavenCentralPlugin : Plugin<Project> {
     override fun apply(target: Project) {
-        target.plugins.apply("maven-publish")
-
-        val ossrhUser = target.propOrEnv("GODOT_KOTLIN_MAVEN_CENTRAL_TOKEN_USERNAME")
-        val ossrhPassword = target.propOrEnv("GODOT_KOTLIN_MAVEN_CENTRAL_TOKEN_PASSWORD")
-        val signingKey = target.propOrEnv("GODOT_KOTLIN_GPG_PRIVATE_KEY_ASCII")
-        val signingPassword = target.propOrEnv("GODOT_KOTLIN_GPG_KEY_PASSPHRASE")
-        val canSign = ossrhUser != null && ossrhPassword != null && signingKey != null && signingPassword != null
-
-        if (canSign) {
-            target.plugins.apply("signing")
-            target.logger.info("Will sign artifact for project \"${target.name}\" and setup publishing")
-        } else {
-            target.logger.warn("Cannot sign project \"${target.name}\" as credentials are missing. Will not setup signing and remote publishing credentials. Publishing will only work to maven local!")
-        }
+        target.plugins.apply(org.gradle.api.publish.maven.plugins.MavenPublishPlugin::class.java)
 
-        target.afterEvaluate { project ->
-            val isReleaseMode = !(project.version as String).endsWith("-SNAPSHOT")
+        target.afterEvaluate { evaluatedProject ->
+            val mavenCentralUser = target.propOrEnv("ORG_GRADLE_PROJECT_mavenCentralUsername") ?: target.propOrEnv("mavenCentralUsername")
+            val mavenCentralPassword = target.propOrEnv("ORG_GRADLE_PROJECT_mavenCentralPassword") ?: target.propOrEnv("mavenCentralPassword")
+            val gpgInMemoryKey = target.propOrEnv("ORG_GRADLE_PROJECT_signingInMemoryKey") ?: target.propOrEnv("signingInMemoryKey")
+            val gpgPassword = target.propOrEnv("ORG_GRADLE_PROJECT_signingInMemoryKeyPassword") ?: target.propOrEnv("signingInMemoryKeyPassword")
 
-            if (canSign) { // for local development, If missing in CI it will fail later on deploy so we would notice the issue then
-                project.extensions.configure(SigningExtension::class.java) { signingExtension ->
-                    signingExtension.useInMemoryPgpKeys(signingKey, signingPassword)
-                    project.extensions.findByType(PublishingExtension::class.java)?.publications?.all { publication ->
-                        signingExtension.sign(publication)
-                    }
-                }
-            }
+            val canSign = mavenCentralUser != null && mavenCentralPassword != null && gpgInMemoryKey != null && gpgPassword != null
 
-            project.extensions.getByType(JavaPluginExtension::class.java).apply {
-                withSourcesJar()
-                withJavadocJar()
-            }
-
-            project.extensions.getByType(PublishingExtension::class.java).apply {
-                repositories.apply {
-                    maven { mavenArtifactRepository ->
-                        val targetRepo = if (isReleaseMode) {
-                            "https://s01.oss.sonatype.org/service/local/staging/deploy/maven2/"
-                        } else {
-                            "https://s01.oss.sonatype.org/content/repositories/snapshots/"
-                        }
-                        mavenArtifactRepository.setUrl(targetRepo)
-
-                        if (canSign) {
-                            mavenArtifactRepository.credentials { passwordCredentials ->
-                                passwordCredentials.username = ossrhUser
-                                passwordCredentials.password = ossrhPassword
-                            }
-                        }
-                    }
-                }
+            target.extensions.getByType(PublishingExtension::class.java).apply {
                 publications { publicationContainer ->
                     publicationContainer.all { publication ->
                         if (publication is MavenPublication) {
                             publication.groupId = "com.utopia-rise"
                             val artifactId = publication.artifactId
-                            publication.artifactId = if (artifactId.isNullOrEmpty()) project.name else artifactId
-                            publication.version = project.version as String
+                            publication.artifactId = if (artifactId.isNullOrEmpty()) target.name else artifactId
+                            publication.version = target.version as String
 
                             publication.pom { mavenPom ->
                                 mavenPom.url.set("https://github.com/utopia-rise/godot-kotlin-jvm.git")
 
                                 if (mavenPom.name.getOrElse("").isNullOrEmpty()) {
-                                    mavenPom.name.set(project.name)
+                                    mavenPom.name.set(target.name)
                                 }
                                 if (mavenPom.description.getOrElse("").isNullOrEmpty()) {
-                                    mavenPom.description.set(project.description ?: "Godot kotlin jvm module")
+                                    mavenPom.description.set(target.description ?: "Godot kotlin jvm module")
                                 }
 
                                 mavenPom.scm { mavenPomScm ->
@@ -127,22 +89,33 @@ class PublishToMavenCentralPlugin : Plugin<Project> {
                 }
             }
 
+
             if (canSign) {
-                project
-                    .tasks
-                    .filter { task -> task.name.startsWith("publish") }
-                    .forEach { task ->
-                        task.dependsOn(project.tasks.withType(Sign::class.java))
-                    }
+                evaluatedProject.logger.info("Will sign artifact for project \"${evaluatedProject.name}\" and setup publishing")
+
+                evaluatedProject.pluginManager.apply(MavenPublishPlugin::class.java)
+                evaluatedProject.extensions.getByType(MavenPublishBaseExtension::class.java).apply {
+                    publishToMavenCentral(SonatypeHost.CENTRAL_PORTAL)
+                    signAllPublications()
+                }
+
+                target.afterEvaluate {
+                    target
+                        .tasks
+                        .filter { task -> task.name.startsWith("publish") }
+                        .forEach { task ->
+                            task.dependsOn(target.tasks.withType(Sign::class.java))
+                        }
+                }
+            } else {
+                evaluatedProject.logger.warn("Cannot sign project \"${evaluatedProject.name}\" as credentials are missing. Will not setup signing and remote publishing credentials. Publishing will only work to maven local!")
             }
         }
     }
 }
 
 fun Project.propOrEnv(name: String): String? {
-    var property: String? = findProperty(name) as String?
-    if (property == null) {
-        property = System.getenv(name)
-    }
-    return property
+    return findProperty(name) as? String?
+        ?: System.getenv(name)?.ifEmpty { null }
+        ?: providers.systemProperty(name).orNull
 }
diff --git a/kt/godot-library/build.gradle.kts b/kt/godot-library/build.gradle.kts
@@ -1,4 +1,3 @@
-import com.github.jengelman.gradle.plugins.shadow.tasks.ShadowJar
 import versioninfo.fullGodotKotlinJvmVersion
 
 plugins {
@@ -31,11 +30,6 @@ kotlin {
     jvmToolchain(libs.versions.toolchain.jvm.get().toInt())
 }
 
-java {
-    withSourcesJar()
-    withJavadocJar()
-}
-
 dependencies {
     // added here as a transitive dependency so the user can use reflection
     // we need to add it here so reflection is available where the code is loaded (Bootstrap.kt) otherwise it will not work
@@ -62,17 +56,14 @@ val targetSuffix = if (isRelease) "release" else "debug"
 
 publishing {
     publications {
-        @Suppress("UNUSED_VARIABLE")
+        @Suppress("UNUSED_VARIABLE", "unused")
         val godotLibraryPublication by registering(MavenPublication::class) {
             pom {
                 name.set("${project.name}-$targetSuffix")
                 description.set("A library allowing to define scripts for the Godot Engine.")
             }
             artifactId = "godot-library-$targetSuffix"
             description = "A library allowing to define scripts for the Godot Engine."
-            artifact(tasks.jar)
-            artifact(tasks.getByName("sourcesJar"))
-            artifact(tasks.getByName("javadocJar"))
         }
     }
 }
diff --git a/kt/godot-library/godot-api-library/build.gradle.kts b/kt/godot-library/godot-api-library/build.gradle.kts
@@ -18,11 +18,6 @@ kotlin {
     jvmToolchain(libs.versions.toolchain.jvm.get().toInt())
 }
 
-java {
-    withSourcesJar()
-    withJavadocJar()
-}
-
 dependencies {
     api("com.utopia-rise:common:$fullGodotKotlinJvmVersion")
     implementation(project(":godot-internal-library"))
@@ -44,17 +39,14 @@ val targetSuffix = if (isRelease) "release" else "debug"
 
 publishing {
     publications {
-        @Suppress("UNUSED_VARIABLE")
-        val godotLibraryPublication by registering(MavenPublication::class) {
+        @Suppress("UNUSED_VARIABLE", "unused")
+        val godotApiLibraryPublication by registering(MavenPublication::class) {
             pom {
                 name.set("${project.name}-$targetSuffix")
                 description.set("Contains godot api as kotlin classes and jvm cpp interaction code.")
             }
             artifactId = "godot-api-library-$targetSuffix"
             description = "Contains godot generated api as kotlin classes and jvm cpp interaction code."
-            artifact(tasks.jar)
-            artifact(tasks.getByName("sourcesJar"))
-            artifact(tasks.getByName("javadocJar"))
         }
     }
 }
diff --git a/kt/godot-library/godot-core-library/build.gradle.kts b/kt/godot-library/godot-core-library/build.gradle.kts
@@ -18,11 +18,6 @@ kotlin {
     jvmToolchain(libs.versions.toolchain.jvm.get().toInt())
 }
 
-java {
-    withSourcesJar()
-    withJavadocJar()
-}
-
 dependencies {
     api("com.utopia-rise:common:$fullGodotKotlinJvmVersion")
     implementation(project(":godot-internal-library"))
@@ -47,17 +42,14 @@ val targetSuffix = if (isRelease) "release" else "debug"
 
 publishing {
     publications {
-        @Suppress("UNUSED_VARIABLE")
-        val godotLibraryPublication by creating(MavenPublication::class) {
+        @Suppress("UNUSED_VARIABLE", "unused")
+        val godotCoreLibraryPublication by creating(MavenPublication::class) {
             pom {
                 name.set("${project.name}-$targetSuffix")
                 description.set("Contains godot api as kotlin classes and jvm cpp interaction code.")
             }
             artifactId = "godot-core-library-$targetSuffix"
             description = "Contains godot api as kotlin classes and jvm cpp interaction code."
-            artifact(tasks.jar)
-            artifact(tasks.getByName("sourcesJar"))
-            artifact(tasks.getByName("javadocJar"))
         }
     }
 }
diff --git a/kt/godot-library/godot-coroutine-library/build.gradle.kts b/kt/godot-library/godot-coroutine-library/build.gradle.kts
@@ -18,11 +18,6 @@ kotlin {
     jvmToolchain(libs.versions.toolchain.jvm.get().toInt())
 }
 
-java {
-    withSourcesJar()
-    withJavadocJar()
-}
-
 dependencies {
     api("org.jetbrains.kotlinx:kotlinx-coroutines-core:${libs.versions.kotlinCoroutine.get()}")
     api("com.utopia-rise:common:$fullGodotKotlinJvmVersion")
@@ -48,17 +43,14 @@ val targetSuffix = if (isRelease) "release" else "debug"
 
 publishing {
     publications {
-        @Suppress("UNUSED_VARIABLE")
+        @Suppress("UNUSED_VARIABLE", "unused")
         val godotCoroutineLibraryPublication by creating(MavenPublication::class) {
             pom {
                 name.set("${project.name}-$targetSuffix")
                 description.set("Godot library extension allowing the use of coroutines in a Godot context.")
             }
             artifactId = "godot-coroutine-library-$targetSuffix"
             description = "Godot library extension allowing the use of coroutines in a Godot context."
-            artifact(tasks.jar)
-            artifact(tasks.getByName("sourcesJar"))
-            artifact(tasks.getByName("javadocJar"))
         }
     }
 }
diff --git a/kt/godot-library/godot-extension-library/build.gradle.kts b/kt/godot-library/godot-extension-library/build.gradle.kts
@@ -19,11 +19,6 @@ kotlin {
     jvmToolchain(libs.versions.toolchain.jvm.get().toInt())
 }
 
-java {
-    withSourcesJar()
-    withJavadocJar()
-}
-
 dependencies {
     api("com.utopia-rise:common:$fullGodotKotlinJvmVersion")
     implementation(project(":godot-internal-library"))
@@ -46,17 +41,14 @@ val targetSuffix = if (isRelease) "release" else "debug"
 
 publishing {
     publications {
-        @Suppress("UNUSED_VARIABLE")
-        val godotCoroutineLibraryPublication by creating(MavenPublication::class) {
+        @Suppress("UNUSED_VARIABLE", "unused")
+        val godotExtensionLibraryPublication by creating(MavenPublication::class) {
             pom {
                 name.set("${project.name}-$targetSuffix")
                 description.set("Godot library extension build on top of the base Godot API.")
             }
             artifactId = "godot-extension-library-$targetSuffix"
             description = "Godot library extension build on top of the base Godot API."
-            artifact(tasks.jar)
-            artifact(tasks.getByName("sourcesJar"))
-            artifact(tasks.getByName("javadocJar"))
         }
     }
 }
diff --git a/kt/godot-library/godot-internal-library/build.gradle.kts b/kt/godot-library/godot-internal-library/build.gradle.kts
@@ -18,11 +18,6 @@ kotlin {
     jvmToolchain(libs.versions.toolchain.jvm.get().toInt())
 }
 
-java {
-    withSourcesJar()
-    withJavadocJar()
-}
-
 dependencies {
     // added here as a transitive dependency so the user can use reflection
     // we need to add it here so reflection is available where the code is loaded (Bootstrap.kt) otherwise it will not work
@@ -33,17 +28,14 @@ val targetSuffix = if (isRelease) "release" else "debug"
 
 publishing {
     publications {
-        @Suppress("UNUSED_VARIABLE")
+        @Suppress("UNUSED_VARIABLE", "unused")
         val godotInternalLibraryPublication by creating(MavenPublication::class) {
             pom {
                 name.set("${project.name}-$targetSuffix")
                 description.set("Contains internal utilities for the Godot kotlin libraries")
             }
             artifactId = "godot-internal-library-$targetSuffix"
             description = "Contains internal utilities for the Godot kotlin libraries"
-            artifact(tasks.jar)
-            artifact(tasks.getByName("sourcesJar"))
-            artifact(tasks.getByName("javadocJar"))
         }
     }
 }
diff --git a/kt/gradle/libs.versions.toml b/kt/gradle/libs.versions.toml
@@ -21,6 +21,7 @@ jacksonDataFormatXml = "2.18.2" # https://mvnrepository.com/artifact/com.fasterx
 grgit = "5.3.0" # https://github.com/ajoberstar/grgit/releases
 
 gradlePublish = "1.3.1" # https://plugins.gradle.org/plugin/com.gradle.plugin-publish
+maven-publish="0.32.0" # https://github.com/vanniktech/gradle-maven-publish-plugin/releases
 
 changelog = "2.2.1" # https://github.com/JetBrains/gradle-changelog-plugin/releases
 gradleIntelliJPlugin = "2.3.0" # https://github.com/JetBrains/intellij-platform-gradle-plugin/releases
@@ -41,6 +42,8 @@ jacksonDataFormatXml = { module = "com.fasterxml.jackson.dataformat:jackson-data
 grgit = { module = "org.ajoberstar.grgit:grgit-gradle", version.ref = "grgit" }
 ideaSync = { module = "org.jetbrains.gradle.plugin.idea-ext:org.jetbrains.gradle.plugin.idea-ext.gradle.plugin", version.ref = "ideaSync" }
 
+maven-publish = { group = "com.vanniktech", name = "gradle-maven-publish-plugin", version.ref = "maven-publish" } # needed for publishing to new maven central repositories
+
 [plugins]
 changelog = { id = "org.jetbrains.changelog", version.ref = "changelog" }
 gradleIntelliJPlugin = { id = "org.jetbrains.intellij.platform", version.ref = "gradleIntelliJPlugin" }

Original file line number	Diff line number	Diff line change
`@@ -12,6 +12,7 @@ kotlin {`
`12`	`12`	`dependencies {`
`13`	`13`	`compileOnly(kotlin("gradle-plugin", version = libs.versions.kotlin.get()))`
`14`	`14`	`implementation(libs.grgit)`
	`15`	`+ implementation(libs.maven.publish)`
`15`	`16`	`}`
`16`	`17`
`17`	`18`	`gradlePlugin {`
Original file line number	Diff line number	Diff line change
`@@ -18,11 +18,6 @@ kotlin {`
`18`	`18`	`jvmToolchain(libs.versions.toolchain.jvm.get().toInt())`
`19`	`19`	`}`
`20`	`20`
`21`		`-java {`
`22`		`- withSourcesJar()`
`23`		`- withJavadocJar()`
`24`		`-}`
`25`		`-`
`26`	`21`	`dependencies {`
`27`	`22`	`api("com.utopia-rise:common:$fullGodotKotlinJvmVersion")`
`28`	`23`	`implementation(project(":godot-internal-library"))`
`@@ -44,17 +39,14 @@ val targetSuffix = if (isRelease) "release" else "debug"`
`44`	`39`
`45`	`40`	`publishing {`
`46`	`41`	`publications {`
`47`		`- @Suppress("UNUSED_VARIABLE")`
`48`		`- val godotLibraryPublication by registering(MavenPublication::class) {`
	`42`	`+ @Suppress("UNUSED_VARIABLE", "unused")`
	`43`	`+ val godotApiLibraryPublication by registering(MavenPublication::class) {`
`49`	`44`	`pom {`
`50`	`45`	`name.set("${project.name}-$targetSuffix")`
`51`	`46`	`description.set("Contains godot api as kotlin classes and jvm cpp interaction code.")`
`52`	`47`	`}`
`53`	`48`	`artifactId = "godot-api-library-$targetSuffix"`
`54`	`49`	`description = "Contains godot generated api as kotlin classes and jvm cpp interaction code."`
`55`		`- artifact(tasks.jar)`
`56`		`- artifact(tasks.getByName("sourcesJar"))`
`57`		`- artifact(tasks.getByName("javadocJar"))`
`58`	`50`	`}`
`59`	`51`	`}`
`60`	`52`	`}`
Original file line number	Diff line number	Diff line change
`@@ -19,11 +19,6 @@ kotlin {`
`19`	`19`	`jvmToolchain(libs.versions.toolchain.jvm.get().toInt())`
`20`	`20`	`}`
`21`	`21`
`22`		`-java {`
`23`		`- withSourcesJar()`
`24`		`- withJavadocJar()`
`25`		`-}`
`26`		`-`
`27`	`22`	`dependencies {`
`28`	`23`	`api("com.utopia-rise:common:$fullGodotKotlinJvmVersion")`
`29`	`24`	`implementation(project(":godot-internal-library"))`
`@@ -46,17 +41,14 @@ val targetSuffix = if (isRelease) "release" else "debug"`
`46`	`41`
`47`	`42`	`publishing {`
`48`	`43`	`publications {`
`49`		`- @Suppress("UNUSED_VARIABLE")`
`50`		`- val godotCoroutineLibraryPublication by creating(MavenPublication::class) {`
	`44`	`+ @Suppress("UNUSED_VARIABLE", "unused")`
	`45`	`+ val godotExtensionLibraryPublication by creating(MavenPublication::class) {`
`51`	`46`	`pom {`
`52`	`47`	`name.set("${project.name}-$targetSuffix")`
`53`	`48`	`description.set("Godot library extension build on top of the base Godot API.")`
`54`	`49`	`}`
`55`	`50`	`artifactId = "godot-extension-library-$targetSuffix"`
`56`	`51`	`description = "Godot library extension build on top of the base Godot API."`
`57`		`- artifact(tasks.jar)`
`58`		`- artifact(tasks.getByName("sourcesJar"))`
`59`		`- artifact(tasks.getByName("javadocJar"))`
`60`	`52`	`}`
`61`	`53`	`}`
`62`	`54`	`}`