Fix starting stream consumer

Author: kaklakariada

product/src/test/java/org/itsallcode/openfasttrace/cli/JarLauncher.java

@@ -47,7 +47,8 @@ public static JarLauncher start(final Path workingDir, final List<String> args)
         try
         {
             final Process process = processBuilder.start();
-            final ProcessOutputConsumer consumer = new ProcessOutputConsumer(process);
+            final ProcessOutputConsumer consumer = new ProcessOutputConsumer(process, Duration.ofSeconds(1));
+            consumer.start();
             return new JarLauncher(process, consumer);
         }
         catch (final IOException exception)
@@ -79,14 +80,15 @@ private static Path getJavaExecutable()
     void waitUntilTerminated(final Duration timeout)
     {
         waitForProcessTerminated(timeout);
-        LOG.fine("Process terminated with exit code %d".formatted(exitValue()));
-        consumer.waitForStreamsClosed(timeout);
+        LOG.fine("Process %d terminated with exit code %d".formatted(process.pid(), exitValue()));
+        consumer.waitForStreamsClosed();
     }
 
     private void waitForProcessTerminated(final Duration timeout)
     {
         try
         {
+            LOG.finest("Waiting %s for process %d to terminate...".formatted(timeout, process.pid()));
             if (!process.waitFor(timeout.toMillis(), TimeUnit.MILLISECONDS))
             {
                 throw new IllegalStateException(
@@ -96,6 +98,8 @@ private void waitForProcessTerminated(final Duration timeout)
         catch (final InterruptedException exception)
         {
             Thread.currentThread().interrupt();
+            throw new IllegalStateException("Interrupted while waiting %s for process to finish".formatted(timeout),
+                    exception);
         }
     }
 

product/src/test/java/org/itsallcode/openfasttrace/cli/ProcessOutputConsumer.java

@@ -16,9 +16,10 @@ class ProcessOutputConsumer
     private final ProcessStreamConsumer stdOutConsumer;
     private final ProcessStreamConsumer stdErrConsumer;
 
-    ProcessOutputConsumer(final Process process)
+    ProcessOutputConsumer(final Process process, final Duration streamCloseTimeout)
     {
-        this(createThreadExecutor(), process, new ProcessStreamConsumer("stdout"), new ProcessStreamConsumer("stderr"));
+        this(createThreadExecutor(), process, new ProcessStreamConsumer("stdout", streamCloseTimeout),
+                new ProcessStreamConsumer("stderr", streamCloseTimeout));
     }
 
     ProcessOutputConsumer(final Executor executor, final Process process,
@@ -42,6 +43,7 @@ private static Executor createThreadExecutor()
 
     void start()
     {
+        LOG.finest("Start reading stdout and stderr streams in background...");
         executor.execute(() -> {
             readStream(process.getInputStream(), stdOutConsumer);
         });
@@ -55,10 +57,12 @@ private void readStream(final InputStream stream, final ProcessStreamConsumer co
         try (final BufferedReader reader = new BufferedReader(new InputStreamReader(stream, StandardCharsets.UTF_8)))
         {
             String line = null;
+            LOG.finest("Start reading from '%s' stream...".formatted(consumer.name));
             while ((line = reader.readLine()) != null)
             {
                 consumer.accept(line);
             }
+            LOG.finest("Stream '%s' finished".formatted(consumer.name));
             consumer.streamFinished();
         }
         catch (final IOException exception)
@@ -78,21 +82,23 @@ String getStdErr()
         return stdErrConsumer.getContent();
     }
 
-    void waitForStreamsClosed(final Duration timeout)
+    void waitForStreamsClosed()
     {
-        stdOutConsumer.waitUntilStreamClosed(timeout);
-        stdErrConsumer.waitUntilStreamClosed(timeout);
+        stdOutConsumer.waitUntilStreamClosed();
+        stdErrConsumer.waitUntilStreamClosed();
     }
 
     private static class ProcessStreamConsumer
     {
         private final CountDownLatch streamFinished = new CountDownLatch(1);
         private final StringBuilder builder = new StringBuilder();
         private final String name;
+        private final Duration streamCloseTimeout;
 
-        ProcessStreamConsumer(final String name)
+        ProcessStreamConsumer(final String name, final Duration streamCloseTimeout)
         {
             this.name = name;
+            this.streamCloseTimeout = streamCloseTimeout;
         }
 
         String getContent()
@@ -111,12 +117,17 @@ void accept(final String line)
             builder.append(line).append("\n");
         }
 
-        void waitUntilStreamClosed(final Duration timeout)
+        void waitUntilStreamClosed()
         {
-            if (!await(timeout))
+            LOG.finest("Waiting %s for stream '%s' to close".formatted(streamCloseTimeout, name));
+            if (!await(streamCloseTimeout))
             {
                 throw new IllegalStateException(
-                        "Stream '%s' not closed within timeout of %s".formatted(name, timeout));
+                        "Stream '%s' not closed within timeout of %s".formatted(name, streamCloseTimeout));
+            }
+            else
+            {
+                LOG.finest("Stream '%s' closed".formatted(name));
             }
         }
 
@@ -129,7 +140,8 @@ private boolean await(final Duration timeout)
             catch (final InterruptedException exception)
             {
                 Thread.currentThread().interrupt();
-                throw new IllegalStateException("Interrupted while waiting for stream to be closed", exception);
+                throw new IllegalStateException("Interrupted while waiting for stream '%s' to be closed: %s"
+                        .formatted(name, exception.getMessage()), exception);
             }
         }
     }