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());
}
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;
}
/**
* 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()));
}
/**
* @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);
}
}
private function buildServerBag(ReactRequest $request)
{
// TODO :: add a few more informations if needed
$server = ['REMOTE_ADDR' => $request->getRemoteAddress(), 'SERVER_SOFTWARE' => 'ReactPHP Reactavel', 'SERVER_PROTOCOL' => 'HTTP/1.0', 'SERVER_NAME' => Reactavel::getHost(), 'SERVER_PORT' => Reactavel::getPort(), 'REQUEST_METHOD' => $request->getMethod(), 'REQUEST_TIME_FLOAT' => microtime(true), 'REQUEST_TIME' => floor(microtime(true))];
foreach ($this->headers as $key => $header) {
$server['HTTP_' . str_replace('-', '_', strtoupper($key))] = $header[0];
}
return $server;
}
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);
}
}
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());
}
/**
* 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;
}
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());
}
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
* @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");
}
}
}
/**
* @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;
}
/**
* @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;
}
public function dispatch(Request $request, Response $response)
{
// Todo PSR logging
if ($this->debug) {
echo date('r') . ": {$request->getPath()}:{$request->getMethod()}\n";
}
if (!isset($this->routes[$request->getMethod()])) {
$this->completeResponse($response, new PageNotFound());
return;
}
$routes = $this->routes[$request->getMethod()];
foreach ($routes as $route => $target) {
if (preg_match("|^{$route}\$|", $request->getPath(), $matches)) {
foreach ($matches as &$match) {
$match = urldecode($match);
}
try {
$result = call_user_func($target, $matches, $request);
} catch (\Exception $e) {
$this->completeResponse($response, new InternalServerError($e));
return;
}
if ($result instanceof PromiseInterface) {
$result->then(function ($result) use($request, $response) {
$this->completeResponse($response, $result);
}, function ($reason) use($request, $response) {
$this->completeResponse($response, new InternalServerError($reason));
});
return;
}
$this->completeResponse($response, $result);
return;
}
}
$this->completeResponse($response, new PageNotFound());
}
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);
}
/**
* Creates a new request object from the data of a reactPHP request object
*
* @param \React\Http\Request $request ReactPHP native request object
*
* @return \Slim\Http\Request
*/
public static function createFromReactRequest(\React\Http\Request $request)
{
$slimHeads = new Headers();
foreach ($request->getHeaders() as $reactHeadKey => $reactHead) {
$slimHeads->add($reactHeadKey, $reactHead);
if ($reactHeadKey === 'Host') {
$host = explode(':', $reactHead);
if (count($host) === 1) {
$host[1] = '80';
}
}
}
$slimUri = new Uri('http', $host[0], (int) $host[1], $request->getPath(), $request->getQuery());
$cookies = [];
$serverParams = $_SERVER;
$serverParams['SERVER_PROTOCOL'] = 'HTTP/' . $request->getHttpVersion();
$slimBody = new RequestBody();
return new self($request->getMethod(), $slimUri, $slimHeads, $cookies, $serverParams, $slimBody);
}
/**
* Handles the requests
*
* @param \React\Http\Request $request Request to handle
* @param \React\Http\Response $response Prebuilt response object
*/
public function serverCallback($request, $response)
{
// Currently the PHP server is readonly
if (!in_array(strtoupper($request->getMethod()), array('GET', 'HEAD'))) {
$response->writeHead(405, array('Content-type' => 'text/plain'));
$response->end('Writing is currently not supported');
return;
}
/** @var \Cundd\Rest\Request $restRequest */
$restRequest = new \Cundd\Rest\Request($request->getMethod(), $this->sanitizePath($request->getPath()));
$this->setServerGlobals($request);
/** @var \Bullet\Response $restResponse */
$restResponse = NULL;
ob_start();
$this->app->dispatch($restRequest, $restResponse);
ob_end_clean();
$response->writeHead($restResponse->status(), $this->getHeadersFromResponse($restResponse));
$response->end($restResponse->content());
unset($restRequest);
unset($restResponse);
}
/**
* Creates a new request object from the data of a reactPHP request object
*
* @param \React\Http\Request $request ReactPHP native request object
* @param string $body Content of received call
*
* @return \Slim\Http\Request
*/
public static function createFromReactRequest(\React\Http\Request $request, $body = '')
{
$slimHeads = new Headers();
$cookies = [];
$host = ['', 80];
foreach ($request->getHeaders() as $reactHeadKey => $reactHead) {
$slimHeads->add($reactHeadKey, $reactHead);
switch ($reactHeadKey) {
case 'Host':
$host = static::getHost($reactHead);
break;
case 'Cookie':
$cookies = Cookies::parseHeader($reactHead);
break;
}
}
$slimUri = new Uri('http', $host[0], (int) $host[1], $request->getPath(), $request->getQuery());
$serverParams = $_SERVER;
$serverParams['SERVER_PROTOCOL'] = 'HTTP/' . $request->getHttpVersion();
$slimBody = static::getBody($body);
return new Request($request->getMethod(), $slimUri, $slimHeads, $cookies, $serverParams, $slimBody);
}
/**
* {@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;
}
/**
* Manages a request, made to the Http server.
*
* @param \React\Http\Request $request
* @param \React\Http\Response $response
*/
public function manageRequest($request, $response)
{
$requestData = [$request->getHeaders()['Host'] . $request->getPath(), $request->getMethod(), array_merge($request->getQuery(), $request->getPost()), [], $request->getFiles(), []];
$contentType = isset($request->getHeaders()['Content-Type']) ? $request->getHeaders()['Content-Type'] : 'application/x-www-form-urlencoded';
if (strtolower($contentType) == 'application/x-www-form-urlencoded') {
$requestData[] = http_build_query($request->getPost());
} else {
$requestData[] = $request->getBody();
}
//Creates the Symfony Request from the React Request.
$sRequest = Request::create(...$requestData);
/** @var Response $sResponse */
$sResponse = $this->kernel->handle($sRequest);
$response->writeHead($sResponse->getStatusCode());
$response->end($sResponse->getContent());
}
/**
* Handle request.
*
* @param Request $request
* @param string $requestBody
* @param Response $response
*/
public function handle(Request $request, $requestBody, Response $response)
{
$status = 200;
$responseBody = '{}';
try {
if ($request->getMethod() !== 'POST') {
throw new HttpException(405);
}
if (!array_key_exists($request->getPath(), $this->actions)) {
throw new HttpException(404);
}
$this->logger->info('Request: ' . $request->getPath());
$responseBody = $this->actions[$request->getPath()]->handleRequest($requestBody, $this->phpcmplr);
} catch (HttpException $e) {
$this->logger->notice($e->getMessage(), ['exception' => $e]);
$status = $e->getStatus();
$responseBody = json_encode(['error' => $e->getStatus(), 'message' => ResponseCodes::$statusTexts[$e->getStatus()]]);
} catch (\Exception $e) {
$this->logger->error($e->getMessage(), ['exception' => $e]);
$status = 500;
$responseBody = json_encode(['error' => 500, 'message' => ResponseCodes::$statusTexts[500] . ': ' . $e->getMessage()]);
} catch (\Error $e) {
// PHP7
$this->logger->error($e->getMessage(), ['exception' => $e]);
$status = 500;
$responseBody = json_encode(['error' => 500, 'message' => ResponseCodes::$statusTexts[500] . ': ' . $e->getMessage()]);
}
$response->writeHead($status, ['Content-Type' => 'application/json', 'Content-Length' => strlen($responseBody)]);
$response->end($responseBody);
}
private function buildSymfonyRequest(Request $request, $requestData = '')
{
$params = $this->extractRequestParameters($requestData);
return SymfonyRequest::create($request->getPath(), $request->getMethod(), $params);
}
public function getMethod()
{
return $this->request->getMethod();
}
protected function handleRequest(\React\Http\Request $request, \React\Http\Response $response)
{
$request_headers = $request->getHeaders();
$requestUri = $this->getRequestUri($request_headers, $request->getPath());
$laravel_request = \Request::create($this->getRequestUri($request_headers, $request->getPath()), $request->getMethod(), array_merge($request->getQuery(), $this->post_params), $this->getCookies($request_headers), [], [], $this->request_body);
$laravel_request->headers->add($request_headers);
$laravel_response = \App::handle($laravel_request);
$headers = array_merge($laravel_response->headers->allPreserveCase(), $this->buildCookies($laravel_response->headers->getCookies()));
$response->writeHead($laravel_response->getStatusCode(), $headers);
$response->end($laravel_response->getContent());
echo $requestUri . "\n";
}
/**
* Handles the requests
*
* @param \React\Http\Request $request Request to handle
* @param \React\Http\Response $response Prebuilt response object
*/
public function serverCallback($request, $response)
{
// Currently the PHP server is readonly
if (!in_array(strtoupper($request->getMethod()), array('GET', 'HEAD'))) {
$response->writeHead(405, array('Content-type' => 'text/plain'));
$response->end('Writing is currently not supported');
return;
}
$requestPath = $this->sanitizePath($request->getPath());
$requestPath = substr($requestPath, 5);
/** @var Request $restRequest */
$restRequest = new Request($request->getMethod(), $requestPath, $request->getQuery(), $request->getHeaders());
$path = '' . strtok($requestPath, '/');
$restRequest->initWithPathAndOriginalPath($path, $path);
$this->setServerGlobals($request);
/** @var \Bullet\Response $restResponse */
$restResponse = NULL;
ob_start();
$this->dispatcher->dispatch($restRequest, $restResponse);
$responseString = ob_get_clean();
if (!$restResponse) {
$response->writeHead(200);
$response->end($responseString);
} else {
$response->writeHead($restResponse->status(), $this->getHeadersFromResponse($restResponse));
$response->end($restResponse->content());
}
unset($restRequest);
unset($restResponse);
}
/**
* Convert React\Http\Request to Symfony\Component\HttpFoundation\Request
*
* @param ReactRequest $reactRequest
* @return SymfonyRequest $syRequest
*/
protected static function mapRequest(ReactRequest $reactRequest, $content)
{
$method = $reactRequest->getMethod();
$headers = $reactRequest->getHeaders();
$query = $reactRequest->getQuery();
$post = array();
// parse body?
if (isset($headers['Content-Type']) && 0 === strpos($headers['Content-Type'], 'application/x-www-form-urlencoded') && in_array(strtoupper($method), array('POST', 'PUT', 'DELETE', 'PATCH'))) {
parse_str($content, $post);
}
$syRequest = new SymfonyRequest($query, $post, array(), array(), array(), array(), $content);
$syRequest->setMethod($method);
$syRequest->headers->replace($headers);
$syRequest->server->set('REQUEST_URI', $reactRequest->getPath());
$syRequest->server->set('SERVER_NAME', explode(':', $headers['Host'])[0]);
return $syRequest;
}
/**
* @param React\Http\Request $reactRequest
* @return Nette\Http\Request
*/
private function createNetteHttpRequest(React\Http\Request $reactRequest)
{
$url = new Nette\Http\UrlScript('http://' . $reactRequest->getHeaders()['Host'] . $reactRequest->getPath());
$url->setQuery($reactRequest->getQuery());
return new Nette\Http\Request($url, NULL, NULL, NULL, NULL, $reactRequest->getHeaders(), $reactRequest->getMethod(), $reactRequest->remoteAddress, NULL, NULL);
}
/**
* Log a request
*
* @param OutputInterface $output Output
* @param string $responseCode Response code
* @param Request $request Request
*/
public static function logRequest(OutputInterface $output, $responseCode, Request $request)
{
$wrapOpen = '';
$wrapClose = '';
if ($responseCode < 400) {
$wrapOpen = '';
$wrapClose = '';
} elseif ($responseCode >= 400) {
$wrapOpen = '<comment>';
$wrapClose = '</comment>';
}
$output->writeln($wrapOpen . sprintf('[%s] "%s %s HTTP/%s" %s', date("d/M/Y H:i:s"), $request->getMethod(), $request->getPath(), $request->getHttpVersion(), $responseCode) . $wrapClose);
}
private function buildSymfonyRequest(Request $request, Response $response)
{
return SymfonyRequest::create($request->getPath(), $request->getMethod());
}
public function handleRequest(Request $request, Response $response)
{
$this->request = $request;
$this->response = $response;
$dispatcher = new Dispatcher($this->router->getData());
try {
$content = $dispatcher->dispatch($request->getMethod(), $request->getPath());
$response->writeHead(200, ['Content-Type' => $this->responseContentType]);
$response->write($content);
} catch (HttpRouteNotFoundException $e) {
$response->writeHead(404, ['Content-Type' => 'text/plain']);
} catch (HttpMethodNotAllowedException $e) {
$response->writeHead(403, ['Content-Type' => 'text/plain']);
} catch (Exception $e) {
$this->getLogger()->error($e->getMessage());
$response->writeHead(500, ['Content-Type' => 'text/plain']);
}
$response->end();
}
