vendor/symfony-cmf/routing/src/ChainRouter.php line 134

  1. <?php
  3. /*
  4.  * This file is part of the Symfony CMF package.
  5.  *
  6.  * (c) Symfony CMF
  7.  *
  8.  * For the full copyright and license information, please view the LICENSE
  9.  * file that was distributed with this source code.
  10.  */
  12. namespace Symfony\Cmf\Component\Routing;
  14. use Psr\Log\LoggerInterface;
  15. use Psr\Log\NullLogger;
  16. use Symfony\Component\HttpFoundation\Request;
  17. use Symfony\Component\HttpKernel\CacheWarmer\WarmableInterface;
  18. use Symfony\Component\Routing\Exception\MethodNotAllowedException;
  19. use Symfony\Component\Routing\Exception\ResourceNotFoundException;
  20. use Symfony\Component\Routing\Exception\RouteNotFoundException;
  21. use Symfony\Component\Routing\Generator\UrlGeneratorInterface;
  22. use Symfony\Component\Routing\Matcher\RequestMatcherInterface;
  23. use Symfony\Component\Routing\Matcher\UrlMatcherInterface;
  24. use Symfony\Component\Routing\RequestContext;
  25. use Symfony\Component\Routing\RequestContextAwareInterface;
  26. use Symfony\Component\Routing\RouteCollection;
  27. use Symfony\Component\Routing\RouterInterface;
  29. /**
  30.  * The ChainRouter allows to combine several routers to try in a defined order.
  31.  *
  32.  * @author Henrik Bjornskov <henrik@bjrnskov.dk>
  33.  * @author Magnus Nordlander <magnus@e-butik.se>
  34.  */
  35. class ChainRouter implements ChainRouterInterface, WarmableInterface
  36. {
  37.     private ?RequestContext $context = null;
  39.     /**
  40.      * Array of arrays of routers grouped by priority.
  41.      *
  42.      * @var array<int, array<RouterInterface|RequestMatcherInterface|UrlGeneratorInterface>> Priority => RouterInterface[]
  43.      */
  44.     private array $routers = [];
  46.     /**
  47.      * @var RouterInterface[] List of routers, sorted by priority
  48.      */
  49.     private array $sortedRouters = [];
  51.     private RouteCollection $routeCollection;
  53.     private LoggerInterface $logger;
  55.     public function __construct(?LoggerInterface $logger = null)
  56.     {
  57.         $this->logger = $logger ?: new NullLogger();
  58.     }
  60.     public function getContext(): RequestContext
  61.     {
  62.         if (!$this->context) {
  63.             $this->context = new RequestContext();
  64.         }
  66.         return $this->context;
  67.     }
  69.     public function add(RouterInterface|RequestMatcherInterface|UrlGeneratorInterface $router, $priority = 0): void
  70.     {
  71.         if (empty($this->routers[$priority])) {
  72.             $this->routers[$priority] = [];
  73.         }
  75.         $this->routers[$priority][] = $router;
  76.         $this->sortedRouters = [];
  77.     }
  79.     public function all(): array
  80.     {
  81.         if (0 === count($this->sortedRouters)) {
  82.             $this->sortedRouters = $this->sortRouters();
  84.             // setContext() is done here instead of in add() to avoid fatal errors when clearing and warming up caches
  85.             // See https://github.com/symfony-cmf/Routing/pull/18
  86.             if (null !== $this->context) {
  87.                 foreach ($this->sortedRouters as $router) {
  88.                     if ($router instanceof RequestContextAwareInterface) {
  89.                         $router->setContext($this->context);
  90.                     }
  91.                 }
  92.             }
  93.         }
  95.         return $this->sortedRouters;
  96.     }
  98.     /**
  99.      * Sort routers by priority.
  100.      * The highest priority number is the highest priority (reverse sorting).
  101.      *
  102.      * @return RouterInterface[]
  103.      */
  104.     protected function sortRouters(): array
  105.     {
  106.         if (0 === count($this->routers)) {
  107.             return [];
  108.         }
  110.         krsort($this->routers);
  112.         return call_user_func_array('array_merge', $this->routers);
  113.     }
  115.     /**
  116.      * {@inheritdoc}
  117.      *
  118.      * Loops through all routes and tries to match the passed url.
  119.      *
  120.      * Note: You should use matchRequest if you can.
  121.      */
  122.     public function match(string $pathinfo): array
  123.     {
  124.         return $this->doMatch($pathinfo);
  125.     }
  127.     /**
  128.      * {@inheritdoc}
  129.      *
  130.      * Loops through all routes and tries to match the passed request.
  131.      */
  132.     public function matchRequest(Request $request): array
  133.     {
  134.         return $this->doMatch($request->getPathInfo(), $request);
  135.     }
  137.     /**
  138.      * Loops through all routers and tries to match the passed request or url.
  139.      *
  140.      * At least the  url must be provided, if a request is additionally provided
  141.      * the request takes precedence.
  142.      *
  143.      * @return array<string, mixed> An array of parameters
  144.      *
  145.      * @throws ResourceNotFoundException If no router matched
  146.      */
  147.     private function doMatch(string $pathinfo, ?Request $request = null): array
  148.     {
  149.         $methodNotAllowed = null;
  151.         $requestForMatching = $request;
  152.         foreach ($this->all() as $router) {
  153.             try {
  154.                 // the request/url match logic is the same as in Symfony/Component/HttpKernel/EventListener/RouterListener.php
  155.                 // matching requests is more powerful than matching URLs only, so try that first
  156.                 if ($router instanceof RequestMatcherInterface) {
  157.                     if (null === $requestForMatching) {
  158.                         $requestForMatching = $this->rebuildRequest($pathinfo);
  159.                     }
  161.                     return $router->matchRequest($requestForMatching);
  162.                 }
  163.                 if ($router instanceof UrlMatcherInterface) {
  164.                     return $router->match($pathinfo);
  165.                 }
  166.                 // otherwise this was only an url generator, move on.
  167.             } catch (ResourceNotFoundException $e) {
  168.                 $this->logger->debug('Router '.get_class($router).' was not able to match, message "'.$e->getMessage().'"');
  169.                 // Needs special care
  170.             } catch (MethodNotAllowedException $e) {
  171.                 $this->logger->debug('Router '.get_class($router).' throws MethodNotAllowedException with message "'.$e->getMessage().'"');
  172.                 $methodNotAllowed = $e;
  173.             }
  174.         }
  176.         $info = $request
  177.             ? "this request\n$request"
  178.             : "url '$pathinfo'";
  180.         throw $methodNotAllowed ?: new ResourceNotFoundException("None of the routers in the chain matched $info");
  181.     }
  183.     /**
  184.      * {@inheritdoc}
  185.      *
  186.      * Loops through all registered routers and returns a router if one is found.
  187.      * It will always return the first route generated.
  188.      */
  189.     public function generate(string $name, array $parameters = [], int $referenceType = UrlGeneratorInterface::ABSOLUTE_PATH): string
  190.     {
  191.         $debug = [];
  193.         foreach ($this->all() as $router) {
  194.             // if $router does not announce it is capable of handling
  195.             // non-string routes and $name is not a string, continue
  196.             if ($name && !is_string($name) && !$router instanceof VersatileGeneratorInterface) {
  197.                 continue;
  198.             }
  200.             try {
  201.                 return $router->generate($name, $parameters, $referenceType);
  202.             } catch (RouteNotFoundException $e) {
  203.                 $hint = $this->getErrorMessage($name, $router, $parameters);
  204.                 $debug[] = $hint;
  205.                 $this->logger->debug('Router '.get_class($router)." was unable to generate route. Reason: '$hint': ".$e->getMessage());
  206.             }
  207.         }
  209.         if ($debug) {
  210.             $debug = array_unique($debug);
  211.             $info = implode(', ', $debug);
  212.         } else {
  213.             $info = $this->getErrorMessage($name);
  214.         }
  216.         throw new RouteNotFoundException(sprintf('None of the chained routers were able to generate route: %s', $info));
  217.     }
  219.     /**
  220.      * Rebuild the request object from a URL with the help of the RequestContext.
  221.      *
  222.      * If the request context is not set, this returns the request object built from $pathinfo.
  223.      */
  224.     private function rebuildRequest(string $pathinfo): Request
  225.     {
  226.         $context = $this->getContext();
  228.         $uri = $pathinfo;
  230.         $server = [];
  231.         if ($context->getBaseUrl()) {
  232.             $uri = $context->getBaseUrl().$pathinfo;
  233.             $server['SCRIPT_FILENAME'] = $context->getBaseUrl();
  234.             $server['PHP_SELF'] = $context->getBaseUrl();
  235.         }
  236.         $host = $context->getHost() ?: 'localhost';
  237.         if ('https' === $context->getScheme() && 443 !== $context->getHttpsPort()) {
  238.             $host .= ':'.$context->getHttpsPort();
  239.         }
  240.         if ('http' === $context->getScheme() && 80 !== $context->getHttpPort()) {
  241.             $host .= ':'.$context->getHttpPort();
  242.         }
  243.         $uri = $context->getScheme().'://'.$host.$uri.'?'.$context->getQueryString();
  245.         return Request::create($uri, $context->getMethod(), $context->getParameters(), [], [], $server);
  246.     }
  248.     private function getErrorMessage(
  249.         string $name,
  250.         RouterInterface|UrlGeneratorInterface|RequestMatcherInterface $router = null,
  251.         array $parameters = null
  252.     ): string {
  253.         if ($router instanceof VersatileGeneratorInterface) {
  254.             // the $parameters are not forced to be array, but versatile generator does typehint it
  255.             if (!is_array($parameters)) {
  256.                 $parameters = [];
  257.             }
  258.             $displayName = $router->getRouteDebugMessage($name, $parameters);
  259.         } elseif (is_object($name)) {
  260.             $displayName = method_exists($name, '__toString')
  261.                 ? (string) $name
  262.                 : get_class($name)
  263.             ;
  264.         } else {
  265.             $displayName = (string) $name;
  266.         }
  268.         return "Route '$displayName' not found";
  269.     }
  271.     public function setContext(RequestContext $context): void
  272.     {
  273.         foreach ($this->all() as $router) {
  274.             if ($router instanceof RequestContextAwareInterface) {
  275.                 $router->setContext($context);
  276.             }
  277.         }
  279.         $this->context = $context;
  280.     }
  282.     public function warmUp(string $cacheDir): array
  283.     {
  284.         foreach ($this->all() as $router) {
  285.             if ($router instanceof WarmableInterface) {
  286.                 $router->warmUp($cacheDir);
  287.             }
  288.         }
  290.         return [];
  291.     }
  293.     public function getRouteCollection(): RouteCollection
  294.     {
  295.         if (!isset($this->routeCollection)) {
  296.             $this->routeCollection = new ChainRouteCollection();
  297.             foreach ($this->all() as $router) {
  298.                 if ($router instanceof RouterInterface) {
  299.                     $this->routeCollection->addCollection($router->getRouteCollection());
  300.                 }
  301.             }
  302.         }
  304.         return $this->routeCollection;
  305.     }
  307.     public function hasRouters(): bool
  308.     {
  309.         return 0 < count($this->routers);
  310.     }
  311. }