vendor/symfony/symfony/src/Symfony/Component/HttpKernel/DataCollector/RequestDataCollector.php line 307

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\DataCollector;
  14. use Symfony\Component\HttpFoundation\ParameterBag;
  15. use Symfony\Component\HttpFoundation\Request;
  16. use Symfony\Component\HttpFoundation\Response;
  17. use Symfony\Component\HttpKernel\Event\FilterResponseEvent;
  18. use Symfony\Component\HttpKernel\KernelEvents;
  19. use Symfony\Component\HttpKernel\Event\FilterControllerEvent;
  20. use Symfony\Component\EventDispatcher\EventSubscriberInterface;
  22. /**
  23.  * @author Fabien Potencier <fabien@symfony.com>
  24.  */
  25. class RequestDataCollector extends DataCollector implements EventSubscriberInterface, LateDataCollectorInterface
  26. {
  27.     protected $controllers;
  29.     public function __construct()
  30.     {
  31.         $this->controllers = new \SplObjectStorage();
  32.     }
  34.     /**
  35.      * {@inheritdoc}
  36.      */
  37.     public function collect(Request $request, Response $response, \Exception $exception = null)
  38.     {
  39.         // attributes are serialized and as they can be anything, they need to be converted to strings.
  40.         $attributes = array();
  41.         $route = '';
  42.         foreach ($request->attributes->all() as $key => $value) {
  43.             if ('_route' === $key) {
  44.                 $route = is_object($value) ? $value->getPath() : $value;
  45.                 $attributes[$key] = $route;
  46.             } else {
  47.                 $attributes[$key] = $value;
  48.             }
  49.         }
  51.         $content = null;
  52.         try {
  53.             $content = $request->getContent();
  54.         } catch (\LogicException $e) {
  55.             // the user already got the request content as a resource
  56.             $content = false;
  57.         }
  59.         $sessionMetadata = array();
  60.         $sessionAttributes = array();
  61.         $session = null;
  62.         $flashes = array();
  63.         if ($request->hasSession()) {
  64.             $session = $request->getSession();
  65.             if ($session->isStarted()) {
  66.                 $sessionMetadata['Created'] = date(DATE_RFC822, $session->getMetadataBag()->getCreated());
  67.                 $sessionMetadata['Last used'] = date(DATE_RFC822, $session->getMetadataBag()->getLastUsed());
  68.                 $sessionMetadata['Lifetime'] = $session->getMetadataBag()->getLifetime();
  69.                 $sessionAttributes = $session->all();
  70.                 $flashes = $session->getFlashBag()->peekAll();
  71.             }
  72.         }
  74.         $statusCode = $response->getStatusCode();
  76.         $responseCookies = array();
  77.         foreach ($response->headers->getCookies() as $cookie) {
  78.             $responseCookies[$cookie->getName()] = $cookie;
  79.         }
  81.         $this->data = array(
  82.             'method' => $request->getMethod(),
  83.             'format' => $request->getRequestFormat(),
  84.             'content' => $content,
  85.             'content_type' => $response->headers->get('Content-Type', 'text/html'),
  86.             'status_text' => isset(Response::$statusTexts[$statusCode]) ? Response::$statusTexts[$statusCode] : '',
  87.             'status_code' => $statusCode,
  88.             'request_query' => $request->query->all(),
  89.             'request_request' => $request->request->all(),
  90.             'request_headers' => $request->headers->all(),
  91.             'request_server' => $request->server->all(),
  92.             'request_cookies' => $request->cookies->all(),
  93.             'request_attributes' => $attributes,
  94.             'route' => $route,
  95.             'response_headers' => $response->headers->all(),
  96.             'response_cookies' => $responseCookies,
  97.             'session_metadata' => $sessionMetadata,
  98.             'session_attributes' => $sessionAttributes,
  99.             'flashes' => $flashes,
  100.             'path_info' => $request->getPathInfo(),
  101.             'controller' => 'n/a',
  102.             'locale' => $request->getLocale(),
  103.         );
  105.         if (isset($this->data['request_headers']['php-auth-pw'])) {
  106.             $this->data['request_headers']['php-auth-pw'] = '******';
  107.         }
  109.         if (isset($this->data['request_server']['PHP_AUTH_PW'])) {
  110.             $this->data['request_server']['PHP_AUTH_PW'] = '******';
  111.         }
  113.         if (isset($this->data['request_request']['_password'])) {
  114.             $this->data['request_request']['_password'] = '******';
  115.         }
  117.         foreach ($this->data as $key => $value) {
  118.             if (!is_array($value)) {
  119.                 continue;
  120.             }
  121.             if ('request_headers' === $key || 'response_headers' === $key) {
  122.                 $this->data[$key] = array_map(function ($v) { return isset($v[0]) && !isset($v[1]) ? $v[0] : $v; }, $value);
  123.             }
  124.         }
  126.         if (isset($this->controllers[$request])) {
  127.             $this->data['controller'] = $this->parseController($this->controllers[$request]);
  128.             unset($this->controllers[$request]);
  129.         }
  131.         if (null !== $session && $session->isStarted()) {
  132.             if ($request->attributes->has('_redirected')) {
  133.                 $this->data['redirect'] = $session->remove('sf_redirect');
  134.             }
  136.             if ($response->isRedirect()) {
  137.                 $session->set('sf_redirect', array(
  138.                     'token' => $response->headers->get('x-debug-token'),
  139.                     'route' => $request->attributes->get('_route', 'n/a'),
  140.                     'method' => $request->getMethod(),
  141.                     'controller' => $this->parseController($request->attributes->get('_controller')),
  142.                     'status_code' => $statusCode,
  143.                     'status_text' => Response::$statusTexts[(int) $statusCode],
  144.                 ));
  145.             }
  146.         }
  148.         $this->data['identifier'] = $this->data['route'] ?: (is_array($this->data['controller']) ? $this->data['controller']['class'].'::'.$this->data['controller']['method'].'()' : $this->data['controller']);
  149.     }
  151.     public function lateCollect()
  152.     {
  153.         $this->data = $this->cloneVar($this->data);
  154.     }
  156.     public function getMethod()
  157.     {
  158.         return $this->data['method'];
  159.     }
  161.     public function getPathInfo()
  162.     {
  163.         return $this->data['path_info'];
  164.     }
  166.     public function getRequestRequest()
  167.     {
  168.         return new ParameterBag($this->data['request_request']->getValue());
  169.     }
  171.     public function getRequestQuery()
  172.     {
  173.         return new ParameterBag($this->data['request_query']->getValue());
  174.     }
  176.     public function getRequestHeaders()
  177.     {
  178.         return new ParameterBag($this->data['request_headers']->getValue());
  179.     }
  181.     public function getRequestServer($raw = false)
  182.     {
  183.         return new ParameterBag($this->data['request_server']->getValue($raw));
  184.     }
  186.     public function getRequestCookies($raw = false)
  187.     {
  188.         return new ParameterBag($this->data['request_cookies']->getValue($raw));
  189.     }
  191.     public function getRequestAttributes()
  192.     {
  193.         return new ParameterBag($this->data['request_attributes']->getValue());
  194.     }
  196.     public function getResponseHeaders()
  197.     {
  198.         return new ParameterBag($this->data['response_headers']->getValue());
  199.     }
  201.     public function getResponseCookies()
  202.     {
  203.         return new ParameterBag($this->data['response_cookies']->getValue());
  204.     }
  206.     public function getSessionMetadata()
  207.     {
  208.         return $this->data['session_metadata']->getValue();
  209.     }
  211.     public function getSessionAttributes()
  212.     {
  213.         return $this->data['session_attributes']->getValue();
  214.     }
  216.     public function getFlashes()
  217.     {
  218.         return $this->data['flashes']->getValue();
  219.     }
  221.     public function getContent()
  222.     {
  223.         return $this->data['content'];
  224.     }
  226.     public function getContentType()
  227.     {
  228.         return $this->data['content_type'];
  229.     }
  231.     public function getStatusText()
  232.     {
  233.         return $this->data['status_text'];
  234.     }
  236.     public function getStatusCode()
  237.     {
  238.         return $this->data['status_code'];
  239.     }
  241.     public function getFormat()
  242.     {
  243.         return $this->data['format'];
  244.     }
  246.     public function getLocale()
  247.     {
  248.         return $this->data['locale'];
  249.     }
  251.     /**
  252.      * Gets the route name.
  253.      *
  254.      * The _route request attributes is automatically set by the Router Matcher.
  255.      *
  256.      * @return string The route
  257.      */
  258.     public function getRoute()
  259.     {
  260.         return $this->data['route'];
  261.     }
  263.     public function getIdentifier()
  264.     {
  265.         return $this->data['identifier'];
  266.     }
  268.     /**
  269.      * Gets the route parameters.
  270.      *
  271.      * The _route_params request attributes is automatically set by the RouterListener.
  272.      *
  273.      * @return array The parameters
  274.      */
  275.     public function getRouteParams()
  276.     {
  277.         return isset($this->data['request_attributes']['_route_params']) ? $this->data['request_attributes']['_route_params']->getValue() : array();
  278.     }
  280.     /**
  281.      * Gets the parsed controller.
  282.      *
  283.      * @return array|string The controller as a string or array of data
  284.      *                      with keys 'class', 'method', 'file' and 'line'
  285.      */
  286.     public function getController()
  287.     {
  288.         return $this->data['controller'];
  289.     }
  291.     /**
  292.      * Gets the previous request attributes.
  293.      *
  294.      * @return array|bool A legacy array of data from the previous redirection response
  295.      *                    or false otherwise
  296.      */
  297.     public function getRedirect()
  298.     {
  299.         return isset($this->data['redirect']) ? $this->data['redirect'] : false;
  300.     }
  302.     public function onKernelController(FilterControllerEvent $event)
  303.     {
  304.         $this->controllers[$event->getRequest()] = $event->getController();
  305.     }
  307.     public function onKernelResponse(FilterResponseEvent $event)
  308.     {
  309.         if (!$event->isMasterRequest() || !$event->getRequest()->hasSession() || !$event->getRequest()->getSession()->isStarted()) {
  310.             return;
  311.         }
  313.         if ($event->getRequest()->getSession()->has('sf_redirect')) {
  314.             $event->getRequest()->attributes->set('_redirected', true);
  315.         }
  316.     }
  318.     public static function getSubscribedEvents()
  319.     {
  320.         return array(
  321.             KernelEvents::CONTROLLER => 'onKernelController',
  322.             KernelEvents::RESPONSE => 'onKernelResponse',
  323.         );
  324.     }
  326.     /**
  327.      * {@inheritdoc}
  328.      */
  329.     public function getName()
  330.     {
  331.         return 'request';
  332.     }
  334.     /**
  335.      * Parse a controller.
  336.      *
  337.      * @param mixed $controller The controller to parse
  338.      *
  339.      * @return array|string An array of controller data or a simple string
  340.      */
  341.     protected function parseController($controller)
  342.     {
  343.         if (is_string($controller) && false !== strpos($controller, '::')) {
  344.             $controller = explode('::', $controller);
  345.         }
  347.         if (is_array($controller)) {
  348.             try {
  349.                 $r = new \ReflectionMethod($controller[0], $controller[1]);
  351.                 return array(
  352.                     'class' => is_object($controller[0]) ? get_class($controller[0]) : $controller[0],
  353.                     'method' => $controller[1],
  354.                     'file' => $r->getFileName(),
  355.                     'line' => $r->getStartLine(),
  356.                 );
  357.             } catch (\ReflectionException $e) {
  358.                 if (is_callable($controller)) {
  359.                     // using __call or  __callStatic
  360.                     return array(
  361.                         'class' => is_object($controller[0]) ? get_class($controller[0]) : $controller[0],
  362.                         'method' => $controller[1],
  363.                         'file' => 'n/a',
  364.                         'line' => 'n/a',
  365.                     );
  366.                 }
  367.             }
  368.         }
  370.         if ($controller instanceof \Closure) {
  371.             $r = new \ReflectionFunction($controller);
  373.             return array(
  374.                 'class' => $r->getName(),
  375.                 'method' => null,
  376.                 'file' => $r->getFileName(),
  377.                 'line' => $r->getStartLine(),
  378.             );
  379.         }
  381.         if (is_object($controller)) {
  382.             $r = new \ReflectionClass($controller);
  384.             return array(
  385.                 'class' => $r->getName(),
  386.                 'method' => null,
  387.                 'file' => $r->getFileName(),
  388.                 'line' => $r->getStartLine(),
  389.             );
  390.         }
  392.         return is_string($controller) ? $controller : 'n/a';
  393.     }
  394. }