Add feature "wait until callback" to process class

Nek- · Nek- · commit 2f6a96ece45c · 2018-10-05T09:40:07.000+02:00
A feature for waiting the process to complete is already present,
but in some cases you may want to just wait for the process to be ready.

This kind of process generaly output things when they are ready. With
this feature you will be able to (for example) wait until the process
is ready.
diff --git a/src/Symfony/Component/Process/Process.php b/src/Symfony/Component/Process/Process.php
@@ -429,6 +429,45 @@ public function wait(callable $callback = null)
         return $this->exitcode;
     }
 
+    /**
+     * Waits until the callback return true.
+     *
+     * The callback receives the type of output (out or err) and some bytes
+     * from the output in real-time while writing the standard input to the process.
+     * It allows to have feedback from the independent process during execution.
+     *
+     * @param callable $callback
+     *
+     * @throws RuntimeException When process timed out
+     * @throws LogicException   When process is not yet started
+     */
+    public function waitUntil(callable $callback)
+    {
+        $this->requireProcessIsStarted(__FUNCTION__);
+        $this->updateStatus(false);
+
+        if (!$this->processPipes->haveReadSupport()) {
+            $this->stop(0);
+            throw new \LogicException('Pass the callback to the Process::start method or enableOutput to use a callback with Process::waitUntil');
+        }
+        $callback = $this->buildCallback($callback);
+
+        $wait = true;
+        do {
+            $this->checkTimeout();
+            $running = '\\' === DIRECTORY_SEPARATOR ? $this->isRunning() : $this->processPipes->areOpen();
+            $output = $this->processPipes->readAndWrite($running, '\\' !== DIRECTORY_SEPARATOR || !$running);
+
+            foreach ($output as $type => $data) {
+                if (3 !== $type) {
+                    $wait = !$callback(self::STDOUT === $type ? self::OUT : self::ERR, $data);
+                } elseif (!isset($this->fallbackStatus['signaled'])) {
+                    $this->fallbackStatus['exitcode'] = (int) $data;
+                }
+            }
+        } while ($wait);
+    }
+
     /**
      * Returns the Pid (process identifier), if applicable.
      *
@@ -1264,7 +1303,7 @@ protected function buildCallback(callable $callback = null)
         if ($this->outputDisabled) {
             return function ($type, $data) use ($callback) {
                 if (null !== $callback) {
-                    \call_user_func($callback, $type, $data);
+                    return $callback($type, $data);
                 }
             };
         }
@@ -1279,7 +1318,7 @@ protected function buildCallback(callable $callback = null)
             }
 
             if (null !== $callback) {
-                \call_user_func($callback, $type, $data);
+                return $callback($type, $data);
             }
         };
     }
diff --git a/src/Symfony/Component/Process/Tests/KillableProcessWithOutput.php b/src/Symfony/Component/Process/Tests/KillableProcessWithOutput.php
@@ -0,0 +1,26 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+$outputs = array(
+    'First iteration output',
+    'Second iteration output',
+    'One more iteration output',
+    'This took more time',
+    'This one was sooooo slow',
+);
+
+$iterationTime = 10000;
+
+foreach ($outputs as $output) {
+    usleep($iterationTime);
+    $iterationTime *= 10;
+    echo $output."\n";
+}
diff --git a/src/Symfony/Component/Process/Tests/ProcessTest.php b/src/Symfony/Component/Process/Tests/ProcessTest.php
@@ -133,6 +133,28 @@ public function testStopWithTimeoutIsActuallyWorking()
         $this->assertLessThan(15, microtime(true) - $start);
     }
 
+    public function testWaitUntilSpecificOutput()
+    {
+        $p = $this->getProcess(array(self::$phpBin, __DIR__.'/KillableProcessWithOutput.php'));
+        $p->start();
+
+        $start = microtime(true);
+
+        $completeOutput = '';
+        $p->waitUntil(function ($type, $output) use (&$completeOutput) {
+            $completeOutput .= $output;
+            if (false !== strpos($output, 'One more')) {
+                return true;
+            }
+
+            return false;
+        });
+        $p->stop();
+
+        $this->assertEquals("First iteration output\nSecond iteration output\nOne more iteration output\n", $completeOutput);
+        $this->assertLessThan(2, microtime(true) - $start);
+    }
+
     public function testAllOutputIsActuallyReadOnTermination()
     {
         // this code will result in a maximum of 2 reads of 8192 bytes by calling
