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;
}
