Added some callbacks to the manager.

Changed pollInterval to milliseconds.

Author: BluePsyduck

src/ProcessManager.php

@@ -21,7 +21,7 @@ class ProcessManager
     protected $numberOfParallelProcesses;
 
     /**
-     * The interval to wait between the polls of the processes, in microseconds.
+     * The interval to wait between the polls of the processes, in milliseconds.
      * @var int
      */
     protected $pollInterval;
@@ -38,26 +38,110 @@ class ProcessManager
      */
     protected $runningProcesses = [];
 
+    /**
+     * The callback for when a process is about to be started.
+     * @var callable|null
+     */
+    protected $processStartCallback;
+
+    /**
+     * The callback for when a process has finished.
+     * @var callable|null
+     */
+    protected $processFinishCallback;
+
+    /**
+     * The callback for when a process has successfully finished with exit code 0.
+     * @var callable|null
+     */
+    protected $processSuccessCallback;
+
+    /**
+     * The callback for when a process has failed to finish with exit code 0.
+     * @var callable|null
+     */
+    protected $processFailCallback;
+
     /**
      * ProcessManager constructor.
      * @param int $numberOfParallelProcesses The number of processes to run in parallel.
-     * @param int $pollInterval The interval to wait between the polls of the processes, in microseconds.
+     * @param int $pollInterval The interval to wait between the polls of the processes, in milliseconds.
      */
-    public function __construct(int $numberOfParallelProcesses = 1, int $pollInterval = 1000)
+    public function __construct(int $numberOfParallelProcesses = 1, int $pollInterval = 100)
     {
         $this->numberOfParallelProcesses = $numberOfParallelProcesses;
         $this->pollInterval = $pollInterval;
     }
 
+    /**
+     * Sets the callback for when a process is about to be started.
+     * @param callable|null $processStartCallback The callback, accepting a Process as only argument.
+     * @return $this
+     */
+    public function setProcessStartCallback(?callable $processStartCallback)
+    {
+        $this->processStartCallback = $processStartCallback;
+        return $this;
+    }
+
+    /**
+     * Sets the callback for when a process has finished.
+     * @param callable|null $processFinishCallback The callback, accepting a Process as only argument.
+     * @return $this
+     */
+    public function setProcessFinishCallback(?callable $processFinishCallback)
+    {
+        $this->processFinishCallback = $processFinishCallback;
+        return $this;
+    }
+
+    /**
+     * Sets the callback for when a process has failed to finish with exit code 0.
+     * @param callable|null $processSuccessCallback The callback, accepting a Process as only argument.
+     * @return $this
+     */
+    public function setProcessSuccessCallback(?callable $processSuccessCallback)
+    {
+        $this->processSuccessCallback = $processSuccessCallback;
+        return $this;
+    }
+
+    /**
+     * Sets the callback for when a process has successfully finished with exit code 0.
+     * @param callable|null $processFailCallback The callback, accepting a Process as only argument.
+     * @return $this
+     */
+    public function setProcessFailCallback(?callable $processFailCallback)
+    {
+        $this->processFailCallback = $processFailCallback;
+        return $this;
+    }
+
+    /**
+     * Invokes the callback if it is an callable.
+     * @param callable|null $callback
+     * @param Process $process
+     */
+    protected function invokeCallback(?callable $callback, Process $process): void
+    {
+        if (is_callable($callback)) {
+            $callback($process);
+        }
+    }
+
     /**
      * Adds a process to the manager.
      * @param Process $process
+     * @param callable|null $callback
+     * @param array $env
+     * @return $this
      */
-    public function addProcess(Process $process, callable $callback = null, array $env = []): void
+    public function addProcess(Process $process, callable $callback = null, array $env = [])
     {
         $this->pendingProcessData[] = [$process, $callback, $env];
         $this->executeNextPendingProcess();
         $this->checkRunningProcesses();
+        return $this;
     }
 
     /**
@@ -68,6 +152,7 @@ protected function executeNextPendingProcess(): void
         if ($this->canExecuteNextPendingRequest()) {
             list($process, $callback, $env) = array_shift($this->pendingProcessData);
             /* @var Process $process */
+            $this->invokeCallback($this->processStartCallback, $process);
             $process->start($callback, $env);
             $this->runningProcesses[$process->getPid()] = $process;
         }
@@ -88,32 +173,49 @@ protected function canExecuteNextPendingRequest(): bool
      */
     protected function checkRunningProcesses(): void
     {
-        foreach ($this->runningProcesses as $pid => $process) {
-            $process->checkTimeout();
-            if (!$process->isRunning()) {
-                unset($this->runningProcesses[$pid]);
-                $this->executeNextPendingProcess();
-            }
+        foreach ($this->runningProcesses as $process) {
+            $this->checkRunningProcess($process);
+        }
+    }
+
+    /**
+     * Checks the process whether it has finished.
+     * @param Process $process
+     */
+    protected function checkRunningProcess(Process $process): void
+    {
+        $process->checkTimeout();
+        if (!$process->isRunning()) {
+            $this->invokeCallback(
+                $process->isSuccessful() ? $this->processSuccessCallback : $this->processFailCallback,
+                $process
+            );
+            $this->invokeCallback($this->processFinishCallback, $process);
+
+            unset($this->runningProcesses[$process->getPid()]);
+            $this->executeNextPendingProcess();
         }
     }
 
     /**
      * Waits for all processes to be finished.
+     * @return $this
      */
-    public function waitForAllProcesses(): void
+    public function waitForAllProcesses()
     {
         while ($this->hasUnfinishedProcesses()) {
             $this->sleep();
             $this->checkRunningProcesses();
         }
+        return $this;
     }
 
     /**
      * Sleeps for the next poll.
      */
     protected function sleep(): void
     {
-        usleep($this->pollInterval);
+        usleep($this->pollInterval * 1000);
     }
 
     /**