Supervisor plugin

src/Internal/ServerStatus/ServerStatus.php

@@ -136,7 +136,7 @@ public function addWorker(ProcessInterface $worker): void
             $this->workerProcesses[$worker->getId()] = new WorkerProcessInfo(
                 user: $worker->getUser(),
                 name: $worker->getName(),
-                count: $worker->count,
+                count: $worker->getProcessCount(),
             );
         } elseif($worker instanceof PeriodicProcessInterface) {
             $this->periodicProcesses[$worker->getId()] = new PeriodicProcessInfo(

src/Internal/Supervisor/Supervisor.php

@@ -64,7 +64,7 @@ private function spawnWorkers(): void
     {
         EventLoop::queue(function (): void {
             foreach ($this->workerPool->getRegisteredWorkers() as $worker) {
-                while (\iterator_count($this->workerPool->getAliveWorkerPids($worker)) < $worker->count) {
+                while (\iterator_count($this->workerPool->getAliveWorkerPids($worker)) < $worker->getProcessCount()) {
                     if ($this->spawnWorker($worker)) {
                         return;
                     }
@@ -122,7 +122,11 @@ private function onChildStop(int $pid, int $exitCode): void
                     default => $this->logger->warning(\sprintf('Worker %s[pid:%d] exit with code %s', $worker->getName(), $pid, $exitCode)),
                 };
                 // Restart worker
-                $this->spawnWorker($worker);
+                if (0 < $delay = $worker->getProcessRestartDelay()) {
+                    EventLoop::delay($delay, function () use ($worker) { $this->spawnWorker($worker); });
+                } else {
+                    $this->spawnWorker($worker);
+                }
                 break;
             case Status::SHUTDOWN:
                 if ($this->workerPool->getProcessesCount() === 0) {

src/Internal/Supervisor/WorkerPool.php

@@ -65,6 +65,7 @@ public function getWorkerByPid(int $pid): WorkerProcessInterface|null
 
     /**
      * @return \Iterator<WorkerProcessInterface>
+     * @psalm-return iterable<WorkerProcessInterface>
      */
     public function getRegisteredWorkers(): \Iterator
     {

src/Plugin/Supervisor/Supervisor.php

@@ -0,0 +1,77 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Luzrain\PHPStreamServer\Plugin\Supervisor;
+
+use Amp\Future;
+use Luzrain\PHPStreamServer\Internal\MasterProcess;
+use Luzrain\PHPStreamServer\Plugin\PluginInterface;
+use Luzrain\PHPStreamServer\WorkerProcess;
+use function Amp\async;
+
+final readonly class Supervisor implements PluginInterface
+{
+    /**
+     * @param string|\Closure(WorkerProcess): void $command bash command as string or php closure
+     */
+    public function __construct(
+        private string|\Closure $command,
+        private string|null $name = null,
+        private int $count = 1,
+        private float $restartDelay = 0.5,
+        private bool $reloadable = true,
+        private string|null $user = null,
+        private string|null $group = null,
+    ) {
+    }
+
+    public function start(MasterProcess $masterProcess): void
+    {
+        $name = match (true) {
+            $this->name === null && \is_string($this->command) => $this->command,
+            $this->name === null => 'closure',
+            default => $this->name,
+        };
+
+        $masterProcess->addWorker(new WorkerProcess(
+            name: $name,
+            count: $this->count,
+            reloadable: $this->reloadable,
+            restartDelay: $this->restartDelay,
+            user: $this->user,
+            group: $this->group,
+            onStart: function (WorkerProcess $worker) {
+                if (\is_string($this->command)) {
+                    $worker->exec(...$this->prepareCommand($this->command));
+                } else {
+                    ($this->command)($worker);
+                }
+            },
+        ));
+    }
+
+    /**
+     * @return array{0: string, 1: list<string>}
+     */
+    private function prepareCommand(string $command): array
+    {
+        \preg_match_all('/\'[^\']*\'|"[^"]*"|\S+/', $command, $matches);
+        $parts = \array_map(static fn (string $part) => \trim($part, '"\''), $matches[0]);
+        $binary = \array_shift($parts);
+        $args = $parts;
+
+        if (!\str_starts_with($binary, '/')) {
+            if (\is_string($absoluteBinaryPath = \shell_exec("command -v $binary"))) {
+                $binary = \trim($absoluteBinaryPath);
+            }
+        }
+
+        return [$binary, $args];
+    }
+
+    public function stop(): Future
+    {
+        return async(static fn() => null);
+    }
+}

src/WorkerProcess.php

@@ -41,8 +41,9 @@ final class WorkerProcess implements WorkerProcessInterface, ReloadStrategyAware
      */
     public function __construct(
         string $name = 'none',
-        public readonly int $count = 1,
+        private readonly int $count = 1,
         private readonly bool $reloadable = true,
+        private readonly float $restartDelay = 0,
         string|null $user = null,
         string|null $group = null,
         private \Closure|null $onStart = null,
@@ -174,4 +175,14 @@ public function getTrafficStatus(): TrafficStatus
     {
         return $this->trafficStatus;
     }
+
+    public function getProcessCount(): int
+    {
+        return $this->count;
+    }
+
+    public function getProcessRestartDelay(): float
+    {
+        return $this->restartDelay;
+    }
 }

src/WorkerProcessInterface.php

@@ -25,4 +25,14 @@ public function reload(): void;
      * Start worker module in this worker
      */
     public function startWorkerModule(WorkerModule $module): void;
+
+    /**
+     * Count of processes
+     */
+    public function getProcessCount(): int;
+
+    /**
+     * Delay in seconds between processes restart
+     */
+    public function getProcessRestartDelay(): float;
 }