Next major release

.github/workflows/ci.yml

@@ -16,5 +16,3 @@ jobs:
     uses: innmind/github-workflows/.github/workflows/psalm-matrix.yml@main
   cs:
     uses: innmind/github-workflows/.github/workflows/cs.yml@main
-    with:
-      php-version: '8.2'

.github/workflows/extensive.yml

@@ -0,0 +1,12 @@
+name: Extensive CI
+
+on:
+  push:
+    tags:
+      - '*'
+    paths:
+      - '.github/workflows/extensive.yml'
+
+jobs:
+  blackbox:
+    uses: innmind/github-workflows/.github/workflows/extensive.yml@main

CHANGELOG.md

@@ -1,5 +1,15 @@
 # Changelog
 
+## [Unreleased]
+
+### Changed
+
+- Requires PHP `8.4`
+- `Innmind\Server\Control\Server` is now a final class, all previous implementations are now flagged as internal
+- `Innmind\Server\Control\Server\Volumes` is now a final class
+- `Innmind\Server\Control\Server\Processes` is now a final class
+- Requires `innmind/time:~1.0`
+
 ## 6.1.0 - 2025-08-06
 
 ### Added

blackbox.php

@@ -10,6 +10,10 @@
 };
 
 Application::new($argv)
+    ->when(
+        \getenv('BLACKBOX_SET_SIZE') !== false,
+        static fn(Application $app) => $app->scenariiPerProof((int) \getenv('BLACKBOX_SET_SIZE')),
+    )
     ->when(
         \getenv('ENABLE_COVERAGE') !== false,
         static fn(Application $app) => $app

composer.json

@@ -14,14 +14,13 @@
         "issues": "http://github.com/Innmind/ServerControl/issues"
     },
     "require": {
-        "php": "~8.2",
-        "innmind/immutable": "~5.12",
-        "innmind/url": "~4.0",
+        "php": "~8.4",
+        "innmind/immutable": "~6.0",
+        "innmind/url": "~5.0",
         "psr/log": "~3.0",
-        "innmind/time-continuum": "^4.1.1",
-        "innmind/filesystem": "~8.0",
-        "innmind/time-warp": "~4.0",
-        "innmind/io": "~3.1"
+        "innmind/time": "~1.0",
+        "innmind/filesystem": "~9.0",
+        "innmind/io": "~4.0"
     },
     "autoload": {
         "psr-4": {
@@ -34,7 +33,7 @@
         }
     },
     "require-dev": {
-        "innmind/static-analysis": "^1.2.1",
+        "innmind/static-analysis": "~1.3",
         "innmind/black-box": "~6.5",
         "innmind/coding-standard": "~2.0"
     }

src/Run/Implementation.php

@@ -0,0 +1,21 @@
+<?php
+declare(strict_types = 1);
+
+namespace Innmind\Server\Control\Run;
+
+use Innmind\Server\Control\Server\{
+    Command,
+    Process,
+};
+use Innmind\Immutable\Attempt;
+
+/**
+ * @internal
+ */
+interface Implementation
+{
+    /**
+     * @return Attempt<Process>
+     */
+    public function __invoke(Command|Command\OverSsh $command): Attempt;
+}

src/Run/Logger.php

@@ -0,0 +1,48 @@
+<?php
+declare(strict_types = 1);
+
+namespace Innmind\Server\Control\Run;
+
+use Innmind\Server\Control\Server\Command;
+use Innmind\Immutable\Attempt;
+use Psr\Log\LoggerInterface;
+
+/**
+ * @internal
+ */
+final class Logger implements Implementation
+{
+    private function __construct(
+        private Implementation $run,
+        private LoggerInterface $logger,
+    ) {
+    }
+
+    #[\Override]
+    public function __invoke(Command|Command\OverSsh $command): Attempt
+    {
+        $toLog = $command;
+
+        if ($toLog instanceof Command\OverSsh) {
+            $toLog = $toLog->normalize();
+        }
+
+        $this->logger->info('About to execute the {command}', [
+            'command' => $toLog->toString(),
+            'workingDirectory' => $toLog->workingDirectory()->match(
+                static fn($path) => $path->toString(),
+                static fn() => null,
+            ),
+        ]);
+
+        return ($this->run)($command);
+    }
+
+    /**
+     * @internal
+     */
+    public static function psr(Implementation $run, LoggerInterface $logger): self
+    {
+        return new self($run, $logger);
+    }
+}

src/Run/Remote.php

@@ -0,0 +1,54 @@
+<?php
+declare(strict_types = 1);
+
+namespace Innmind\Server\Control\Run;
+
+use Innmind\Server\Control\Server\Command;
+use Innmind\Url\Authority\{
+    Host,
+    Port,
+    UserInformation\User,
+};
+use Innmind\Immutable\Attempt;
+
+/**
+ * @internal
+ */
+final class Remote implements Implementation
+{
+    private function __construct(
+        private Implementation $run,
+        private User $user,
+        private Host $host,
+        private ?Port $port,
+    ) {
+    }
+
+    #[\Override]
+    public function __invoke(Command|Command\OverSsh $command): Attempt
+    {
+        return ($this->run)(Command\OverSsh::of(
+            $this->user,
+            $this->host,
+            $this->port,
+            $command,
+        ));
+    }
+
+    /**
+     * @internal
+     */
+    public static function of(
+        Implementation $run,
+        User $user,
+        Host $host,
+        ?Port $port = null,
+    ): self {
+        return new self(
+            $run,
+            $user,
+            $host,
+            $port,
+        );
+    }
+}

src/Run/Unix.php

@@ -0,0 +1,71 @@
+<?php
+declare(strict_types = 1);
+
+namespace Innmind\Server\Control\Run;
+
+use Innmind\Server\Control\Server\{
+    Command,
+    Process,
+};
+use Innmind\Time\{
+    Clock,
+    Period,
+    Halt,
+};
+use Innmind\IO\IO;
+use Innmind\Immutable\Attempt;
+
+/**
+ * @internal
+ */
+final class Unix implements Implementation
+{
+    private function __construct(
+        private Clock $clock,
+        private IO $io,
+        private Halt $halt,
+        private Period $grace,
+    ) {
+    }
+
+    #[\Override]
+    public function __invoke(Command|Command\OverSsh $command): Attempt
+    {
+        if ($command instanceof Command\OverSsh) {
+            $command = $command->normalize();
+        }
+
+        return Attempt::of(function() use ($command) {
+            $process = new Process\Unix(
+                $this->clock,
+                $this->io,
+                $this->halt,
+                $this->grace,
+                $command,
+            );
+
+            if ($command->toBeRunInBackground()) {
+                return Process::background($process());
+            }
+
+            return Process::foreground($process(), $command->outputToBeStreamed());
+        });
+    }
+
+    /**
+     * @internal
+     */
+    public static function of(
+        Clock $clock,
+        IO $io,
+        Halt $halt,
+        ?Period $grace = null,
+    ): self {
+        return new self(
+            $clock,
+            $io,
+            $halt,
+            $grace ?? Period::second(1),
+        );
+    }
+}

src/Run/Via.php

@@ -0,0 +1,40 @@
+<?php
+declare(strict_types = 1);
+
+namespace Innmind\Server\Control\Run;
+
+use Innmind\Server\Control\Server\{
+    Command,
+    Process,
+};
+use Innmind\Immutable\Attempt;
+
+/**
+ * @internal
+ */
+final class Via implements Implementation
+{
+    /**
+     * @param \Closure(Command|Command\OverSsh): Attempt<Process> $run
+     */
+    private function __construct(
+        private \Closure $run,
+    ) {
+    }
+
+    #[\Override]
+    public function __invoke(Command|Command\OverSsh $command): Attempt
+    {
+        return ($this->run)($command);
+    }
+
+    /**
+     * @internal
+     *
+     * @param callable(Command|Command\OverSsh): Attempt<Process> $run
+     */
+    public static function of(callable $run): self
+    {
+        return new self(\Closure::fromCallable($run));
+    }
+}