2010-08-28 14:23:21 +01:00
|
|
|
<?php
|
|
|
|
|
2011-01-15 13:29:43 +00:00
|
|
|
/*
|
|
|
|
* This file is part of the Symfony package.
|
|
|
|
*
|
2011-03-06 11:40:06 +00:00
|
|
|
* (c) Fabien Potencier <fabien@symfony.com>
|
2011-01-15 13:29:43 +00:00
|
|
|
*
|
|
|
|
* For the full copyright and license information, please view the LICENSE
|
|
|
|
* file that was distributed with this source code.
|
|
|
|
*/
|
|
|
|
|
2010-08-28 14:23:21 +01:00
|
|
|
namespace Symfony\Component\HttpKernel\DataCollector;
|
|
|
|
|
|
|
|
use Symfony\Component\HttpFoundation\ParameterBag;
|
|
|
|
use Symfony\Component\HttpFoundation\HeaderBag;
|
|
|
|
use Symfony\Component\HttpFoundation\Request;
|
|
|
|
use Symfony\Component\HttpFoundation\Response;
|
2010-11-18 17:49:08 +00:00
|
|
|
use Symfony\Component\HttpFoundation\ResponseHeaderBag;
|
2016-04-22 18:42:42 +01:00
|
|
|
use Symfony\Component\HttpKernel\Event\FilterResponseEvent;
|
2012-07-18 09:39:31 +01:00
|
|
|
use Symfony\Component\HttpKernel\KernelEvents;
|
|
|
|
use Symfony\Component\HttpKernel\Event\FilterControllerEvent;
|
|
|
|
use Symfony\Component\EventDispatcher\EventSubscriberInterface;
|
2010-08-28 14:23:21 +01:00
|
|
|
|
|
|
|
/**
|
|
|
|
* RequestDataCollector.
|
|
|
|
*
|
2011-03-06 11:40:06 +00:00
|
|
|
* @author Fabien Potencier <fabien@symfony.com>
|
2010-08-28 14:23:21 +01:00
|
|
|
*/
|
2012-07-18 09:39:31 +01:00
|
|
|
class RequestDataCollector extends DataCollector implements EventSubscriberInterface
|
2010-08-28 14:23:21 +01:00
|
|
|
{
|
2016-03-02 08:56:55 +00:00
|
|
|
/** @var \SplObjectStorage */
|
2012-07-18 09:39:31 +01:00
|
|
|
protected $controllers;
|
|
|
|
|
|
|
|
public function __construct()
|
|
|
|
{
|
|
|
|
$this->controllers = new \SplObjectStorage();
|
|
|
|
}
|
|
|
|
|
2010-08-28 14:23:21 +01:00
|
|
|
/**
|
|
|
|
* {@inheritdoc}
|
|
|
|
*/
|
|
|
|
public function collect(Request $request, Response $response, \Exception $exception = null)
|
|
|
|
{
|
2011-01-15 22:28:26 +00:00
|
|
|
$responseHeaders = $response->headers->all();
|
|
|
|
$cookies = array();
|
|
|
|
foreach ($response->headers->getCookies() as $cookie) {
|
2011-04-13 19:09:04 +01:00
|
|
|
$cookies[] = $this->getCookieHeader($cookie->getName(), $cookie->getValue(), $cookie->getExpiresTime(), $cookie->getPath(), $cookie->getDomain(), $cookie->isSecure(), $cookie->isHttpOnly());
|
2011-01-15 22:28:26 +00:00
|
|
|
}
|
|
|
|
if (count($cookies) > 0) {
|
|
|
|
$responseHeaders['Set-Cookie'] = $cookies;
|
|
|
|
}
|
|
|
|
|
2014-03-03 15:15:12 +00:00
|
|
|
// attributes are serialized and as they can be anything, they need to be converted to strings.
|
2011-02-08 18:09:50 +00:00
|
|
|
$attributes = array();
|
|
|
|
foreach ($request->attributes->all() as $key => $value) {
|
2013-09-17 17:48:45 +01:00
|
|
|
if ('_route' === $key && is_object($value)) {
|
2014-03-03 15:15:12 +00:00
|
|
|
$attributes[$key] = $this->varToString($value->getPath());
|
|
|
|
} elseif ('_route_params' === $key) {
|
|
|
|
// we need to keep route params as an array (see getRouteParams())
|
|
|
|
foreach ($value as $k => $v) {
|
|
|
|
$value[$k] = $this->varToString($v);
|
|
|
|
}
|
|
|
|
$attributes[$key] = $value;
|
|
|
|
} else {
|
|
|
|
$attributes[$key] = $this->varToString($value);
|
2012-12-26 08:59:40 +00:00
|
|
|
}
|
2011-02-08 18:09:50 +00:00
|
|
|
}
|
|
|
|
|
2011-04-19 13:02:32 +01:00
|
|
|
$content = null;
|
|
|
|
try {
|
|
|
|
$content = $request->getContent();
|
|
|
|
} catch (\LogicException $e) {
|
|
|
|
// the user already got the request content as a resource
|
|
|
|
$content = false;
|
|
|
|
}
|
|
|
|
|
2012-05-26 21:51:24 +01:00
|
|
|
$sessionMetadata = array();
|
2012-07-14 14:04:55 +01:00
|
|
|
$sessionAttributes = array();
|
|
|
|
$flashes = array();
|
2012-05-26 21:51:24 +01:00
|
|
|
if ($request->hasSession()) {
|
2012-07-14 14:04:55 +01:00
|
|
|
$session = $request->getSession();
|
|
|
|
if ($session->isStarted()) {
|
|
|
|
$sessionMetadata['Created'] = date(DATE_RFC822, $session->getMetadataBag()->getCreated());
|
|
|
|
$sessionMetadata['Last used'] = date(DATE_RFC822, $session->getMetadataBag()->getLastUsed());
|
|
|
|
$sessionMetadata['Lifetime'] = $session->getMetadataBag()->getLifetime();
|
|
|
|
$sessionAttributes = $session->all();
|
|
|
|
$flashes = $session->getFlashBag()->peekAll();
|
|
|
|
}
|
2012-05-26 21:51:24 +01:00
|
|
|
}
|
|
|
|
|
2013-02-17 10:03:55 +00:00
|
|
|
$statusCode = $response->getStatusCode();
|
|
|
|
|
2010-08-28 14:23:21 +01:00
|
|
|
$this->data = array(
|
2016-03-03 07:22:07 +00:00
|
|
|
'method' => $request->getMethod(),
|
2014-10-22 19:27:13 +01:00
|
|
|
'format' => $request->getRequestFormat(),
|
|
|
|
'content' => $content,
|
2015-02-09 03:38:13 +00:00
|
|
|
'content_type' => $response->headers->get('Content-Type', 'text/html'),
|
2014-10-22 19:27:13 +01:00
|
|
|
'status_text' => isset(Response::$statusTexts[$statusCode]) ? Response::$statusTexts[$statusCode] : '',
|
|
|
|
'status_code' => $statusCode,
|
|
|
|
'request_query' => $request->query->all(),
|
|
|
|
'request_request' => $request->request->all(),
|
|
|
|
'request_headers' => $request->headers->all(),
|
|
|
|
'request_server' => $request->server->all(),
|
|
|
|
'request_cookies' => $request->cookies->all(),
|
2011-02-08 18:09:50 +00:00
|
|
|
'request_attributes' => $attributes,
|
2014-10-22 19:27:13 +01:00
|
|
|
'response_headers' => $responseHeaders,
|
|
|
|
'session_metadata' => $sessionMetadata,
|
2012-07-14 14:04:55 +01:00
|
|
|
'session_attributes' => $sessionAttributes,
|
2014-10-22 19:27:13 +01:00
|
|
|
'flashes' => $flashes,
|
|
|
|
'path_info' => $request->getPathInfo(),
|
|
|
|
'controller' => 'n/a',
|
|
|
|
'locale' => $request->getLocale(),
|
2010-08-28 14:23:21 +01:00
|
|
|
);
|
2012-07-18 09:39:31 +01:00
|
|
|
|
2012-12-26 05:54:14 +00:00
|
|
|
if (isset($this->data['request_headers']['php-auth-pw'])) {
|
|
|
|
$this->data['request_headers']['php-auth-pw'] = '******';
|
|
|
|
}
|
|
|
|
|
|
|
|
if (isset($this->data['request_server']['PHP_AUTH_PW'])) {
|
|
|
|
$this->data['request_server']['PHP_AUTH_PW'] = '******';
|
|
|
|
}
|
|
|
|
|
2014-12-15 00:05:11 +00:00
|
|
|
if (isset($this->data['request_request']['_password'])) {
|
|
|
|
$this->data['request_request']['_password'] = '******';
|
|
|
|
}
|
|
|
|
|
2012-07-18 09:39:31 +01:00
|
|
|
if (isset($this->controllers[$request])) {
|
2016-01-28 10:45:34 +00:00
|
|
|
$this->data['controller'] = $this->parseController($this->controllers[$request]);
|
2012-07-18 09:39:31 +01:00
|
|
|
unset($this->controllers[$request]);
|
|
|
|
}
|
2016-01-28 10:45:34 +00:00
|
|
|
|
2016-04-22 18:42:42 +01:00
|
|
|
if (isset($session)) {
|
2016-04-23 02:01:41 +01:00
|
|
|
if ($request->attributes->has('_redirected')) {
|
|
|
|
$this->data['redirect'] = $session->remove('sf_redirect');
|
2016-04-22 18:42:42 +01:00
|
|
|
}
|
2016-01-28 10:45:34 +00:00
|
|
|
|
2016-04-22 18:42:42 +01:00
|
|
|
if ($response->isRedirect()) {
|
|
|
|
$session->set('sf_redirect', array(
|
|
|
|
'token' => $response->headers->get('x-debug-token'),
|
|
|
|
'route' => $request->attributes->get('_route', 'n/a'),
|
|
|
|
'method' => $request->getMethod(),
|
|
|
|
'controller' => $this->parseController($request->attributes->get('_controller')),
|
|
|
|
'status_code' => $statusCode,
|
|
|
|
'status_text' => Response::$statusTexts[(int) $statusCode],
|
|
|
|
));
|
|
|
|
}
|
2016-01-28 10:45:34 +00:00
|
|
|
}
|
2010-08-28 14:23:21 +01:00
|
|
|
}
|
|
|
|
|
2016-03-03 07:22:07 +00:00
|
|
|
public function getMethod()
|
|
|
|
{
|
|
|
|
return $this->data['method'];
|
|
|
|
}
|
|
|
|
|
2011-12-31 14:51:33 +00:00
|
|
|
public function getPathInfo()
|
|
|
|
{
|
|
|
|
return $this->data['path_info'];
|
|
|
|
}
|
|
|
|
|
2010-08-28 14:23:21 +01:00
|
|
|
public function getRequestRequest()
|
|
|
|
{
|
|
|
|
return new ParameterBag($this->data['request_request']);
|
|
|
|
}
|
|
|
|
|
|
|
|
public function getRequestQuery()
|
|
|
|
{
|
|
|
|
return new ParameterBag($this->data['request_query']);
|
|
|
|
}
|
|
|
|
|
|
|
|
public function getRequestHeaders()
|
|
|
|
{
|
|
|
|
return new HeaderBag($this->data['request_headers']);
|
|
|
|
}
|
|
|
|
|
|
|
|
public function getRequestServer()
|
|
|
|
{
|
|
|
|
return new ParameterBag($this->data['request_server']);
|
|
|
|
}
|
|
|
|
|
|
|
|
public function getRequestCookies()
|
|
|
|
{
|
|
|
|
return new ParameterBag($this->data['request_cookies']);
|
|
|
|
}
|
|
|
|
|
2010-11-06 15:47:49 +00:00
|
|
|
public function getRequestAttributes()
|
|
|
|
{
|
|
|
|
return new ParameterBag($this->data['request_attributes']);
|
|
|
|
}
|
|
|
|
|
2010-08-28 14:23:21 +01:00
|
|
|
public function getResponseHeaders()
|
|
|
|
{
|
changed Cache-Control default value behavior
The PHP native cache limiter feature has been disabled as this is now managed
by the HeaderBag class directly instead (see below.)
The HeaderBag class uses the following rules to define a sensible and
convervative default value for the Response 'Cache-Control' header:
* If no cache header is defined ('Cache-Control', 'ETag', 'Last-Modified',
and 'Expires'), 'Cache-Control' is set to 'no-cache';
* If 'Cache-Control' is empty, its value is set to "private, max-age=0,
must-revalidate";
* But if at least one 'Cache-Control' directive is set, and no 'public' or
'private' directives have been explicitely added, Symfony2 adds the
'private' directive automatically (except when 's-maxage' is set.)
So, remember to explicitly add the 'public' directive to 'Cache-Control' when
you want shared caches to store your application resources:
// The Response is private by default
$response->setEtag($etag);
$response->setLastModified($date);
$response->setMaxAge(10);
// Change the Response to be public
$response->setPublic();
// Set cache settings in one call
$response->setCache(array(
'etag' => $etag,
'last_modified' => $date,
'max_age' => 10,
'public' => true,
));
2010-11-10 09:48:22 +00:00
|
|
|
return new ResponseHeaderBag($this->data['response_headers']);
|
2010-08-28 14:23:21 +01:00
|
|
|
}
|
|
|
|
|
2012-05-26 21:51:24 +01:00
|
|
|
public function getSessionMetadata()
|
|
|
|
{
|
|
|
|
return $this->data['session_metadata'];
|
|
|
|
}
|
|
|
|
|
2010-08-28 14:23:21 +01:00
|
|
|
public function getSessionAttributes()
|
|
|
|
{
|
2010-09-27 20:17:37 +01:00
|
|
|
return $this->data['session_attributes'];
|
2010-08-28 14:23:21 +01:00
|
|
|
}
|
|
|
|
|
2012-02-12 12:37:15 +00:00
|
|
|
public function getFlashes()
|
|
|
|
{
|
|
|
|
return $this->data['flashes'];
|
|
|
|
}
|
|
|
|
|
2011-04-15 10:31:08 +01:00
|
|
|
public function getContent()
|
|
|
|
{
|
|
|
|
return $this->data['content'];
|
|
|
|
}
|
|
|
|
|
2010-08-28 14:23:21 +01:00
|
|
|
public function getContentType()
|
|
|
|
{
|
|
|
|
return $this->data['content_type'];
|
|
|
|
}
|
|
|
|
|
2013-02-17 10:03:55 +00:00
|
|
|
public function getStatusText()
|
|
|
|
{
|
|
|
|
return $this->data['status_text'];
|
|
|
|
}
|
|
|
|
|
2010-08-28 14:23:21 +01:00
|
|
|
public function getStatusCode()
|
|
|
|
{
|
|
|
|
return $this->data['status_code'];
|
|
|
|
}
|
|
|
|
|
|
|
|
public function getFormat()
|
|
|
|
{
|
|
|
|
return $this->data['format'];
|
|
|
|
}
|
|
|
|
|
2012-10-17 09:50:16 +01:00
|
|
|
public function getLocale()
|
|
|
|
{
|
|
|
|
return $this->data['locale'];
|
|
|
|
}
|
|
|
|
|
2012-07-15 18:07:14 +01:00
|
|
|
/**
|
2012-07-18 09:39:31 +01:00
|
|
|
* Gets the route name.
|
|
|
|
*
|
|
|
|
* The _route request attributes is automatically set by the Router Matcher.
|
2012-07-15 18:07:14 +01:00
|
|
|
*
|
|
|
|
* @return string The route
|
|
|
|
*/
|
|
|
|
public function getRoute()
|
|
|
|
{
|
2012-07-18 09:39:31 +01:00
|
|
|
return isset($this->data['request_attributes']['_route']) ? $this->data['request_attributes']['_route'] : '';
|
2012-07-15 18:07:14 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2012-07-18 09:39:31 +01:00
|
|
|
* Gets the route parameters.
|
|
|
|
*
|
|
|
|
* The _route_params request attributes is automatically set by the RouterListener.
|
2012-07-15 18:07:14 +01:00
|
|
|
*
|
|
|
|
* @return array The parameters
|
|
|
|
*/
|
|
|
|
public function getRouteParams()
|
|
|
|
{
|
2012-07-18 09:39:31 +01:00
|
|
|
return isset($this->data['request_attributes']['_route_params']) ? $this->data['request_attributes']['_route_params'] : array();
|
2012-07-15 18:07:14 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2016-01-28 10:45:34 +00:00
|
|
|
* Gets the parsed controller.
|
2012-07-15 18:07:14 +01:00
|
|
|
*
|
2016-01-28 10:45:34 +00:00
|
|
|
* @return array|string The controller as a string or array of data
|
|
|
|
* with keys 'class', 'method', 'file' and 'line'
|
2012-07-15 18:07:14 +01:00
|
|
|
*/
|
|
|
|
public function getController()
|
|
|
|
{
|
2012-07-18 09:39:31 +01:00
|
|
|
return $this->data['controller'];
|
|
|
|
}
|
|
|
|
|
2016-01-28 10:45:34 +00:00
|
|
|
/**
|
|
|
|
* Gets the previous request attributes.
|
|
|
|
*
|
|
|
|
* @return array|bool A legacy array of data from the previous redirection response
|
|
|
|
* or false otherwise
|
|
|
|
*/
|
|
|
|
public function getRedirect()
|
|
|
|
{
|
|
|
|
return isset($this->data['redirect']) ? $this->data['redirect'] : false;
|
|
|
|
}
|
|
|
|
|
2012-07-18 09:39:31 +01:00
|
|
|
public function onKernelController(FilterControllerEvent $event)
|
|
|
|
{
|
|
|
|
$this->controllers[$event->getRequest()] = $event->getController();
|
|
|
|
}
|
|
|
|
|
2016-04-22 18:42:42 +01:00
|
|
|
public function onKernelResponse(FilterResponseEvent $event)
|
|
|
|
{
|
|
|
|
if (!$event->isMasterRequest() || !$event->getRequest()->hasSession()) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
if ($event->getRequest()->getSession()->has('sf_redirect')) {
|
2016-04-23 02:01:41 +01:00
|
|
|
$event->getRequest()->attributes->set('_redirected', true);
|
2016-04-22 18:42:42 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-07-18 09:39:31 +01:00
|
|
|
public static function getSubscribedEvents()
|
|
|
|
{
|
2016-04-22 18:42:42 +01:00
|
|
|
return array(
|
|
|
|
KernelEvents::CONTROLLER => 'onKernelController',
|
|
|
|
KernelEvents::RESPONSE => 'onKernelResponse',
|
|
|
|
);
|
2012-07-15 18:07:14 +01:00
|
|
|
}
|
|
|
|
|
2010-08-28 14:23:21 +01:00
|
|
|
/**
|
|
|
|
* {@inheritdoc}
|
|
|
|
*/
|
|
|
|
public function getName()
|
|
|
|
{
|
|
|
|
return 'request';
|
|
|
|
}
|
2011-01-15 22:28:26 +00:00
|
|
|
|
2016-01-28 10:45:34 +00:00
|
|
|
/**
|
|
|
|
* Parse a controller.
|
|
|
|
*
|
|
|
|
* @param mixed $controller The controller to parse
|
|
|
|
*
|
|
|
|
* @return array|string An array of controller data or a simple string
|
|
|
|
*/
|
2016-03-02 08:56:55 +00:00
|
|
|
protected function parseController($controller)
|
2016-01-28 10:45:34 +00:00
|
|
|
{
|
|
|
|
if (is_string($controller) && false !== strpos($controller, '::')) {
|
|
|
|
$controller = explode('::', $controller);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (is_array($controller)) {
|
|
|
|
try {
|
|
|
|
$r = new \ReflectionMethod($controller[0], $controller[1]);
|
|
|
|
|
|
|
|
return array(
|
|
|
|
'class' => is_object($controller[0]) ? get_class($controller[0]) : $controller[0],
|
|
|
|
'method' => $controller[1],
|
|
|
|
'file' => $r->getFileName(),
|
|
|
|
'line' => $r->getStartLine(),
|
|
|
|
);
|
|
|
|
} catch (\ReflectionException $e) {
|
|
|
|
if (is_callable($controller)) {
|
|
|
|
// using __call or __callStatic
|
|
|
|
return array(
|
|
|
|
'class' => is_object($controller[0]) ? get_class($controller[0]) : $controller[0],
|
|
|
|
'method' => $controller[1],
|
|
|
|
'file' => 'n/a',
|
|
|
|
'line' => 'n/a',
|
|
|
|
);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if ($controller instanceof \Closure) {
|
|
|
|
$r = new \ReflectionFunction($controller);
|
|
|
|
|
|
|
|
return array(
|
|
|
|
'class' => $r->getName(),
|
|
|
|
'method' => null,
|
|
|
|
'file' => $r->getFileName(),
|
|
|
|
'line' => $r->getStartLine(),
|
|
|
|
);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (is_object($controller)) {
|
|
|
|
$r = new \ReflectionClass($controller);
|
|
|
|
|
|
|
|
return array(
|
|
|
|
'class' => $r->getName(),
|
|
|
|
'method' => null,
|
|
|
|
'file' => $r->getFileName(),
|
|
|
|
'line' => $r->getStartLine(),
|
|
|
|
);
|
|
|
|
}
|
|
|
|
|
|
|
|
return (string) $controller ?: 'n/a';
|
|
|
|
}
|
2016-03-02 08:56:55 +00:00
|
|
|
|
|
|
|
private function getCookieHeader($name, $value, $expires, $path, $domain, $secure, $httponly)
|
|
|
|
{
|
|
|
|
$cookie = sprintf('%s=%s', $name, urlencode($value));
|
|
|
|
|
|
|
|
if (0 !== $expires) {
|
|
|
|
if (is_numeric($expires)) {
|
|
|
|
$expires = (int) $expires;
|
|
|
|
} elseif ($expires instanceof \DateTime) {
|
|
|
|
$expires = $expires->getTimestamp();
|
|
|
|
} else {
|
|
|
|
$tmp = strtotime($expires);
|
|
|
|
if (false === $tmp || -1 == $tmp) {
|
|
|
|
throw new \InvalidArgumentException(sprintf('The "expires" cookie parameter is not valid (%s).', $expires));
|
|
|
|
}
|
|
|
|
$expires = $tmp;
|
|
|
|
}
|
|
|
|
|
|
|
|
$cookie .= '; expires='.str_replace('+0000', '', \DateTime::createFromFormat('U', $expires, new \DateTimeZone('GMT'))->format('D, d-M-Y H:i:s T'));
|
|
|
|
}
|
|
|
|
|
|
|
|
if ($domain) {
|
|
|
|
$cookie .= '; domain='.$domain;
|
|
|
|
}
|
|
|
|
|
|
|
|
$cookie .= '; path='.$path;
|
|
|
|
|
|
|
|
if ($secure) {
|
|
|
|
$cookie .= '; secure';
|
|
|
|
}
|
|
|
|
|
|
|
|
if ($httponly) {
|
|
|
|
$cookie .= '; httponly';
|
|
|
|
}
|
|
|
|
|
|
|
|
return $cookie;
|
|
|
|
}
|
2010-08-28 14:23:21 +01:00
|
|
|
}
|