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

  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\HttpFoundation\Exception\RequestExceptionInterface;
  15. use Symfony\Component\HttpFoundation\Request;
  16. use Symfony\Component\HttpFoundation\RequestStack;
  17. use Symfony\Component\HttpFoundation\Response;
  18. use Symfony\Component\HttpFoundation\StreamedResponse;
  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\ControllerArgumentsEvent;
  23. use Symfony\Component\HttpKernel\Event\ControllerEvent;
  24. use Symfony\Component\HttpKernel\Event\ExceptionEvent;
  25. use Symfony\Component\HttpKernel\Event\FinishRequestEvent;
  26. use Symfony\Component\HttpKernel\Event\RequestEvent;
  27. use Symfony\Component\HttpKernel\Event\ResponseEvent;
  28. use Symfony\Component\HttpKernel\Event\TerminateEvent;
  29. use Symfony\Component\HttpKernel\Event\ViewEvent;
  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;
  34. use Symfony\Contracts\EventDispatcher\EventDispatcherInterface;
  36. // Help opcache.preload discover always-needed symbols
  37. class_exists(ControllerArgumentsEvent::class);
  38. class_exists(ControllerEvent::class);
  39. class_exists(ExceptionEvent::class);
  40. class_exists(FinishRequestEvent::class);
  41. class_exists(RequestEvent::class);
  42. class_exists(ResponseEvent::class);
  43. class_exists(TerminateEvent::class);
  44. class_exists(ViewEvent::class);
  45. class_exists(KernelEvents::class);
  47. /**
  48. * HttpKernel notifies events to convert a Request object to a Response one.
  49. *
  50. * @author Fabien Potencier <fabien@symfony.com>
  51. */
  52. class HttpKernel implements HttpKernelInterface, TerminableInterface
  53. {
  54. protected RequestStack $requestStack;
  55. private ArgumentResolverInterface $argumentResolver;
  56. private bool $terminating = false;
  58. public function __construct(
  59. protected EventDispatcherInterface $dispatcher,
  60. protected ControllerResolverInterface $resolver,
  61. ?RequestStack $requestStack = null,
  62. ?ArgumentResolverInterface $argumentResolver = null,
  63. private bool $handleAllThrowables = false,
  64. ) {
  65. $this->requestStack = $requestStack ?? new RequestStack();
  66. $this->argumentResolver = $argumentResolver ?? new ArgumentResolver();
  67. }
  69. public function handle(Request $request, int $type = HttpKernelInterface::MAIN_REQUEST, bool $catch = true): Response
  70. {
  71. $request->headers->set('X-Php-Ob-Level', (string) ob_get_level());
  73. $this->requestStack->push($request);
  74. $response = null;
  75. try {
  76. return $response = $this->handleRaw($request, $type);
  77. } catch (\Throwable $e) {
  78. if ($e instanceof \Error && !$this->handleAllThrowables) {
  79. throw $e;
  80. }
  82. if ($e instanceof RequestExceptionInterface) {
  83. $e = new BadRequestHttpException($e->getMessage(), $e);
  84. }
  85. if (false === $catch) {
  86. $this->finishRequest($request, $type);
  88. throw $e;
  89. }
  91. return $response = $this->handleThrowable($e, $request, $type);
  92. } finally {
  93. $this->requestStack->pop();
  95. if ($response instanceof StreamedResponse && $callback = $response->getCallback()) {
  96. $requestStack = $this->requestStack;
  98. $response->setCallback(static function () use ($request, $callback, $requestStack) {
  99. $requestStack->push($request);
  100. try {
  101. $callback();
  102. } finally {
  103. $requestStack->pop();
  104. }
  105. });
  106. }
  107. }
  108. }
  110. public function terminate(Request $request, Response $response): void
  111. {
  112. try {
  113. $this->terminating = true;
  114. $this->dispatcher->dispatch(new TerminateEvent($this, $request, $response), KernelEvents::TERMINATE);
  115. } finally {
  116. $this->terminating = false;
  117. }
  118. }
  120. /**
  121. * @internal
  122. */
  123. public function terminateWithException(\Throwable $exception, ?Request $request = null): void
  124. {
  125. if (!$request ??= $this->requestStack->getMainRequest()) {
  126. throw $exception;
  127. }
  129. if ($pop = $request !== $this->requestStack->getMainRequest()) {
  130. $this->requestStack->push($request);
  131. }
  133. try {
  134. $response = $this->handleThrowable($exception, $request, self::MAIN_REQUEST);
  135. } finally {
  136. if ($pop) {
  137. $this->requestStack->pop();
  138. }
  139. }
  141. $response->sendHeaders();
  142. $response->sendContent();
  144. $this->terminate($request, $response);
  145. }
  147. /**
  148. * Handles a request to convert it to a response.
  149. *
  150. * Exceptions are not caught.
  151. *
  152. * @throws \LogicException If one of the listener does not behave as expected
  153. * @throws NotFoundHttpException When controller cannot be found
  154. */
  155. private function handleRaw(Request $request, int $type = self::MAIN_REQUEST): Response
  156. {
  157. // request
  158. $event = new RequestEvent($this, $request, $type);
  159. $this->dispatcher->dispatch($event, KernelEvents::REQUEST);
  161. if ($event->hasResponse()) {
  162. return $this->filterResponse($event->getResponse(), $request, $type);
  163. }
  165. // load controller
  166. if (false === $controller = $this->resolver->getController($request)) {
  167. throw new NotFoundHttpException(sprintf('Unable to find the controller for path "%s". The route is wrongly configured.', $request->getPathInfo()));
  168. }
  170. $event = new ControllerEvent($this, $controller, $request, $type);
  171. $this->dispatcher->dispatch($event, KernelEvents::CONTROLLER);
  172. $controller = $event->getController();
  174. // controller arguments
  175. $arguments = $this->argumentResolver->getArguments($request, $controller, $event->getControllerReflector());
  177. $event = new ControllerArgumentsEvent($this, $event, $arguments, $request, $type);
  178. $this->dispatcher->dispatch($event, KernelEvents::CONTROLLER_ARGUMENTS);
  179. $controller = $event->getController();
  180. $arguments = $event->getArguments();
  182. // call controller
  183. $response = $controller(...$arguments);
  185. // view
  186. if (!$response instanceof Response) {
  187. $event = new ViewEvent($this, $request, $type, $response, $event);
  188. $this->dispatcher->dispatch($event, KernelEvents::VIEW);
  190. if ($event->hasResponse()) {
  191. $response = $event->getResponse();
  192. } else {
  193. $msg = sprintf('The controller must return a "Symfony\Component\HttpFoundation\Response" object but it returned %s.', $this->varToString($response));
  195. // the user may have forgotten to return something
  196. if (null === $response) {
  197. $msg .= ' Did you forget to add a return statement somewhere in your controller?';
  198. }
  200. throw new ControllerDoesNotReturnResponseException($msg, $controller, __FILE__, __LINE__ - 17);
  201. }
  202. }
  204. return $this->filterResponse($response, $request, $type);
  205. }
  207. /**
  208. * Filters a response object.
  209. *
  210. * @throws \RuntimeException if the passed object is not a Response instance
  211. */
  212. private function filterResponse(Response $response, Request $request, int $type): Response
  213. {
  214. $event = new ResponseEvent($this, $request, $type, $response);
  216. $this->dispatcher->dispatch($event, KernelEvents::RESPONSE);
  218. $this->finishRequest($request, $type);
  220. return $event->getResponse();
  221. }
  223. /**
  224. * Publishes the finish request event, then pop the request from the stack.
  225. *
  226. * Note that the order of the operations is important here, otherwise
  227. * operations such as {@link RequestStack::getParentRequest()} can lead to
  228. * weird results.
  229. */
  230. private function finishRequest(Request $request, int $type): void
  231. {
  232. $this->dispatcher->dispatch(new FinishRequestEvent($this, $request, $type), KernelEvents::FINISH_REQUEST);
  233. }
  235. /**
  236. * Handles a throwable by trying to convert it to a Response.
  237. */
  238. private function handleThrowable(\Throwable $e, Request $request, int $type): Response
  239. {
  240. $event = new ExceptionEvent($this, $request, $type, $e, isKernelTerminating: $this->terminating);
  241. $this->dispatcher->dispatch($event, KernelEvents::EXCEPTION);
  243. // a listener might have replaced the exception
  244. $e = $event->getThrowable();
  246. if (!$event->hasResponse()) {
  247. $this->finishRequest($request, $type);
  249. throw $e;
  250. }
  252. $response = $event->getResponse();
  254. // the developer asked for a specific status code
  255. if (!$event->isAllowingCustomResponseCode() && !$response->isClientError() && !$response->isServerError() && !$response->isRedirect()) {
  256. // ensure that we actually have an error response
  257. if ($e instanceof HttpExceptionInterface) {
  258. // keep the HTTP status code and headers
  259. $response->setStatusCode($e->getStatusCode());
  260. $response->headers->add($e->getHeaders());
  261. } else {
  262. $response->setStatusCode(500);
  263. }
  264. }
  266. try {
  267. return $this->filterResponse($response, $request, $type);
  268. } catch (\Throwable $e) {
  269. if ($e instanceof \Error && !$this->handleAllThrowables) {
  270. throw $e;
  271. }
  273. return $response;
  274. }
  275. }
  277. /**
  278. * Returns a human-readable string for the specified variable.
  279. */
  280. private function varToString(mixed $var): string
  281. {
  282. if (\is_object($var)) {
  283. return sprintf('an object of type %s', $var::class);
  284. }
  286. if (\is_array($var)) {
  287. $a = [];
  288. foreach ($var as $k => $v) {
  289. $a[] = sprintf('%s => ...', $k);
  290. }
  292. return sprintf('an array ([%s])', mb_substr(implode(', ', $a), 0, 255));
  293. }
  295. if (\is_resource($var)) {
  296. return sprintf('a resource (%s)', get_resource_type($var));
  297. }
  299. if (null === $var) {
  300. return 'null';
  301. }
  303. if (false === $var) {
  304. return 'a boolean value (false)';
  305. }
  307. if (true === $var) {
  308. return 'a boolean value (true)';
  309. }
  311. if (\is_string($var)) {
  312. return sprintf('a string ("%s%s")', mb_substr($var, 0, 255), mb_strlen($var) > 255 ? '...' : '');
  313. }
  315. if (is_numeric($var)) {
  316. return sprintf('a number (%s)', (string) $var);
  317. }
  319. return (string) $var;
  320. }
  321. }