Merge branch 'develop'

* develop:
  specify next release
  CS
  fix using synchronous operating system
  fix loading the whole response body in memory
  wait for the server to boot
  dump server output to see why it fails
  return error to see why the test fail
  make sure the connections tasks are loaded in memory

CHANGELOG.md

@@ -1,5 +1,12 @@
 # Changelog
 
+## 3.0.1 - 2024-08-03
+
+### Fixed
+
+- The whole response body was loaded in memory
+- The server was blocking while waiting new connections, preventing previous requests from being served
+
 ## 3.0.0 - 2024-03-10
 
 ### Changed

composer.json

@@ -16,6 +16,7 @@
     },
     "require": {
         "php": "~8.2",
+        "innmind/immutable": "~5.7",
         "innmind/mantle": "~2.0",
         "innmind/io": "~2.7",
         "innmind/http-parser": "~2.1",

src/Command/Serve.php

@@ -21,8 +21,6 @@
     ServerRequest\Environment as HttpEnv,
 };
 use Innmind\Url\Authority\Port;
-use Innmind\IO\Sockets\Server as IOServer;
-use Innmind\Immutable\Str;
 
 final class Serve implements Command
 {
@@ -52,12 +50,7 @@ public function __invoke(Console $console): Console
                 static fn() => 8080,
             );
 
-        return Open::of(Port::of($port))($this->os)->match(
-            fn($servers) => $this->serve($console, $servers),
-            static fn() => $console
-                ->error(Str::of("Failed to open sockets\n"))
-                ->exit(1),
-        );
+        return $this->serve($console, Open::of(Port::of($port)));
     }
 
     /**
@@ -84,20 +77,18 @@ public function usage(): string
         USAGE;
     }
 
-    private function serve(Console $console, IOServer|IOServer\Pool $servers): Console
+    private function serve(Console $console, Open $open): Console
     {
         $source = Server::of(
             $this->os->clock(),
-            $servers,
+            $open,
             InjectEnvironment::of(HttpEnv::of($console->variables())),
             $this->handle,
         );
         $forerunner = Forerunner::of($this->os);
 
         if ($console->options()->contains('no-output')) {
             $source = $source->withOutput(Nothing::of());
-        } else {
-            $console = $console->output(Str::of("HTTP server ready!\n"));
         }
 
         return $forerunner($console, $source);

src/Encode.php

@@ -46,17 +46,19 @@ public function __invoke(Response $response): Sequence
             $response->statusCode()->toString(),
             $response->statusCode()->reasonPhrase(),
         );
-        /** @var Sequence<string> */
-        $chunks = Sequence::of($firstLine);
-
-        return $chunks
-            ->append($headers->all()->map(
-                static fn($header) => $header->toString(),
-            ))
-            ->add('')
-            ->map(Str::of(...))
-            ->map(static fn($line) => $line->append(self::EOL))
-            ->append($response->body()->chunks())
+
+        return $response
+            ->body()
+            ->chunks()
+            ->prepend(
+                $headers
+                    ->all()
+                    ->map(static fn($header) => $header->toString())
+                    ->prepend(Sequence::of($firstLine))
+                    ->add('')
+                    ->map(Str::of(...))
+                    ->map(static fn($line) => $line->append(self::EOL)),
+            )
             ->add(Str::of(self::EOL))
             ->add(Str::of(self::EOL));
     }

src/Server.php

@@ -34,7 +34,8 @@
 
 final class Server
 {
-    private IOServer|IOServer\Pool $servers;
+    private Open $open;
+    private IOServer|IOServer\Pool|null $servers = null;
     private InjectEnvironment $injectEnv;
     private Encode $encode;
     /** @var callable(ServerRequest, OperatingSystem): Response */
@@ -47,13 +48,13 @@ final class Server
      * @param callable(ServerRequest, OperatingSystem): Response $handle
      */
     private function __construct(
-        IOServer|IOServer\Pool $servers,
+        Open $open,
         InjectEnvironment $injectEnv,
         Encode $encode,
         callable $handle,
         Display $display,
     ) {
-        $this->servers = $servers->watch();
+        $this->open = $open;
         $this->injectEnv = $injectEnv;
         $this->encode = $encode;
         $this->handle = $handle;
@@ -72,6 +73,30 @@ public function __invoke(
         Continuation $continuation,
         Sequence $terminated,
     ): Continuation {
+        if (\is_null($this->servers)) {
+            $this->servers = ($this->open)($os)->match(
+                static fn($servers) => $servers->watch(),
+                static fn() => null,
+            );
+
+            if (!\is_null($this->servers)) {
+                $console = ($this->display)(
+                    $console,
+                    Str::of("HTTP server ready!\n"),
+                );
+            }
+        }
+
+        if (\is_null($this->servers)) {
+            return $continuation
+                ->carryWith(
+                    $console
+                        ->error(Str::of("Failed to open sockets\n"))
+                        ->exit(1),
+                )
+                ->terminate();
+        }
+
         $console = ($this->display)($console, Str::of("Pending connections...\n"));
 
         $connections = $this
@@ -127,20 +152,20 @@ public function __invoke(
 
         return $continuation
             ->carryWith($console)
-            ->launch($connections);
+            ->launch($connections->memoize());
     }
 
     /**
      * @param callable(ServerRequest, OperatingSystem): Response $handle
      */
     public static function of(
         Clock $clock,
-        IOServer|IOServer\Pool $servers,
+        Open $open,
         InjectEnvironment $injectEnv,
         callable $handle,
     ): self {
         return new self(
-            $servers,
+            $open,
             $injectEnv,
             new Encode($clock),
             $handle,
@@ -154,7 +179,7 @@ public static function of(
     public function withOutput(Output $output): self
     {
         return new self(
-            $this->servers,
+            $this->open,
             $this->injectEnv,
             $this->encode,
             $this->handle,

tests/FunctionalTest.php

@@ -48,8 +48,15 @@ public function tearDown(): void
 
     public function testServerRespond()
     {
-        // let time for the server to boot
-        \sleep(1);
+        $found = $this
+            ->server
+            ->output()
+            ->chunks()
+            ->find(static fn($pair) => $pair[0]->startsWith('HTTP server ready!'));
+        $this->assertTrue($found->match(
+            static fn() => true,
+            static fn() => false,
+        ));
 
         $response = $this
             ->os
@@ -61,7 +68,7 @@ public function testServerRespond()
             ))
             ->match(
                 static fn($success) => $success->response(),
-                static fn() => null,
+                static fn($error) => $error,
             );
 
         $this->assertInstanceOf(Response::class, $response);