Refactor: Coroutine-safe request dispatch

src/Http/Dispatcher.php

@@ -0,0 +1,205 @@
+<?php
+
+namespace Utopia\Http;
+
+/**
+ * Per-request request dispatcher.
+ *
+ * Owns the mutable state for a single request/response cycle so the
+ * {@see Http} singleton carries only bootstrap configuration. This keeps
+ * the library safe under concurrent request handling (Swoole coroutines).
+ *
+ * One Dispatcher instance is constructed per request by {@see Http::run()}.
+ * @internal
+ */
+final class Dispatcher
+{
+    private ?RouteMatch $match = null;
+
+    public function __construct(
+        private readonly Http $http,
+        private readonly Request $request,
+        private readonly Response $response,
+    ) {}
+
+    public function matchedRoute(): ?Route
+    {
+        return $this->match?->route;
+    }
+
+    public function matchedRouteMatch(): ?RouteMatch
+    {
+        return $this->match;
+    }
+
+    public function handle(): void
+    {
+        if ($this->http->isCompressionEnabled()) {
+            $this->response->setAcceptEncoding($this->request->getHeader('accept-encoding', ''));
+            $this->response->setCompressionMinSize($this->http->getCompressionMinSize());
+            $this->response->setCompressionSupported($this->http->getCompressionSupported());
+        }
+
+        $this->http->setRequestResource('request', fn() => $this->request);
+        $this->http->setRequestResource('response', fn() => $this->response);
+
+        try {
+            foreach (Hooks::$request as $hook) {
+                $arguments = $this->http->getArguments($hook, [], []);
+                \call_user_func_array($hook->getAction(), $arguments);
+            }
+        } catch (\Exception $e) {
+            $this->http->setRequestResource('error', fn() => $e);
+
+            foreach (Hooks::$errors as $error) {
+                if (\in_array('*', $error->getGroups())) {
+                    try {
+                        $arguments = $this->http->getArguments($error, [], []);
+                        \call_user_func_array($error->getAction(), $arguments);
+                    } catch (\Throwable $e) {
+                        throw new Exception('Error handler had an error: ' . $e->getMessage(), 500, $e);
+                    }
+                }
+            }
+        }
+
+        if ($this->http->isFileLoaded($this->request->getURI())) {
+            $time = (60 * 60 * 24 * 365 * 2);
+
+            $this->response
+                ->setContentType($this->http->getFileMimeType($this->request->getURI()))
+                ->addHeader('Cache-Control', 'public, max-age=' . $time)
+                ->addHeader('Expires', \date('D, d M Y H:i:s', \time() + $time) . ' GMT')
+                ->send($this->http->getFileContents($this->request->getURI()));
+
+            return;
+        }
+
+        $method = $this->request->getMethod();
+        $this->match = Router::matchRequest($this->request);
+
+        $this->http->setRequestResource('route', fn() => $this->match?->route);
+        $this->http->setRequestResource('routeMatch', fn() => $this->match);
+
+        $groups = $this->match?->route->getGroups() ?? [];
+
+        if (Http::REQUEST_METHOD_HEAD === $method) {
+            $method = Http::REQUEST_METHOD_GET;
+            $this->response->disablePayload();
+        }
+
+        if (Http::REQUEST_METHOD_OPTIONS === $method) {
+            try {
+                foreach ($groups as $group) {
+                    foreach (Hooks::$options as $option) {
+                        if (\in_array($group, $option->getGroups())) {
+                            \call_user_func_array($option->getAction(), $this->http->getArguments($option, [], $this->request->getParams()));
+                        }
+                    }
+                }
+
+                foreach (Hooks::$options as $option) {
+                    if (\in_array('*', $option->getGroups())) {
+                        \call_user_func_array($option->getAction(), $this->http->getArguments($option, [], $this->request->getParams()));
+                    }
+                }
+            } catch (\Throwable $e) {
+                foreach (Hooks::$errors as $error) {
+                    if (\in_array('*', $error->getGroups())) {
+                        $this->http->setRequestResource('error', fn() => $e);
+                        \call_user_func_array($error->getAction(), $this->http->getArguments($error, [], $this->request->getParams()));
+                    }
+                }
+            }
+
+            return;
+        }
+
+        if ($this->match !== null) {
+            $this->execute($this->match);
+
+            return;
+        }
+
+        foreach (Hooks::$errors as $error) {
+            if (\in_array('*', $error->getGroups())) {
+                $this->http->setRequestResource('error', fn() => new Exception('Not Found', 404));
+                \call_user_func_array($error->getAction(), $this->http->getArguments($error, [], $this->request->getParams()));
+            }
+        }
+    }
+
+    public function execute(RouteMatch $match): void
+    {
+        $route = $match->route;
+        $groups = $route->getGroups();
+        $pathValues = $route->getPathValues($this->request, $match->preparedPath);
+
+        // Request params are re-read at each call site: init/request hooks
+        // may mutate the request (e.g. applying filters), and later hooks +
+        // the route action must see the updated view. Hoisting this into a
+        // local would cache stale params across the lifecycle.
+
+        try {
+            if ($route->getHook()) {
+                foreach (Hooks::$init as $hook) {
+                    if (\in_array('*', $hook->getGroups())) {
+                        \call_user_func_array($hook->getAction(), $this->http->getArguments($hook, $pathValues, $this->request->getParams()));
+                    }
+                }
+            }
+
+            foreach ($groups as $group) {
+                foreach (Hooks::$init as $hook) {
+                    if (\in_array($group, $hook->getGroups())) {
+                        \call_user_func_array($hook->getAction(), $this->http->getArguments($hook, $pathValues, $this->request->getParams()));
+                    }
+                }
+            }
+
+            if (!$this->response->isSent()) {
+                \call_user_func_array($route->getAction(), $this->http->getArguments($route, $pathValues, $this->request->getParams()));
+            }
+
+            foreach ($groups as $group) {
+                foreach (Hooks::$shutdown as $hook) {
+                    if (\in_array($group, $hook->getGroups())) {
+                        \call_user_func_array($hook->getAction(), $this->http->getArguments($hook, $pathValues, $this->request->getParams()));
+                    }
+                }
+            }
+
+            if ($route->getHook()) {
+                foreach (Hooks::$shutdown as $hook) {
+                    if (\in_array('*', $hook->getGroups())) {
+                        \call_user_func_array($hook->getAction(), $this->http->getArguments($hook, $pathValues, $this->request->getParams()));
+                    }
+                }
+            }
+        } catch (\Throwable $e) {
+            $this->http->setRequestResource('error', fn() => $e);
+
+            foreach ($groups as $group) {
+                foreach (Hooks::$errors as $error) {
+                    if (\in_array($group, $error->getGroups())) {
+                        try {
+                            \call_user_func_array($error->getAction(), $this->http->getArguments($error, $pathValues, $this->request->getParams()));
+                        } catch (\Throwable $e) {
+                            throw new Exception('Error handler had an error: ' . $e->getMessage(), 500, $e);
+                        }
+                    }
+                }
+            }
+
+            foreach (Hooks::$errors as $error) {
+                if (\in_array('*', $error->getGroups())) {
+                    try {
+                        \call_user_func_array($error->getAction(), $this->http->getArguments($error, $pathValues, $this->request->getParams()));
+                    } catch (\Throwable $e) {
+                        throw new Exception('Error handler had an error: ' . $e->getMessage(), 500, $e);
+                    }
+                }
+            }
+        }
+    }
+}

src/Http/Hooks.php

@@ -0,0 +1,125 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Utopia\Http;
+
+use Utopia\Servers\Hook;
+
+/**
+ * Process-global hook registry.
+ *
+ * Owns the lifecycle-hook arrays (init/shutdown/options/error/start/request)
+ * that used to live on {@see Http} as protected statics. Keeping them here
+ * means {@see Dispatcher} can read the registries through a dedicated
+ * primitive instead of forcing {@see Http} to expose six `getXxxHooks()`
+ * accessors purely for internal consumption.
+ *
+ * Hooks are populated at bootstrap and must not be mutated after the
+ * server starts accepting requests; registration APIs are public static
+ * methods, reads are public static arrays.
+ */
+final class Hooks
+{
+    /** @var Hook[] */
+    public static array $init = [];
+
+    /** @var Hook[] */
+    public static array $shutdown = [];
+
+    /** @var Hook[] */
+    public static array $options = [];
+
+    /** @var Hook[] */
+    public static array $errors = [];
+
+    /** @var Hook[] */
+    public static array $start = [];
+
+    /** @var Hook[] */
+    public static array $request = [];
+
+    /**
+     * Register a callback that runs before the matched route action.
+     */
+    public static function init(): Hook
+    {
+        $hook = new Hook();
+        $hook->groups(['*']);
+        self::$init[] = $hook;
+
+        return $hook;
+    }
+
+    /**
+     * Register a callback that runs after the matched route action.
+     */
+    public static function shutdown(): Hook
+    {
+        $hook = new Hook();
+        $hook->groups(['*']);
+        self::$shutdown[] = $hook;
+
+        return $hook;
+    }
+
+    /**
+     * Register a callback for OPTIONS method requests.
+     */
+    public static function options(): Hook
+    {
+        $hook = new Hook();
+        $hook->groups(['*']);
+        self::$options[] = $hook;
+
+        return $hook;
+    }
+
+    /**
+     * Register an error callback.
+     */
+    public static function error(): Hook
+    {
+        $hook = new Hook();
+        $hook->groups(['*']);
+        self::$errors[] = $hook;
+
+        return $hook;
+    }
+
+    /**
+     * Register a callback that runs once when the server starts.
+     */
+    public static function onStart(): Hook
+    {
+        $hook = new Hook();
+        self::$start[] = $hook;
+
+        return $hook;
+    }
+
+    /**
+     * Register a callback that runs at the top of every request, before
+     * route matching.
+     */
+    public static function onRequest(): Hook
+    {
+        $hook = new Hook();
+        self::$request[] = $hook;
+
+        return $hook;
+    }
+
+    /**
+     * Clear every registered hook. Intended for test isolation.
+     */
+    public static function reset(): void
+    {
+        self::$init = [];
+        self::$shutdown = [];
+        self::$options = [];
+        self::$errors = [];
+        self::$start = [];
+        self::$request = [];
+    }
+}