/**
* @throws NotImplementedException If Content is missing location as this is not supported in current version
*/
public function previewContentAction(Request $request, $contentId, $versionNo, $language, $siteAccessName = null)
{
$this->previewHelper->setPreviewActive(true);
try {
$content = $this->contentService->loadContent($contentId, array($language), $versionNo);
$location = $this->locationProvider->loadMainLocation($contentId);
if (!$location instanceof Location) {
throw new NotImplementedException("Preview for content without locations");
}
$this->previewHelper->setPreviewedContent($content);
$this->previewHelper->setPreviewedLocation($location);
} catch (UnauthorizedException $e) {
throw new AccessDeniedException();
}
if (!$this->authorizationChecker->isGranted(new AuthorizationAttribute('content', 'versionread', array('valueObject' => $content)))) {
throw new AccessDeniedException();
}
$siteAccess = $this->previewHelper->getOriginalSiteAccess();
// Only switch if $siteAccessName is set and different from original
if ($siteAccessName !== null && $siteAccessName !== $siteAccess->name) {
$siteAccess = $this->previewHelper->changeConfigScope($siteAccessName);
}
$response = $this->kernel->handle($this->getForwardRequest($location, $content, $siteAccess, $request), HttpKernelInterface::SUB_REQUEST);
$response->headers->remove('cache-control');
$response->headers->remove('expires');
$this->previewHelper->restoreConfigScope();
$this->previewHelper->setPreviewActive(false);
return $response;
}
/**
* Handle a request
*
* @param ReactRequest $request
* @param ReactResponse $response
*/
public function onRequest(ReactRequest $request, ReactResponse $response)
{
$content = '';
$headers = $request->getHeaders();
$contentLength = isset($headers['Content-Length']) ? (int) $headers['Content-Length'] : 0;
$request->on('data', function ($data) use($request, $response, &$content, $contentLength) {
// Read data (may be empty for GET request)
$content .= $data;
// Handle request after receive
if (strlen($content) >= $contentLength) {
$symfonyRequest = static::mapRequest($request, $content);
try {
// Execute
$symfonyResponse = $this->application->handle($symfonyRequest);
} catch (\Throwable $t) {
// Executed only in PHP 7, will not match in PHP 5.x
$this->fatalError($response, $t);
return;
} catch (\Exception $e) {
// Executed only in PHP 5.x, will not be reached in PHP 7
$this->fatalError($response, $e);
return;
}
static::mapResponse($response, $symfonyResponse);
if ($this->application instanceof SymfonyHttpKernel\TerminableInterface) {
$this->application->terminate($symfonyRequest, $symfonyResponse);
}
}
});
}
protected function redirect($params, $event)
{
$subRequest = $this->request->duplicate(array(), null, $params);
$response = $this->httpKernel->handle($subRequest, HttpKernelInterface::SUB_REQUEST);
$event->setResponse($response);
$event->stopPropagation();
}
/**
* {@inheritdoc}
*/
public function handle(Request $request, $type = HttpKernelInterface::MASTER_REQUEST, $catch = true)
{
// always set the session onto the request object.
$request->setSession($this->session);
// we only need to manage the session for the master request.
// subrequests will have the session available anyways, but we will
// be closing and setting the cookie for the master request only.
if ($type !== HttpKernelInterface::MASTER_REQUEST) {
return $this->kernel->handle($request, $type, $catch);
}
// the session may have been manually started before the middleware is
// invoked - in this case, we cross our fingers and hope the session has
// properly initialised itself
if (!$this->session->isStarted()) {
$this->initSession($request);
}
$response = $this->kernel->handle($request, $type, $catch);
// if the session has started, save it and attach the session cookie. if
// the session has not started, there is nothing to save and there is no
// point in attaching a cookie to persist it.
if ($this->session->isStarted()) {
$this->closeSession($request, $response);
}
return $response;
}
/**
* {@inheritdoc}
*/
public function handle(Request $request, $type = self::MASTER_REQUEST, $catch = TRUE)
{
// TODO Probably we can move here the database log start and the initial
// read of memory usage.
Timer::start('devel_page');
return $this->httpKernel->handle($request, $type, $catch);
}
/**
* {@inheritdoc}
*/
public function handle(Request $request, $type = self::MASTER_REQUEST, $catch = TRUE)
{
if (\Drupal::state()->get('error_service_test.break_bare_html_renderer')) {
// Let the bedlam begin.
// 1) Force a container rebuild.
/** @var \Drupal\Core\DrupalKernelInterface $kernel */
$kernel = \Drupal::service('kernel');
$kernel->rebuildContainer();
// 2) Fetch the in-situ container builder.
$container = ErrorServiceTestServiceProvider::$containerBuilder;
// Ensure the compiler pass worked.
if (!$container) {
throw new \Exception('Oh oh, monkeys stole the ServiceProvider.');
}
// Stop the theme manager from being found - and triggering error
// maintenance mode.
$container->removeDefinition('theme.manager');
// Mash. Mash. Mash.
\Drupal::setContainer($container);
throw new \Exception('Oh oh, bananas in the instruments.');
}
if (\Drupal::state()->get('error_service_test.break_logger')) {
throw new \Exception('Deforestation');
}
return $this->app->handle($request, $type, $catch);
}
/**
* {@inheritdoc}
*/
public function handle(Request $request, $type = HttpKernelInterface::MASTER_REQUEST, $catch = true)
{
$route = $request->getPathInfo();
// We have an active login
if ($this->sessionAuth->check()) {
switch ($route) {
case '/login':
$returnUri = $request->query->get('uri', $request->attributes->get('stack.url_map.prefix', '/'));
return new RedirectResponse($returnUri);
break;
case '/logout':
$this->sessionAuth->logout();
return new RedirectResponse($request->attributes->get('stack.url_map.prefix', '/'));
break;
default:
$caller = $this->sessionAuth->getCurrentCaller();
$request->attributes->set('stack.authn.token', $caller->getLoginToken());
if ($this->options['delegateCaller']) {
$request->attributes->set('stack.authn.caller', $caller);
}
break;
}
} elseif ($route !== '/login') {
$routePrefix = $request->attributes->get('stack.url_map.prefix', '');
$fullRoute = $request->server->get('PATH_INFO', '/');
return new RedirectResponse(sprintf('%s/%s?uri=%s', $routePrefix, $this->options['loginUri'], $fullRoute));
}
return $this->app->handle($request, $type, $catch);
}
/**
* After each scenario, reboot the kernel.
*/
public function rebootKernel()
{
$this->kernel->flush();
$laravel = new LaravelBooter($this->kernel->basePath(), $this->kernel->environmentFile());
$this->context->getSession('laravel')->getDriver()->reboot($this->kernel = $laravel->boot());
$this->setAppOnContext();
}
/**
* @return string Json encoded
*/
protected function getAuditFields()
{
$path = ['_controller' => 'OroDataAuditBundle:Api/Rest/Audit:getFields'];
$subRequest = $this->request->duplicate(['_format' => 'json'], null, $path);
$response = $this->httpKernel->handle($subRequest, HttpKernelInterface::MASTER_REQUEST);
return $response->getContent();
}
/**
* {@inheritdoc}
*/
public function handle(Request $request, $type = self::MASTER_REQUEST, $catch = TRUE)
{
if ($request->headers->has('Accept')) {
$request->setRequestFormat($request->getFormat($request->headers->get('Accept')));
}
return $this->httpKernel->handle($request, $type, $catch);
}
/**
* {@inheritdoc}
*/
public function handle(Request $request, $type = self::MASTER_REQUEST, $catch = true)
{
/** @var LaravelDebugbar $debugbar */
$debugbar = $this->app['debugbar'];
$response = $this->kernel->handle($request, $type, $catch);
return $debugbar->modifyResponse($request, $response);
}
/**
* {@inheritdoc}
*/
public function handle(Request $request, $type = self::MASTER_REQUEST, $catch = TRUE)
{
$config = $this->configFactory->get('shield.settings');
$allow_cli = $config->get('allow_cli');
$user = $config->get('user');
$pass = $config->get('pass');
if (empty($user) || PHP_SAPI === 'cli' && $allow_cli) {
// If username is empty, then authentication is disabled,
// or if request is coming from a cli and it is allowed,
// then proceed with response without shield authentication.
return $this->httpKernel->handle($request, $type, $catch);
} else {
if ($request->server->has('PHP_AUTH_USER') && $request->server->has('PHP_AUTH_PW')) {
$input_user = $request->server->get('PHP_AUTH_USER');
$input_pass = $request->server->get('PHP_AUTH_PW');
} elseif ($request->server->has('HTTP_AUTHORIZATION')) {
list($input_user, $input_pass) = explode(':', base64_decode(substr($request->server->get('HTTP_AUTHORIZATION'), 6)), 2);
} elseif ($request->server->has('REDIRECT_HTTP_AUTHORIZATION')) {
list($input_user, $input_pass) = explode(':', base64_decode(substr($request->server->get('REDIRECT_HTTP_AUTHORIZATION'), 6)), 2);
}
if (isset($input_user) && $input_user === $user && Crypt::hashEquals($pass, $input_pass)) {
return $this->httpKernel->handle($request, $type, $catch);
}
}
$response = new Response();
$response->headers->add(['WWW-Authenticate' => 'Basic realm="' . strtr($config->get('print'), ['[user]' => $user, '[pass]' => $pass]) . '"']);
$response->setStatusCode(401);
return $response;
}
/**
* {@inheritdoc}
*/
public function handle(Request $request, $type = self::MASTER_REQUEST, $catch = TRUE)
{
if ($request->getClientIp() == '127.0.0.10') {
return new Response(t('Bye!'), 403);
}
return $this->httpKernel->handle($request, $type, $catch);
}
/**
* {@inheritdoc}
*/
public function terminate(Request $request, Response $response)
{
parent::terminate($request, $response);
if ($this->app instanceof TerminableInterface) {
$this->app->terminate($request, $response);
}
}
/**
* {@inheritdoc}
*/
public function handle(Request $request, $type = self::MASTER_REQUEST, $catch = true)
{
try {
$response = $this->app->handle($request, $type, $catch);
if ($response instanceof Response) {
return $response;
}
} catch (DatabaseConnectionException $e) {
$message = $e->getMessage();
} catch (\Exception $e) {
error_log($e);
if (MAUTIC_ENV == 'dev') {
$message = "<pre>{$e->getMessage()} - in file {$e->getFile()} - at line {$e->getLine()}</pre>";
$submessage = "<pre>{$e->getTraceAsString()}</pre>";
} else {
$message = 'The site is currently offline due to encountering an error. If the problem persists, please contact the system administrator.';
$submessage = 'System administrators, check server logs for errors.';
}
}
if (isset($message)) {
define('MAUTIC_OFFLINE', 1);
ob_start();
include MAUTIC_ROOT_DIR . '/offline.php';
$content = ob_get_clean();
return new Response($content, 500);
}
}
/**
* @param \Symfony\Component\HttpKernel\Event\GetResponseEvent $event
*/
public function onKernelRequest(GetResponseEvent $event)
{
if ($event->getRequestType() != HttpKernelInterface::MASTER_REQUEST) {
return;
}
// @todo make endpoint(s) customizable
if ($event->getRequest()->getMethod() !== 'POST') {
return;
}
if ($event->getRequest()->getPathInfo() != '/xmlrpc' && $event->getRequest()->getPathInfo() != '/xmlrpc.php') {
return;
}
try {
$request = $this->requestGenerator->generateFromRequest($event->getRequest());
if (isset($this->logger)) {
$this->logger->debug((string) $request);
}
} catch (UnexpectedValueException $e) {
$event->setResponse(new Response("Invalid request XML\n" . $e->getMessage(), 400));
return;
}
// @todo refactor to dynamically set follow-up events instead of testing (cors bundle like)
$request->attributes->set('IsXmlRpcRequest', true);
$requestContext = new RequestContext();
$requestContext->fromRequest($request);
$originalContext = $this->router->getContext();
$this->router->setContext($requestContext);
$response = $this->httpKernel->handle($request);
$event->setResponse($response);
$this->router->setContext($originalContext);
if ($response instanceof Response) {
$event->setResponse($response);
}
}
/**
* @param Request $request
* @param Response $response
*/
public function terminate(Request $request, Response $response)
{
$this->newRelic->endOfTransaction();
if ($this->app instanceof TerminableInterface) {
$this->app->terminate($request, $response);
}
}
/**
* Handle a request using a HttpKernelInterface implementing application.
*
* @param \React\Http\Request $request
* @param \React\Http\Response $response
*/
public function onRequest(ReactRequest $request, ReactResponse $response)
{
if (null === $this->application) {
return;
}
$content = '';
$headers = $request->getHeaders();
$contentLength = isset($headers['Content-Length']) ? (int) $headers['Content-Length'] : 0;
$request->on('data', function ($data) use($request, $response, &$content, $contentLength) {
// read data (may be empty for GET request)
$content .= $data;
// handle request after receive
if (strlen($content) >= $contentLength) {
$syRequest = self::mapRequest($request, $content);
try {
$syResponse = $this->application->handle($syRequest);
} catch (\Exception $exception) {
$response->writeHead(500);
// internal server error
$response->end();
return;
}
self::mapResponse($response, $syResponse);
if ($this->application instanceof TerminableInterface) {
$this->application->terminate($syRequest, $syResponse);
}
}
});
}
/**
* {@inheritDoc}
*/
public function handle(Request $request, $type = HttpKernelInterface::MASTER_REQUEST, $catch = true)
{
if (HttpKernelInterface::MASTER_REQUEST !== $type) {
return $this->app->handle($request, $type, $catch);
}
$session = new SymfonySession();
$request->setSession($session);
if ($this->start) {
$cookies = $request->cookies;
if ($cookies->has($session->getName())) {
$session->setId($cookies->get($session->getName()));
} else {
//starts the session if no session exists
$session->start();
$session->migrate(false);
}
$session->start();
}
$response = $this->app->handle($request, $type, $catch);
if ($session && $session->isStarted()) {
$session->save();
$params = array_merge(session_get_cookie_params(), $this->cookieParams);
if (array_key_exists('domain', $this->cookieParams)) {
$response->headers->clearCookie($session->getName());
}
$cookie = new Cookie($session->getName(), $session->getId(), 0 === $params['lifetime'] ? 0 : $request->server->get('REQUEST_TIME') + $params['lifetime'], $params['path'], $params['domain'], $params['secure'], $params['httponly']);
$response->headers->setCookie($cookie);
}
return $response;
}
/**
* Constructor.
*
* @param HttpKernelInterface $kernel An HttpKernelInterface instance
*/
public function __construct(HttpKernelInterface $kernel)
{
$store = new Store($kernel->getCacheDir().'/http_cache');
$esi = new Esi();
parent::__construct($kernel, $store, $esi, array_merge(array('debug' => $kernel->isDebug()), $this->getOptions()));
}
/**
* {@inheritdoc}
*/
public function handle(Request $request, $type = self::MASTER_REQUEST, $catch = TRUE)
{
foreach (Database::getAllConnectionInfo() as $key => $info) {
Database::startLog('webprofiler', $key);
}
return $this->httpKernel->handle($request, $type, $catch);
}
/**
* Handle a given request and return the response.
*
* @param \Symfony\Component\HttpFoundation\Request $request
* @param int $type
* @param bool $catch
* @return \Symfony\Component\HttpFoundation\Response
* @throws \Symfony\Component\HttpKernel\Exception\UnauthorizedHttpException
*/
public function handle(Request $request, $type = HttpKernelInterface::MASTER_REQUEST, $catch = true)
{
// Our middleware needs to ensure that Laravel is booted before we
// can do anything. This gives us access to all the booted
// service providers and other container bindings.
$this->container->boot();
if ($request instanceof InternalRequest || $this->auth->user()) {
return $this->app->handle($request, $type, $catch);
}
// If a collection exists for the request and we can match a route
// from the request then we'll check to see if the route is
// protected and, if it is, we'll attempt to authenticate.
if ($this->router->requestTargettingApi($request) && ($collection = $this->getApiRouteCollection($request))) {
try {
$route = $this->controllerReviser->revise($collection->match($request));
if ($this->routeIsProtected($route)) {
return $this->authenticate($request, $route) ?: $this->app->handle($request, $type, $catch);
}
} catch (HttpExceptionInterface $exception) {
// If we catch an HTTP exception then we'll simply let
// the wrapping kernel do its thing.
}
}
return $this->app->handle($request, $type, $catch);
}
/**
* This check prevents access to debug front controllers
* that are deployed by accident to production servers.
*
* {@inheritdoc}
*/
public function handle(Request $request, $type = self::MASTER_REQUEST, $catch = true)
{
if (in_array($request->getClientIp(), $this->allowedIps)) {
return $this->app->handle($request, $type, $catch);
}
return new Response('You are not allowed to access this file.', 403);
}
/**
* Handle the given request and get the response.
*
* @implements HttpKernelInterface::handle
*
* @param \Symfony\Component\HttpFoundation\Request $request
* @param int $type
* @param bool $catch
* @return \Symfony\Component\HttpFoundation\Response
*/
public function handle(Request $request, $type = HttpKernelInterface::MASTER_REQUEST, $catch = true)
{
$response = $this->app->handle($request, $type, $catch);
foreach ($this->cookies->getQueuedCookies() as $cookie) {
$response->headers->setCookie($cookie);
}
return $response;
}
/**
* {@inheritdoc}
*/
public function handle(Request $request, $type = self::MASTER_REQUEST, $catch = true)
{
/** @var \Barryvdh\Debugbar\LaravelDebugbar $debugbar */
$debugbar = $this->app['debugbar'];
/** @var \Illuminate\Http\Response $response */
$response = $this->kernel->handle($request, $type, $catch);
return $debugbar->modifyResponse($request, $response);
}
public function handle(Request $request, $type = HttpKernelInterface::MASTER_REQUEST, $catch = true)
{
if ($this->response === null) {
// Dispatch legacy application only once.
$this->response = $this->legacyKernel->handle($request, $type, $catch);
}
return $this->response;
}
/**
* {@inheritdoc}
*/
public function handle(Request $request, $type = self::MASTER_REQUEST, $catch = true)
{
foreach ($this->formats as $format => $mime_type) {
$request->setFormat($format, $mime_type);
}
$request->setRequestFormat($this->negotiator->getContentType($request));
return $this->app->handle($request, $type, $catch);
}
/**
* {@inheritdoc}
*/
public function handle(Request $request, $type = self::MASTER_REQUEST, $catch = true)
{
$ip = $request->getClientIp();
if (!in_array($ip, $this->allowedIps)) {
return new Response(sprintf('IP %s is not allowed.', $ip), 403);
}
return $this->app->handle($request, $type, $catch);
}
/**
* {@inheritdoc}
*/
public function handle(Request $request, $type = self::MASTER_REQUEST, $catch = TRUE)
{
$ip = $request->getClientIp();
if ($this->banIpManager->isBanned($ip)) {
return new Response(SafeMarkup::format('@ip has been banned', ['@ip' => $ip]), 403);
}
return $this->httpKernel->handle($request, $type, $catch);
}
/**
* {@inheritdoc}
*/
public function handle(Request $request, $type = self::MASTER_REQUEST, $catch = true)
{
$response = $this->app->handle($request, $type, $catch);
if (self::MASTER_REQUEST === $type) {
$this->turbolinks->decorateResponse($request, $response);
}
return $response;
}
