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

Open in your IDE?
  1. <?php
  3. /*
  4.  * This file is part of the Symfony CMF package.
  5.  *
  6.  * (c) 2011-2017 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 Symfony\Component\HttpFoundation\Request;
  16. use Symfony\Component\HttpKernel\CacheWarmer\WarmableInterface;
  17. use Symfony\Component\Routing\Exception\MethodNotAllowedException;
  18. use Symfony\Component\Routing\Exception\ResourceNotFoundException;
  19. use Symfony\Component\Routing\Exception\RouteNotFoundException;
  20. use Symfony\Component\Routing\Generator\UrlGeneratorInterface;
  21. use Symfony\Component\Routing\Matcher\RequestMatcherInterface;
  22. use Symfony\Component\Routing\RequestContext;
  23. use Symfony\Component\Routing\RequestContextAwareInterface;
  24. use Symfony\Component\Routing\RouteCollection;
  25. use Symfony\Component\Routing\RouterInterface;
  27. /**
  28.  * The ChainRouter allows to combine several routers to try in a defined order.
  29.  *
  30.  * @author Henrik Bjornskov <henrik@bjrnskov.dk>
  31.  * @author Magnus Nordlander <magnus@e-butik.se>
  32.  */
  33. class ChainRouter implements ChainRouterInterface, WarmableInterface
  34. {
  35.     /**
  36.      * @var RequestContext|null
  37.      */
  38.     private $context;
  40.     /**
  41.      * Array of arrays of routers grouped by priority.
  42.      *
  43.      * @var RouterInterface[][] Priority => RouterInterface[]
  44.      */
  45.     private $routers = [];
  47.     /**
  48.      * @var RouterInterface[] List of routers, sorted by priority
  49.      */
  50.     private $sortedRouters = [];
  52.     /**
  53.      * @var RouteCollection
  54.      */
  55.     private $routeCollection;
  57.     /**
  58.      * @var null|LoggerInterface
  59.      */
  60.     protected $logger;
  62.     /**
  63.      * @param LoggerInterface $logger
  64.      */
  65.     public function __construct(LoggerInterface $logger = null)
  66.     {
  67.         $this->logger = $logger;
  68.     }
  70.     /**
  71.      * @return RequestContext
  72.      */
  73.     public function getContext()
  74.     {
  75.         if (!$this->context) {
  76.             $this->context = new RequestContext();
  77.         }
  79.         return $this->context;
  80.     }
  82.     /**
  83.      * {@inheritdoc}
  84.      */
  85.     public function add($router, $priority = 0)
  86.     {
  87.         if (!$router instanceof RouterInterface
  88.             && !($router instanceof RequestMatcherInterface && $router instanceof UrlGeneratorInterface)
  89.         ) {
  90.             throw new \InvalidArgumentException(sprintf('%s is not a valid router.', get_class($router)));
  91.         }
  92.         if (empty($this->routers[$priority])) {
  93.             $this->routers[$priority] = [];
  94.         }
  96.         $this->routers[$priority][] = $router;
  97.         $this->sortedRouters = [];
  98.     }
  100.     /**
  101.      * {@inheritdoc}
  102.      */
  103.     public function all()
  104.     {
  105.         if (0 === count($this->sortedRouters)) {
  106.             $this->sortedRouters = $this->sortRouters();
  108.             // setContext() is done here instead of in add() to avoid fatal errors when clearing and warming up caches
  109.             // See https://github.com/symfony-cmf/Routing/pull/18
  110.             if (null !== $this->context) {
  111.                 foreach ($this->sortedRouters as $router) {
  112.                     if ($router instanceof RequestContextAwareInterface) {
  113.                         $router->setContext($this->context);
  114.                     }
  115.                 }
  116.             }
  117.         }
  119.         return $this->sortedRouters;
  120.     }
  122.     /**
  123.      * Sort routers by priority.
  124.      * The highest priority number is the highest priority (reverse sorting).
  125.      *
  126.      * @return RouterInterface[]
  127.      */
  128.     protected function sortRouters()
  129.     {
  130.         if (0 === count($this->routers)) {
  131.             return [];
  132.         }
  134.         krsort($this->routers);
  136.         return call_user_func_array('array_merge', $this->routers);
  137.     }
  139.     /**
  140.      * {@inheritdoc}
  141.      *
  142.      * Loops through all routes and tries to match the passed url.
  143.      *
  144.      * Note: You should use matchRequest if you can.
  145.      */
  146.     public function match($pathinfo)
  147.     {
  148.         return $this->doMatch($pathinfo);
  149.     }
  151.     /**
  152.      * {@inheritdoc}
  153.      *
  154.      * Loops through all routes and tries to match the passed request.
  155.      */
  156.     public function matchRequest(Request $request)
  157.     {
  158.         return $this->doMatch($request->getPathInfo(), $request);
  159.     }
  161.     /**
  162.      * Loops through all routers and tries to match the passed request or url.
  163.      *
  164.      * At least the  url must be provided, if a request is additionally provided
  165.      * the request takes precedence.
  166.      *
  167.      * @param string  $pathinfo
  168.      * @param Request $request
  169.      *
  170.      * @return array An array of parameters
  171.      *
  172.      * @throws ResourceNotFoundException If no router matched
  173.      */
  174.     private function doMatch($pathinfo, Request $request = null)
  175.     {
  176.         $methodNotAllowed = null;
  178.         $requestForMatching = $request;
  179.         foreach ($this->all() as $router) {
  180.             try {
  181.                 // the request/url match logic is the same as in Symfony/Component/HttpKernel/EventListener/RouterListener.php
  182.                 // matching requests is more powerful than matching URLs only, so try that first
  183.                 if ($router instanceof RequestMatcherInterface) {
  184.                     if (null === $requestForMatching) {
  185.                         $requestForMatching = $this->rebuildRequest($pathinfo);
  186.                     }
  188.                     return $router->matchRequest($requestForMatching);
  189.                 }
  191.                 // every router implements the match method
  192.                 return $router->match($pathinfo);
  193.             } catch (ResourceNotFoundException $e) {
  194.                 if ($this->logger) {
  195.                     $this->logger->debug('Router '.get_class($router).' was not able to match, message "'.$e->getMessage().'"');
  196.                 }
  197.                 // Needs special care
  198.             } catch (MethodNotAllowedException $e) {
  199.                 if ($this->logger) {
  200.                     $this->logger->debug('Router '.get_class($router).' throws MethodNotAllowedException with message "'.$e->getMessage().'"');
  201.                 }
  202.                 $methodNotAllowed = $e;
  203.             }
  204.         }
  206.         $info = $request
  207.             ? "this request\n$request"
  208.             : "url '$pathinfo'";
  210.         throw $methodNotAllowed ?: new ResourceNotFoundException("None of the routers in the chain matched $info");
  211.     }
  213.     /**
  214.      * {@inheritdoc}
  215.      *
  216.      * Loops through all registered routers and returns a router if one is found.
  217.      * It will always return the first route generated.
  218.      */
  219.     public function generate($name, $parameters = [], $absolute = UrlGeneratorInterface::ABSOLUTE_PATH)
  220.     {
  221.         $debug = [];
  223.         foreach ($this->all() as $router) {
  224.             // if $router does not announce it is capable of handling
  225.             // non-string routes and $name is not a string, continue
  226.             if ($name && !is_string($name) && !$router instanceof VersatileGeneratorInterface) {
  227.                 continue;
  228.             }
  230.             // If $router is versatile and doesn't support this route name, continue
  231.             if ($router instanceof VersatileGeneratorInterface && !$router->supports($name)) {
  232.                 continue;
  233.             }
  235.             try {
  236.                 return $router->generate($name, $parameters, $absolute);
  237.             } catch (RouteNotFoundException $e) {
  238.                 $hint = $this->getErrorMessage($name, $router, $parameters);
  239.                 $debug[] = $hint;
  240.                 if ($this->logger) {
  241.                     $this->logger->debug('Router '.get_class($router)." was unable to generate route. Reason: '$hint': ".$e->getMessage());
  242.                 }
  243.             }
  244.         }
  246.         if ($debug) {
  247.             $debug = array_unique($debug);
  248.             $info = implode(', ', $debug);
  249.         } else {
  250.             $info = $this->getErrorMessage($name);
  251.         }
  253.         throw new RouteNotFoundException(sprintf('None of the chained routers were able to generate route: %s', $info));
  254.     }
  256.     /**
  257.      * Rebuild the request object from a URL with the help of the RequestContext.
  258.      *
  259.      * If the request context is not set, this returns the request object built from $pathinfo.
  260.      *
  261.      * @param string $pathinfo
  262.      *
  263.      * @return Request
  264.      */
  265.     private function rebuildRequest($pathinfo)
  266.     {
  267.         $context = $this->getContext();
  269.         $uri = $pathinfo;
  271.         $server = [];
  272.         if ($context->getBaseUrl()) {
  273.             $uri = $context->getBaseUrl().$pathinfo;
  274.             $server['SCRIPT_FILENAME'] = $context->getBaseUrl();
  275.             $server['PHP_SELF'] = $context->getBaseUrl();
  276.         }
  277.         $host = $context->getHost() ?: 'localhost';
  278.         if ('https' === $context->getScheme() && 443 !== $context->getHttpsPort()) {
  279.             $host .= ':'.$context->getHttpsPort();
  280.         }
  281.         if ('http' === $context->getScheme() && 80 !== $context->getHttpPort()) {
  282.             $host .= ':'.$context->getHttpPort();
  283.         }
  284.         $uri = $context->getScheme().'://'.$host.$uri.'?'.$context->getQueryString();
  286.         return Request::create($uri, $context->getMethod(), $context->getParameters(), [], [], $server);
  287.     }
  289.     private function getErrorMessage($name, $router = null, $parameters = null)
  290.     {
  291.         if ($router instanceof VersatileGeneratorInterface) {
  292.             // the $parameters are not forced to be array, but versatile generator does typehint it
  293.             if (!is_array($parameters)) {
  294.                 $parameters = [];
  295.             }
  296.             $displayName = $router->getRouteDebugMessage($name, $parameters);
  297.         } elseif (is_object($name)) {
  298.             $displayName = method_exists($name, '__toString')
  299.                 ? (string) $name
  300.                 : get_class($name)
  301.             ;
  302.         } else {
  303.             $displayName = (string) $name;
  304.         }
  306.         return "Route '$displayName' not found";
  307.     }
  309.     /**
  310.      * {@inheritdoc}
  311.      */
  312.     public function setContext(RequestContext $context)
  313.     {
  314.         foreach ($this->all() as $router) {
  315.             if ($router instanceof RequestContextAwareInterface) {
  316.                 $router->setContext($context);
  317.             }
  318.         }
  320.         $this->context = $context;
  321.     }
  323.     /**
  324.      * {@inheritdoc}
  325.      *
  326.      * check for each contained router if it can warmup
  327.      */
  328.     public function warmUp($cacheDir)
  329.     {
  330.         foreach ($this->all() as $router) {
  331.             if ($router instanceof WarmableInterface) {
  332.                 $router->warmUp($cacheDir);
  333.             }
  334.         }
  335.     }
  337.     /**
  338.      * {@inheritdoc}
  339.      */
  340.     public function getRouteCollection()
  341.     {
  342.         if (!$this->routeCollection instanceof RouteCollection) {
  343.             $this->routeCollection = new ChainRouteCollection();
  344.             foreach ($this->all() as $router) {
  345.                 $this->routeCollection->addCollection($router->getRouteCollection());
  346.             }
  347.         }
  349.         return $this->routeCollection;
  350.     }
  352.     /**
  353.      * Identify if any routers have been added into the chain yet.
  354.      *
  355.      * @return bool
  356.      */
  357.     public function hasRouters()
  358.     {
  359.         return 0 < count($this->routers);
  360.     }
  361. }