Maven central publication (#1319)

Publication to Maven Central instead of Bintray

RELEASING.md

@@ -34,9 +34,9 @@ To release new `<version>` of `kotlinx.serialization`:
  * On 'Changes' tab, select `dev` branch and corresponding commit.
  * On 'Parameters' tab, find 'Deploy version' and fill in with `<version>`.
 
-4. In [Bintray](https://bintray.com/kotlin/kotlinx/kotlinx.serialization.runtime) admin interface:
- * Publish artifacts of the new version.
- * Wait until newly published version becomes the most recent.
+4. In [Sonatype](oss.sonatype.org/#stagingRepositories) admin interface:
+ * Close the repository and wait for it to verify.
+ * Release it.
 
 5. Update documentation website:<br>
  `./update_docs.sh <version> push`

buildSrc/build.gradle.kts

@@ -0,0 +1,14 @@
+import org.jetbrains.kotlin.gradle.plugin.*
+import java.util.*
+
+plugins {
+ `kotlin-dsl`
+}
+
+repositories {
+ jcenter()
+}
+
+kotlinDslPluginOptions {
+ experimentalWarning.set(false)
+}

buildSrc/src/main/kotlin/Publishing.kt

@@ -0,0 +1,98 @@
+/*
+ * Copyright 2016-2021 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license.
+ */
+
+@file:Suppress("UnstableApiUsage")
+
+import org.gradle.api.*
+import org.gradle.api.artifacts.dsl.*
+import org.gradle.api.provider.*
+import org.gradle.api.publish.maven.*
+import org.gradle.plugins.signing.*
+import java.net.*
+
+// Pom configuration
+
+infix fun <T> Property<T>.by(value: T) {
+ set(value)
+}
+
+fun MavenPom.configureMavenCentralMetadata(project: Project) {
+ name by project.name
+ description by "Kotlin multiplatform serialization runtime library"
+ url by "https://github.com/Kotlin/kotlinx.serialization"
+
+ licenses {
+ license {
+ name by "The Apache Software License, Version 2.0"
+ url by "https://www.apache.org/licenses/LICENSE-2.0.txt"
+ distribution by "repo"
+ }
+ }
+
+ developers {
+ developer {
+ id by "JetBrains"
+ name by "JetBrains Team"
+ organization by "JetBrains"
+ organizationUrl by "https://www.jetbrains.com"
+ }
+ }
+
+ scm {
+ url by "https://github.com/Kotlin/kotlinx.serialization"
+ }
+}
+
+fun configureBintrayPublication(rh: RepositoryHandler, project: Project) {
+ rh.maven {
+ val user = "kotlin"
+ val repo = "kotlinx"
+ val name = "kotlinx.serialization"
+ url = URI("https://api.bintray.com/maven/$user/$repo/$name/;publish=0;override=0")
+
+ credentials {
+ username = project.findProperty("bintrayUser") as? String ?: System.getenv("BINTRAY_USER")
+ password = project.findProperty("bintrayApiKey") as? String ?: System.getenv("BINTRAY_API_KEY")
+ }
+ }
+}
+
+fun mavenRepositoryUri(): URI {
+ // TODO -SNAPSHOT detection can be made here as well
+ val repositoryId: String? = System.getenv("libs.repository.id")
+ return if (repositoryId == null) {
+ // Using implicitly created staging, for MPP it's likely to be a mistake because
+ // publication on TeamCity will create 3 independent staging repositories
+ System.err.println("Warning: using an implicitly created staging for serialization")
+ URI("https://oss.sonatype.org/service/local/staging/deploy/maven2/")
+ } else {
+ URI("https://oss.sonatype.org/service/local/staging/deployByRepositoryId/$repositoryId")
+ }
+}
+
+fun configureMavenPublication(rh: RepositoryHandler, project: Project) {
+ rh.maven {
+ url = mavenRepositoryUri()
+ credentials {
+ username = project.getSensitiveProperty("libs.sonatype.user")
+ password = project.getSensitiveProperty("libs.sonatype.password")
+ }
+ }
+}
+
+fun signPublicationIfKeyPresent(project: Project, publication: MavenPublication) {
+ val keyId = project.getSensitiveProperty("libs.sign.key.id")
+ val signingKey = project.getSensitiveProperty("libs.sign.key.private")
+ val signingKeyPassphrase = project.getSensitiveProperty("libs.sign.passphrase")
+ if (!signingKey.isNullOrBlank()) {
+ project.extensions.configure<SigningExtension>("signing") {
+ useInMemoryPgpKeys(keyId, signingKey, signingKeyPassphrase)
+ sign(publication)
+ }
+ }
+}
+
+private fun Project.getSensitiveProperty(name: String): String? {
+ return project.findProperty(name) as? String ?: System.getenv(name)
+}

gradle/publishing.gradle

@@ -1,13 +1,14 @@
 import org.gradle.util.VersionNumber
 
 /*
- * Copyright 2017-2020 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license.
+ * Copyright 2017-2021 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license.
  */
 
 // Configures publishing of Maven artifacts to Bintray
 
 apply plugin: 'maven'
 apply plugin: 'maven-publish'
+apply plugin: 'signing'
 
 apply from: project.rootProject.file('gradle/maven-metadata.gradle')
 
@@ -17,16 +18,18 @@ def isMultiplatform = project.name in ["kotlinx-serialization-core", "kotlinx-se
 def isKotlin137x = VersionNumber.parse(kotlin_version) <= VersionNumber.parse("1.3.79")
 
 task stubSources(type: Jar) {
- classifier = 'sources'
+ archiveClassifier = 'sources'
 }
 
 task stubJavadoc(type: Jar) {
- classifier = 'javadoc'
+ archiveClassifier = 'javadoc'
 }
 
 task emptyJar(type: Jar) {
 }
 
+def bintrayUploadFlag = System.getenv("libs.bintray.upload") != null
+
 afterEvaluate {
  task mainSourcesJar(type: Jar) {
  classifier = 'sources'
@@ -49,7 +52,11 @@ afterEvaluate {
  publication.from components.java
  publication.artifact mainSourcesJar
  artifact stubJavadoc
- publication.pom.withXml(configureMavenCentralMetadata)
+
+ PublishingKt.configureMavenCentralMetadata(publication.pom, project)
+ if (!bintrayUploadFlag) {
+ PublishingKt.signPublicationIfKeyPresent(project, publication)
+ }
  }
  }
 
@@ -92,7 +99,10 @@ afterEvaluate {
  }
  logger.info("Artifact id = ${it.artifactId}")
 
- pom.withXml(configureMavenCentralMetadata)
+ PublishingKt.configureMavenCentralMetadata(pom, project)
+ if (!bintrayUploadFlag) {
+ PublishingKt.signPublicationIfKeyPresent(project, it)
+ }
 
  // The 'root' module publishes the JVM module's Javadoc JAR as per publishPlatformArtifactsInRootModule, and
  // every other module should publish an empty Javadoc JAR. TODO: provide proper documentation artifacts?
@@ -106,8 +116,15 @@ afterEvaluate {
  }
 }
 
-
-apply from: project.rootProject.file("gradle/bintray.gradle")
+publishing {
+ repositories {
+ if (bintrayUploadFlag) {
+ PublishingKt.configureBintrayPublication(delegate, project)
+ } else {
+ PublishingKt.configureMavenPublication(delegate, project)
+ }
+ }
+}
 
 // Compatibility with old TeamCity configurations that perform :kotlinx-coroutines-core:bintrayUpload
 task bintrayUpload(dependsOn: publish)