Move ProcessUtil, customize builder

Author: Lipen

buildSrc/src/main/kotlin/ProcessUtil.kt

@@ -1,5 +1,12 @@
 import com.github.gradle.node.npm.task.NpmTask
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.joinAll
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.runBlocking
 import java.io.FileNotFoundException
+import java.io.Reader
+import kotlin.time.Duration
 import kotlin.time.Duration.Companion.minutes
 
 plugins {
@@ -87,23 +94,92 @@ tasks.register("generateTestResources") {
             outputDir.relativeTo(resources).path,
             "-t",
         )
-        println("Running: '${cmd.joinToString(" ")}'")
+        logger.lifecycle("Running command: ${cmd.joinToString(" ")}")
         val result = ProcessUtil.run(cmd, timeout = 1.minutes) {
             directory(resources)
         }
         if (result.stdout.isNotBlank()) {
-            println("[STDOUT]:\n--------\n${result.stdout}\n--------")
+            logger.lifecycle("[STDOUT]:\n--------\n${result.stdout}\n--------")
         }
         if (result.stderr.isNotBlank()) {
-            println("[STDERR]:\n--------\n${result.stderr}\n--------")
+            logger.lifecycle("[STDERR]:\n--------\n${result.stderr}\n--------")
         }
         if (result.isTimeout) {
-            println("Timeout!")
+            logger.warn("Timeout!")
         }
         if (result.exitCode != 0) {
-            println("Exit code: ${result.exitCode}")
+            logger.warn("Exit code: ${result.exitCode}")
         }
 
         println("Done generating test resources in %.1fs".format((System.currentTimeMillis() - startTime) / 1000.0))
     }
 }
+
+object ProcessUtil {
+    data class Result(
+        val exitCode: Int,
+        val stdout: String,
+        val stderr: String,
+        val isTimeout: Boolean, // true if the process was terminated due to timeout
+    )
+
+    fun run(
+        command: List<String>,
+        input: Reader = "".reader(),
+        timeout: Duration? = null,
+        builder: ProcessBuilder.() -> Unit = {},
+    ): Result {
+        val process = ProcessBuilder(command).apply(builder).start()
+        return communicate(process, input, timeout)
+    }
+
+    private fun communicate(
+        process: Process,
+        input: Reader,
+        timeout: Duration? = null,
+    ): Result {
+        val stdout = StringBuilder()
+        val stderr = StringBuilder()
+
+        val scope = CoroutineScope(Dispatchers.IO)
+
+        // Handle process input
+        val stdinJob = scope.launch {
+            process.outputStream.bufferedWriter().use { writer ->
+                input.copyTo(writer)
+            }
+        }
+
+        // Launch output capture coroutines
+        val stdoutJob = scope.launch {
+            process.inputStream.bufferedReader().useLines { lines ->
+                lines.forEach { stdout.appendLine(it) }
+            }
+        }
+        val stderrJob = scope.launch {
+            process.errorStream.bufferedReader().useLines { lines ->
+                lines.forEach { stderr.appendLine(it) }
+            }
+        }
+
+        // Wait for completion
+        val isTimeout = if (timeout != null) {
+            !process.waitFor(timeout.inWholeNanoseconds, TimeUnit.NANOSECONDS)
+        } else {
+            process.waitFor()
+            false
+        }
+
+        // Wait for all coroutines to finish
+        runBlocking {
+            joinAll(stdinJob, stdoutJob, stderrJob)
+        }
+
+        return Result(
+            exitCode = process.exitValue(),
+            stdout = stdout.toString(),
+            stderr = stderr.toString(),
+            isTimeout = isTimeout,
+        )
+    }
+}

jacodb-ets/build.gradle.kts

@@ -18,6 +18,7 @@ package org.jacodb.ets.utils
 
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.joinAll
 import kotlinx.coroutines.launch
 import kotlinx.coroutines.runBlocking
 import mu.KotlinLogging
@@ -37,20 +38,12 @@ object ProcessUtil {
 
     fun run(
         command: List<String>,
-        input: String? = null,
-        timeout: Duration? = null,
-    ): Result {
-        val reader = input?.reader() ?: "".reader()
-        return run(command, reader, timeout)
-    }
-
-    fun run(
-        command: List<String>,
-        input: Reader,
+        input: Reader = "".reader(),
         timeout: Duration? = null,
+        builder: ProcessBuilder.() -> Unit = {},
     ): Result {
         logger.debug { "Running command: $command" }
-        val process = ProcessBuilder(command).start()
+        val process = ProcessBuilder(command).apply(builder).start()
         return communicate(process, input, timeout)
     }
 
@@ -90,10 +83,10 @@ object ProcessUtil {
             process.waitFor()
             false
         }
+
+        // Wait for all coroutines to finish
         runBlocking {
-            stdinJob.join()
-            stdoutJob.join()
-            stderrJob.join()
+            joinAll(stdinJob, stdoutJob, stderrJob)
         }
 
         return Result(