Merge pull request #9823 from MrPetovan/task/9677-2fa-remember-device

[friendica.git] / src / App / Router.php

diff --git a/src/App/Router.php b/src/App/Router.php
index 8094e3b46d5f5db11d2e3c08c9d0bd43f0199647..78d8ab629f8fd27afb31e3f7c8ca637bf6dd4e3e 100644 (file)
--- a/src/App/Router.php
+++ b/src/App/Router.php
@@ -26,6 +26,8 @@ use FastRoute\DataGenerator\GroupCountBased;
 use FastRoute\Dispatcher;
 use FastRoute\RouteCollector;
 use FastRoute\RouteParser\Std;
+use Friendica\Core\Cache\Duration;
+use Friendica\Core\Cache\ICache;
 use Friendica\Core\Hook;
 use Friendica\Core\L10n;
 use Friendica\Network\HTTPException;
@@ -42,12 +44,18 @@ use Friendica\Network\HTTPException;
  */
 class Router
 {
-       const POST = 'POST';
-       const GET  = 'GET';
+       const DELETE = 'DELETE';
+       const GET    = 'GET';
+       const PATCH  = 'PATCH';
+       const POST   = 'POST';
+       const PUT    = 'PUT';
 
        const ALLOWED_METHODS = [
-               self::POST,
+               self::DELETE,
                self::GET,
+               self::PATCH,
+               self::POST,
+               self::PUT,
        ];
 
        /** @var RouteCollector */
@@ -66,14 +74,24 @@ class Router
        /** @var L10n */
        private $l10n;
 
+       /** @var ICache */
+       private $cache;
+
+       /** @var string */
+       private $baseRoutesFilepath;
+
        /**
-        * @param array $server The $_SERVER variable
-        * @param L10n  $l10n
-        * @param RouteCollector|null $routeCollector Optional the loaded Route collector
+        * @param array               $server             The $_SERVER variable
+        * @param string              $baseRoutesFilepath The path to a base routes file to leverage cache, can be empty
+        * @param L10n                $l10n
+        * @param ICache              $cache
+        * @param RouteCollector|null $routeCollector
         */
-       public function __construct(array $server, L10n $l10n, RouteCollector $routeCollector = null)
+       public function __construct(array $server, string $baseRoutesFilepath, L10n $l10n, ICache $cache, RouteCollector $routeCollector = null)
        {
+               $this->baseRoutesFilepath = $baseRoutesFilepath;
                $this->l10n = $l10n;
+               $this->cache = $cache;
 
                $httpMethod = $server['REQUEST_METHOD'] ?? self::GET;
                $this->httpMethod = in_array($httpMethod, self::ALLOWED_METHODS) ? $httpMethod : self::GET;
@@ -81,9 +99,16 @@ class Router
                $this->routeCollector = isset($routeCollector) ?
                        $routeCollector :
                        new RouteCollector(new Std(), new GroupCountBased());
+
+               if ($this->baseRoutesFilepath && !file_exists($this->baseRoutesFilepath)) {
+                       throw new HTTPException\InternalServerErrorException('Routes file path does\'n exist.');
+               }
        }
 
        /**
+        * This will be called either automatically if a base routes file path was submitted,
+        * or can be called manually with a custom route array.
+        *
         * @param array $routes The routes to add to the Router
         *
         * @return self The router instance with the loaded routes
@@ -100,6 +125,9 @@ class Router
 
                $this->routeCollector = $routeCollector;
 
+               // Add routes from addons
+               Hook::callAll('route_collection', $this->routeCollector);
+
                return $this;
        }
 
@@ -191,12 +219,9 @@ class Router
         */
        public function getModuleClass($cmd)
        {
-               // Add routes from addons
-               Hook::callAll('route_collection', $this->routeCollector);
-
                $cmd = '/' . ltrim($cmd, '/');
 
-               $dispatcher = new Dispatcher\GroupCountBased($this->routeCollector->getData());
+               $dispatcher = new Dispatcher\GroupCountBased($this->getCachedDispatchData());
 
                $moduleClass = null;
                $this->parameters = [];
@@ -223,4 +248,64 @@ class Router
        {
                return $this->parameters;
        }
+
+       /**
+        * If a base routes file path has been provided, we can load routes from it if the cache misses.
+        *
+        * @return array
+        * @throws HTTPException\InternalServerErrorException
+        */
+       private function getDispatchData()
+       {
+               $dispatchData = [];
+
+               if ($this->baseRoutesFilepath) {
+                       $dispatchData = require $this->baseRoutesFilepath;
+                       if (!is_array($dispatchData)) {
+                               throw new HTTPException\InternalServerErrorException('Invalid base routes file');
+                       }
+               }
+
+               $this->loadRoutes($dispatchData);
+
+               return $this->routeCollector->getData();
+       }
+
+       /**
+        * We cache the dispatch data for speed, as computing the current routes (version 2020.09)
+        * takes about 850ms for each requests.
+        *
+        * The cached "routerDispatchData" lasts for a day, and must be cleared manually when there
+        * is any changes in the enabled addons list.
+        *
+        * Additionally, we check for the base routes file last modification time to automatically
+        * trigger re-computing the dispatch data.
+        *
+        * @return array|mixed
+        * @throws HTTPException\InternalServerErrorException
+        */
+       private function getCachedDispatchData()
+       {
+               $routerDispatchData = $this->cache->get('routerDispatchData');
+               $lastRoutesFileModifiedTime = $this->cache->get('lastRoutesFileModifiedTime');
+               $forceRecompute = false;
+
+               if ($this->baseRoutesFilepath) {
+                       $routesFileModifiedTime = filemtime($this->baseRoutesFilepath);
+                       $forceRecompute = $lastRoutesFileModifiedTime != $routesFileModifiedTime;
+               }
+
+               if (!$forceRecompute && $routerDispatchData) {
+                       return $routerDispatchData;
+               }
+
+               $routerDispatchData = $this->getDispatchData();
+
+               $this->cache->set('routerDispatchData', $routerDispatchData, Duration::DAY);
+               if (!empty($routesFileModifiedTime)) {
+                       $this->cache->set('lastRoutesFileMtime', $routesFileModifiedTime, Duration::MONTH);
+               }
+
+               return $routerDispatchData;
+       }
 }