Add publishAggregationToCentralSnapshots and publishFooPublicationToCentralSnapshots

src/main/kotlin/nmcp/NmcpAggregationExtension.kt

@@ -4,7 +4,8 @@ import gratatouille.GExtension
 import javax.inject.Inject
 import nmcp.internal.configureAttributes
 import nmcp.internal.nmcpConsumerConfigurationName
-import nmcp.internal.task.registerPublishTask
+import nmcp.internal.task.registerPublishReleaseTask
+import nmcp.internal.task.registerPublishSnapshotTask
 import org.gradle.api.Action
 import org.gradle.api.Project
 import org.gradle.api.file.ArchiveOperations
@@ -42,12 +43,19 @@ abstract class NmcpAggregationExtension(private val project: Project) {
             })
         }
 
-        project.registerPublishTask(
+        project.registerPublishReleaseTask(
             taskName = "publishAggregationToCentralPortal",
             inputFile = zipTaskProvider.flatMap { it.archiveFile },
             artifactId = project.provider { "${project.name}" },
             spec = spec
         )
+        project.registerPublishSnapshotTask(
+            taskName = "publishAggregationToCentralSnapshots",
+            inputFile = zipTaskProvider.flatMap { it.archiveFile },
+            username = spec.username,
+            password = spec.password,
+            version = project.provider { "${project.version}" },
+        )
     }
 
     /**

src/main/kotlin/nmcp/NmcpExtension.kt

@@ -4,7 +4,8 @@ import gratatouille.GExtension
 import gratatouille.capitalizeFirstLetter
 import nmcp.internal.configureAttributes
 import nmcp.internal.nmcpProducerConfigurationName
-import nmcp.internal.task.registerPublishTask
+import nmcp.internal.task.registerPublishReleaseTask
+import nmcp.internal.task.registerPublishSnapshotTask
 import nmcp.internal.withRequiredPlugin
 import org.gradle.api.Action
 import org.gradle.api.Project
@@ -15,8 +16,9 @@ import org.gradle.api.tasks.bundling.Zip
 @GExtension(pluginId = "com.gradleup.nmcp")
 open class NmcpExtension(private val project: Project) {
     internal val spec = project.objects.newInstance(CentralPortalOptions::class.java)
-    // Lifecycle task to publish all the publications in the given project
+    // Lifecycle tasks to publish all the publications in the given project
     private val publishAllPublicationsToCentralPortal = project.tasks.register("publishAllPublicationsToCentralPortal")
+    private val publishAllPublicationsToCentralSnapshots = project.tasks.register("publishAllPublicationsToCentralSnapshots")
 
     init {
         project.configurations.create(nmcpProducerConfigurationName) {
@@ -86,15 +88,25 @@ open class NmcpExtension(private val project: Project) {
         } else {
             project.provider { "${project.name}"}
         }
-        val publishTaskProvider = project.registerPublishTask(
+        val publishRelease = project.registerPublishReleaseTask(
             taskName = "publish${capitalized}PublicationToCentralPortal",
             inputFile = zipTaskProvider.flatMap { it.archiveFile },
             artifactId = artifactId,
             spec = spec
         )
+        val publishSnapshots = project.registerPublishSnapshotTask(
+            taskName = "publish${capitalized}PublicationToCentralSnapshots",
+            inputFile = zipTaskProvider.flatMap { it.archiveFile },
+            username = spec.username,
+            password = spec.password,
+            version = project.provider { "${project.version}" },
+        )
 
+        publishAllPublicationsToCentralSnapshots.configure {
+            it.dependsOn(publishSnapshots)
+        }
         publishAllPublicationsToCentralPortal.configure {
-            it.dependsOn((publishTaskProvider))
+            it.dependsOn((publishRelease))
         }
 
         project.artifacts.add(nmcpProducerConfigurationName, zipTaskProvider)

src/main/kotlin/nmcp/internal/task/okhttp.kt

@@ -0,0 +1,10 @@
+package nmcp.internal.task
+
+import java.time.Duration
+import okhttp3.OkHttpClient
+
+internal val client = OkHttpClient.Builder()
+    .connectTimeout(Duration.ofSeconds(30))
+    .writeTimeout(Duration.ofSeconds(30))
+    .readTimeout(Duration.ofSeconds(60))
+    .build()

src/main/kotlin/nmcp/internal/task/publish.kt → src/main/kotlin/nmcp/internal/task/publishRelease.kt

@@ -4,14 +4,12 @@ import gratatouille.GInputFile
 import gratatouille.GLogger
 import gratatouille.GTask
 import java.net.SocketTimeoutException
-import java.time.Duration
 import kotlinx.serialization.json.Json
 import kotlinx.serialization.json.JsonObject
 import kotlinx.serialization.json.JsonPrimitive
 import nmcp.CentralPortalOptions
 import okhttp3.MediaType.Companion.toMediaType
 import okhttp3.MultipartBody
-import okhttp3.OkHttpClient
 import okhttp3.Request
 import okhttp3.RequestBody.Companion.asRequestBody
 import okhttp3.RequestBody.Companion.toRequestBody
@@ -27,7 +25,7 @@ import kotlin.time.TimeSource.Monotonic.markNow
 
 
 @GTask(pure = false)
-fun publish(
+fun publishRelease(
     logger: GLogger,
     username: String?,
     password: String?,
@@ -144,12 +142,6 @@ private data object PUBLISHED : Status
 // A deployment has encountered an error
 private class FAILED(val error: String) : Status
 
-private val client = OkHttpClient.Builder()
-    .connectTimeout(Duration.ofSeconds(30))
-    .writeTimeout(Duration.ofSeconds(30))
-    .readTimeout(Duration.ofSeconds(60))
-    .build()
-
 private fun verifyStatus(
     deploymentId: String,
     baseUrl: String,
@@ -196,14 +188,14 @@ private fun verifyStatus(
         }
 }
 
-internal fun Project.registerPublishTask(
+internal fun Project.registerPublishReleaseTask(
     taskName: String,
     inputFile: Provider<RegularFile>,
     artifactId: Provider<String>,
     spec: CentralPortalOptions
-): TaskProvider<PublishTask> {
+): TaskProvider<PublishReleaseTask> {
     val defaultPublicationName = artifactId.map { "${project.group}:${it}:${project.version}.zip" }
-    return registerPublishTask(
+    return registerPublishReleaseTask(
         taskName = taskName,
         inputFile = inputFile,
         username = spec.username,

src/main/kotlin/nmcp/internal/task/publishSnapshot.kt

@@ -0,0 +1,61 @@
+package nmcp.internal.task
+
+import gratatouille.GInputFile
+import gratatouille.GLogger
+import gratatouille.GTask
+import java.util.zip.ZipInputStream
+import okhttp3.Credentials
+import okhttp3.MediaType.Companion.toMediaType
+import okhttp3.Request
+import okhttp3.RequestBody.Companion.toRequestBody
+import okio.buffer
+import okio.source
+
+@GTask(pure = false)
+fun publishSnapshot(
+    logger: GLogger,
+    username: String?,
+    password: String?,
+    version: String,
+    inputFile: GInputFile,
+) {
+    check(!username.isNullOrBlank()) {
+        "Ncmp: username is missing"
+    }
+    check(!password.isNullOrBlank()) {
+        "Ncmp: password is missing"
+    }
+    check(version.endsWith("-SNAPSHOT")) {
+        "Ncmp: Cannot publish snapshot version '$version' without -SNAPSHOT suffix"
+    }
+
+    val okHttpClient = client.newBuilder()
+        .addInterceptor { chain ->
+            val builder = chain.request().newBuilder()
+            builder.addHeader("Authorization", Credentials.basic(username, password))
+            builder.addHeader("Accept", "application/json")
+            builder.addHeader("Content-Type", "application/json")
+            builder.addHeader("User-Agent", "vespene")
+            chain.proceed(builder.build())
+        }.build()
+
+    ZipInputStream(inputFile.inputStream()).use {
+        while (true) {
+            val entry = it.nextEntry ?: break
+            if (entry.isDirectory) continue
+            val relativePath = entry.name
+            logger.lifecycle("Nmcp: uploading $relativePath...")
+
+            val url = "https://central.sonatype.com/repository/maven-snapshots/$relativePath"
+            val request = Request.Builder()
+                .put(it.source().buffer().readByteArray().toRequestBody("application/octet-stream".toMediaType()))
+                .url(url)
+                .build()
+
+            val uploadResponse = okHttpClient.newCall(request).execute()
+            check(uploadResponse.isSuccessful) {
+                "Cannot put $url:\n${uploadResponse.body?.string()}"
+            }
+        }
+    }
+}

tests/README.md

@@ -7,7 +7,12 @@ Integration tests that check the contents of the zip bundle. To run from the roo
 ./gradlew -p tests/kmp build
 ```
 
-* `tests/jvm` can be used to deploy to the real Central Portal.
+* `tests/jvm` can be used to deploy to the real Central Portal:
+
+```shell
+./gradlew -p tests/jvm publishAggregationToCentralPortal
+./gradlew -p tests/jvm publishAggregationToCentralSnapshots
+```
 * `tests/kmp` uses a mockserver to verify the contents uploaded without having to do a real upload every time.
 
-Open `tests/kmp` or `tests/jvm` in IntelliJ for development 
+Open `tests/kmp` or `tests/jvm` in IntelliJ for development 

tests/jvm/build.gradle.kts

@@ -91,6 +91,11 @@ extensions.getByType<NmcpAggregationExtension>().apply {
     }
 }
 
+/**
+ * A task that checks that the zip file generated by the aggregation plugin contains the expected files.
+ *
+ * This task assumes that no signing key is present (GPG_PRIVATE_KEY must be empty). If it fails, double check your environment variables.
+ */
 val checkZip = tasks.register("checkZip") {
     inputs.file(tasks.named("zipAggregation").flatMap { (it as Zip).archiveFile })