/**
* Forwards the request to the Frontend class if there is a page object.
*
* @param PostResponseEvent $event The event object
*/
public function onKernelTerminate(PostResponseEvent $event)
{
if (!$this->framework->isInitialized()) {
return;
}
Frontend::indexPageIfApplicable($event->getResponse());
}
public function onKernelTerminate(PostResponseEvent $event)
{
if (!$event->isMasterRequest() || !$event->getRequest()->headers->has(self::GENERATE_LOG_HEADER)) {
return;
}
$this->responseLogger->logReponse($event->getRequest(), $event->getResponse());
}
/**
* @param PostResponseEvent $event
*/
public function onTerminate(PostResponseEvent $event)
{
if (!$event->isMasterRequest()) {
return;
}
$this->eventDispatcher->dispatch(Events::REQUEST_ENDS, new RequestEnded($event->getRequest(), $event->getResponse()));
}
public function onKernelTerminate(PostResponseEvent $event)
{
/** @var Request $request */
$request = $event->getRequest();
if (!$this->isEnable || !$this->isLoggableRequest($request)) {
return;
}
try {
/** @var Response $response */
$response = $event->getResponse();
$route = $request->get('_route');
$content = $this->cleanSensitiveContent($route, $request->getContent());
$token = $this->tokenStorage->getToken();
$user = !is_null($token) ? $token->getUser() : null;
$logRequest = new LogRequest();
$logRequest->setRoute($route)->setPath($request->getPathInfo())->setMethod($request->getMethod())->setQuery(urldecode($request->getQueryString()))->setContent($content)->setStatus($response->getStatusCode())->setIp($request->getClientIp())->setUser(!is_string($user) ? $user : null);
if ($this->logResponse($response)) {
$logRequest->setResponse($response->getContent());
}
$this->em->persist($logRequest);
$this->em->flush();
} catch (\Exception $e) {
$this->logger->error(sprintf("LogRequest couldn't be persist : %s", $e->getMessage()));
}
}
function it_do_not_trace_if_no_request_in_stack(Tracer $tracer, SpanStack $spanStack, Span $span, PostResponseEvent $event)
{
$event->isMasterRequest()->willReturn(true);
$spanStack->pop()->willReturn(null);
$tracer->trace(Argument::any())->shouldNotBeCalled();
$this->onKernelTerminate($event);
}
/**
* Save the previous URL in session which is based on the referer header or the request, or
* the _previous_url request attribute, if defined.
*
* If the value of _previous_url is "dont-save", the current referrer is not saved.
*
* @param FilterResponseEvent $event
*/
public function registerPreviousUrl(PostResponseEvent $event)
{
$request = $event->getRequest();
$referrer = $request->attributes->get('_previous_url', null);
if (null !== $referrer) {
// A previous URL (or the keyword 'dont-save') has been specified.
if ('dont-save' == $referrer) {
// We should not save the current URL as the previous URL
$referrer = null;
}
} else {
// The current URL will become the previous URL
$referrer = $request->getUri();
}
// Set previous URL, if defined
if (null !== $referrer) {
$session = $request->getSession();
if (ConfigQuery::read("one_domain_foreach_lang", false) == 1) {
$components = parse_url($referrer);
$lang = LangQuery::create()->filterByUrl(sprintf("%s://%s", $components["scheme"], $components["host"]), ModelCriteria::LIKE)->findOne();
if (null !== $lang) {
$session->setReturnToUrl($referrer);
}
} else {
if (false !== strpos($referrer, $request->getSchemeAndHttpHost())) {
$session->setReturnToUrl($referrer);
}
}
}
}
/**
* @param PostResponseEvent $event
*
* @return float
*/
protected function getExecutionTime(PostResponseEvent $event)
{
$request = $event->getRequest();
$startTime = $request->server->get('REQUEST_TIME_FLOAT', $request->server->get('REQUEST_TIME'));
$time = microtime(true) - $startTime;
return round($time * 1000);
}
public function onKernelTerminate(PostResponseEvent $event)
{
$requestMethod = $event->getRequest()->getMethod();
$requestUri = $event->getRequest()->getRequestUri();
if (strpos($requestUri, '/api/orders') && ($requestMethod == 'PUT' || $requestMethod == 'POST')) {
$this->getOrderUpdater()->processIds();
}
}
/**
* dispatchRequestTime dispatch the request time.
* This time is a "fake" one, because some actions are performed before the initialization of the request
* It is ~100ms smaller than the real kernel time.
*
* @param PostResponseEvent $event
*/
private function dispatchRequestTime(PostResponseEvent $event)
{
$request = $event->getRequest();
$startTime = $request->server->get('REQUEST_TIME_FLOAT', $request->server->get('REQUEST_TIME'));
$time = microtime(true) - $startTime;
$time = round($time * 1000);
$this->eventDispatcher->dispatch('statsd.time', new StatsdEvent($time));
}
/**
* @param PostResponseEvent $event
*/
public function onKernelTerminate(PostResponseEvent $event)
{
$stopwatchEvent = $this->stopwatch->stop('request');
$duration = $stopwatchEvent->getDuration();
$attributes = $this->flattenAttributes($event->getRequest()->attributes->all());
$data = ['service' => 'request.duration', 'metrics' => $duration];
$this->logger->log($data, $attributes);
}
/**
* @param PostResponseEvent $event
*/
public function onKernelTerminate(PostResponseEvent $event)
{
if (!$event->isMasterRequest()) {
return;
}
if ($span = $this->spanStack->pop()) {
$this->tracer->trace([$this->httpFoundationSpanFactory->fromOutgoingResponse($event->getResponse(), $span)]);
}
}
/**
* Forwards the request to the Frontend class if there is a page object.
*
* @param PostResponseEvent $event
*/
public function onKernelTerminate(PostResponseEvent $event)
{
if (!$this->framework->isInitialized()) {
return;
}
/** @var Frontend $frontend */
$frontend = $this->framework->getAdapter('Contao\\Frontend');
$frontend->indexPageIfApplicable($event->getResponse());
}
/**
* Run the automated cron if enabled.
*
* @param \Symfony\Component\HttpKernel\Event\PostResponseEvent $event
* The Event to process.
*/
public function onTerminate(PostResponseEvent $event)
{
$interval = $this->config->get('interval');
if ($interval > 0) {
$cron_next = $this->state->get('system.cron_last', 0) + $interval;
if ((int) $event->getRequest()->server->get('REQUEST_TIME') > $cron_next) {
$this->cron->run();
}
}
}
/**
* @param PostResponseEvent $event
*/
public function onTerminate(PostResponseEvent $event)
{
$response = $event->getResponse();
if (!is_null($this->logger)) {
$this->logger->info('< ' . $response->getStatusCode());
if (!is_null($this->benchmark)) {
$total = $this->benchmark->getAppStatistic();
$this->logger->info('= Time: ' . $total['time'] . ', Memory: ' . FileSizeHelper::humanize($total['memory']));
}
}
}
/**
* Updates the user last action
*
* @param PostResponseEvent $event
*/
public function onRequestTermination(PostResponseEvent $event)
{
$this->userFetcher->setThrowOnTokenError(false);
if (null === ($user = $this->userFetcher->resolve())) {
return;
}
$requestTime = $event->getRequest()->server->get('REQUEST_TIME');
$dateTime = new \DateTime();
$dateTime->setTimestamp($requestTime);
$user->updateLastAction($dateTime);
$this->userRepository->modify($user);
}
/**
* Forwards the request to the Frontend class if there is a page object.
*
* @param PostResponseEvent $event
*/
public function onKernelTerminate(PostResponseEvent $event)
{
if (!$this->framework->isInitialized()) {
return;
}
// Do not index fragments
if (preg_match('~(?:^|/)' . preg_quote($this->fragmentPath, '~') . '/~', $event->getRequest()->getPathInfo())) {
return;
}
/** @var Frontend $frontend */
$frontend = $this->framework->getAdapter(Frontend::class);
$frontend->indexPageIfApplicable($event->getResponse());
}
/**
* Apply invalidators and flush cache manager
*
* On kernel.terminate:
* - see if any invalidators apply to the current request and, if so, add
* their routes to the cache manager;
* - flush the cache manager in order to send invalidation requests to the
* HTTP cache.
*
* @param PostResponseEvent $event
*/
public function onKernelTerminate(PostResponseEvent $event)
{
$request = $event->getRequest();
$response = $event->getResponse();
// Don't invalidate any caches if the request was unsuccessful
if ($response->isSuccessful()) {
$this->handleInvalidation($request, $response);
}
try {
$this->cacheManager->flush();
} catch (ExceptionCollection $e) {
// swallow exception
// there is the fos_http_cache.event_listener.log to log them
}
}
public function onKernelTerminate(PostResponseEvent $pre)
{
//Symfony2 locks the session for the Request's lifecycle.
//Here, we need this method to be executed asynchronously.
//Thus, we release the session immediately.
//$pre->getRequest()->getSession()->save();
$this->container->get('session')->save();
session_write_close();
if ($pre->getRequest()->attributes->has('fetch_request')) {
$attr = $pre->getRequest()->attributes->get('fetch_request');
try {
$this->fetcher->fetch($attr['resource'], $attr['url']);
} catch (ResourceFetcherException $e) {
$this->logger->error("AsyncFetchListener Error : " . $e->getMessage());
}
}
}
/**
* If needed, executes the ezperformancelogger logging on the Symfony Post-Response event
* We wrap the logging code in a runCallback call, as it might need to read inis and such stuff
* NB: we do not need to check for request type - this event only fires on master requests
*
* @param $event
*/
public function onTerminate(PostResponseEvent $event)
{
// small speed gain: avoid useless callback if measurement was already done
if ($this->hasRun) {
return;
}
$response = $event->getResponse();
$legacyKernelClosure = $this->legacyKernelClosure;
$legacyKernel = $legacyKernelClosure();
// accommodate for treemenu kernel not allowing runCallback
try {
$legacyKernel->runCallback(function () use($response) {
eZPerfLogger::cleanup($response->getContent(), $response->getStatusCode());
});
} catch (\RuntimeException $e) {
}
$this->hasRun = true;
}
/**
* Runs the cron job after the response was sent
*
* @param PostResponseEvent $event The event
*/
public function on_kernel_terminate(PostResponseEvent $event)
{
$request = $event->getRequest();
$controller_name = $request->get('_route');
if ($controller_name !== 'phpbb_cron_run') {
return;
}
$cron_type = $request->get('cron_type');
if ($this->cron_lock->acquire()) {
$task = $this->cron_manager->find_task($cron_type);
if ($task) {
if ($task->is_parametrized()) {
$task->parse_parameters($this->request);
}
if ($task->is_ready()) {
$task->run();
}
$this->cron_lock->release();
}
}
}
public function onKernelTerminate(PostResponseEvent $event)
{
if ($this->container->has('profiler')) {
/** @var $profiler \Symfony\Component\HttpKernel\Profiler\Profiler */
$profiler = $this->container->get('profiler');
if ($profile = $profiler->loadProfileFromResponse($event->getResponse())) {
$logRequest = $this->jarvesLogHandler->getLogRequest();
$logRequest->setCounts(json_encode($this->jarvesLogHandler->getCounts()));
$logRequest->setProfileToken($profile->getToken());
$logRequest->save();
return;
}
}
//are there any warnings+?
if ($this->jarvesLogHandler->getCounts()) {
$logRequest = $this->jarvesLogHandler->getLogRequest();
$logRequest->setCounts(json_encode($this->jarvesLogHandler->getCounts()));
$logRequest->save();
}
$this->jarvesLogHandler->resetLogRequest();
}
/**
* @param PostResponseEvent $event
*/
public function onTerminate(PostResponseEvent $event)
{
if (!$event->isMasterRequest()) {
return;
}
$request = $event->getRequest();
if ($request->getRealMethod() == 'OPTIONS') {
return;
}
if (!preg_match($this->rule, $request->getRequestUri())) {
return;
}
$response = $event->getResponse();
$message = $this->formatter->format($request, $response);
if ($response->isClientError()) {
$this->logger->error($message);
return;
}
if ($response->isServerError()) {
$this->logger->critical($message);
return;
}
$this->logger->info($message);
}
/**
* @param PostResponseEvent $event
*/
public function cacheData(PostResponseEvent $event)
{
if ($event->getRequest()->query->get('no-cache', null)) {
return;
}
if (array_key_exists($route = $event->getRequest()->attributes->get('_route'), $this->cachedRoutes)) {
/** @var Response $response */
$response = $event->getResponse();
if ($response->getStatusCode() < 400) {
if (!$event->getRequest()->attributes->has('cached_data')) {
$this->responseCacher->writeCache($event->getRequest(), $event->getResponse(), $this->cachedRoutes[$route]);
}
}
}
}
/**
* @param PostResponseEvent $event
*/
public function onKernelTerminate(PostResponseEvent $event)
{
$request = new Request($event->getRequest(), $event->getResponse(), $this->getUsername());
$this->entityManager->persist($request);
$this->entityManager->flush();
}
/**
* Save new messages
*
* @author Krzysztof Bednarczyk
*/
public function onKernelTerminate(PostResponseEvent $event)
{
if (!$event->isMasterRequest()) {
return;
}
if (!method_exists($this->translator, 'getCollectedMessages')) {
return;
}
$messages = $this->translator->getCollectedMessages();
if (empty($messages)) {
return;
}
$languagesToClear = [];
foreach ($messages as $message) {
if (!in_array((int) $message['state'], [DataCollectorTranslator::MESSAGE_MISSING, DataCollectorTranslator::MESSAGE_EQUALS_FALLBACK])) {
continue;
}
if (!$this->manager->hasLocale($message['locale'])) {
continue;
}
$language = $this->manager->getLanguage($message['locale']);
$languagesToClear[$language->getId()] = $language;
$this->manager->createTranslation($language, $message['id'], $message['domain']);
}
foreach ($languagesToClear as $language) {
$this->manager->clearTranslationCache($language);
}
}
/**
* @param PostResponseEvent $event
*/
public function onKernelTerminate(PostResponseEvent $event)
{
$route = $this->getRoute($event->getRequest());
$this->logger->info('PROCESS END', array($route));
}
public function onKernelTerminate(PostResponseEvent $event)
{
$this->releaseLocks($event->getRequest());
}
/**
* Listen to requests on the pages corresponding to analysis reading actions and mark the associated
* analyses as viewed by setting their "new" property to false.
*
* @param PostResponseEvent $event
*
* @return void
*/
public function onTerminate(PostResponseEvent $event)
{
$requestAttributes = $event->getRequest()->attributes;
// Firstly, we check if we are on an analysis reading page and afterwards, we try to fetch
// the analysis id from the request attributes.
if (!in_array($requestAttributes->get('_route'), $this->analysisViewingRoutes) || ($analysisId = $requestAttributes->get('id')) === null) {
return;
}
// Try to fetch the analysis from the database.
$analysis = $this->doctrine->getRepository('PHPSanitizer\\ProjectBundle\\Entity\\Analysis')->find($analysisId);
// Check if the analysis actually exists and if the user was allowed to read its results.
if ($analysis !== null && $this->authorizationChecker->isGranted('VIEW', $analysis->getProject())) {
// Finally, mark the analysis as viewed.
$this->markViewedAnalysis($analysis);
}
}
public function __construct(Request $request, Response $response)
{
parent::__construct(new NullHttpKernel(), $request, $response);
}
/**
* On kernel terminate
*
* @param PostResponseEvent $postResponseEvent postResponseEvent
*
* @return void
*/
public function onKernelTerminate(PostResponseEvent $postResponseEvent)
{
$request = $postResponseEvent->getRequest();
$transaction = $request->attributes->get('transaction');
if ($transaction) {
$this->entityManager->clear();
$this->entityManager->persist($transaction);
$this->entityManager->flush();
}
}
