[react] runtime improvements (#118)

* allow configuring react host
react config can now be controlled by REACT_xxx env/server vars, or from runtime config. This allows listening on interfaces
other than 127.0.0.1, for example 0.0.0.0 when running under docker

* refactor react setup
making react runtime more testable, and adding some tests

* simplify react by moving loop creation into factory

* tidy

* tidy

* cs fixer

* removing redundant setup code

* moving run() from factory to runner

* linting

* handle container signals
> docker and k8s send SIGTERM and/or SIGKILL when terminating a container, so exit gracefully

* Remove first $loop->run()

* Fixed tests

Co-authored-by: Nyholm <tobias.nyholm@gmail.com>

Author: brettmc

README.md

@@ -42,3 +42,10 @@ return function (array $context) {
     return new Application($context['APP_ENV'] ?? 'dev');
 };
 ```
+
+## Options
+
+| Option | Description                                                                                | Default     |
+| --- |--------------------------------------------------------------------------------------------|-------------|
+| `host` | The host where the server should bind to (precedes `REACT_HOST` environment variable)      | `127.0.0.1` |
+| `port` | The port where the server should be listening (precedes `REACT_PORT` environment variable) | `8080`      |

composer.json

@@ -11,7 +11,7 @@
     ],
     "require": {
         "psr/http-server-handler": "^1.0",
-        "react/http": "^1.2",
+        "react/http": "^1.6",
         "symfony/runtime": "^5.3 || ^6.0"
     },
     "require-dev": {

src/Runner.php

@@ -2,32 +2,23 @@
 
 namespace Runtime\React;
 
-use Psr\Http\Message\ServerRequestInterface;
+use Psr\Http\Server\RequestHandlerInterface;
 use Symfony\Component\Runtime\RunnerInterface;
 
 class Runner implements RunnerInterface
 {
-    private $application;
-    private $port;
+    private RequestHandlerInterface $application;
+    private ServerFactory $serverFactory;
 
-    public function __construct($application, $port)
+    public function __construct(ServerFactory $serverFactory, RequestHandlerInterface $application)
     {
+        $this->serverFactory = $serverFactory;
         $this->application = $application;
-        $this->port = $port;
     }
 
     public function run(): int
     {
-        $application = $this->application;
-        $loop = \React\EventLoop\Factory::create();
-
-        $server = new \React\Http\Server($loop, function (ServerRequestInterface $request) use ($application) {
-            return $application->handle($request);
-        });
-
-        $socket = new \React\Socket\Server($this->port, $loop);
-        $server->listen($socket);
-
+        $loop = $this->serverFactory->createServer($this->application);
         $loop->run();
 
         return 0;

src/Runtime.php

@@ -13,18 +13,10 @@
  */
 class Runtime extends GenericRuntime
 {
-    private $port;
-
-    public function __construct(array $options)
-    {
-        $this->port = $options['port'] ?? 8080;
-        parent::__construct($options);
-    }
-
     public function getRunner(?object $application): RunnerInterface
     {
         if ($application instanceof RequestHandlerInterface) {
-            return new Runner($application, $this->port);
+            return new Runner(new ServerFactory($this->options), $application);
         }
 
         return parent::getRunner($application);

src/ServerFactory.php

@@ -0,0 +1,56 @@
+<?php
+
+namespace Runtime\React;
+
+use Psr\Http\Message\ServerRequestInterface;
+use Psr\Http\Server\RequestHandlerInterface;
+use React\EventLoop\Loop;
+use React\EventLoop\LoopInterface;
+use React\Http\HttpServer;
+use React\Socket\SocketServer;
+
+class ServerFactory
+{
+    private const DEFAULT_OPTIONS = [
+        'host' => '127.0.0.1',
+        'port' => 8080,
+    ];
+    private array $options;
+
+    public static function getDefaultOptions(): array
+    {
+        return self::DEFAULT_OPTIONS;
+    }
+
+    public function __construct(array $options = [])
+    {
+        $options['host'] = $options['host'] ?? $_SERVER['REACT_HOST'] ?? $_ENV['REACT_HOST'] ?? self::DEFAULT_OPTIONS['host'];
+        $options['port'] = $options['port'] ?? $_SERVER['REACT_PORT'] ?? $_ENV['REACT_PORT'] ?? self::DEFAULT_OPTIONS['port'];
+
+        $this->options = array_replace_recursive(self::DEFAULT_OPTIONS, $options);
+    }
+
+    public function createServer(RequestHandlerInterface $requestHandler): LoopInterface
+    {
+        $loop = Loop::get();
+        $loop->addSignal(SIGTERM, function (int $signal) {
+            exit(128 + $signal);
+        });
+        $loop->addSignal(SIGKILL, function (int $signal) {
+            exit(128 + $signal);
+        });
+        $server = new HttpServer($loop, function (ServerRequestInterface $request) use ($requestHandler) {
+            return $requestHandler->handle($request);
+        });
+
+        $socket = new SocketServer(sprintf('%s:%s', $this->options['host'], $this->options['port']), [], $loop);
+        $server->listen($socket);
+
+        return $loop;
+    }
+
+    public function getOptions(): array
+    {
+        return $this->options;
+    }
+}

tests/RunnerTest.php

@@ -0,0 +1,30 @@
+<?php
+
+namespace Runtime\React\Tests;
+
+use PHPUnit\Framework\TestCase;
+use Psr\Http\Server\RequestHandlerInterface;
+use React\EventLoop\Loop;
+use React\EventLoop\LoopInterface;
+use React\Http\HttpServer;
+use Runtime\React\Runner;
+use Runtime\React\ServerFactory;
+
+class RunnerTest extends TestCase
+{
+    public function testRun(): void
+    {
+        $handler = function () {};
+        $loop = $this->createMock(LoopInterface::class);
+        Loop::set($loop);
+        $server = new HttpServer($handler); //final, cannot be mocked
+        $factory = $this->createMock(ServerFactory::class);
+        $application = $this->createMock(RequestHandlerInterface::class);
+
+        $factory->expects(self::once())->method('createServer')->willReturn($loop);
+
+        $runner = new Runner($factory, $application);
+
+        self::assertSame(0, $runner->run());
+    }
+}

tests/RuntimeTest.php

@@ -0,0 +1,22 @@
+<?php
+
+namespace Runtime\React\Tests;
+
+use PHPUnit\Framework\TestCase;
+use Psr\Http\Server\RequestHandlerInterface;
+use Runtime\React\Runner;
+use Runtime\React\Runtime;
+
+class RuntimeTest extends TestCase
+{
+    public function testGetRunnerCreatesARunnerForRequestHandlers(): void
+    {
+        $options = [];
+        $runtime = new Runtime($options);
+
+        $application = $this->createMock(RequestHandlerInterface::class);
+        $runner = $runtime->getRunner($application);
+
+        self::assertInstanceOf(Runner::class, $runner);
+    }
+}

tests/ServerFactoryTest.php

@@ -0,0 +1,45 @@
+<?php
+
+namespace Runtime\React\Tests;
+
+use PHPUnit\Framework\TestCase;
+use Psr\Http\Server\RequestHandlerInterface;
+use React\EventLoop\Loop;
+use React\EventLoop\LoopInterface;
+use Runtime\React\ServerFactory;
+
+class ServerFactoryTest extends TestCase
+{
+    private RequestHandlerInterface $handler;
+    private LoopInterface $loop;
+
+    public function setUp(): void
+    {
+        parent::setUp();
+        $this->handler = $this->createMock(RequestHandlerInterface::class);
+        $this->loop = $this->createMock(LoopInterface::class);
+        $this->loop->expects($this->never())->method('run');
+        Loop::set($this->loop);
+    }
+
+    public function testCreateServerWithDefaultOptions(): void
+    {
+        $factory = new ServerFactory();
+        $loop = $factory->createServer($this->handler);
+
+        self::assertInstanceOf(LoopInterface::class, $loop);
+        self::assertSame(ServerFactory::getDefaultOptions(), $factory->getOptions());
+    }
+
+    public function testCreateServerWithOptions(): void
+    {
+        $options = [
+            'host' => '0.0.0.0',
+            'port' => '9999',
+        ];
+        $factory = new ServerFactory($options);
+        $factory->createServer($this->handler);
+
+        self::assertSame($options, $factory->getOptions());
+    }
+}