2010-02-17 13:53:18 +00:00
|
|
|
<?php
|
|
|
|
|
|
|
|
/*
|
2010-04-07 01:51:29 +01:00
|
|
|
* This file is part of the Symfony package.
|
2010-02-17 13:53:18 +00:00
|
|
|
*
|
2011-03-06 11:40:06 +00:00
|
|
|
* (c) Fabien Potencier <fabien@symfony.com>
|
2010-02-17 13:53:18 +00:00
|
|
|
*
|
|
|
|
* For the full copyright and license information, please view the LICENSE
|
|
|
|
* file that was distributed with this source code.
|
|
|
|
*/
|
|
|
|
|
2011-01-15 13:29:43 +00:00
|
|
|
namespace Symfony\Component\HttpKernel;
|
|
|
|
|
|
|
|
use Symfony\Component\HttpKernel\Controller\ControllerResolverInterface;
|
|
|
|
use Symfony\Component\HttpKernel\Exception\NotFoundHttpException;
|
2012-07-13 10:55:51 +01:00
|
|
|
use Symfony\Component\HttpKernel\Exception\HttpExceptionInterface;
|
2011-03-13 18:16:56 +00:00
|
|
|
use Symfony\Component\HttpKernel\Event\FilterControllerEvent;
|
|
|
|
use Symfony\Component\HttpKernel\Event\FilterResponseEvent;
|
2013-08-31 21:02:11 +01:00
|
|
|
use Symfony\Component\HttpKernel\Event\FinishRequestEvent;
|
2011-03-13 18:16:56 +00:00
|
|
|
use Symfony\Component\HttpKernel\Event\GetResponseEvent;
|
|
|
|
use Symfony\Component\HttpKernel\Event\GetResponseForControllerResultEvent;
|
|
|
|
use Symfony\Component\HttpKernel\Event\GetResponseForExceptionEvent;
|
2011-12-06 09:00:36 +00:00
|
|
|
use Symfony\Component\HttpKernel\Event\PostResponseEvent;
|
2011-01-15 13:29:43 +00:00
|
|
|
use Symfony\Component\HttpFoundation\Request;
|
2013-09-07 21:38:41 +01:00
|
|
|
use Symfony\Component\HttpFoundation\RequestStack;
|
2011-01-15 13:29:43 +00:00
|
|
|
use Symfony\Component\HttpFoundation\Response;
|
2011-03-13 18:16:56 +00:00
|
|
|
use Symfony\Component\EventDispatcher\EventDispatcherInterface;
|
2011-01-15 13:29:43 +00:00
|
|
|
|
2010-02-17 13:53:18 +00:00
|
|
|
/**
|
2010-05-06 11:04:50 +01:00
|
|
|
* HttpKernel notifies events to convert a Request object to a Response one.
|
2010-02-17 13:53:18 +00:00
|
|
|
*
|
2011-03-06 11:40:06 +00:00
|
|
|
* @author Fabien Potencier <fabien@symfony.com>
|
2010-02-17 13:53:18 +00:00
|
|
|
*/
|
2011-12-06 19:18:45 +00:00
|
|
|
class HttpKernel implements HttpKernelInterface, TerminableInterface
|
2010-02-17 13:53:18 +00:00
|
|
|
{
|
2012-04-20 08:20:31 +01:00
|
|
|
protected $dispatcher;
|
|
|
|
protected $resolver;
|
2013-04-18 09:33:03 +01:00
|
|
|
protected $requestStack;
|
2010-05-06 12:25:53 +01:00
|
|
|
|
|
|
|
/**
|
2014-12-21 17:00:50 +00:00
|
|
|
* Constructor.
|
2010-05-06 12:25:53 +01:00
|
|
|
*
|
2013-04-18 09:33:03 +01:00
|
|
|
* @param EventDispatcherInterface $dispatcher An EventDispatcherInterface instance
|
|
|
|
* @param ControllerResolverInterface $resolver A ControllerResolverInterface instance
|
|
|
|
* @param RequestStack $requestStack A stack for master/sub requests
|
2010-05-06 12:25:53 +01:00
|
|
|
*/
|
2013-04-18 09:33:03 +01:00
|
|
|
public function __construct(EventDispatcherInterface $dispatcher, ControllerResolverInterface $resolver, RequestStack $requestStack = null)
|
2010-04-25 12:18:42 +01:00
|
|
|
{
|
2011-03-13 18:16:56 +00:00
|
|
|
$this->dispatcher = $dispatcher;
|
2010-12-08 23:58:26 +00:00
|
|
|
$this->resolver = $resolver;
|
2013-04-18 09:33:03 +01:00
|
|
|
$this->requestStack = $requestStack ?: new RequestStack();
|
2010-04-25 12:18:42 +01:00
|
|
|
}
|
|
|
|
|
2010-05-06 12:25:53 +01:00
|
|
|
/**
|
2013-05-06 00:35:31 +01:00
|
|
|
* {@inheritdoc}
|
2010-05-06 12:25:53 +01:00
|
|
|
*/
|
2010-11-06 14:13:23 +00:00
|
|
|
public function handle(Request $request, $type = HttpKernelInterface::MASTER_REQUEST, $catch = true)
|
2010-02-17 13:53:18 +00:00
|
|
|
{
|
2015-01-06 11:15:55 +00:00
|
|
|
$request->headers->set('X-Php-Ob-Level', ob_get_level());
|
|
|
|
|
2010-12-08 23:58:26 +00:00
|
|
|
try {
|
2011-03-17 08:16:53 +00:00
|
|
|
return $this->handleRaw($request, $type);
|
2010-12-08 23:58:26 +00:00
|
|
|
} catch (\Exception $e) {
|
|
|
|
if (false === $catch) {
|
2013-08-31 21:10:38 +01:00
|
|
|
$this->finishRequest($request, $type);
|
|
|
|
|
2010-12-08 23:58:26 +00:00
|
|
|
throw $e;
|
|
|
|
}
|
|
|
|
|
2011-03-17 08:16:53 +00:00
|
|
|
return $this->handleException($e, $request, $type);
|
2010-12-08 23:58:26 +00:00
|
|
|
}
|
2010-12-09 17:50:49 +00:00
|
|
|
}
|
|
|
|
|
2011-12-06 19:18:45 +00:00
|
|
|
/**
|
2011-12-06 19:38:33 +00:00
|
|
|
* {@inheritdoc}
|
2011-12-06 19:18:45 +00:00
|
|
|
*/
|
2011-12-15 17:16:29 +00:00
|
|
|
public function terminate(Request $request, Response $response)
|
2011-12-06 19:18:45 +00:00
|
|
|
{
|
2011-12-15 17:16:29 +00:00
|
|
|
$this->dispatcher->dispatch(KernelEvents::TERMINATE, new PostResponseEvent($this, $request, $response));
|
2011-12-06 19:18:45 +00:00
|
|
|
}
|
|
|
|
|
2014-04-17 08:44:42 +01:00
|
|
|
/**
|
2014-05-19 11:15:59 +01:00
|
|
|
* @throws \LogicException If the request stack is empty
|
|
|
|
*
|
2014-04-17 08:44:42 +01:00
|
|
|
* @internal
|
|
|
|
*/
|
2014-05-19 11:15:59 +01:00
|
|
|
public function terminateWithException(\Exception $exception)
|
2014-04-17 08:44:42 +01:00
|
|
|
{
|
2014-05-19 11:15:59 +01:00
|
|
|
if (!$request = $this->requestStack->getMasterRequest()) {
|
|
|
|
throw new \LogicException('Request stack is empty', 0, $exception);
|
|
|
|
}
|
|
|
|
|
2014-04-17 08:44:42 +01:00
|
|
|
$response = $this->handleException($exception, $request, self::MASTER_REQUEST);
|
|
|
|
|
|
|
|
$response->sendHeaders();
|
|
|
|
$response->sendContent();
|
|
|
|
|
|
|
|
$this->terminate($request, $response);
|
|
|
|
}
|
|
|
|
|
2010-12-08 23:58:26 +00:00
|
|
|
/**
|
|
|
|
* Handles a request to convert it to a response.
|
|
|
|
*
|
|
|
|
* Exceptions are not caught.
|
|
|
|
*
|
|
|
|
* @param Request $request A Request instance
|
2014-04-12 18:54:57 +01:00
|
|
|
* @param int $type The type of the request (one of HttpKernelInterface::MASTER_REQUEST or HttpKernelInterface::SUB_REQUEST)
|
2010-12-08 23:58:26 +00:00
|
|
|
*
|
|
|
|
* @return Response A Response instance
|
|
|
|
*
|
2014-11-30 13:33:44 +00:00
|
|
|
* @throws \LogicException If one of the listener does not behave as expected
|
2010-12-08 23:58:26 +00:00
|
|
|
* @throws NotFoundHttpException When controller cannot be found
|
|
|
|
*/
|
2011-03-23 18:47:16 +00:00
|
|
|
private function handleRaw(Request $request, $type = self::MASTER_REQUEST)
|
2010-12-08 23:58:26 +00:00
|
|
|
{
|
2013-04-18 09:33:03 +01:00
|
|
|
$this->requestStack->push($request);
|
|
|
|
|
2010-12-08 23:58:26 +00:00
|
|
|
// request
|
2011-03-13 18:16:56 +00:00
|
|
|
$event = new GetResponseEvent($this, $request, $type);
|
2011-06-21 15:34:33 +01:00
|
|
|
$this->dispatcher->dispatch(KernelEvents::REQUEST, $event);
|
Replaced EventDispatcher by Doctrine's EventManager implementation
Doctrine's EventManager implementation has several advantages over the
EventDispatcher implementation of Symfony2. Therefore I suggest that we
use their implementation.
Advantages:
* Event Listeners are objects, not callbacks. These objects have handler
methods that have the same name as the event. This helps a lot when
reading the code and makes the code for adding an event listener shorter.
* You can create Event Subscribers, which are event listeners with an
additional getSubscribedEvents() method. The benefit here is that the
code that registers the subscriber doesn't need to know about its
implementation.
* All events are defined in static Events classes, so users of IDEs benefit
of code completion
* The communication between the dispatching class of an event and all
listeners is done through a subclass of EventArgs. This subclass can be
tailored to the type of event. A constructor, setters and getters can be
implemented that verify the validity of the data set into the object.
See examples below.
* Because each event type corresponds to an EventArgs implementation,
developers of event listeners can look up the available EventArgs methods
and benefit of code completion.
* EventArgs::stopPropagation() is more flexible and (IMO) clearer to use
than notifyUntil(). Also, it is a concept that is also used in other
event implementations
Before:
class EventListener
{
public function handle(EventInterface $event, $data) { ... }
}
$dispatcher->connect('core.request', array($listener, 'handle'));
$dispatcher->notify('core.request', new Event(...));
After (with listeners):
final class Events
{
const onCoreRequest = 'onCoreRequest';
}
class EventListener
{
public function onCoreRequest(RequestEventArgs $eventArgs) { ... }
}
$evm->addEventListener(Events::onCoreRequest, $listener);
$evm->dispatchEvent(Events::onCoreRequest, new RequestEventArgs(...));
After (with subscribers):
class EventSubscriber
{
public function onCoreRequest(RequestEventArgs $eventArgs) { ... }
public function getSubscribedEvents()
{
return Events::onCoreRequest;
}
}
$evm->addEventSubscriber($subscriber);
$evm->dispatchEvent(Events::onCoreRequest, new RequestEventArgs(...));
2011-03-05 14:30:34 +00:00
|
|
|
|
2011-03-13 18:16:56 +00:00
|
|
|
if ($event->hasResponse()) {
|
|
|
|
return $this->filterResponse($event->getResponse(), $request, $type);
|
2010-12-08 23:58:26 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// load controller
|
|
|
|
if (false === $controller = $this->resolver->getController($request)) {
|
2014-08-26 09:42:26 +01:00
|
|
|
throw new NotFoundHttpException(sprintf('Unable to find the controller for path "%s". The route is wrongly configured.', $request->getPathInfo()));
|
2010-12-08 23:58:26 +00:00
|
|
|
}
|
2010-05-06 12:25:53 +01:00
|
|
|
|
2011-03-13 18:16:56 +00:00
|
|
|
$event = new FilterControllerEvent($this, $controller, $request, $type);
|
2011-06-21 15:34:33 +01:00
|
|
|
$this->dispatcher->dispatch(KernelEvents::CONTROLLER, $event);
|
2011-03-13 18:16:56 +00:00
|
|
|
$controller = $event->getController();
|
2010-12-08 23:58:26 +00:00
|
|
|
|
|
|
|
// controller arguments
|
|
|
|
$arguments = $this->resolver->getArguments($request, $controller);
|
|
|
|
|
|
|
|
// call controller
|
2011-02-03 18:39:28 +00:00
|
|
|
$response = call_user_func_array($controller, $arguments);
|
2010-12-08 23:58:26 +00:00
|
|
|
|
|
|
|
// view
|
2011-02-03 18:39:28 +00:00
|
|
|
if (!$response instanceof Response) {
|
2011-03-13 18:16:56 +00:00
|
|
|
$event = new GetResponseForControllerResultEvent($this, $request, $type, $response);
|
2011-06-21 15:34:33 +01:00
|
|
|
$this->dispatcher->dispatch(KernelEvents::VIEW, $event);
|
Replaced EventDispatcher by Doctrine's EventManager implementation
Doctrine's EventManager implementation has several advantages over the
EventDispatcher implementation of Symfony2. Therefore I suggest that we
use their implementation.
Advantages:
* Event Listeners are objects, not callbacks. These objects have handler
methods that have the same name as the event. This helps a lot when
reading the code and makes the code for adding an event listener shorter.
* You can create Event Subscribers, which are event listeners with an
additional getSubscribedEvents() method. The benefit here is that the
code that registers the subscriber doesn't need to know about its
implementation.
* All events are defined in static Events classes, so users of IDEs benefit
of code completion
* The communication between the dispatching class of an event and all
listeners is done through a subclass of EventArgs. This subclass can be
tailored to the type of event. A constructor, setters and getters can be
implemented that verify the validity of the data set into the object.
See examples below.
* Because each event type corresponds to an EventArgs implementation,
developers of event listeners can look up the available EventArgs methods
and benefit of code completion.
* EventArgs::stopPropagation() is more flexible and (IMO) clearer to use
than notifyUntil(). Also, it is a concept that is also used in other
event implementations
Before:
class EventListener
{
public function handle(EventInterface $event, $data) { ... }
}
$dispatcher->connect('core.request', array($listener, 'handle'));
$dispatcher->notify('core.request', new Event(...));
After (with listeners):
final class Events
{
const onCoreRequest = 'onCoreRequest';
}
class EventListener
{
public function onCoreRequest(RequestEventArgs $eventArgs) { ... }
}
$evm->addEventListener(Events::onCoreRequest, $listener);
$evm->dispatchEvent(Events::onCoreRequest, new RequestEventArgs(...));
After (with subscribers):
class EventSubscriber
{
public function onCoreRequest(RequestEventArgs $eventArgs) { ... }
public function getSubscribedEvents()
{
return Events::onCoreRequest;
}
}
$evm->addEventSubscriber($subscriber);
$evm->dispatchEvent(Events::onCoreRequest, new RequestEventArgs(...));
2011-03-05 14:30:34 +00:00
|
|
|
|
2011-03-13 18:16:56 +00:00
|
|
|
if ($event->hasResponse()) {
|
|
|
|
$response = $event->getResponse();
|
Replaced EventDispatcher by Doctrine's EventManager implementation
Doctrine's EventManager implementation has several advantages over the
EventDispatcher implementation of Symfony2. Therefore I suggest that we
use their implementation.
Advantages:
* Event Listeners are objects, not callbacks. These objects have handler
methods that have the same name as the event. This helps a lot when
reading the code and makes the code for adding an event listener shorter.
* You can create Event Subscribers, which are event listeners with an
additional getSubscribedEvents() method. The benefit here is that the
code that registers the subscriber doesn't need to know about its
implementation.
* All events are defined in static Events classes, so users of IDEs benefit
of code completion
* The communication between the dispatching class of an event and all
listeners is done through a subclass of EventArgs. This subclass can be
tailored to the type of event. A constructor, setters and getters can be
implemented that verify the validity of the data set into the object.
See examples below.
* Because each event type corresponds to an EventArgs implementation,
developers of event listeners can look up the available EventArgs methods
and benefit of code completion.
* EventArgs::stopPropagation() is more flexible and (IMO) clearer to use
than notifyUntil(). Also, it is a concept that is also used in other
event implementations
Before:
class EventListener
{
public function handle(EventInterface $event, $data) { ... }
}
$dispatcher->connect('core.request', array($listener, 'handle'));
$dispatcher->notify('core.request', new Event(...));
After (with listeners):
final class Events
{
const onCoreRequest = 'onCoreRequest';
}
class EventListener
{
public function onCoreRequest(RequestEventArgs $eventArgs) { ... }
}
$evm->addEventListener(Events::onCoreRequest, $listener);
$evm->dispatchEvent(Events::onCoreRequest, new RequestEventArgs(...));
After (with subscribers):
class EventSubscriber
{
public function onCoreRequest(RequestEventArgs $eventArgs) { ... }
public function getSubscribedEvents()
{
return Events::onCoreRequest;
}
}
$evm->addEventSubscriber($subscriber);
$evm->dispatchEvent(Events::onCoreRequest, new RequestEventArgs(...));
2011-03-05 14:30:34 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
if (!$response instanceof Response) {
|
2011-03-26 19:35:55 +00:00
|
|
|
$msg = sprintf('The controller must return a response (%s given).', $this->varToString($response));
|
|
|
|
|
|
|
|
// the user may have forgotten to return something
|
|
|
|
if (null === $response) {
|
|
|
|
$msg .= ' Did you forget to add a return statement somewhere in your controller?';
|
|
|
|
}
|
|
|
|
throw new \LogicException($msg);
|
2011-02-21 17:24:33 +00:00
|
|
|
}
|
2011-02-03 18:39:28 +00:00
|
|
|
}
|
2010-12-08 23:58:26 +00:00
|
|
|
|
Replaced EventDispatcher by Doctrine's EventManager implementation
Doctrine's EventManager implementation has several advantages over the
EventDispatcher implementation of Symfony2. Therefore I suggest that we
use their implementation.
Advantages:
* Event Listeners are objects, not callbacks. These objects have handler
methods that have the same name as the event. This helps a lot when
reading the code and makes the code for adding an event listener shorter.
* You can create Event Subscribers, which are event listeners with an
additional getSubscribedEvents() method. The benefit here is that the
code that registers the subscriber doesn't need to know about its
implementation.
* All events are defined in static Events classes, so users of IDEs benefit
of code completion
* The communication between the dispatching class of an event and all
listeners is done through a subclass of EventArgs. This subclass can be
tailored to the type of event. A constructor, setters and getters can be
implemented that verify the validity of the data set into the object.
See examples below.
* Because each event type corresponds to an EventArgs implementation,
developers of event listeners can look up the available EventArgs methods
and benefit of code completion.
* EventArgs::stopPropagation() is more flexible and (IMO) clearer to use
than notifyUntil(). Also, it is a concept that is also used in other
event implementations
Before:
class EventListener
{
public function handle(EventInterface $event, $data) { ... }
}
$dispatcher->connect('core.request', array($listener, 'handle'));
$dispatcher->notify('core.request', new Event(...));
After (with listeners):
final class Events
{
const onCoreRequest = 'onCoreRequest';
}
class EventListener
{
public function onCoreRequest(RequestEventArgs $eventArgs) { ... }
}
$evm->addEventListener(Events::onCoreRequest, $listener);
$evm->dispatchEvent(Events::onCoreRequest, new RequestEventArgs(...));
After (with subscribers):
class EventSubscriber
{
public function onCoreRequest(RequestEventArgs $eventArgs) { ... }
public function getSubscribedEvents()
{
return Events::onCoreRequest;
}
}
$evm->addEventSubscriber($subscriber);
$evm->dispatchEvent(Events::onCoreRequest, new RequestEventArgs(...));
2011-03-05 14:30:34 +00:00
|
|
|
return $this->filterResponse($response, $request, $type);
|
2010-12-08 23:58:26 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Filters a response object.
|
|
|
|
*
|
|
|
|
* @param Response $response A Response instance
|
2013-04-21 14:23:54 +01:00
|
|
|
* @param Request $request An error message in case the response is not a Response object
|
2014-04-12 18:54:57 +01:00
|
|
|
* @param int $type The type of the request (one of HttpKernelInterface::MASTER_REQUEST or HttpKernelInterface::SUB_REQUEST)
|
2010-12-08 23:58:26 +00:00
|
|
|
*
|
|
|
|
* @return Response The filtered Response instance
|
|
|
|
*
|
|
|
|
* @throws \RuntimeException if the passed object is not a Response instance
|
|
|
|
*/
|
2011-03-23 18:47:16 +00:00
|
|
|
private function filterResponse(Response $response, Request $request, $type)
|
2010-12-08 23:58:26 +00:00
|
|
|
{
|
2011-03-13 18:16:56 +00:00
|
|
|
$event = new FilterResponseEvent($this, $request, $type, $response);
|
2010-11-06 14:13:23 +00:00
|
|
|
|
2011-06-21 15:34:33 +01:00
|
|
|
$this->dispatcher->dispatch(KernelEvents::RESPONSE, $event);
|
2010-02-17 13:53:18 +00:00
|
|
|
|
2013-04-18 09:33:03 +01:00
|
|
|
$this->finishRequest($request, $type);
|
|
|
|
|
2011-03-13 18:16:56 +00:00
|
|
|
return $event->getResponse();
|
2010-02-17 13:53:18 +00:00
|
|
|
}
|
2011-01-29 14:31:42 +00:00
|
|
|
|
2013-04-18 09:33:03 +01:00
|
|
|
/**
|
2013-08-31 21:10:38 +01:00
|
|
|
* Publishes the finish request event, then pop the request from the stack.
|
2013-04-18 09:33:03 +01:00
|
|
|
*
|
2013-08-31 21:10:38 +01:00
|
|
|
* Note that the order of the operations is important here, otherwise
|
|
|
|
* operations such as {@link RequestStack::getParentRequest()} can lead to
|
|
|
|
* weird results.
|
2013-04-18 09:33:03 +01:00
|
|
|
*
|
|
|
|
* @param Request $request
|
2013-08-31 21:10:38 +01:00
|
|
|
* @param int $type
|
2013-04-18 09:33:03 +01:00
|
|
|
*/
|
|
|
|
private function finishRequest(Request $request, $type)
|
|
|
|
{
|
2013-08-31 21:02:11 +01:00
|
|
|
$this->dispatcher->dispatch(KernelEvents::FINISH_REQUEST, new FinishRequestEvent($this, $request, $type));
|
2013-04-18 09:33:03 +01:00
|
|
|
$this->requestStack->pop();
|
|
|
|
}
|
|
|
|
|
2011-03-17 08:16:53 +00:00
|
|
|
/**
|
2013-01-30 14:15:26 +00:00
|
|
|
* Handles an exception by trying to convert it to a Response.
|
2011-03-17 08:16:53 +00:00
|
|
|
*
|
2012-05-15 21:19:31 +01:00
|
|
|
* @param \Exception $e An \Exception instance
|
|
|
|
* @param Request $request A Request instance
|
2014-04-12 18:54:57 +01:00
|
|
|
* @param int $type The type of the request
|
2011-03-17 08:16:53 +00:00
|
|
|
*
|
|
|
|
* @return Response A Response instance
|
2012-12-16 12:02:54 +00:00
|
|
|
*
|
|
|
|
* @throws \Exception
|
2011-03-17 08:16:53 +00:00
|
|
|
*/
|
2011-03-23 18:47:16 +00:00
|
|
|
private function handleException(\Exception $e, $request, $type)
|
2011-03-17 08:16:53 +00:00
|
|
|
{
|
2011-03-17 11:34:12 +00:00
|
|
|
$event = new GetResponseForExceptionEvent($this, $request, $type, $e);
|
2011-06-21 15:34:33 +01:00
|
|
|
$this->dispatcher->dispatch(KernelEvents::EXCEPTION, $event);
|
2011-03-17 11:34:12 +00:00
|
|
|
|
2012-07-13 10:25:21 +01:00
|
|
|
// a listener might have replaced the exception
|
|
|
|
$e = $event->getException();
|
|
|
|
|
2011-03-17 11:34:12 +00:00
|
|
|
if (!$event->hasResponse()) {
|
2013-08-31 21:10:38 +01:00
|
|
|
$this->finishRequest($request, $type);
|
|
|
|
|
2015-04-11 07:36:53 +01:00
|
|
|
throw $e;
|
2011-03-17 08:16:53 +00:00
|
|
|
}
|
|
|
|
|
2012-07-13 10:55:51 +01:00
|
|
|
$response = $event->getResponse();
|
|
|
|
|
2012-07-31 09:32:57 +01:00
|
|
|
// the developer asked for a specific status code
|
|
|
|
if ($response->headers->has('X-Status-Code')) {
|
|
|
|
$response->setStatusCode($response->headers->get('X-Status-Code'));
|
|
|
|
|
|
|
|
$response->headers->remove('X-Status-Code');
|
|
|
|
} elseif (!$response->isClientError() && !$response->isServerError() && !$response->isRedirect()) {
|
|
|
|
// ensure that we actually have an error response
|
2012-07-13 10:55:51 +01:00
|
|
|
if ($e instanceof HttpExceptionInterface) {
|
|
|
|
// keep the HTTP status code and headers
|
|
|
|
$response->setStatusCode($e->getStatusCode());
|
|
|
|
$response->headers->add($e->getHeaders());
|
|
|
|
} else {
|
|
|
|
$response->setStatusCode(500);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2011-04-01 15:10:41 +01:00
|
|
|
try {
|
2012-07-13 10:55:51 +01:00
|
|
|
return $this->filterResponse($response, $request, $type);
|
2011-04-01 15:10:41 +01:00
|
|
|
} catch (\Exception $e) {
|
2012-07-13 10:55:51 +01:00
|
|
|
return $response;
|
2011-04-01 15:10:41 +01:00
|
|
|
}
|
2011-03-17 08:16:53 +00:00
|
|
|
}
|
|
|
|
|
2011-03-23 18:47:16 +00:00
|
|
|
private function varToString($var)
|
2011-01-29 14:31:42 +00:00
|
|
|
{
|
|
|
|
if (is_object($var)) {
|
2011-06-20 09:27:01 +01:00
|
|
|
return sprintf('Object(%s)', get_class($var));
|
2011-01-29 14:31:42 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
if (is_array($var)) {
|
|
|
|
$a = array();
|
|
|
|
foreach ($var as $k => $v) {
|
|
|
|
$a[] = sprintf('%s => %s', $k, $this->varToString($v));
|
|
|
|
}
|
|
|
|
|
2015-03-21 10:51:07 +00:00
|
|
|
return sprintf('Array(%s)', implode(', ', $a));
|
2011-01-29 14:31:42 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
if (is_resource($var)) {
|
2011-06-20 09:27:01 +01:00
|
|
|
return sprintf('Resource(%s)', get_resource_type($var));
|
2011-01-29 14:31:42 +00:00
|
|
|
}
|
|
|
|
|
2011-03-26 19:35:55 +00:00
|
|
|
if (null === $var) {
|
|
|
|
return 'null';
|
|
|
|
}
|
|
|
|
|
2011-06-20 09:27:01 +01:00
|
|
|
if (false === $var) {
|
|
|
|
return 'false';
|
|
|
|
}
|
|
|
|
|
|
|
|
if (true === $var) {
|
|
|
|
return 'true';
|
|
|
|
}
|
|
|
|
|
|
|
|
return (string) $var;
|
2011-01-29 14:31:42 +00:00
|
|
|
}
|
2010-02-17 13:53:18 +00:00
|
|
|
}
|