antidot-framework · kpicaza · Aug 14, 2021
diff --git a/composer.json b/composer.json
@@ -1,5 +1,5 @@
 {
-    "name": "antidot-fw/roadd-runner",
+    "name": "antidot-fw/road-runner",
     "description": "Antidot Framework integgration wit Road Runner PHP/GO concurrency server.",
     "keywords": [
         "psr-11",
@@ -15,7 +15,9 @@
         }
     ],
     "require": {
-        "php": "^7.4.3|^8.0"
+        "php": "^7.4.3|^8.0",
+        "antidot-fw/framework": "^0.2.1",
+        "ramsey/uuid": "^4.2"
     },
     "require-dev": {
         "infection/infection": "^0.24.0",
@@ -41,12 +43,14 @@
             "@cs-check",
             "@test",
             "@inspect",
+            "@psalm",
             "@infection"
         ],
         "cs-check": "phpcs src --colors",
         "cs-fix": "phpcbf src --colors",
         "inspect": "phpstan analyse src -l7 --ansi",
         "infection": "XDEBUG_MODE=coverage infection --ansi",
+        "psalm": "psalm",
         "test": "phpunit --colors=always"
     },
     "config": {

diff --git a/src/Container/ApplicationFactory.php b/src/Container/ApplicationFactory.php
@@ -0,0 +1,47 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Antidot\RoadRunner\Container;
+
+use Antidot\Application\Http\Application;
+use Antidot\Application\Http\Response\ErrorResponseGenerator;
+use Antidot\Application\Http\RouteFactory;
+use Antidot\Application\Http\Router;
+use Antidot\Application\Http\WebServerApplication;
+use Antidot\Container\MiddlewareFactory;
+use Antidot\Container\RequestFactory;
+use Antidot\RoadRunner\MiddlewarePipeline;
+use Antidot\RoadRunner\RoadRunnerApplication;
+use Laminas\HttpHandlerRunner\Emitter\EmitterInterface;
+use Laminas\HttpHandlerRunner\Emitter\EmitterStack;
+use Laminas\HttpHandlerRunner\RequestHandlerRunner;
+use Psr\Container\ContainerInterface;
+
+final class ApplicationFactory
+{
+    public function __invoke(ContainerInterface $container): Application
+    {
+        $pipeline = new MiddlewarePipeline();
+
+        /** @var EmitterInterface $emitterStack */
+        $emitterStack = $container->get(EmitterStack::class);
+        /** @var RequestFactory $requestFactory */
+        $requestFactory = $container->get(RequestFactory::class);
+        /** @var ErrorResponseGenerator $errorResponseGenerator */
+        $errorResponseGenerator = $container->get(ErrorResponseGenerator::class);
+        $runner = new RequestHandlerRunner($pipeline, $emitterStack, $requestFactory(), $errorResponseGenerator);
+        /** @var Router $router */
+        $router = $container->get(Router::class);
+        /** @var MiddlewareFactory $middleware */
+        $middleware = $container->get(MiddlewareFactory::class);
+        /** @var RouteFactory $routeFactory */
+        $routeFactory = $container->get(RouteFactory::class);
+
+        return new RoadRunnerApplication(
+            new WebServerApplication($runner, $pipeline, $router, $middleware, $routeFactory),
+            $pipeline,
+            $errorResponseGenerator
+        );
+    }
+}
diff --git a/src/Container/Config/ConfigProvider.php b/src/Container/Config/ConfigProvider.php
@@ -0,0 +1,23 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Antidot\RoadRunner\Container\Config;
+
+use Antidot\Application\Http\Application;
+use Antidot\RoadRunner\Container\ApplicationFactory;
+
+final class ConfigProvider
+{
+    /**
+     * @return array<string, array<string, string>>
+     */
+    public function __invoke(): array
+    {
+        return [
+            'factories' => [
+                Application::class => ApplicationFactory::class,
+            ]
+        ];
+    }
+}
diff --git a/src/MiddlewarePipeline.php b/src/MiddlewarePipeline.php
@@ -0,0 +1,93 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Antidot\RoadRunner;
+
+use Antidot\Application\Http\Handler\NextHandler;
+use Antidot\Application\Http\Middleware\MiddlewareQueue;
+use Antidot\Application\Http\Middleware\Pipeline;
+use Antidot\Application\Http\Middleware\SyncMiddlewareQueue;
+use Psr\Http\Message\ResponseInterface;
+use Psr\Http\Message\ServerRequestInterface;
+use Psr\Http\Server\MiddlewareInterface;
+use Psr\Http\Server\RequestHandlerInterface;
+use Ramsey\Uuid\Uuid;
+use Throwable;
+
+final class MiddlewarePipeline implements Pipeline
+{
+    /** @var array<MiddlewareQueue> */
+    public array $concurrentPipelines;
+    /** @var array<MiddlewareInterface> */
+    private array $middlewareCollection;
+
+    /**
+     * @param array<MiddlewareInterface> $middlewareCollection
+     * @param array<MiddlewareQueue> $concurrentPipelines
+     */
+    public function __construct(
+        array $middlewareCollection = [],
+        array $concurrentPipelines = []
+    ) {
+        $this->concurrentPipelines = $concurrentPipelines;
+        $this->middlewareCollection = $middlewareCollection;
+    }
+
+    public function pipe(MiddlewareInterface $middleware): void
+    {
+        $this->middlewareCollection[] = $middleware;
+    }
+
+    public function handle(ServerRequestInterface $request): ResponseInterface
+    {
+        /** @var string $requestId */
+        $requestId = $request->getAttribute('request_id');
+        $this->setCurrentPipeline($requestId);
+
+        try {
+            $middleware = $this->concurrentPipelines[$requestId]->dequeue();
+
+            $response = $middleware->process($request, $this);
+            unset($this->concurrentPipelines[$requestId]);
+
+            return $response;
+        } catch (Throwable $exception) {
+            unset($this->concurrentPipelines[$requestId]);
+
+            throw $exception;
+        }
+    }
+
+    public function process(ServerRequestInterface $request, RequestHandlerInterface $handler): ResponseInterface
+    {
+        /** @var ?string $requestId */
+        $requestId = $request->getAttribute('request_id');
+        if (!$requestId) {
+            $requestId = Uuid::uuid4()->toString();
+            $request = $request->withAttribute('request_id', $requestId);
+        }
+
+        try {
+            $queue = $this->concurrentPipelines[$requestId];
+            $next = new NextHandler($queue, $handler);
+
+            return $next->handle($request);
+        } catch (Throwable $exception) {
+            unset($this->concurrentPipelines[$requestId]);
+
+            throw $exception;
+        }
+    }
+
+    private function setCurrentPipeline(string $requestId): void
+    {
+        if (empty($this->concurrentPipelines[$requestId])) {
+            $queue = new SyncMiddlewareQueue();
+            foreach ($this->middlewareCollection as $middlewareName) {
+                $queue->enqueue($middlewareName);
+            }
+            $this->concurrentPipelines[$requestId] = $queue;
+        }
+    }
+}
diff --git a/src/RoadRunnerApplication.php b/src/RoadRunnerApplication.php
@@ -0,0 +1,87 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Antidot\RoadRunner;
+
+use Antidot\Application\Http\Application;
+use Antidot\Application\Http\Middleware\Pipeline;
+use Antidot\Application\Http\Response\ErrorResponseGenerator;
+use Antidot\Application\Http\WebServerApplication;
+use Psr\Http\Message\ResponseInterface;
+use Psr\Http\Message\ServerRequestInterface;
+use Psr\Http\Server\RequestHandlerInterface;
+use Ramsey\Uuid\Uuid;
+use RuntimeException;
+use Throwable;
+
+final class RoadRunnerApplication implements Application, RequestHandlerInterface
+{
+    private ErrorResponseGenerator $errorResponseGenerator;
+    private WebServerApplication $application;
+    private Pipeline $pipeline;
+
+    public function __construct(
+        WebServerApplication $application,
+        Pipeline $pipeline,
+        ErrorResponseGenerator $errorResponseGenerator
+    ) {
+        $this->errorResponseGenerator = $errorResponseGenerator;
+        $this->application = $application;
+        $this->pipeline = $pipeline;
+    }
+
+    public function handle(ServerRequestInterface $request): ResponseInterface
+    {
+        try {
+            return $this->pipeline->handle($request->withAttribute('request_id', Uuid::uuid4()->toString()));
+        } catch (Throwable $exception) {
+            return $this->errorResponseGenerator->__invoke($exception);
+        }
+    }
+
+    public function run(): void
+    {
+        throw new RuntimeException('Connot run Road Runner Application out of Road Runner server.');
+    }
+
+    public function pipe(string $middlewareName): void
+    {
+        $this->application->pipe($middlewareName);
+    }
+
+    public function get(string $uri, array $middleware, string $name): void
+    {
+        $this->application->get($uri, $middleware, $name);
+    }
+
+    public function post(string $uri, array $middleware, string $name): void
+    {
+        $this->application->post($uri, $middleware, $name);
+    }
+
+    public function patch(string $uri, array $middleware, string $name): void
+    {
+        $this->patch($uri, $middleware, $name);
+    }
+
+    public function put(string $uri, array $middleware, string $name): void
+    {
+        $this->application->put($uri, $middleware, $name);
+    }
+
+    public function delete(string $uri, array $middleware, string $name): void
+    {
+        $this->application->delete($uri, $middleware, $name);
+    }
+
+    public function options(string $uri, array $middleware, string $name): void
+    {
+        $this->application->options($uri, $middleware, $name);
+    }
+
+    public function route(string $uri, array $middleware, array $methods, string $name): void
+    {
+        $this->application->route($uri, $middleware, $methods, $name);
+    }
+}
diff --git a/test/Container/ApplicationFactoryTest.php b/test/Container/ApplicationFactoryTest.php
@@ -0,0 +1,43 @@
+<?php
+
+namespace Antidot\Test\RoadRunner\Container;
+
+use Antidot\Application\Http\Response\ErrorResponseGenerator;
+use Antidot\Application\Http\RouteFactory;
+use Antidot\Application\Http\Router;
+use Antidot\Container\MiddlewareFactory;
+use Antidot\Container\RequestFactory;
+use Antidot\RoadRunner\Container\ApplicationFactory;
+use Laminas\HttpHandlerRunner\Emitter\EmitterStack;
+use PHPUnit\Framework\TestCase;
+use Psr\Container\ContainerInterface;
+
+class ApplicationFactoryTest extends TestCase
+{
+    public function testItCreatesRoadRunnerApplicationInstances(): void
+    {
+        $factory = new ApplicationFactory();
+        $container = $this->createMock(ContainerInterface::class);
+        $container->expects(static::exactly(6))
+            ->method('get')
+            ->withConsecutive(
+                [EmitterStack::class],
+                [RequestFactory::class],
+                [ErrorResponseGenerator::class],
+                [Router::class],
+                [MiddlewareFactory::class],
+                [RouteFactory::class],
+            )
+            ->willReturnOnConsecutiveCalls(
+                $this->createMock(EmitterStack::class),
+                $this->createMock(RequestFactory::class),
+                $this->createMock(ErrorResponseGenerator::class),
+                $this->createMock(Router::class),
+                $this->createMock(MiddlewareFactory::class),
+                $this->createMock(RouteFactory::class),
+            );
+
+
+        $factory($container);
+    }
+}