handle() public méthode

When $catch is true, the implementation must catch all exceptions and do its best to convert them to a Response instance.
public handle ( Request $request, integer $type = self::MASTER_REQUEST, boolean $catch = true ) : Response
$request Symfony\Component\HttpFoundation\Request A Request instance
$type integer The type of the request (one of HttpKernelInterface::MASTER_REQUEST or HttpKernelInterface::SUB_REQUEST)
$catch boolean Whether to catch exceptions or not
Résultat Response A Response instance
 /**
  * {@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;
 }
 /**
  * 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);
             }
         }
     });
 }
 /**
  * {@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)
 {
     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);
 }
 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 = 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 = 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);
 }
 /**
  * @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)
 {
     if ($request->getClientIp() == '127.0.0.10') {
         return new Response(t('Bye!'), 403);
     }
     return $this->httpKernel->handle($request, $type, $catch);
 }
Exemple #11
0
 /**
  * @param Request $request
  * @param int     $type
  * @param bool    $catch
  *
  * @return Response
  * @throws \Exception
  */
 public function handle(Request $request, $type = self::MASTER_REQUEST, $catch = true)
 {
     if ($type === HttpKernelInterface::SUB_REQUEST) {
         return $this->app->handle($request, $type, $catch);
     }
     $parameters = $this->config->get('cookie_parameters');
     if (!isset($parameters[$this->config->get('current_locale')])) {
         throw new \Exception(sprintf('Domain %s not available', $this->config->get('current_locale')));
     }
     $cookieParams = $parameters[$this->config->get('current_locale')];
     $this->config->set('current_cookie_domain', $cookieParams['domain']);
     if (HttpKernelInterface::MASTER_REQUEST !== $type) {
         return $this->app->handle($request, $type, $catch);
     }
     $session = new Session();
     $request->setSession($session);
     $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(), $cookieParams);
         $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;
 }
Exemple #12
0
 /**
  * Handle a request.
  *
  * @param SyfmonyRequest $request
  * @param int $type
  * @param bool $catch
  * @return Response
  */
 public function handle(SyfmonyRequest $request, $type = self::MASTER_REQUEST, $catch = true)
 {
     $request = Request::createFromBase($request);
     $request->enableHttpMethodParameterOverride();
     $this->app->bind('request', $request);
     return $this->httpKernel->handle($request);
 }
 /**
  * {@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);
     }
 }
 /**
  * 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);
             }
         }
     });
 }
 /**
  * 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);
 }
 /**
  * @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);
     }
 }
 /**
  * {@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);
 }
Exemple #18
0
 /**
  * {@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;
 }
 /**
  * {@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);
 }
 /**
  * @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;
 }
 /**
  * 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);
 }
 /**
  * {@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);
 }
 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;
 }
Exemple #24
0
 /**
  * {@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);
 }
 /**
  * {@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);
 }
Exemple #26
0
 /**
  * {@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);
 }
Exemple #27
0
 /**
  * {@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;
 }
Exemple #28
0
 /**
  * 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;
 }
Exemple #29
0
 /**
  * @inheritDoc
  */
 public function handle(Request $request, $type = self::MASTER_REQUEST, $catch = true)
 {
     $this->startSession($request);
     $request->setSession($this->session);
     $response = $this->wrapped->handle($request, $type, $catch);
     $this->session->save();
     $this->writeSessionTo($response);
     return $response;
 }
Exemple #30
0
 /**
  * @param Request $request
  * @param int     $type
  * @param bool    $catch
  */
 public function handle(Request $request, $type = self::MASTER_REQUEST, $catch = true)
 {
     if (false === $this->kernel->isStarted()) {
         $container = $this->kernel->startContainer();
         $container->bind('Request', $request);
         $container->bind('LoggerFactory', $this->kernel->getLoggerFactory());
     }
     return $this->app->handle($request, $type, $catch);
 }