eliminates bintray. fixes sonotype release. minor fixes to build. increments patch version

Signed-off-by: Oleh Dokuka <[email protected]>

Author: OlegDokuka

.github/workflows/gradle-release.yml

@@ -8,94 +8,6 @@ on:
       - '*' # Push events to matching *, i.e. 1.0, 20.15.10
 
 jobs:
-  test:
-    name: ${{ matrix.target }} Test Run (JVM ${{ matrix.jvm }})
-    strategy:
-      fail-fast: false
-      matrix:
-        os: [ macos-latest ]
-        target: [ macosX64, iosX64, tvosX64, watchosX86 ]
-        jvm: [ 11 ]
-        include:
-          - os: windows-latest
-            target: mingwX64
-            jvm: 11
-          - os: ubuntu-latest
-            target: linuxX64
-            jvm: 11
-          - os: ubuntu-latest
-            target: jsIrNode
-            jvm: 11
-          - os: ubuntu-latest
-            target: jsIrBrowser
-            jvm: 11
-          - os: ubuntu-latest
-            target: jsLegacyNode
-            jvm: 11
-          - os: ubuntu-latest
-            target: jsLegacyBrowser
-            jvm: 11
-          - os: ubuntu-latest
-            target: jvm
-            jvm: 8
-          - os: ubuntu-latest
-            target: jvm
-            jvm: 11
-          - os: ubuntu-latest
-            target: jvm
-            jvm: 15
-    runs-on: ${{ matrix.os }}
-    steps:
-      - uses: actions/checkout@v2
-      - uses: actions/setup-java@v2
-        with:
-          distribution: 'adopt'
-          java-version: ${{ matrix.jvm }}
-      - uses: actions/cache@v2
-        with:
-          path: |
-            ~/.gradle/caches/modules-2
-            ~/.gradle/wrapper
-            ~/.konan
-          key: ${{ runner.os }}-gradle-${{ hashFiles('**/*.gradle*', '**/gradle-wrapper.properties', '**/gradle.properties') }}
-          restore-keys: ${{ runner.os }}-gradle-
-      - name: Test rsocket-core module
-        if: success() || failure()
-        timeout-minutes: 10
-        uses: eskatos/gradle-command-action@v1
-        with:
-          arguments: rsocket-core:${{ matrix.target }}Test --scan --info
-          wrapper-cache-enabled: false
-          dependencies-cache-enabled: false
-          configuration-cache-enabled: false
-      - name: Test rsocket-transport-local module
-        if: success() || failure()
-        timeout-minutes: 10
-        uses: eskatos/gradle-command-action@v1
-        with:
-          arguments: rsocket-transport-local:${{ matrix.target }}Test --scan --info
-          wrapper-cache-enabled: false
-          dependencies-cache-enabled: false
-          configuration-cache-enabled: false
-      - name: Test rsocket-transport-ktor module
-        if: matrix.target != 'mingwX64' && matrix.target != 'jsIrNode' && matrix.target != 'jsIrBrowser' && matrix.target != 'jsLegacyNode' && matrix.target != 'jsLegacyBrowser' && (success() || failure())
-        timeout-minutes: 10
-        uses: eskatos/gradle-command-action@v1
-        with:
-          arguments: rsocket-transport-ktor:${{ matrix.target }}Test --scan --info
-          wrapper-cache-enabled: false
-          dependencies-cache-enabled: false
-          configuration-cache-enabled: false
-
-      - name: Publish Test Report
-        if: always()
-        uses: mikepenz/action-junit-report@v2
-        with:
-          fail_on_failure: true
-          check_name: ${{ matrix.target }} Test Report (JVM ${{ matrix.jvm }})
-          report_paths: '**/build/test-results/*Test/TEST-*.xml'
-          github_token: ${{ secrets.GITHUB_TOKEN }}
-
   build:
     strategy:
       matrix:
@@ -150,21 +62,14 @@ jobs:
       - name: Set TAG_NAME for publication
         run: echo "TAG_NAME=${GITHUB_REF#refs/tags/}" >> $GITHUB_ENV
         shell: bash
-      - name: Sign Packages
+      - name: Publish Packages to Sonotype (version ${{ env.TAG_NAME }})
         uses: eskatos/gradle-command-action@v1
         with:
-          arguments: sign --info
+          arguments: publishAllPublicationsToSonatypeRepository -Pversion=${{ env.TAG_NAME }} --info --no-daemon
           wrapper-cache-enabled: false
           dependencies-cache-enabled: false
           configuration-cache-enabled: false
           ORG_GRADLE_PROJECT_signingKey: ${{secrets.signingKey}}
           ORG_GRADLE_PROJECT_signingPassword: ${{secrets.signingPassword}}
-      - name: Publish Packages to Sonotype (version ${{ env.TAG_NAME }})
-        uses: eskatos/gradle-command-action@v1
-        with:
-          arguments: publishMavenPublicationToSonatypeRepository -Pversion=${{ env.TAG_NAME }} --info
-          wrapper-cache-enabled: false
-          dependencies-cache-enabled: false
-          configuration-cache-enabled: false
           ORG_GRADLE_PROJECT_sonatypeUsername: ${{secrets.sonatypeUsername}}
           ORG_GRADLE_PROJECT_sonatypePassword: ${{secrets.sonatypePassword}}

build.gradle.kts

@@ -14,6 +14,8 @@
  * limitations under the License.
  */
 
+import groovy.util.Node
+import groovy.util.NodeList
 import org.gradle.api.publish.maven.internal.artifact.FileBasedMavenArtifact
 import org.jetbrains.kotlin.gradle.dsl.*
 import org.jetbrains.kotlin.gradle.plugin.mpp.*
@@ -202,52 +204,117 @@ subprojects {
     }
 }
 
+fun publishPlatformArtifactsInRootModule(platformPublication:MavenPublication,
+                                         kotlinMultiplatformPublication: MavenPublication) {
+    lateinit var platformXml: XmlProvider
+
+    platformPublication.pom.withXml { platformXml = this }
+
+    kotlinMultiplatformPublication.apply {
+        pom.withXml {
+            val root = asNode()
+            // Remove the original content and add the content from the platform POM:
+            root.children().toList().forEach { root.remove(it as Node) }
+            platformXml.asNode().children()
+                .forEach { root.append(it as Node) }
+
+            // Adjust the self artifact ID, as it should match the root module's coordinates:
+            ((root.get("artifactId") as NodeList)[0] as Node).setValue(artifactId)
+
+            // Set packaging to POM to indicate that there's no artifact:
+            root.appendNode("packaging", "pom")
+
+            // Remove the original platform dependencies and add a single dependency on the platform module:
+            val dependencies = (root.get("dependencies") as NodeList)[0] as Node
+            dependencies.children().toList()
+                .forEach { dependencies.remove(it as Node) }
+            val singleDependency = dependencies.appendNode("dependency")
+            singleDependency.appendNode(
+                "groupId",
+                platformPublication.groupId
+            )
+            singleDependency.appendNode(
+                "artifactId",
+                platformPublication.artifactId
+            )
+            singleDependency.appendNode(
+                "version",
+                platformPublication.version
+            )
+            singleDependency.appendNode("scope", "compile")
+        }
+    }
+
+    tasks.matching { it.name == "generatePomFileForKotlinMultiplatformPublication" }
+        .configureEach {
+            dependsOn(tasks["generatePomFileFor${platformPublication.name.capitalize()}Publication"])
+        }
+
+}
 
 //publication
 subprojects {
+    afterEvaluate {
 
-    val versionSuffix: String? by project
-    if (versionSuffix != null) {
-        project.version = project.version.toString() + versionSuffix
-    }
+        val versionSuffix: String? by project
+        if (versionSuffix != null) {
+            project.version = project.version.toString() + versionSuffix
+        }
 
-    plugins.withId("org.jetbrains.kotlin.multiplatform") {
-        extensions.configure<KotlinMultiplatformExtension> {
-            targets.all {
-                mavenPublication {
-                    pom {
-                        name.set(project.name)
-                        description.set(project.description)
-                        url.set("http://rsocket.io")
-
-                        licenses {
-                            license {
-                                name.set("The Apache Software License, Version 2.0")
-                                url.set("https://www.apache.org/licenses/LICENSE-2.0.txt")
-                                distribution.set("repo")
+        task<Jar>("javadocJar") {
+            archiveClassifier.set("javadoc")
+        }
+
+        tasks.withType<Sign> {
+            dependsOn("javadocJar")
+        }
+
+        plugins.withId("org.jetbrains.kotlin.multiplatform") {
+            extensions.configure<KotlinMultiplatformExtension> {
+                targets.all {
+                    mavenPublication {
+                        pom {
+                            name.set(project.name)
+                            description.set(project.description)
+                            url.set("http://rsocket.io")
+
+                            licenses {
+                                license {
+                                    name.set("The Apache Software License, Version 2.0")
+                                    url.set("https://www.apache.org/licenses/LICENSE-2.0.txt")
+                                    distribution.set("repo")
+                                }
                             }
-                        }
-                        developers {
-                            developer {
-                                id.set("whyoleg")
-                                name.set("Oleg Yukhnevich")
-                                email.set("[email protected]")
+                            developers {
+                                developer {
+                                    id.set("whyoleg")
+                                    name.set("Oleg Yukhnevich")
+                                    email.set("[email protected]")
+                                }
+                                developer {
+                                    id.set("OlegDokuka")
+                                    name.set("Oleh Dokuka")
+                                    email.set("[email protected]")
+                                }
                             }
-                            developer {
-                                id.set("OlegDokuka")
-                                name.set("Oleh Dokuka")
-                                email.set("oleh.dokuka@icloud.com")
+                            scm {
+                                connection.set("https://github.com/rsocket/rsocket-kotlin.git")
+                                developerConnection.set("https://github.com/rsocket/rsocket-kotlin.git")
+                                url.set("https://github.com/rsocket/rsocket-kotlin")
                             }
                         }
-                        scm {
-                            connection.set("https://github.com/rsocket/rsocket-kotlin.git")
-                            developerConnection.set("https://github.com/rsocket/rsocket-kotlin.git")
-                            url.set("https://github.com/rsocket/rsocket-kotlin")
-                        }
                     }
                 }
             }
         }
+
+        tasks.withType<PublishToMavenRepository> {
+            dependsOn(tasks.withType<Sign>())
+        }
+
+        tasks.matching { it.name == "generatePomFileForKotlinMultiplatformPublication"}.configureEach {
+            dependsOn(tasks["generatePomFileForJvmPublication"])
+        }
     }
 }
 
@@ -282,14 +349,16 @@ if (bintrayUser != null && bintrayKey != null) {
             }
         }
     }
+}
 
-    //configure bintray / maven central
-    val sonatypeUsername: String? by project
-    val sonatypePassword: String? by project
-    if (sonatypeUsername != null && sonatypePassword != null) {
-        subprojects {
-            plugins.withType<MavenPublishPlugin> {
-                plugins.withType<SigningPlugin> {
+//configure bintray / maven central
+val sonatypeUsername: String? by project
+val sonatypePassword: String? by project
+if (sonatypeUsername != null && sonatypePassword != null) {
+    subprojects {
+        afterEvaluate {
+            plugins.withId("maven-publish") {
+                plugins.withId("signing") {
                     extensions.configure<SigningExtension> {
                         //requiring signature if there is a publish task that is not to MavenLocal
                         isRequired = gradle.taskGraph.allTasks.any {
@@ -303,20 +372,23 @@ if (bintrayUser != null && bintrayKey != null) {
                         useInMemoryPgpKeys(signingKey, signingPassword)
                         val names = publicationNames
                         val publishing: PublishingExtension by project.extensions
-                        afterEvaluate {
+                        beforeEvaluate {
                             publishing.publications
-                            .filterIsInstance<MavenPublication>()
-                            .filter { it.name in names }
-                            .forEach { publication ->
-                                val moduleFile = buildDir.resolve("publications/${publication.name}/module.json")
-                                if (moduleFile.exists()) {
-                                    publication.artifact(object : FileBasedMavenArtifact(moduleFile) {
-                                        override fun getDefaultExtension() = "module"
-                                    })
+                                .filterIsInstance<MavenPublication>()
+                                .filter { it.name in names }
+                                .forEach { publication ->
+                                    val moduleFile =
+                                        buildDir.resolve("publications/${publication.name}/module.json")
+                                    if (moduleFile.exists()) {
+                                        publication.artifact(object :
+                                            FileBasedMavenArtifact(moduleFile) {
+                                            override fun getDefaultExtension() = "module"
+                                        })
+                                    }
                                 }
-                                sign(publication)
-                            }
-
+                        }
+                        afterEvaluate {
+                            sign(*publishing.publications.toTypedArray())
                         }
                     }
 
@@ -331,6 +403,27 @@ if (bintrayUser != null && bintrayKey != null) {
                                 }
                             }
                         }
+
+                        publications.filterIsInstance<MavenPublication>().forEach {
+                            // add empty javadocs
+                            if (name != "kotlinMultiplatform") {
+                                it.artifact(tasks["javadocJar"])
+                            }
+
+                            val type = it.name
+                            when (type) {
+                                "kotlinMultiplatform" -> {
+                                    // With Kotlin 1.4 & HMPP, the root module should have no suffix in the ID, but for compatibility with
+                                    // the consumers who can't read Gradle module metadata, we publish the JVM artifacts in it, too
+                                    it.artifactId = project.name
+                                    publishPlatformArtifactsInRootModule(
+                                        publications["jvm"] as MavenPublication,
+                                        it
+                                    )
+                                }
+                                else -> it.artifactId = "${project.name}-$type"
+                            }
+                        }
                     }
                 }
             }

gradle.properties

@@ -16,7 +16,7 @@
 
 #Project
 group=io.rsocket.kotlin
-version=0.13.0
+version=0.13.1
 
 #Versions
 kotlinVersion=1.5.20

rsocket-core/build.gradle.kts

@@ -19,7 +19,7 @@ plugins {
     id("kotlinx-atomicfu")
 
     signing
-    id("maven-publish")
+    `maven-publish`
     id("com.jfrog.artifactory")
 }
 
@@ -41,3 +41,5 @@ kotlin {
         }
     }
 }
+
+description = "Core functionality for the RSocket library"