PHP HttpKernel\HttpKernelInterface類代碼示例

 /**
  * @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;
 }

 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 = 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();
 }

 /**
  * @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);
     }
 }

 /**
  * 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()));
    }

 /**
  * 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 = 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);
 }

 /**
  * 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();
 }

 /**
  * {@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);
 }