PHP Kernel::handle方法代码示例

 /**
  * @return \Symfony\Component\HttpFoundation\Response $response
  */
 public function saveTokenAction()
 {
     if (!$this->request->query->has('oauth_token') || !$this->request->query->has('oauth_verifier')) {
         return $this->goToSettingsAction();
     }
     $path['_controller'] = 'weaving_the_web_user.controller.twitter:getAccessTokenAction';
     $subRequest = $this->request->duplicate(['oauth_token' => $this->request->get('oauth_token'), 'oauth_verifier' => $this->request->get('oauth_verifier')], null, $path);
     /**
      * @var \Symfony\Component\HttpFoundation\Response $response
      */
     $response = $this->kernel->handle($subRequest, HttpKernelInterface::SUB_REQUEST);
     $content = $response->getContent();
     $tokenParameters = json_decode($content, true);
     if (json_last_error() !== JSON_ERROR_NONE) {
         return $this->goToSettingsAction();
     }
     $this->persistToken($tokenParameters);
     $subRequest = $this->request->duplicate(null, null, ['_controller' => 'weaving_the_web_user.controller.settings:showAction']);
     return $this->kernel->handle($subRequest, HttpKernelInterface::SUB_REQUEST);
 }

 /**
  * {@inheritdoc}
  */
 public function handleRequest(RequestInterface $request)
 {
     $symfonyRequest = $request->getHttpFoundationRequest();
     $symfonyResponse = $this->kernel->handle($symfonyRequest);
     $this->kernel->terminate($symfonyRequest, $symfonyResponse);
     return $symfonyResponse;
 }

 public function replay(Request $baseRequest, Notification $notification)
 {
     $webHook = $notification->getWebHook();
     $endpoint = $webHook->getEndpoint();
     $content = json_decode($notification->getContent(), true);
     $query = array_merge(['username' => $webHook->getUser()->getUsername(), 'endpoint' => $endpoint], $content['query']);
     $url = $this->router->generate('notifications', $query);
     $request = Request::create($url, $content['method'], [], [], [], $baseRequest->server->all(), $content['body']);
     $request->headers->replace($content['headers']);
     $response = $this->kernel->handle($request, HttpKernelInterface::SUB_REQUEST);
     return $response;
 }

 public function handle(Request $request, $type = HttpKernelInterface::MASTER_REQUEST, $catch = true)
 {
     $isUserHashRequest = $this->isUserHashRequest($request);
     if ($isUserHashRequest && !$this->canGenerateUserHash($request)) {
         return new Response('', 405);
     } else {
         if ($isUserHashRequest && !$this->generatingUserHash) {
             return new Response('', 200, array('X-User-Hash' => $this->generateUserHash($request)));
         }
     }
     return parent::handle($request, $type, $catch);
 }

 /**
  * Renders the given route with the given parameter.
  *
  * @param Route  $route     Route.
  * @param string $name      Name of the route; the default value is `null`.
  * @param array  $parameter Array of parameters; the default value is an empty array.
  *
  * @return void
  */
 protected function renderWithParameters(Route $route, $name = null, array $parameter = array())
 {
     $request = $this->buildRequest($route, $name, $parameter);
     $response = $this->kernel->handle($request);
     $content = $response->getContent();
     $this->kernel->terminate($request, $response);
     $this->kernel->shutdown();
     if (null !== $name) {
         $filename = $this->router->generate($name, $parameter);
     } else {
         $filename = $route->getPath();
     }
     $this->writer->write($filename, $content);
 }

 public function handle(Request $request, $type = HttpKernelInterface::MASTER_REQUEST, $catch = true)
 {
     if (false === $this->booted && $this->enableTenanting) {
         // Find and set the current tenant
         try {
             $tenant = $this->getCurrentTenantKey($request);
             $this->getTenantRegistry()->setCurrent($tenant);
             // Change the environment to the tenant's environment
             $this->environment = 'tenant_' . $tenant;
         } catch (\OutOfBoundsException $e) {
             throw new NotFoundHttpException('Could not find tenant');
         } catch (\RuntimeException $e) {
         }
         $this->boot();
     }
     return parent::handle($request, $type, $catch);
 }

 /**
  * {@inheritdoc}
  */
 public function handle(Request $request, $type = HttpKernelInterface::MASTER_REQUEST, $catch = true)
 {
     if (strpos($request->getRequestUri(), 'installer') !== false || !$this->isInstalled()) {
         define('MAUTIC_INSTALLER', 1);
     }
     if (false === $this->booted) {
         $this->boot();
     }
     //the context is not populated at this point so have to do it manually
     $router = $this->getContainer()->get('router');
     $requestContext = new \Symfony\Component\Routing\RequestContext();
     $requestContext->fromRequest($request);
     $router->setContext($requestContext);
     if (strpos($request->getRequestUri(), 'installer') === false && !$this->isInstalled()) {
         //the context is not populated at this point so have to do it manually
         $router = $this->getContainer()->get('router');
         $requestContext = new \Symfony\Component\Routing\RequestContext();
         $requestContext->fromRequest($request);
         $router->setContext($requestContext);
         $base = $requestContext->getBaseUrl();
         //check to see if the .htaccess file exists or if not running under apache
         if (strpos(strtolower($_SERVER["SERVER_SOFTWARE"]), 'apache') === false || !file_exists(__DIR__ . '../.htaccess') && strpos($base, 'index') === false) {
             $base .= '/index.php';
         }
         //return new RedirectResponse();
         return new RedirectResponse($base . '/installer');
     }
     // Check for an an active db connection and die with error if unable to connect
     if (!defined('MAUTIC_INSTALLER')) {
         $db = $this->getContainer()->get('database_connection');
         try {
             $db->connect();
         } catch (\Exception $e) {
             error_log($e);
             throw new \Mautic\CoreBundle\Exception\DatabaseConnectionException($this->getContainer()->get('translator')->trans('mautic.core.db.connection.error', array('%code%' => $e->getCode())));
         }
     }
     return parent::handle($request, $type, $catch);
 }

 private function handleRaw(Request $request, $type = self::MASTER_REQUEST, $catch = true)
 {
     $this->container->enterScope('request');
     $this->container->set('request', $request, 'request');
     $this->container->get('request_stack')->push($request);
     if ($type === self::MASTER_REQUEST) {
         $this->request = $request;
     }
     Service::setRequest($request);
     $event = new GetResponseEvent($this, $request, $type);
     $this->container->get('event_dispatcher')->dispatch(KernelEvents::REQUEST, $event);
     if ($request->attributes->get('_defaultHandler')) {
         return parent::handle($request, $type, $catch);
     }
     // An event may have given a response
     if ($event->hasResponse()) {
         return $this->filterResponse($event->getResponse(), $request, $type);
     }
     $session = $this->container->get('session');
     $session->start();
     Service::setFormFactory($this->container->get('form.factory'));
     $con = Controller::getController($request->attributes);
     $response = $con->callAction();
     return $this->filterResponse($response, $request, $type);
 }

 /**
  * @When the kernel terminates
  */
 public function theKernelTerminates()
 {
     $request = Request::create('/', 'GET');
     $response = $this->kernel->handle($request);
     $this->kernel->terminate($request, $response);
 }

 /**
  * @return string
  */
 public function updateJsLib()
 {
     $response = $this->kernel->handle(Request::create('/js/fp_js_validator.js'));
     $libFile = $this->kernel->getRootDir() . '/../../Resources/public/js/fp_js_validator.js';
     file_put_contents($libFile, $response->getContent());
 }

 /**
  * @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)
 {
     $catch = false;
     return parent::handle($request, $type, $catch);
 }