vendor/symfony/http-kernel/DataCollector/RequestDataCollector.php line 317

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