vendor/symfony/http-kernel/HttpKernel.php line 121

Open in your IDE?
  1. <?php
  3. /*
  4.  * This file is part of the Symfony package.
  5.  *
  6.  * (c) Fabien Potencier <fabien@symfony.com>
  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\Component\HttpKernel;
  14. use Symfony\Component\EventDispatcher\EventDispatcherInterface;
  15. use Symfony\Component\HttpFoundation\Exception\RequestExceptionInterface;
  16. use Symfony\Component\HttpFoundation\Request;
  17. use Symfony\Component\HttpFoundation\RequestStack;
  18. use Symfony\Component\HttpFoundation\Response;
  19. use Symfony\Component\HttpKernel\Controller\ArgumentResolver;
  20. use Symfony\Component\HttpKernel\Controller\ArgumentResolverInterface;
  21. use Symfony\Component\HttpKernel\Controller\ControllerResolverInterface;
  22. use Symfony\Component\HttpKernel\Event\FilterControllerArgumentsEvent;
  23. use Symfony\Component\HttpKernel\Event\FilterControllerEvent;
  24. use Symfony\Component\HttpKernel\Event\FilterResponseEvent;
  25. use Symfony\Component\HttpKernel\Event\FinishRequestEvent;
  26. use Symfony\Component\HttpKernel\Event\GetResponseEvent;
  27. use Symfony\Component\HttpKernel\Event\GetResponseForControllerResultEvent;
  28. use Symfony\Component\HttpKernel\Event\GetResponseForExceptionEvent;
  29. use Symfony\Component\HttpKernel\Event\PostResponseEvent;
  30. use Symfony\Component\HttpKernel\Exception\BadRequestHttpException;
  31. use Symfony\Component\HttpKernel\Exception\ControllerDoesNotReturnResponseException;
  32. use Symfony\Component\HttpKernel\Exception\HttpExceptionInterface;
  33. use Symfony\Component\HttpKernel\Exception\NotFoundHttpException;
  35. /**
  36.  * HttpKernel notifies events to convert a Request object to a Response one.
  37.  *
  38.  * @author Fabien Potencier <fabien@symfony.com>
  39.  */
  40. class HttpKernel implements HttpKernelInterface, TerminableInterface {
  42.     protected $dispatcher;
  43.     protected $resolver;
  44.     protected $requestStack;
  45.     private $argumentResolver;
  47.     public function __construct(EventDispatcherInterface $dispatcher, ControllerResolverInterface $resolver, RequestStack $requestStack = null, ArgumentResolverInterface $argumentResolver = null) {
  48.         $this->dispatcher = $dispatcher;
  49.         $this->resolver = $resolver;
  50.         $this->requestStack = $requestStack ?: new RequestStack();
  51.         $this->argumentResolver = $argumentResolver;
  53.         if (null === $this->argumentResolver) {
  54.             $this->argumentResolver = new ArgumentResolver();
  55.         }
  56.     }
  58.     /**
  59.      * {@inheritdoc}
  60.      */
  61.     public function handle(Request $request, $type = HttpKernelInterface::MASTER_REQUEST, $catch = true) {
  62.         $request->headers->set('X-Php-Ob-Level', ob_get_level());
  64.         try {
  65.             return $this->handleRaw($request, $type);
  66.         } catch (\Exception $e) {
  67.             if ($e instanceof RequestExceptionInterface) {
  68.                 $e = new BadRequestHttpException($e->getMessage(), $e);
  69.             }
  70.             if (false === $catch) {
  71.                 $this->finishRequest($request, $type);
  73.                 throw $e;
  74.             }
  76.             return $this->handleException($e, $request, $type);
  77.         }
  78.     }
  80.     /**
  81.      * {@inheritdoc}
  82.      */
  83.     public function terminate(Request $request, Response $response) {
  84.         $this->dispatcher->dispatch(KernelEvents::TERMINATE, new PostResponseEvent($this, $request, $response));
  85.     }
  87.     /**
  88.      * @internal
  89.      */
  90.     public function terminateWithException(\Exception $exception, Request $request = null) {
  91.         if (!$request = $request ?: $this->requestStack->getMasterRequest()) {
  92.             throw $exception;
  93.         }
  95.         $response = $this->handleException($exception, $request, self::MASTER_REQUEST);
  97.         $response->sendHeaders();
  98.         $response->sendContent();
  100.         $this->terminate($request, $response);
  101.     }
  103.     /**
  104.      * Handles a request to convert it to a response.
  105.      *
  106.      * Exceptions are not caught.
  107.      *
  108.      * @param Request $request A Request instance
  109.      * @param int     $type    The type of the request (one of HttpKernelInterface::MASTER_REQUEST or HttpKernelInterface::SUB_REQUEST)
  110.      *
  111.      * @return Response A Response instance
  112.      *
  113.      * @throws \LogicException       If one of the listener does not behave as expected
  114.      * @throws NotFoundHttpException When controller cannot be found
  115.      */
  116.     private function handleRaw(Request $request, int $type = self::MASTER_REQUEST) {
  117.         $this->requestStack->push($request);
  119.         // request
  120.         $event = new GetResponseEvent($this, $request, $type);
  121.         $this->dispatcher->dispatch(KernelEvents::REQUEST, $event);
  123.         if ($event->hasResponse()) {
  124.             return $this->filterResponse($event->getResponse(), $request, $type);
  125.         }
  127.         // load controller
  128.         if (false === $controller = $this->resolver->getController($request)) {
  129.             throw new NotFoundHttpException(sprintf('Unable to find the controller for path "%s". The route is wrongly configured.', $request->getPathInfo()));
  130.         }
  132.         $event = new FilterControllerEvent($this, $controller, $request, $type);
  133.         $this->dispatcher->dispatch(KernelEvents::CONTROLLER, $event);
  134.         $controller = $event->getController();
  136.         // controller arguments
  137.         $arguments = $this->argumentResolver->getArguments($request, $controller);
  139.         $event = new FilterControllerArgumentsEvent($this, $controller, $arguments, $request, $type);
  140.         $this->dispatcher->dispatch(KernelEvents::CONTROLLER_ARGUMENTS, $event);
  141.         $controller = $event->getController();
  142.         $arguments = $event->getArguments();
  144.         // call controller
  145.         $response = $controller(...$arguments);
  147.         // view
  148.         if (!$response instanceof Response) {
  149.             $event = new GetResponseForControllerResultEvent($this, $request, $type, $response);
  150.             $this->dispatcher->dispatch(KernelEvents::VIEW, $event);
  152.             if ($event->hasResponse()) {
  153.                 $response = $event->getResponse();
  154.             } else {
  155.                 $msg = sprintf('The controller must return a "Symfony\Component\HttpFoundation\Response" object but it returned %s.', $this->varToString($response));
  157.                 // the user may have forgotten to return something
  158.                 if (null === $response) {
  159.                     $msg .= ' Did you forget to add a return statement somewhere in your controller?';
  160.                 }
  162.                 throw new ControllerDoesNotReturnResponseException($msg, $controller, __FILE__, __LINE__ - 17);
  163.             }
  164.         }
  166.         return $this->filterResponse($response, $request, $type);
  167.     }
  169.     /**
  170.      * Filters a response object.
  171.      *
  172.      * @param Response $response A Response instance
  173.      * @param Request  $request  An error message in case the response is not a Response object
  174.      * @param int      $type     The type of the request (one of HttpKernelInterface::MASTER_REQUEST or HttpKernelInterface::SUB_REQUEST)
  175.      *
  176.      * @return Response The filtered Response instance
  177.      *
  178.      * @throws \RuntimeException if the passed object is not a Response instance
  179.      */
  180.     private function filterResponse(Response $response, Request $request, int $type) {
  181.         $event = new FilterResponseEvent($this, $request, $type, $response);
  183.         $this->dispatcher->dispatch(KernelEvents::RESPONSE, $event);
  185.         $this->finishRequest($request, $type);
  187.         return $event->getResponse();
  188.     }
  190.     /**
  191.      * Publishes the finish request event, then pop the request from the stack.
  192.      *
  193.      * Note that the order of the operations is important here, otherwise
  194.      * operations such as {@link RequestStack::getParentRequest()} can lead to
  195.      * weird results.
  196.      */
  197.     private function finishRequest(Request $request, int $type) {
  198.         $this->dispatcher->dispatch(KernelEvents::FINISH_REQUEST, new FinishRequestEvent($this, $request, $type));
  199.         $this->requestStack->pop();
  200.     }
  202.     /**
  203.      * Handles an exception by trying to convert it to a Response.
  204.      *
  205.      * @param \Exception $e       An \Exception instance
  206.      * @param Request    $request A Request instance
  207.      * @param int        $type    The type of the request (one of HttpKernelInterface::MASTER_REQUEST or HttpKernelInterface::SUB_REQUEST)
  208.      *
  209.      * @throws \Exception
  210.      */
  211.     private function handleException(\Exception $e, Request $request, int $type): Response {
  212.         $event = new GetResponseForExceptionEvent($this, $request, $type, $e);
  213.         $this->dispatcher->dispatch(KernelEvents::EXCEPTION, $event);
  215.         // a listener might have replaced the exception
  216.         $e = $event->getException();
  218.         if (!$event->hasResponse()) {
  219.             $this->finishRequest($request, $type);
  221.             throw $e;
  222.         }
  224.         $response = $event->getResponse();
  226.         // the developer asked for a specific status code
  227.         if (!$event->isAllowingCustomResponseCode() && !$response->isClientError() && !$response->isServerError() && !$response->isRedirect()) {
  228.             // ensure that we actually have an error response
  229.             if ($e instanceof HttpExceptionInterface) {
  230.                 // keep the HTTP status code and headers
  231.                 $response->setStatusCode($e->getStatusCode());
  232.                 $response->headers->add($e->getHeaders());
  233.             } else {
  234.                 $response->setStatusCode(500);
  235.             }
  236.         }
  238.         try {
  239.             return $this->filterResponse($response, $request, $type);
  240.         } catch (\Exception $e) {
  241.             return $response;
  242.         }
  243.     }
  245.     /**
  246.      * Returns a human-readable string for the specified variable.
  247.      */
  248.     private function varToString($var): string {
  249.         if (\is_object($var)) {
  250.             return sprintf('an object of type %s', \get_class($var));
  251.         }
  253.         if (\is_array($var)) {
  254.             $a = [];
  255.             foreach ($var as $k => $v) {
  256.                 $a[] = sprintf('%s => ...', $k);
  257.             }
  259.             return sprintf('an array ([%s])', mb_substr(implode(', ', $a), 0, 255));
  260.         }
  262.         if (\is_resource($var)) {
  263.             return sprintf('a resource (%s)', get_resource_type($var));
  264.         }
  266.         if (null === $var) {
  267.             return 'null';
  268.         }
  270.         if (false === $var) {
  271.             return 'a boolean value (false)';
  272.         }
  274.         if (true === $var) {
  275.             return 'a boolean value (true)';
  276.         }
  278.         if (\is_string($var)) {
  279.             return sprintf('a string ("%s%s")', mb_substr($var, 0, 255), mb_strlen($var) > 255 ? '...' : '');
  280.         }
  282.         if (is_numeric($var)) {
  283.             return sprintf('a number (%s)', (string) $var);
  284.         }
  286.         return (string) $var;
  287.     }
  289. }