public function onHttpRequest(\React\Http\Request $request, $response) { if ($request->getPath() !== "/auth/github/callback") { $response->writeHead(404, array('Content-Type' => 'text/plain')); $response->end("Not Found"); } $query = $request->getQuery(); if (!isset($query['state']) || !isset($query['code'])) { $response->writeHead(200, array('Content-Type' => 'text/plain')); $response->end("No Code or State query params found"); return; } //If we don't already have a promise for this state, create one if (!isset($this->promises[$query['state']])) { $deferred = new \React\Promise\Deferred(); $this->promises[$query['state']] = $deferred; } $accessToken = $this->getAccessToken($query['code']); if ($accessToken) { $this->promises[$query['state']]->resolve(array("SUCCESS", $accessToken)); } else { $this->promises[$query['state']]->resolve(array("FAILURE")); } $response->writeHead(200, array('Content-Type' => 'text/html')); $response->end("<script>window.close();</script>"); }
private function buildSymfonyRequest(Request $request, Response $response) { $sfRequest = SymfonyRequest::create($request->getPath(), $request->getMethod()); $sfRequest->attributes->set('react.espresso.request', $request); $sfRequest->attributes->set('react.espresso.response', $response); return $sfRequest; }
/** * @param ReactRequest $reactRequest * @return resource */ private function createBodyStream(ReactRequest $reactRequest) { $body = fopen('php://temp', 'w+'); fwrite($body, $reactRequest->getBody()); fseek($body, 0); return $body; }
public function __invoke(Request $request, Response $response) { $sfRequest = SymfonyRequest::create($request->getPath(), $request->getMethod()); $sfResponse = $this->handle($sfRequest, HttpKernelInterface::MASTER_REQUEST, true); $response->writeHead($sfResponse->getStatusCode(), ['Content-Type' => 'text/html']); $response->end($sfResponse->getContent()); }
/** * @param string $data * @param Request $request * @return mixed */ public function parse($data, $request) { try { return $this->serializer->unserialize($data); } catch (Exception $exception) { throw new InvalidBodyException(sprintf('Could not parse body of request with path %s and method %s', $request->getPath(), $request->getMethod()), 1413214227, $exception); } }
/** * Set value of ReactRequest * * @param \React\Http\Request $reactRequest */ public function setReactRequest($reactRequest) { $this->reactRequest = $reactRequest; $this->setUri($reactRequest->getPath()); $this->getHeaders()->addHeaders($reactRequest->getHeaders()); $this->setMethod($reactRequest->getMethod()); $this->setQuery(new Parameters($reactRequest->getQuery())); }
protected function handleSse(Request $request, Response $response) { $headers = $request->getHeaders(); $id = isset($headers['Last-Event-ID']) ? $headers['Last-Event-ID'] : null; $response->writeHead(200, array('Content-Type' => 'text/event-stream')); $this->channel->connect($response, $id); $response->on('close', function () use($response) { $this->channel->disconnect($response); }); }
public function perform(Request $request, Response $response, $jsonData) { $httpRequest = new HttpRequest($request, $jsonData); $method = $request->getMethod(); $path = $request->getPath(); if (array_key_exists($method, $this->controllers)) { $controllers = $this->controllers[$method]; $input_paths = $this->getPaths($path); /** * @var RoutePath $pathObject */ $target_controller = null; $restParams = array(); foreach ($controllers as $route_path => $pathObject) { $restInput = array(); $check = $this->checkPaths($pathObject->path, $input_paths, $restInput); if (!$check) { continue; } else { $target_controller = $pathObject->controller; $restParams = $restInput; break; } } if ($target_controller == null) { // not found throw new ReactHttpException("URL not found!", 404); } else { foreach ($restParams as $key => $restParam) { $httpRequest->set($key, $restParam); } $inputs = array($httpRequest, $response); $input_params = array_values($restParams); $inputs = array_merge($inputs, $input_params); if (is_callable($target_controller)) { call_user_func_array($target_controller, $inputs); } else { $function_array = preg_split("/@/", $target_controller); if (!isset($function_array[1])) { throw ReactHttpException::internalError('Routing Error'); } $class_name = $function_array[0]; $method_name = $function_array[1]; //$response = $class_name::$method_name(); // Initialization controller object $controller = new $class_name(); call_user_func_array(array($controller, $method_name), $inputs); //$response = $controller->$method_name(); } } } else { // not found throw new ReactHttpException("URL not found!", 404); } }
function __construct(Request $request) { $this->request = $request; $headers = $request->getHeaders(); if (isset($headers['Content-Length']) && is_numeric($contentLength = $headers['Content-Length'])) { $this->contentLength = $contentLength; } $request->on('data', [$this, 'handleData']); $request->on('close', [$this, 'handleClose']); $request->on('error', [$this, 'handleError']); }
/** * Extract the server parameters ($_SERVER). * * @param ReactRequest $request * * @return array */ private function extractServer(ReactRequest $request) { $server = ['SERVER_PROTOCOL' => 'HTTP/' . $request->getHttpVersion(), 'REQUEST_METHOD' => $request->getMethod(), 'REQUEST_URI' => $request->getPath(), 'REQUEST_TIME' => time()]; // headers foreach ($request->getHeaders() as $key => $value) { $name = mb_strtoupper($key, 'UTF-8'); $name = str_replace('-', '_', $name); $server[$name] = $value; } return $server; }
public function handleRequest(ConnectionInterface $conn, Request $request, $bodyBuffer) { $response = new HttpResponse($conn); $response->on('close', array($request, 'close')); if (!$this->listeners('request')) { $response->end(); return; } $this->emit('request', array($request, $response)); $request->emit('data', array($bodyBuffer)); }
public function handleRequest(React\Http\Request $req, React\Http\Response $res) { $request = Request::create($req->getPath(), $req->getMethod(), $req->getQuery()); $response = $this->httpKernel->handle($request); $headers = array(); foreach ($response->headers as $k => $v) { $headers[$k] = $v[0]; } $res->writeHead($response->getStatusCode(), $headers); $res->end($response->getContent()); }
private function handle(React\Http\Request $request, React\Http\Response $response, $requestHandler) { $sfRequest = Request::create($request->getPath(), $request->getMethod(), $request->getQuery()); $output = call_user_func_array($requestHandler, [$sfRequest]); if ($output instanceof Response) { $response->writeHead($output->getStatusCode(), $output->headers->all()); $response->end($output->getContent()); } else { $response->writeHead(200, array('Content-Type' => 'text/plain')); $response->end($output); } }
/** * @param Request $request * @return mixed[] */ public function handleRequest(Request $request) { $query = $request->getQuery(); if (isset($query['time'])) { $time = $query['time']; if ($time) { $this->entityService->add($time); return ['code' => '200', 'status' => 'OK']; } } return ['code' => '400', 'status' => 'Bad request']; }
/** * @param Request $request * @param Response $response */ public function handleRequest(Request $request, Response $response) { if ($request->getPath() == '/pub' && $request->getMethod() == 'POST') { $this->handlePublishHttpPost($request, $response); } else { if ($request->getPath() == '/call' && $request->getMethod() == 'POST') { $this->handleCallHttpRequest($request, $response); } else { $response->writeHead(404, ['Content-Type' => 'text/plain', 'Connection' => 'close']); $response->end("Not found"); } } }
/** * Constructor * * @param React\HttpClient\Client $client * @param Irto\OAuth2Proxy\Server $server * @param React\Http\Request $request original request * * @return Irto\OAuth2Proxy\ProxyRequest */ public function __construct(HttpClient $client, Server $server, Request $request) { $headers = $request->getHeaders(); $headers = array_combine(array_map('strtolower', array_keys($headers)), $headers); $headers = Arr::except($headers, $this->headersNotAllowed); $this->original = $request; $this->client = $client; $this->server = $server; $this->query = new Collection(); $headers = new Collection($headers); $headers->put('cookie', new Collection((new \Guzzle\Parser\Cookie\CookieParser())->parseCookie($headers->get('cookie')))); $this->headers = $headers; $request->on('data', array($this, 'write')); }
public function load($url, $deep) { if (null !== $this->url) { throw new \RuntimeException("This Loader object already loading an url."); } $url = filter_var($url, FILTER_VALIDATE_URL); if (false === $url) { return false; } $this->url = $url; $this->deep = $deep; $this->request = $this->client->request('GET', $url); $this->request->on('response', array($this, 'onResponse')); $this->request->end(); return true; }
public function parseBody($content) { $headers = $this->request->getHeaders(); if (array_key_exists('Content-Type', $headers)) { if (strpos($headers['Content-Type'], 'multipart/') === 0) { //TODO :: parse the content while it is streaming preg_match("/boundary=\"?(.*)\"?\$/", $headers['Content-Type'], $matches); $boundary = $matches[1]; $parser = new MultipartParser($content, $boundary); $parser->parse(); $this->request->setPost($parser->getPost()); $this->request->setFiles($parser->getFiles()); return; } if (strtolower($headers['Content-Type']) == 'application/x-www-form-urlencoded') { parse_str($content, $result); $this->request->setPost($result); return; } if (strtolower($headers['Content-Type']) == 'application/json') { $result = json_decode($content); $this->request->setBody($result); return; } } $this->request->setBody($content); }
/** * Ends request and dispatch * * @return void */ public function dispatch() { $method = $this->original->getMethod(); $url = $this->server->get('api_url') . $this->getPath(); $headers = Arr::except($this->headers()->all(), ['cookie']); $this->request = $this->createClientRequest($method, $url, $headers); $this->request->end($this->getBufferEnd()); }
/** * @inheritdoc */ public function handle(Request $request) { $headers = $request->getHeaders(); if (array_key_exists('Authorization', $headers)) { $authorization = $headers['Authorization']; if (substr($authorization, 0, strlen('Basic ')) !== 'Basic ') { return false; } $authentication = base64_decode(substr($authorization, strlen('Basic '))); $parts = explode(':', $authentication); if (count($parts) !== 2) { return false; } return call_user_func($this->implementation, $parts[0], $parts[1]); } return false; }
protected function onRequest(Request $request, Response $response) { $this->resolver->request = $request; $this->resolver->response = $response; $responseStatus = 200; $responseData = null; try { $responseData = $this->dispatcher->dispatch($request->getMethod(), $request->getPath()); } catch (HttpRouteNotFoundException $e) { $responseStatus = 404; $responseData = 'Page not found. Try harder'; } catch (HttpMethodNotAllowedException $e) { $responseStatus = 405; $responseData = 'Method not allowed. Use force'; } $response->writeHead($responseStatus); $response->end($responseData); }
public function handle(Request $request, Response $response) { $headers = array_change_key_case($request->getHeaders(), CASE_LOWER); // Only enable when the X-Blackfire-Query header is present if (!isset($headers['x-blackfire-query'])) { return array(); } $probe = new \BlackfireProbe($headers['x-blackfire-query']); // Stop if it failed if (!$probe->enable()) { return array(); } // Stop profiling once the request ends $response->on('end', array($probe, 'close')); // Return the header $header = explode(':', $probe->getResponseLine(), 2); return array('x-' . $header[0] => $header[1]); }
protected function fixHeaderNames(Request $request) { $headers = $request->getHeaders(); foreach ($headers as $name => $v) { $newName = str_replace(' ', '-', ucwords(strtolower(str_replace('-', ' ', $name)))); $headers[$newName] = $headers[$name]; } if (isset($headers['Content-Type'])) { $headers['Content-Type'] = explode(';', $headers['Content-Type'])[0]; } $request->__construct($request->getMethod(), $request->getUrl(), $request->getQuery(), $request->getHttpVersion(), $headers, $request->getBody()); }
/** * @param \React\Http\Request $request * @param \React\Http\Response $response */ public function processRequest($request, $response) { $request->on('data', function ($dataBuffer) use($request, $response) { $this->request = new Request(); $this->request->setContent($dataBuffer); $this->request->setReactRequest($request); $this->response = new Response(); $this->response->setReactResponse($response); $allow = $this->getServiceManager()->getAllowOverride(); $this->getServiceManager()->setAllowOverride(true); $this->getServiceManager()->setService('Request', $this->request); $this->getServiceManager()->setService('Response', $this->response); $this->getServiceManager()->setAllowOverride($allow); $event = $this->getMvcEvent(); $event->setError(null); $event->setRequest($this->getRequest()); $event->setResponse($this->getResponse()); $this->run(); }); }
/** * {@inheritdoc} */ protected static function mapRequest(ReactRequest $reactRequest, $content) { $method = strtoupper($reactRequest->getMethod()); $headers = $reactRequest->getHeaders(); $query = $reactRequest->getQuery(); $post = array(); $requestIsPostType = in_array($method, array('POST', 'PUT', 'DELETE', 'PATCH')); // Parse body? if (isset($headers['Content-Type']) && 0 === strpos($headers['Content-Type'], 'application/x-www-form-urlencoded') && $requestIsPostType) { parse_str($content, $post); } $cookies = array(); if (isset($headers['Cookie'])) { $headersCookie = explode(';', $headers['Cookie']); foreach ($headersCookie as $cookie) { list($name, $value) = explode('=', trim($cookie)); $cookies[$name] = $value; } } // Add any query string to URI so SymfonyRequest::create() can access it. $uri = $reactRequest->getPath() . (empty($query) ? '' : '?' . http_build_query($query)); // SymfonyRequest::create() expects $parameters to contain either // $_GET or $_POST. $parameters = $requestIsPostType ? $post : $query; $syRequest = SymfonyRequest::create($uri, $method, $parameters, $cookies, array(), array(), $content); $syRequest->headers->replace($headers); // Set CGI/1.1 (RFC 3875) server vars. if (empty($_ENV)) { // In some cases with cli, $_ENV isn't set, so get with getenv(). // @see http://stackoverflow.com/questions/8798294/getenv-vs-env-in-php/21473853#21473853 // @todo: Make this more efficient to eliminate running per request. // Static variable? $_ENV['DOCUMENT_ROOT'] = getenv('DOCUMENT_ROOT'); $_ENV['SCRIPT_NAME'] = getenv('SCRIPT_NAME'); } $serverVars = array_merge($syRequest->server->all(), array('DOCUMENT_ROOT' => $_ENV['DOCUMENT_ROOT'], 'GATEWAY_INTERFACE' => 'CGI/1.1', 'SCRIPT_NAME' => $_ENV['SCRIPT_NAME'], 'SCRIPT_FILENAME' => $_ENV['DOCUMENT_ROOT'] . $_ENV['SCRIPT_NAME'])); $syRequest->server->replace($serverVars); return $syRequest; }
public function transformFromReact(ReactRequest $request) { $this->baseUrl = ''; $this->requestUri = $request->getPath(); $this->content = $request->getBody(); // Request Headers $this->headers = new HeaderBag($request->getHeaders()); // Server informations ($_SERVER) $this->server = new ServerBag($this->buildServerBag($request)); // Request body parameters ($_POST). if (0 === strpos($this->headers->get('CONTENT_TYPE'), 'application/x-www-form-urlencoded') && in_array(strtoupper($this->server->get('REQUEST_METHOD', 'GET')), ['POST', 'PUT', 'DELETE', 'PATCH'])) { $this->request = new ParameterBag($request->getPost()); } // Query string parameters ($_GET). $this->query = new ParameterBag($request->getQuery()); // Request attributes $this->attributes = new ParameterBag([]); // Cookies $this->cookies = new ParameterBag($this->buildCookieBag()); // Files uploads $this->files = new FileBag($this->buildFileBag($request)); }
/** * main push request/ websocket response loop */ function onRequest(Request $request, Response $response) { $content = ''; $headers = $request->getHeaders(); $contentLength = isset($headers['Content-Length']) ? (int) $headers['Content-Length'] : null; // length required, chunked encoding not supported if (null === $contentLength) { $response->writeHead(411); $response->end(); return; } $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) { $headers = array('Content-Type' => 'application/json'); try { $data = $this->hub->handlePushMessage($content); $headers['Content-Length'] = strlen($data); if (null === $data) { $response->writeHead(400, $headers); $response->end(); } else { $response->writeHead(200, $headers); $response->end($data); } } catch (\Exception $exception) { $data = $this->getExceptionAsJson($exception, true); $headers['Content-Length'] = strlen($data); $response->writeHead(500, $headers); // internal server error $response->end($data); } } }); }
/** * @param Request $request * @param array $parameters * @return SymfonyRequest */ private function buildSfRequest(Request $request, array $parameters) { $sfRequest = SymfonyRequest::create($request->getPath(), $request->getMethod()); $requestHeaders = $request->getHeaders(); if (isset($requestHeaders['Cookie'])) { $sfRequest->cookies->replace($this->deserializeCookiesHeader($requestHeaders['Cookie'])); } $sfRequest->request->replace($parameters); $sfRequest->query->replace($request->getQuery()); $sfRequest->server->set('REQUEST_URI', $request->getPath()); $sfRequest->server->set('SERVER_NAME', rtrim($requestHeaders['Host'], ':0..9')); $sfRequest->headers->replace($request->getHeaders()); return $sfRequest; }
/** * @param Request $request * @param string $postData * @return SymfonyRequest */ private function buildSfRequest(Request $request, $postData = null) { if ($postData !== null) { parse_str($postData, $postDataArray); $parameters = empty($postDataArray) ? [] : $postDataArray; $content = empty($postDataArray) ? [] : $postData; // TODO Maybe check Content-Type too? $sfRequest = SymfonyRequest::create($request->getPath(), $request->getMethod(), $parameters, [], [], [], $content); } else { $sfRequest = SymfonyRequest::create($request->getPath(), $request->getMethod()); } $requestHeaders = $request->getHeaders(); if (isset($requestHeaders['Cookie'])) { $sfRequest->cookies->replace($this->deserializeCookiesHeader($requestHeaders['Cookie'])); } // $sfRequest->request->replace($parameters); $sfRequest->query->replace($request->getQuery()); $sfRequest->server->set('REQUEST_URI', $request->getPath()); $sfRequest->server->set('SERVER_NAME', rtrim($requestHeaders['Host'], ':0..9')); $sfRequest->headers->replace($request->getHeaders()); return $sfRequest; }
/** * Convert React\Http\Request to Symfony\Component\HttpFoundation\Request * * @param ReactRequest $reactRequest * @param string $content * * @return SymfonyRequest $symfonyRequest */ protected static function mapRequest(ReactRequest $reactRequest, $content) { $method = $reactRequest->getMethod(); $headers = $reactRequest->getHeaders(); $query = $reactRequest->getQuery(); $post = []; // Parse body? if (in_array(strtoupper($method), ['POST', 'PUT', 'DELETE', 'PATCH']) && isset($headers['Content-Type']) && 0 === strpos($headers['Content-Type'], 'application/x-www-form-urlencoded')) { parse_str($content, $post); } // Map to a SymfonyRequest $symfonyRequest = new SymfonyRequest($query, $post, array(), array(), array(), array(), $content); $symfonyRequest->setMethod($method); $symfonyRequest->headers->replace($headers); $symfonyRequest->server->set('REQUEST_URI', $reactRequest->getPath()); if (isset($headers['Host'])) { $symfonyRequest->server->set('SERVER_NAME', explode(':', $headers['Host'])[0]); } return $symfonyRequest; }