Make uploading snapshots less verbose

nmcp/api/nmcp.api

@@ -72,13 +72,13 @@ public final class nmcp/internal/task/MetadataKt {
 	public static final fun getXml ()Lkotlinx/serialization/StringFormat;
 }
 
-public final class nmcp/internal/task/NmcpPublishFileByFileEntryPoint {
-	public static final field Companion Lnmcp/internal/task/NmcpPublishFileByFileEntryPoint$Companion;
+public final class nmcp/internal/task/NmcpPublishFileByFileToSnapshotsEntryPoint {
+	public static final field Companion Lnmcp/internal/task/NmcpPublishFileByFileToSnapshotsEntryPoint$Companion;
 	public fun <init> ()V
 	public static final fun run (Ljava/util/function/BiConsumer;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/util/List;)V
 }
 
-public final class nmcp/internal/task/NmcpPublishFileByFileEntryPoint$Companion {
+public final class nmcp/internal/task/NmcpPublishFileByFileToSnapshotsEntryPoint$Companion {
 	public final fun run (Ljava/util/function/BiConsumer;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/util/List;)V
 }
 

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

@@ -0,0 +1,40 @@
+package nmcp.internal.task
+
+import gratatouille.tasks.GInputFiles
+import gratatouille.tasks.GLogger
+import gratatouille.tasks.GTask
+import nmcp.transport.HttpTransport
+import nmcp.transport.publishFileByFile
+import okhttp3.Credentials
+
+@GTask(pure = false)
+internal fun nmcpPublishFileByFileToSnapshots(
+    logger: GLogger,
+    snapshotsUrl: String,
+    username: String?,
+    password: String?,
+    inputFiles: GInputFiles,
+) {
+    val authorizationHeader = if (username != null) {
+        check(!password.isNullOrBlank()) {
+            "Nmcp: password is missing"
+        }
+        /**
+         * Should this be "Basic ${Credentials.basic(username, password)}"?
+         * I can't find a good reference on this
+         */
+        Credentials.basic(username, password)
+    } else {
+        null
+    }
+
+    val transport = HttpTransport(
+        baseUrl = snapshotsUrl,
+        getAuthorization = null,
+        putAuthorization = authorizationHeader,
+        logger = logger,
+    )
+
+    logger.lifecycle("Nmcp: uploading files to $snapshotsUrl")
+    publishFileByFile(transport, inputFiles)
+}

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

@@ -166,7 +166,7 @@ private fun verifyStatus(
 ): Status {
     Request.Builder()
         .post(ByteString.EMPTY.toRequestBody())
-        .addHeader("Authorization", "UserToken $token")
+        .addHeader("Authorization", "Bearer $token")
         .url(baseUrl + "api/v1/publisher/status?id=$deploymentId")
         .build()
         .let {

nmcp/src/main/kotlin/nmcp/internal/utils.kt

@@ -3,7 +3,7 @@ package nmcp.internal
 import gratatouille.wiring.capitalizeFirstLetter
 import nmcp.CentralPortalOptions
 import nmcp.internal.task.NmcpPublishWithPublisherApiTask
-import nmcp.internal.task.registerNmcpPublishFileByFileTask
+import nmcp.internal.task.registerNmcpPublishFileByFileToSnapshotsTask
 import nmcp.internal.task.registerNmcpPublishWithPublisherApiTask
 import org.gradle.api.Action
 import org.gradle.api.Named
@@ -82,11 +82,11 @@ internal fun Project.registerPublishToCentralPortalTasks(
         }
     }
 
-    val snapshots = registerNmcpPublishFileByFileTask(
+    val snapshots = registerNmcpPublishFileByFileToSnapshotsTask(
         taskName = snapshotTaskName,
         username = spec.username,
         password = spec.password,
-        url = project.provider { "https://central.sonatype.com/repository/maven-snapshots/" },
+        snapshotsUrl = project.provider { "https://central.sonatype.com/repository/maven-snapshots/" },
         inputFiles = inputFiles,
     )
     if (snapshotsLifecycleTaskName != null) {

nmcp/src/main/kotlin/nmcp/transport/transport.kt

@@ -49,22 +49,21 @@ interface Content {
     fun writeTo(sink: BufferedSink)
 }
 
-internal class NmcpCredentials(val username: String, val password: String)
+private fun Request.Builder.maybeAddAuthorization(authorization: String?) = apply {
+    if (authorization != null) {
+        addHeader("Authorization", authorization)
+    }
+}
 
 internal class HttpTransport(
     baseUrl: String,
-    private val credentials: NmcpCredentials?,
+    private val getAuthorization: String?,
+    private val putAuthorization: String?,
     private val logger: GLogger,
 ) : Transport {
     private val client = nmcp.internal.task.nmcpClient.newBuilder()
         .addInterceptor { chain ->
             val builder = chain.request().newBuilder()
-            if (credentials != null) {
-                builder.addHeader(
-                    "Authorization",
-                    Credentials.basic(credentials.username, credentials.password),
-                )
-            }
             builder.addHeader("Accept", "application/json")
             builder.addHeader("User-Agent", "nmcp")
             chain.proceed(builder.build())
@@ -78,11 +77,12 @@ internal class HttpTransport(
             .addPathSegments(path)
             .build()
 
-        logger.lifecycle("Nmcp: get '$url'")
+        logger.info("Nmcp: get '$url'")
 
         val response = Request.Builder()
             .get()
             .url(url)
+            .maybeAddAuthorization(getAuthorization)
             .build()
             .let {
                 client.newCall(it).execute()
@@ -103,11 +103,12 @@ internal class HttpTransport(
             .addPathSegments(path)
             .build()
 
-        logger.lifecycle("Nmcp: put '$url'")
+        logger.info("Nmcp: put '$url'")
 
         val response = Request.Builder()
             .put(body.toRequestBody())
             .url(url)
+            .maybeAddAuthorization(putAuthorization)
             .build()
             .let {
                 client.newCall(it).execute()