www.aleph1.co.uk Git - yaffs-website/blob - vendor/symfony/http-kernel/HttpKernel.php

   1 <?php
   2
   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  */
  11
  12 namespace Symfony\Component\HttpKernel;
  13
  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\HttpExceptionInterface;
  32 use Symfony\Component\HttpKernel\Exception\NotFoundHttpException;
  33
  34 /**
  35  * HttpKernel notifies events to convert a Request object to a Response one.
  36  *
  37  * @author Fabien Potencier <fabien@symfony.com>
  38  */
  39 class HttpKernel implements HttpKernelInterface, TerminableInterface
  40 {
  41     protected $dispatcher;
  42     protected $resolver;
  43     protected $requestStack;
  44     private $argumentResolver;
  45
  46     public function __construct(EventDispatcherInterface $dispatcher, ControllerResolverInterface $resolver, RequestStack $requestStack = null, ArgumentResolverInterface $argumentResolver = null)
  47     {
  48         $this->dispatcher = $dispatcher;
  49         $this->resolver = $resolver;
  50         $this->requestStack = $requestStack ?: new RequestStack();
  51         $this->argumentResolver = $argumentResolver;
  52
  53         if (null === $this->argumentResolver) {
  54             @trigger_error(sprintf('As of 3.1 an %s is used to resolve arguments. In 4.0 the $argumentResolver becomes the %s if no other is provided instead of using the $resolver argument.', ArgumentResolverInterface::class, ArgumentResolver::class), E_USER_DEPRECATED);
  55             // fallback in case of deprecations
  56             $this->argumentResolver = $resolver;
  57         }
  58     }
  59
  60     /**
  61      * {@inheritdoc}
  62      */
  63     public function handle(Request $request, $type = HttpKernelInterface::MASTER_REQUEST, $catch = true)
  64     {
  65         $request->headers->set('X-Php-Ob-Level', ob_get_level());
  66
  67         try {
  68             return $this->handleRaw($request, $type);
  69         } catch (\Exception $e) {
  70             if ($e instanceof RequestExceptionInterface) {
  71                 $e = new BadRequestHttpException($e->getMessage(), $e);
  72             }
  73             if (false === $catch) {
  74                 $this->finishRequest($request, $type);
  75
  76                 throw $e;
  77             }
  78
  79             return $this->handleException($e, $request, $type);
  80         }
  81     }
  82
  83     /**
  84      * {@inheritdoc}
  85      */
  86     public function terminate(Request $request, Response $response)
  87     {
  88         $this->dispatcher->dispatch(KernelEvents::TERMINATE, new PostResponseEvent($this, $request, $response));
  89     }
  90
  91     /**
  92      * @internal
  93      */
  94     public function terminateWithException(\Exception $exception, Request $request = null)
  95     {
  96         if (!$request = $request ?: $this->requestStack->getMasterRequest()) {
  97             throw $exception;
  98         }
  99
 100         $response = $this->handleException($exception, $request, self::MASTER_REQUEST);
 101
 102         $response->sendHeaders();
 103         $response->sendContent();
 104
 105         $this->terminate($request, $response);
 106     }
 107
 108     /**
 109      * Handles a request to convert it to a response.
 110      *
 111      * Exceptions are not caught.
 112      *
 113      * @param Request $request A Request instance
 114      * @param int     $type    The type of the request (one of HttpKernelInterface::MASTER_REQUEST or HttpKernelInterface::SUB_REQUEST)
 115      *
 116      * @return Response A Response instance
 117      *
 118      * @throws \LogicException       If one of the listener does not behave as expected
 119      * @throws NotFoundHttpException When controller cannot be found
 120      */
 121     private function handleRaw(Request $request, $type = self::MASTER_REQUEST)
 122     {
 123         $this->requestStack->push($request);
 124
 125         // request
 126         $event = new GetResponseEvent($this, $request, $type);
 127         $this->dispatcher->dispatch(KernelEvents::REQUEST, $event);
 128
 129         if ($event->hasResponse()) {
 130             return $this->filterResponse($event->getResponse(), $request, $type);
 131         }
 132
 133         // load controller
 134         if (false === $controller = $this->resolver->getController($request)) {
 135             throw new NotFoundHttpException(sprintf('Unable to find the controller for path "%s". The route is wrongly configured.', $request->getPathInfo()));
 136         }
 137
 138         $event = new FilterControllerEvent($this, $controller, $request, $type);
 139         $this->dispatcher->dispatch(KernelEvents::CONTROLLER, $event);
 140         $controller = $event->getController();
 141
 142         // controller arguments
 143         $arguments = $this->argumentResolver->getArguments($request, $controller);
 144
 145         $event = new FilterControllerArgumentsEvent($this, $controller, $arguments, $request, $type);
 146         $this->dispatcher->dispatch(KernelEvents::CONTROLLER_ARGUMENTS, $event);
 147         $controller = $event->getController();
 148         $arguments = $event->getArguments();
 149
 150         // call controller
 151         $response = \call_user_func_array($controller, $arguments);
 152
 153         // view
 154         if (!$response instanceof Response) {
 155             $event = new GetResponseForControllerResultEvent($this, $request, $type, $response);
 156             $this->dispatcher->dispatch(KernelEvents::VIEW, $event);
 157
 158             if ($event->hasResponse()) {
 159                 $response = $event->getResponse();
 160             }
 161
 162             if (!$response instanceof Response) {
 163                 $msg = sprintf('The controller must return a response (%s given).', $this->varToString($response));
 164
 165                 // the user may have forgotten to return something
 166                 if (null === $response) {
 167                     $msg .= ' Did you forget to add a return statement somewhere in your controller?';
 168                 }
 169                 throw new \LogicException($msg);
 170             }
 171         }
 172
 173         return $this->filterResponse($response, $request, $type);
 174     }
 175
 176     /**
 177      * Filters a response object.
 178      *
 179      * @param Response $response A Response instance
 180      * @param Request  $request  An error message in case the response is not a Response object
 181      * @param int      $type     The type of the request (one of HttpKernelInterface::MASTER_REQUEST or HttpKernelInterface::SUB_REQUEST)
 182      *
 183      * @return Response The filtered Response instance
 184      *
 185      * @throws \RuntimeException if the passed object is not a Response instance
 186      */
 187     private function filterResponse(Response $response, Request $request, $type)
 188     {
 189         $event = new FilterResponseEvent($this, $request, $type, $response);
 190
 191         $this->dispatcher->dispatch(KernelEvents::RESPONSE, $event);
 192
 193         $this->finishRequest($request, $type);
 194
 195         return $event->getResponse();
 196     }
 197
 198     /**
 199      * Publishes the finish request event, then pop the request from the stack.
 200      *
 201      * Note that the order of the operations is important here, otherwise
 202      * operations such as {@link RequestStack::getParentRequest()} can lead to
 203      * weird results.
 204      *
 205      * @param Request $request
 206      * @param int     $type
 207      */
 208     private function finishRequest(Request $request, $type)
 209     {
 210         $this->dispatcher->dispatch(KernelEvents::FINISH_REQUEST, new FinishRequestEvent($this, $request, $type));
 211         $this->requestStack->pop();
 212     }
 213
 214     /**
 215      * Handles an exception by trying to convert it to a Response.
 216      *
 217      * @param \Exception $e       An \Exception instance
 218      * @param Request    $request A Request instance
 219      * @param int        $type    The type of the request
 220      *
 221      * @return Response A Response instance
 222      *
 223      * @throws \Exception
 224      */
 225     private function handleException(\Exception $e, $request, $type)
 226     {
 227         $event = new GetResponseForExceptionEvent($this, $request, $type, $e);
 228         $this->dispatcher->dispatch(KernelEvents::EXCEPTION, $event);
 229
 230         // a listener might have replaced the exception
 231         $e = $event->getException();
 232
 233         if (!$event->hasResponse()) {
 234             $this->finishRequest($request, $type);
 235
 236             throw $e;
 237         }
 238
 239         $response = $event->getResponse();
 240
 241         // the developer asked for a specific status code
 242         if ($response->headers->has('X-Status-Code')) {
 243             @trigger_error(sprintf('Using the X-Status-Code header is deprecated since Symfony 3.3 and will be removed in 4.0. Use %s::allowCustomResponseCode() instead.', GetResponseForExceptionEvent::class), E_USER_DEPRECATED);
 244
 245             $response->setStatusCode($response->headers->get('X-Status-Code'));
 246
 247             $response->headers->remove('X-Status-Code');
 248         } elseif (!$event->isAllowingCustomResponseCode() && !$response->isClientError() && !$response->isServerError() && !$response->isRedirect()) {
 249             // ensure that we actually have an error response
 250             if ($e instanceof HttpExceptionInterface) {
 251                 // keep the HTTP status code and headers
 252                 $response->setStatusCode($e->getStatusCode());
 253                 $response->headers->add($e->getHeaders());
 254             } else {
 255                 $response->setStatusCode(500);
 256             }
 257         }
 258
 259         try {
 260             return $this->filterResponse($response, $request, $type);
 261         } catch (\Exception $e) {
 262             return $response;
 263         }
 264     }
 265
 266     private function varToString($var)
 267     {
 268         if (\is_object($var)) {
 269             return sprintf('Object(%s)', \get_class($var));
 270         }
 271
 272         if (\is_array($var)) {
 273             $a = array();
 274             foreach ($var as $k => $v) {
 275                 $a[] = sprintf('%s => %s', $k, $this->varToString($v));
 276             }
 277
 278             return sprintf('Array(%s)', implode(', ', $a));
 279         }
 280
 281         if (\is_resource($var)) {
 282             return sprintf('Resource(%s)', get_resource_type($var));
 283         }
 284
 285         if (null === $var) {
 286             return 'null';
 287         }
 288
 289         if (false === $var) {
 290             return 'false';
 291         }
 292
 293         if (true === $var) {
 294             return 'true';
 295         }
 296
 297         return (string) $var;
 298     }
 299 }