src/App/Router.php

   1 <?php
   2 /**
   3  * @copyright Copyright (C) 2010-2022, the Friendica project
   4  *
   5  * @license GNU AGPL version 3 or any later version
   6  *
   7  * This program is free software: you can redistribute it and/or modify
   8  * it under the terms of the GNU Affero General Public License as
   9  * published by the Free Software Foundation, either version 3 of the
  10  * License, or (at your option) any later version.
  11  *
  12  * This program is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  * GNU Affero General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Affero General Public License
  18  * along with this program.  If not, see <https://www.gnu.org/licenses/>.
  19  *
  20  */
  21
  22 namespace Friendica\App;
  23
  24 use Dice\Dice;
  25 use FastRoute\DataGenerator\GroupCountBased;
  26 use FastRoute\Dispatcher;
  27 use FastRoute\RouteCollector;
  28 use FastRoute\RouteParser\Std;
  29 use Friendica\Capabilities\ICanHandleRequests;
  30 use Friendica\Core\Addon;
  31 use Friendica\Core\Cache\Enum\Duration;
  32 use Friendica\Core\Cache\Capability\ICanCache;
  33 use Friendica\Core\Config\Capability\IManageConfigValues;
  34 use Friendica\Core\Hook;
  35 use Friendica\Core\L10n;
  36 use Friendica\Core\Lock\Capability\ICanLock;
  37 use Friendica\LegacyModule;
  38 use Friendica\Module\HTTPException\MethodNotAllowed;
  39 use Friendica\Module\HTTPException\PageNotFound;
  40 use Friendica\Module\Special\Options;
  41 use Friendica\Network\HTTPException;
  42 use Friendica\Network\HTTPException\MethodNotAllowedException;
  43 use Friendica\Network\HTTPException\NotFoundException;
  44 use Friendica\Util\Router\FriendicaGroupCountBased;
  45 use Psr\Log\LoggerInterface;
  46
  47 /**
  48  * Wrapper for FastRoute\Router
  49  *
  50  * This wrapper only makes use of a subset of the router features, mainly parses a route rule to return the relevant
  51  * module class.
  52  *
  53  * Actual routes are defined in App->collectRoutes.
  54  *
  55  * @package Friendica\App
  56  */
  57 class Router
  58 {
  59         const DELETE  = 'DELETE';
  60         const GET     = 'GET';
  61         const PATCH   = 'PATCH';
  62         const POST    = 'POST';
  63         const PUT     = 'PUT';
  64         const OPTIONS = 'OPTIONS';
  65
  66         const ALLOWED_METHODS = [
  67                 self::DELETE,
  68                 self::GET,
  69                 self::PATCH,
  70                 self::POST,
  71                 self::PUT,
  72                 self::OPTIONS
  73         ];
  74
  75         /** @var RouteCollector */
  76         protected $routeCollector;
  77
  78         /**
  79          * @var array Module parameters
  80          */
  81         private $parameters = [];
  82
  83         /** @var L10n */
  84         private $l10n;
  85
  86         /** @var ICanCache */
  87         private $cache;
  88
  89         /** @var ICanLock */
  90         private $lock;
  91
  92         /** @var Arguments */
  93         private $args;
  94
  95         /** @var IManageConfigValues */
  96         private $config;
  97
  98         /** @var LoggerInterface */
  99         private $logger;
 100
 101         /** @var float */
 102         private $dice_profiler_threshold;
 103
 104         /** @var Dice */
 105         private $dice;
 106
 107         /** @var string */
 108         private $baseRoutesFilepath;
 109
 110         /** @var array */
 111         private $server;
 112
 113         /**
 114          * @param array               $server             The $_SERVER variable
 115          * @param string              $baseRoutesFilepath The path to a base routes file to leverage cache, can be empty
 116          * @param L10n                $l10n
 117          * @param ICanCache           $cache
 118          * @param ICanLock            $lock
 119          * @param IManageConfigValues $config
 120          * @param Arguments           $args
 121          * @param LoggerInterface     $logger
 122          * @param Dice                $dice
 123          * @param RouteCollector|null $routeCollector
 124          */
 125         public function __construct(array $server, string $baseRoutesFilepath, L10n $l10n, ICanCache $cache, ICanLock $lock, IManageConfigValues $config, Arguments $args, LoggerInterface $logger, Dice $dice, RouteCollector $routeCollector = null)
 126         {
 127                 $this->baseRoutesFilepath      = $baseRoutesFilepath;
 128                 $this->l10n                    = $l10n;
 129                 $this->cache                   = $cache;
 130                 $this->lock                    = $lock;
 131                 $this->args                    = $args;
 132                 $this->config                  = $config;
 133                 $this->dice                    = $dice;
 134                 $this->server                  = $server;
 135                 $this->logger                  = $logger;
 136                 $this->dice_profiler_threshold = $config->get('system', 'dice_profiler_threshold', 0);
 137
 138                 $this->routeCollector = $routeCollector ?? new RouteCollector(new Std(), new GroupCountBased());
 139
 140                 if ($this->baseRoutesFilepath && !file_exists($this->baseRoutesFilepath)) {
 141                         throw new HTTPException\InternalServerErrorException('Routes file path does\'n exist.');
 142                 }
 143         }
 144
 145         /**
 146          * This will be called either automatically if a base routes file path was submitted,
 147          * or can be called manually with a custom route array.
 148          *
 149          * @param array $routes The routes to add to the Router
 150          *
 151          * @return self The router instance with the loaded routes
 152          *
 153          * @throws HTTPException\InternalServerErrorException In case of invalid configs
 154          */
 155         public function loadRoutes(array $routes)
 156         {
 157                 $routeCollector = ($this->routeCollector ?? new RouteCollector(new Std(), new GroupCountBased()));
 158
 159                 $this->addRoutes($routeCollector, $routes);
 160
 161                 $this->routeCollector = $routeCollector;
 162
 163                 // Add routes from addons
 164                 Hook::callAll('route_collection', $this->routeCollector);
 165
 166                 return $this;
 167         }
 168
 169         private function addRoutes(RouteCollector $routeCollector, array $routes)
 170         {
 171                 foreach ($routes as $route => $config) {
 172                         if ($this->isGroup($config)) {
 173                                 $this->addGroup($route, $config, $routeCollector);
 174                         } elseif ($this->isRoute($config)) {
 175                                 // Always add the OPTIONS endpoint to a route
 176                                 $httpMethods   = (array) $config[1];
 177                                 $httpMethods[] = Router::OPTIONS;
 178                                 $routeCollector->addRoute($httpMethods, $route, $config[0]);
 179                         } else {
 180                                 throw new HTTPException\InternalServerErrorException("Wrong route config for route '" . print_r($route, true) . "'");
 181                         }
 182                 }
 183         }
 184
 185         /**
 186          * Adds a group of routes to a given group
 187          *
 188          * @param string         $groupRoute     The route of the group
 189          * @param array          $routes         The routes of the group
 190          * @param RouteCollector $routeCollector The route collector to add this group
 191          */
 192         private function addGroup(string $groupRoute, array $routes, RouteCollector $routeCollector)
 193         {
 194                 $routeCollector->addGroup($groupRoute, function (RouteCollector $routeCollector) use ($routes) {
 195                         $this->addRoutes($routeCollector, $routes);
 196                 });
 197         }
 198
 199         /**
 200          * Returns true in case the config is a group config
 201          *
 202          * @param array $config
 203          *
 204          * @return bool
 205          */
 206         private function isGroup(array $config)
 207         {
 208                 return
 209                         is_array($config) &&
 210                         is_string(array_keys($config)[0]) &&
 211                         // This entry should NOT be a BaseModule
 212                         (substr(array_keys($config)[0], 0, strlen('Friendica\Module')) !== 'Friendica\Module') &&
 213                         // The second argument is an array (another routes)
 214                         is_array(array_values($config)[0]);
 215         }
 216
 217         /**
 218          * Returns true in case the config is a route config
 219          *
 220          * @param array $config
 221          *
 222          * @return bool
 223          */
 224         private function isRoute(array $config)
 225         {
 226                 return
 227                         // The config array should at least have one entry
 228                         !empty($config[0]) &&
 229                         // This entry should be a BaseModule
 230                         (substr($config[0], 0, strlen('Friendica\Module')) === 'Friendica\Module') &&
 231                         // Either there is no other argument
 232                         (empty($config[1]) ||
 233                          // Or the second argument is an array (HTTP-Methods)
 234                          is_array($config[1]));
 235         }
 236
 237         /**
 238          * The current route collector
 239          *
 240          * @return RouteCollector|null
 241          */
 242         public function getRouteCollector()
 243         {
 244                 return $this->routeCollector;
 245         }
 246
 247         /**
 248          * Returns the relevant module class name for the given page URI or NULL if no route rule matched.
 249          *
 250          * @return string A Friendica\BaseModule-extending class name if a route rule matched
 251          *
 252          * @throws HTTPException\InternalServerErrorException
 253          * @throws HTTPException\MethodNotAllowedException    If a rule matched but the method didn't
 254          * @throws HTTPException\NotFoundException            If no rule matched
 255          */
 256         private function getModuleClass()
 257         {
 258                 $cmd = $this->args->getCommand();
 259                 $cmd = '/' . ltrim($cmd, '/');
 260
 261                 $dispatcher = new FriendicaGroupCountBased($this->getCachedDispatchData());
 262
 263                 $this->parameters = [];
 264
 265                 // Check if the HTTP method is OPTIONS and return the special Options Module with the possible HTTP methods
 266                 if ($this->args->getMethod() === static::OPTIONS) {
 267                         $moduleClass      = Options::class;
 268                         $this->parameters = ['allowedMethods' => $dispatcher->getOptions($cmd)];
 269                 } else {
 270                         $routeInfo = $dispatcher->dispatch($this->args->getMethod(), $cmd);
 271                         if ($routeInfo[0] === Dispatcher::FOUND) {
 272                                 $moduleClass      = $routeInfo[1];
 273                                 $this->parameters = $routeInfo[2];
 274                         } elseif ($routeInfo[0] === Dispatcher::METHOD_NOT_ALLOWED) {
 275                                 throw new HTTPException\MethodNotAllowedException($this->l10n->t('Method not allowed for this module. Allowed method(s): %s', implode(', ', $routeInfo[1])));
 276                         } else {
 277                                 throw new HTTPException\NotFoundException($this->l10n->t('Page not found.'));
 278                         }
 279                 }
 280
 281                 return $moduleClass;
 282         }
 283
 284         public function getModule(?string $module_class = null): ICanHandleRequests
 285         {
 286                 $module_parameters = [$this->server];
 287                 /**
 288                  * ROUTING
 289                  *
 290                  * From the request URL, routing consists of obtaining the name of a BaseModule-extending class of which the
 291                  * post() and/or content() static methods can be respectively called to produce a data change or an output.
 292                  **/
 293                 try {
 294                         $module_class        = $module_class ?? $this->getModuleClass();
 295                         $module_parameters[] = $this->parameters;
 296                 } catch (MethodNotAllowedException $e) {
 297                         $module_class = MethodNotAllowed::class;
 298                 } catch (NotFoundException $e) {
 299                         $moduleName = $this->args->getModuleName();
 300                         // Then we try addon-provided modules that we wrap in the LegacyModule class
 301                         if (Addon::isEnabled($moduleName) && file_exists("addon/{$moduleName}/{$moduleName}.php")) {
 302                                 //Check if module is an app and if public access to apps is allowed or not
 303                                 $privateapps = $this->config->get('config', 'private_addons', false);
 304                                 if ((!local_user()) && Hook::isAddonApp($moduleName) && $privateapps) {
 305                                         throw new MethodNotAllowedException($this->l10n->t("You must be logged in to use addons. "));
 306                                 } else {
 307                                         include_once "addon/{$moduleName}/{$moduleName}.php";
 308                                         if (function_exists($moduleName . '_module')) {
 309                                                 $module_parameters[] = "addon/{$moduleName}/{$moduleName}.php";
 310                                                 $module_class        = LegacyModule::class;
 311                                         }
 312                                 }
 313                         }
 314
 315                         /* Finally, we look for a 'standard' program module in the 'mod' directory
 316                          * We emulate a Module class through the LegacyModule class
 317                          */
 318                         if (!$module_class && file_exists("mod/{$moduleName}.php")) {
 319                                 $module_parameters[] = "mod/{$moduleName}.php";
 320                                 $module_class        = LegacyModule::class;
 321                         }
 322
 323                         $module_class = $module_class ?: PageNotFound::class;
 324                 }
 325
 326                 $stamp = microtime(true);
 327
 328                 try {
 329                         /** @var ICanHandleRequests $module */
 330                         return $this->dice->create($module_class, $module_parameters);
 331                 } finally {
 332                         if ($this->dice_profiler_threshold > 0) {
 333                                 $dur = floatval(microtime(true) - $stamp);
 334                                 if ($dur >= $this->dice_profiler_threshold) {
 335                                         $this->logger->warning('Dice module creation lasts too long.', ['duration' => round($dur, 3), 'module' => $module_class, 'parameters' => $module_parameters]);
 336                                 }
 337                         }
 338                 }
 339         }
 340
 341         /**
 342          * If a base routes file path has been provided, we can load routes from it if the cache misses.
 343          *
 344          * @return array
 345          * @throws HTTPException\InternalServerErrorException
 346          */
 347         private function getDispatchData()
 348         {
 349                 $dispatchData = [];
 350
 351                 if ($this->baseRoutesFilepath) {
 352                         $dispatchData = require $this->baseRoutesFilepath;
 353                         if (!is_array($dispatchData)) {
 354                                 throw new HTTPException\InternalServerErrorException('Invalid base routes file');
 355                         }
 356                 }
 357
 358                 $this->loadRoutes($dispatchData);
 359
 360                 return $this->routeCollector->getData();
 361         }
 362
 363         /**
 364          * We cache the dispatch data for speed, as computing the current routes (version 2020.09)
 365          * takes about 850ms for each requests.
 366          *
 367          * The cached "routerDispatchData" lasts for a day, and must be cleared manually when there
 368          * is any changes in the enabled addons list.
 369          *
 370          * Additionally, we check for the base routes file last modification time to automatically
 371          * trigger re-computing the dispatch data.
 372          *
 373          * @return array|mixed
 374          * @throws HTTPException\InternalServerErrorException
 375          */
 376         private function getCachedDispatchData()
 377         {
 378                 $routerDispatchData         = $this->cache->get('routerDispatchData');
 379                 $lastRoutesFileModifiedTime = $this->cache->get('lastRoutesFileModifiedTime');
 380                 $forceRecompute             = false;
 381
 382                 if ($this->baseRoutesFilepath) {
 383                         $routesFileModifiedTime = filemtime($this->baseRoutesFilepath);
 384                         $forceRecompute         = $lastRoutesFileModifiedTime != $routesFileModifiedTime;
 385                 }
 386
 387                 if (!$forceRecompute && $routerDispatchData) {
 388                         return $routerDispatchData;
 389                 }
 390
 391                 if (!$this->lock->acquire('getCachedDispatchData', 0)) {
 392                         // Immediately return uncached data when we can't aquire a lock
 393                         return $this->getDispatchData();
 394                 }
 395
 396                 $routerDispatchData = $this->getDispatchData();
 397
 398                 $this->cache->set('routerDispatchData', $routerDispatchData, Duration::DAY);
 399                 if (!empty($routesFileModifiedTime)) {
 400                         $this->cache->set('lastRoutesFileModifiedTime', $routesFileModifiedTime, Duration::MONTH);
 401                 }
 402
 403                 if ($this->lock->isLocked('getCachedDispatchData')) {
 404                         $this->lock->release('getCachedDispatchData');
 405                 }
 406
 407                 return $routerDispatchData;
 408         }
 409 }