Add and use ProcessUtil

Author: Lipen

buildSrc/src/main/kotlin/ProcessUtil.kt

@@ -0,0 +1,93 @@
+import java.io.Reader
+import java.time.Duration
+import java.util.concurrent.TimeUnit
+import kotlin.concurrent.thread
+
+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: String? = null,
+        timeout: Duration? = null,
+        builder: ProcessBuilder.() -> Unit = {},
+    ): Result {
+        val reader = input?.reader() ?: "".reader()
+        return run(command, reader, timeout, builder)
+    }
+
+    fun run(
+        command: List<String>,
+        input: 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?,
+    ): Result {
+        // Handle process input (stdin)
+        val stdinThread = thread {
+            process.outputStream.bufferedWriter().use { writer ->
+                input.copyTo(writer)
+                writer.flush()
+            }
+        }
+
+        // Capture process output (stdout)
+        val stdout = StringBuilder()
+        val stdoutThread = thread {
+            process.inputStream.bufferedReader().useLines { lines ->
+                lines.forEach { stdout.appendLine(it) }
+            }
+        }
+
+        // Capture process error output (stderr)
+        val stderr = StringBuilder()
+        val stderrThread = thread {
+            process.errorStream.bufferedReader().useLines { lines ->
+                lines.forEach { stderr.appendLine(it) }
+            }
+        }
+
+        // Start all threads
+        stdinThread.start()
+        stdoutThread.start()
+        stderrThread.start()
+
+        // Wait for completion
+        val isTimeout = if (timeout != null) {
+            !process.waitFor(timeout.toMillis(), TimeUnit.MILLISECONDS)
+        } else {
+            process.waitFor()
+            false
+        }
+
+        // If timeout occurred, destroy the process forcibly
+        if (isTimeout) {
+            process.destroyForcibly()
+        }
+
+        // Wait for stream threads to finish
+        stdinThread.join()
+        stdoutThread.join()
+        stderrThread.join()
+
+        return Result(
+            exitCode = if (isTimeout) -1 else process.exitValue(),
+            stdout = stdout.toString(),
+            stderr = stderr.toString(),
+            isTimeout = isTimeout
+        )
+    }
+}

jacodb-ets/build.gradle.kts

@@ -93,21 +93,20 @@ tasks.register("generateTestResources") {
             "-t",
         )
         println("Running: '${cmd.joinToString(" ")}'")
-        val process = ProcessBuilder(cmd).directory(resources).start()
-        val ok = process.waitFor(10, TimeUnit.MINUTES)
-
-        val stdout = process.inputStream.bufferedReader().readText().trim()
-        if (stdout.isNotBlank()) {
-            println("[STDOUT]:\n--------\n$stdout\n--------")
+        val result = ProcessUtil.run(cmd) {
+            directory(resources)
         }
-        val stderr = process.errorStream.bufferedReader().readText().trim()
-        if (stderr.isNotBlank()) {
-            println("[STDERR]:\n--------\n$stderr\n--------")
+        if (result.stdout.isNotBlank()) {
+            println("[STDOUT]:\n--------\n${result.stdout}\n--------")
         }
-
-        if (!ok) {
+        if (result.stderr.isNotBlank()) {
+            println("[STDERR]:\n--------\n${result.stderr}\n--------")
+        }
+        if (result.isTimeout) {
             println("Timeout!")
-            process.destroy()
+        }
+        if (result.exitCode != 0) {
+            println("Exit code: ${result.exitCode}")
         }
 
         println("Done generating test resources in %.1fs".format((System.currentTimeMillis() - startTime) / 1000.0))