Migrate to new Maven Central API (#5344)

- new API requires creating a zip
- API code is copied and adapted from
[compose-hot-reload](https://github.com/JetBrains/compose-hot-reload/blob/799b90b76ffc6d93207c25626be53ecb0cb86a63/buildSrc/src/main/kotlin/PublishToMavenCentralTask.kt#L39)
- [CI change](https://jetbrains.team/p/ui/reviews/31/timeline)

## Testing
1. Configure Maven Space Token in
https://public.jetbrains.space/p/compose/edit/applications, write it in
cli/build.gradle.kts

2. Use Maven Central token, write it in cli/gradle.properties

3.
```
..\gradlew reuploadArtifactsToMavenCentral --info --stacktrace -Pmaven.central.coordinates=org.jetbrains.compose*:*:1.8.0,org.jetbrains.compose.material:material-navigation*:2.9.0-beta02,org.jetbrains.compose.material3.adaptive:*:1.1.0 -Pmaven.central.deployName="Compose1.8.0 and associated libs" --rerun-tasks

..\gradlew reuploadArtifactsToMavenCentral --info --stacktrace -Pmaven.central.coordinates=org.jetbrains.skiko*:*:0.9.16 -Pmaven.central.deployName="Skiko 0.9.16" --rerun-tasks
```
downloads packages from Space, creates a zip, and uploads as a new
(non-published) deployment.

With failed state, because signing was disabled:
<img width="305" alt="image"
src="https://github.com/user-attachments/assets/0a32e185-e43b-4783-9145-84aba64d41c0"
/>
I will check on a valid uploading on Skiko after the merge

## Release Notes
N/A

Author: igordmn

ci/build-helpers/cli/build.gradle.kts

@@ -49,12 +49,10 @@ val reuploadArtifactsToMavenCentral by tasks.registering(UploadToSonatypeTask::c
 
     modulesToUpload.set(project.provider { readComposeModules(modulesFile, preparedArtifactsRoot) })
 
-    sonatypeServer.set("https://oss.sonatype.org")
     user.set(mavenCentral.user)
     password.set(mavenCentral.password)
-    autoCommitOnSuccess.set(mavenCentral.autoCommitOnSuccess)
-    stagingProfileName.set(mavenCentral.stage)
-    stagingDescription.set(mavenCentral.description)
+    deployName.set(mavenCentral.deployName)
+    publishAfterUploading.set(mavenCentral.publishAfterUploading)
 }
 
 fun readComposeModules(

ci/build-helpers/publishing/build.gradle.kts

@@ -26,7 +26,9 @@ dependencies {
     val jacksonVersion = "2.12.5"
     implementation("com.fasterxml.jackson.dataformat:jackson-dataformat-xml:$jacksonVersion")
     implementation("com.fasterxml.jackson.module:jackson-module-kotlin:$jacksonVersion")
-    implementation("io.ktor:ktor-client-okhttp:2.3.13")
+    implementation("io.ktor:ktor-client-core:3.1.3")
+    implementation("io.ktor:ktor-client-cio:3.1.3")
+    implementation("io.ktor:ktor-client-okhttp:3.1.3")
     implementation("org.apache.tika:tika-parsers:1.24.1")
     implementation("org.jsoup:jsoup:1.14.3")
     implementation("org.jetbrains:space-sdk-jvm:2024.3-185883")

ci/build-helpers/publishing/src/main/kotlin/org/jetbrains/compose/internal/publishing/DownloadFromSpaceTask.kt

@@ -30,6 +30,7 @@ abstract class DownloadFromSpaceMavenRepoTask : DefaultTask() {
     }
 
     private fun downloadArtifactsFromComposeDev(module: ModuleToUpload) {
+        logger.info("Downloading ${module.coordinate}...")
         val groupUrl = module.groupId.replace(".", "/")
 
         val filesListingDocument =

ci/build-helpers/publishing/src/main/kotlin/org/jetbrains/compose/internal/publishing/MavenCentralProperties.kt

@@ -13,20 +13,17 @@ class MavenCentralProperties(private val myProject: Project) {
     val coordinates: Provider<String> =
         propertyProvider("maven.central.coordinates")
 
-    val stage: Provider<String> =
-        propertyProvider("maven.central.stage")
-
-    val description: Provider<String> =
-        propertyProvider("maven.central.description")
+    val deployName: Provider<String> =
+        propertyProvider("maven.central.deployName")
 
     val user: Provider<String> =
         propertyProvider("maven.central.user", envVar = "MAVEN_CENTRAL_USER")
 
     val password: Provider<String> =
         propertyProvider("maven.central.password", envVar = "MAVEN_CENTRAL_PASSWORD")
 
-    val autoCommitOnSuccess: Provider<Boolean> =
-        propertyProvider("maven.central.staging.close.after.upload", defaultValue = "false")
+    val publishAfterUploading: Provider<Boolean> =
+        propertyProvider("maven.central.publishAfterUploading", defaultValue = "false")
             .map { it.toBoolean() }
 
     val signArtifacts: Boolean

ci/build-helpers/publishing/src/main/kotlin/org/jetbrains/compose/internal/publishing/UploadToSonatypeTask.kt

@@ -5,18 +5,38 @@
 
 package org.jetbrains.compose.internal.publishing
 
+import io.ktor.client.*
+import io.ktor.client.engine.cio.*
+import io.ktor.client.plugins.*
+import io.ktor.client.plugins.HttpTimeout
+import io.ktor.client.request.accept
+import io.ktor.client.request.bearerAuth
+import io.ktor.client.request.forms.*
+import io.ktor.client.request.parameter
+import io.ktor.client.request.post
+import io.ktor.client.request.setBody
+import io.ktor.client.request.url
+import io.ktor.client.statement.bodyAsText
+import io.ktor.http.*
+import io.ktor.http.headers
+import io.ktor.utils.io.streams.asInput
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.runBlocking
 import org.gradle.api.DefaultTask
 import org.gradle.api.provider.ListProperty
 import org.gradle.api.provider.Property
 import org.gradle.api.tasks.Internal
 import org.gradle.api.tasks.TaskAction
 import org.jetbrains.compose.internal.publishing.utils.*
+import java.io.FileInputStream
+import java.io.FileOutputStream
+import java.util.*
+import java.util.zip.ZipEntry
+import java.util.zip.ZipOutputStream
 
 @Suppress("unused") // public api
 abstract class UploadToSonatypeTask : DefaultTask() {
     // the task must always re-run anyway, so all inputs can be declared Internal
-    @get:Internal
-    abstract val sonatypeServer: Property<String>
 
     @get:Internal
     abstract val user: Property<String>
@@ -25,73 +45,134 @@ abstract class UploadToSonatypeTask : DefaultTask() {
     abstract val password: Property<String>
 
     @get:Internal
-    abstract val stagingProfileName: Property<String>
-
-    @get:Internal
-    abstract val stagingDescription: Property<String>
+    abstract val deployName: Property<String>
 
     @get:Internal
-    abstract val autoCommitOnSuccess: Property<Boolean>
+    abstract val publishAfterUploading: Property<Boolean>
 
     @get:Internal
     abstract val modulesToUpload: ListProperty<ModuleToUpload>
 
     @TaskAction
     fun run() {
-        SonatypeRestApiClient(
-            sonatypeServer = sonatypeServer.get(),
-            user = user.get(),
-            password = password.get(),
-            logger = logger
-        ).use { client -> run(client) }
+        val deploymentBundle = createDeploymentBundle(modulesToUpload.get())
+        runBlocking {
+            HttpClient(CIO) {
+                install(HttpTimeout) {
+                    requestTimeoutMillis = 5 * 60 * 1000 // 5 minutes
+                    connectTimeoutMillis = 60 * 1000     // 1 minute
+                    socketTimeoutMillis = 5 * 60 * 1000  // 5 minutes
+                }
+                install(HttpRequestRetry) {
+                    retryOnExceptionOrServerErrors(maxRetries = 5)
+                    exponentialDelay()
+                }
+            }.use { client ->
+                client.publish(deploymentBundle)
+            }
+        }
     }
 
-    private fun run(sonatype: SonatypeApi) {
-        val stagingProfiles = sonatype.stagingProfiles()
-        val stagingProfileName = stagingProfileName.get()
-        val stagingProfile = stagingProfiles.data.firstOrNull { it.name == stagingProfileName }
-            ?: error(
-                "Cannot find staging profile '$stagingProfileName' among existing staging profiles: " +
-                        stagingProfiles.data.joinToString { "'${it.name}'" }
-            )
-        val modules = modulesToUpload.get()
+    private fun createDeploymentBundle(modules: List<ModuleToUpload>): InputProvider {
+        val zipFile = project.buildDir.resolve("publishing/compose-deploy.zip")
+        zipFile.parentFile.mkdirs()
 
-        validate(stagingProfile, modules)
+        ZipOutputStream(FileOutputStream(zipFile)).use { zipOut ->
+            val sourcesToDestinations = modules.map { it.localDir to it.mavenDirectory() }
 
-        val stagingRepo = sonatype.createStagingRepo(
-            stagingProfile, stagingDescription.get()
-        )
-        try {
-            for (module in modules) {
-                sonatype.upload(stagingRepo, module)
-            }
-            if (autoCommitOnSuccess.get()) {
-                sonatype.closeStagingRepo(stagingRepo)
+            for ((sourceDir, destDir) in sourcesToDestinations) {
+                val files = sourceDir.listFiles() ?: continue
+
+                for (file in files) {
+                    if (file.isFile) {
+                        val entryPath = "$destDir/${file.name}"
+                        val entry = ZipEntry(entryPath)
+                        zipOut.putNextEntry(entry)
+                        file.inputStream().use { input ->
+                            input.copyTo(zipOut)
+                        }
+                        zipOut.closeEntry()
+                    }
+                }
             }
-        } catch (e: Exception) {
-            throw e
         }
-    }
 
-    private fun validate(stagingProfile: StagingProfile, modules: List<ModuleToUpload>) {
-        val validationIssues = arrayListOf<Pair<ModuleToUpload, ModuleValidator.Status.Error>>()
-        for (module in modules) {
-            val status = ModuleValidator(stagingProfile, module).validate()
-            if (status is ModuleValidator.Status.Error) {
-                validationIssues.add(module to status)
-            }
+        logger.info("Zip bundle is created at $zipFile")
+
+        return InputProvider(zipFile.length()) {
+            FileInputStream(zipFile).asInput()
         }
-        if (validationIssues.isNotEmpty()) {
-            val message = buildString {
-                appendLine("Some modules violate Maven Central requirements:")
-                for ((module, status) in validationIssues) {
-                    appendLine("* ${module.coordinate} (files: ${module.localDir})")
-                    for (error in status.errors) {
-                        appendLine("  * $error")
+    }
+
+    // By the doc https://central.sonatype.org/publish/publish-portal-api/
+    private suspend fun HttpClient.publish(deploymentBundle: InputProvider) {
+        val publishAfterUploading = publishAfterUploading.get()
+
+        val bearerToken = Base64.getEncoder().encode(
+            "${user.get()}:${password.get()}".toByteArray()
+        ).toString(Charsets.UTF_8)
+
+        logger.info("Start uploading ${deployName.get()}")
+
+        val response = submitForm {
+            url("https://central.sonatype.com/api/v1/publisher/upload")
+            parameter("name", deployName.get())
+            parameter("publishingType", if (publishAfterUploading) "AUTOMATIC" else "USER_MANAGED")
+            bearerAuth(bearerToken)
+            setBody(
+                MultiPartFormDataContent(
+                    formData {
+                        append("bundle", deploymentBundle, headers {
+                            append(HttpHeaders.ContentType, ContentType.Application.OctetStream.contentType)
+                            append(HttpHeaders.ContentDisposition, "filename=\"bundle.zip\"")
+                        })
                     }
+                )
+            )
+            var lastUploadLogTime = 0L
+            onUpload { bytesSentTotal, contentLength ->
+                val currentTime = System.currentTimeMillis()
+                if (currentTime - lastUploadLogTime >= 5000) { // 5 seconds debounce
+                    logger.info("Sent $bytesSentTotal bytes from $contentLength")
+                    lastUploadLogTime = currentTime
                 }
             }
-            error(message)
         }
+
+        if (response.status != HttpStatusCode.Created) {
+            error("Deployment failed (${response.status}):\n ${response.bodyAsText()}")
+        }
+
+        val deploymentId = response.bodyAsText().trim()
+        logger.info("Successfully uploaded ${deploymentId.take(4)}")
+
+        val endStatus = if (publishAfterUploading) "PUBLISHED" else "VALIDATED"
+
+        while (true) {
+            logger.info("Checking the status of the deployment...")
+
+            val statusResponse = post {
+                bearerAuth(bearerToken)
+                accept(ContentType.Application.Json)
+                url("https://central.sonatype.com/api/v1/publisher/status")
+                parameter("id", deploymentId)
+            }
+
+            if (statusResponse.status != HttpStatusCode.OK) {
+                error("Deployment failed (${statusResponse.status}):\n ${statusResponse.bodyAsText()}")
+            }
+
+            if (statusResponse.bodyAsText().contains(endStatus)) break
+            if (statusResponse.bodyAsText().contains("FAILED")) {
+                error("Deployment failed (${statusResponse.status}):\n ${statusResponse.bodyAsText()}")
+            }
+
+            delay(5000)
+        }
+
+        logger.info("Successfully published")
     }
-}
+
+    private fun ModuleToUpload.mavenDirectory() =
+        groupId.replace(".", "/") + "/" + artifactId + "/" + version
+}