/**
* Will call for the measurement protocol endpoint
*
* @param \AppserverIo\Psr\HttpMessage\RequestInterface $request A request object
* @param \AppserverIo\Psr\HttpMessage\ResponseInterface $response A response object
* @param \AppserverIo\Server\Interfaces\RequestContextInterface $requestContext A requests context instance
*
* @return null
*/
public function call(RequestInterface $request, ResponseInterface $response, RequestContextInterface $requestContext)
{
// merge default and configured parameters into our list
$parameters = array_merge($this->defaultParameters, $this->parameters);
// we want the request to be like it came from the same host, so we will reuse part of it
$parameters['ua'] = $request->getHeader(HttpProtocol::HEADER_USER_AGENT);
$parameters['uip'] = $requestContext->getServerVar(ServerVars::REMOTE_ADDR);
// the client will be a random UUID, at least if we do not get a matching cookie
if ($request->hasHeader(HttpProtocol::HEADER_COOKIE)) {
// the user is known to us
$cookie = $request->getHeader(HttpProtocol::HEADER_COOKIE);
$matches = array();
preg_match('/_ga=GA[0-9]\\.[0-9]\\.(.+)/', $cookie, $matches);
if (isset($matches[1])) {
$parameters['cid'] = $matches[1];
// remove the cookie to avoid additional calls
$response->removeCookie('_ga');
// filter the parameters for a known cookie
$parameters = $this->filterParameters($parameters, self::COOKIE_PRESENT);
}
}
// if there is no known client id we will set one randomly
if (!isset($parameters['cid'])) {
$uuid4 = Uuid::uuid4();
$parameters['cid'] = $uuid4->toString();
// filter the parameters for usage without cookie
$parameters = $this->filterParameters($parameters, self::COOKIE_NOT_PRESENT);
}
// make the actual call
$this->sendToService($parameters);
}
/**
* Implement's module logic for given hook
*
* @param \AppserverIo\Psr\HttpMessage\RequestInterface $request A request object
* @param \AppserverIo\Psr\HttpMessage\ResponseInterface $response A response object
* @param \AppserverIo\Server\Interfaces\RequestContextInterface $requestContext A requests context instance
* @param int $hook The current hook to process logic for
*
* @return bool
* @throws \AppserverIo\Server\Exceptions\ModuleException
*/
public function process(RequestInterface $request, ResponseInterface $response, RequestContextInterface $requestContext, $hook)
{
try {
// in php an interface is, by definition, a fixed contract. It is immutable.
// so we have to declair the right ones afterwards...
/**
* @var $request \AppserverIo\Psr\HttpMessage\RequestInterface
*/
/**
* @var $request \AppserverIo\Psr\HttpMessage\ResponseInterface
*/
// if false hook is coming do nothing
if (ModuleHooks::REQUEST_POST !== $hook) {
return;
}
// check if server handler sais php modules should react on this request as file handler
if ($requestContext->getServerVar(ServerVars::SERVER_HANDLER) !== self::MODULE_NAME) {
return;
}
// check if file does not exist
if (!$requestContext->hasServerVar(ServerVars::SCRIPT_FILENAME)) {
$response->setStatusCode(404);
throw new ModuleException(null, 404);
}
// create a new the FastCGI client/connection
$fastCgiConnection = $this->getFastCgiClient($requestContext)->connect();
// prepare the Fast-CGI environment variables
$environment = $this->prepareEnvironment($request, $requestContext);
// rewind the body stream
$bodyStream = $request->getBodyStream();
rewind($bodyStream);
// initialize a new FastCGI request instance
$fastCgiRequest = $fastCgiConnection->newRequest($environment, $bodyStream);
// process the request
$rawResponse = $fastCgiConnection->request($fastCgiRequest);
// format the raw response
$fastCgiResponse = $this->formatResponse($rawResponse->content);
// set the Fast-CGI response value in the WebServer response
$response->setStatusCode($fastCgiResponse['statusCode']);
$response->appendBodyStream($fastCgiResponse['body']);
// set the headers found in the Fast-CGI response
if (array_key_exists('headers', $fastCgiResponse)) {
foreach ($fastCgiResponse['headers'] as $headerName => $headerValue) {
// if found an array, e. g. for the Set-Cookie header, we add each value
if (is_array($headerValue)) {
foreach ($headerValue as $value) {
$response->addHeader($headerName, $value, true);
}
} else {
$response->addHeader($headerName, $headerValue);
}
}
}
// add the X-Powered-By header
$response->addHeader(Protocol::HEADER_X_POWERED_BY, __CLASS__);
// set response state to be dispatched after this without calling other modules process
$response->setState(HttpResponseStates::DISPATCH);
} catch (\Exception $e) {
// catch all exceptions
throw new ModuleException($e->getMessage(), $e->getCode());
}
}
/**
* Copies the values from the request handler back to the passed HTTP response instance.
*
* @param \AppserverIo\Psr\HttpMessage\ResponseInterface $httpResponse A HTTP response object
*
* @return void
*/
public function copyToHttpResponse(ResponseInterface $httpResponse)
{
// copy response values to the HTTP response
$httpResponse->setStatusCode($this->statusCode);
$httpResponse->setStatusReasonPhrase($this->statusReasonPhrase);
$httpResponse->setVersion($this->version);
$httpResponse->setState($this->state);
// copy the body content to the HTTP response
$httpResponse->appendBodyStream($this->bodyStream);
// copy headers to the HTTP response
foreach ($this->headers as $headerName => $headerValue) {
$httpResponse->addHeader($headerName, $headerValue);
}
// copy cookies to the HTTP response
$httpResponse->setCookies($this->cookies);
// query whether an exception has been thrown, if yes, re-throw it
if ($this->exception instanceof \Exception) {
throw $this->exception;
}
}
/**
* Implements module logic for given hook
*
* @param \AppserverIo\Psr\HttpMessage\RequestInterface $request A request object
* @param \AppserverIo\Psr\HttpMessage\ResponseInterface $response A response object
* @param \AppserverIo\Server\Interfaces\RequestContextInterface $requestContext A requests context instance
* @param int $hook The current hook to process logic for
*
* @return bool
* @throws \AppserverIo\Server\Exceptions\ModuleException
*/
public function process(RequestInterface $request, ResponseInterface $response, RequestContextInterface $requestContext, $hook)
{
/**
* @var $request \AppserverIo\Psr\HttpMessage\RequestInterface
*/
/**
* @var $response \AppserverIo\Psr\HttpMessage\ResponseInterface
*/
// if false hook is comming do nothing
if (ModuleHooks::REQUEST_POST !== $hook) {
return;
}
// make request context available for usage in template
$this->requestContext = $requestContext;
// query whether the auto index module is available
if ($this->getRequestContext()->hasServerVar(ServerVars::SERVER_AUTO_INDEX) === false) {
return;
}
// query whether the auto index module is available and enabled
if ($this->getRequestContext()->getServerVar(ServerVars::SERVER_AUTO_INDEX) === ServerVars::VALUE_AUTO_INDEX_OFF) {
return;
}
// stop processing if file handler will not be core in case that location module
// has changed the server handler to be proxy, fastcgi or what ever.
if ($requestContext->getServerVar(ServerVars::SERVER_HANDLER) !== 'core') {
return;
}
// now load the URL without path information and query string
$url = $this->getUrl();
// query whether the URL ends with a slash
if ($url[strlen($url) - 1] !== '/') {
return;
}
// query whether an existing path is requested
if (is_dir($realPath = $this->getRealPath()) === false) {
return;
}
// load the auto index template if available
$autoIndexTemplatePath = $this->getRequestContext()->getServerVar(ServerVars::SERVER_AUTO_INDEX_TEMPLATE_PATH);
// query whether a template is configured and available
if ($autoIndexTemplatePath && is_file($autoIndexTemplatePath)) {
// render errors page
ob_start();
require $autoIndexTemplatePath;
$autoIndexPage = ob_get_clean();
} else {
// initialize the directory listing content
$directoryListing = '<tr><th>Name</th><th>Last Modified</th><th>Size</th></tr>';
// query whether if we've parent directory or not
if ($this->hasParent($realPath)) {
$directoryListing .= sprintf('<tr><td colspan="3"><a href="%s">Parent Directory</a></td></tr>', $this->getParentLink());
}
// append the found files + directories to the directory listing
foreach ($this->getDirectoryContent($realPath) as $directory) {
// append the file or directory to the directory listing
$directoryListing .= sprintf('<tr><td><a href="%s">%s</a></td><td>%s</td><td>%d</td></tr>', $this->getLink($directory), $this->getName($directory), $this->getDate($directory), $this->getFilesize($directory));
}
// concatenate the elements of the auto index page
$autoIndexPage = sprintf('<!DOCTYPE html><html><head><title>Index of %s</title></head><body><h1>Index of %s</h1><table>%s</table></body></html>', $this->getUri(), $this->getUri(), $directoryListing);
}
// append errors page to response body
$response->appendBodyStream($autoIndexPage);
// set the Content-Type to text/html
$response->addHeader(Protocol::HEADER_CONTENT_TYPE, 'text/html');
// set response state to be dispatched after this without calling other modules process
$response->setState(HttpResponseStates::DISPATCH);
}
/**
* Copies the values from the request handler back to the passed HTTP response instance.
*
* @param \AppserverIo\Psr\HttpMessage\ResponseInterface $httpResponse A HTTP response object
*
* @return void
*/
public function copyToHttpResponse(ResponseInterface $httpResponse)
{
// create a local copy of the response
$servletResponse = $this->servletResponse;
// copy response values to the HTTP response
$httpResponse->setStatusCode($servletResponse->getStatusCode());
$httpResponse->setStatusReasonPhrase($servletResponse->getStatusReasonPhrase());
$httpResponse->setVersion($servletResponse->getVersion());
$httpResponse->setState($servletResponse->getState());
// copy the body content to the HTTP response
$httpResponse->appendBodyStream($servletResponse->getBodyStream());
// copy headers to the HTTP response
foreach ($servletResponse->getHeaders() as $headerName => $headerValue) {
$httpResponse->addHeader($headerName, $headerValue);
}
// copy cookies to the HTTP response
$httpResponse->setCookies($servletResponse->getCookies());
}
/**
* Implements module logic for given hook
*
* @param \AppserverIo\Psr\HttpMessage\RequestInterface $request A request object
* @param \AppserverIo\Psr\HttpMessage\ResponseInterface $response A response object
* @param \AppserverIo\Server\Interfaces\RequestContextInterface $requestContext A requests context instance
* @param int $hook The current hook to process logic for
*
* @return bool
* @throws \AppserverIo\Server\Exceptions\ModuleException
*/
public function process(RequestInterface $request, ResponseInterface $response, RequestContextInterface $requestContext, $hook)
{
// In php an interface is, by definition, a fixed contract. It is immutable.
// So we have to declare the right ones afterwards...
/**
* @var $request \AppserverIo\Psr\HttpMessage\RequestInterface
*/
/**
* @var $response \AppserverIo\Psr\HttpMessage\ResponseInterface
*/
// if false hook is comming do nothing
if (ModuleHooks::RESPONSE_PRE !== $hook) {
return;
}
// check if content type header exists if not stop processing
if (!$response->hasHeader(Protocol::HEADER_CONTENT_TYPE)) {
return;
}
// check if no accept encoding headers are sent
if (!$request->hasHeader(Protocol::HEADER_ACCEPT_ENCODING)) {
return;
}
// check if response was encoded before and exit than
if ($response->hasHeader(Protocol::HEADER_CONTENT_ENCODING)) {
return;
}
// do not deflate on proxy requests because proxy servers are responsible for sending correct responses
if ($requestContext->getServerVar(ServerVars::SERVER_HANDLER) === 'proxy') {
// stop processing
return;
}
// check if request accepts deflate
if (strpos($request->getHeader(Protocol::HEADER_ACCEPT_ENCODING), 'deflate') !== false) {
// get stream meta data
$streamMetaData = stream_get_meta_data($response->getBodyStream());
/**
* Currently it's not possible to apply zlib.deflate filter on memory (php://memory) or
* temp (php://temp) streams due to a bug in that zlib library.,
*
* So for now we'll check if stream type is not MEMORY in case of static files and add
* deflate filter just for static files served via core module.
*
* @link https://bugs.php.net/bug.php?id=48725
*/
if ($streamMetaData['stream_type'] !== 'MEMORY' && $this->isRelevantMimeType($response->getHeader(Protocol::HEADER_CONTENT_TYPE))) {
// apply encoding filter to response body stream
stream_filter_append($response->getBodyStream(), 'zlib.deflate', STREAM_FILTER_READ);
// rewind current body stream
@rewind($response->getBodyStream());
// copy body stream to make use of filter in read mode
$deflateBodyStream = fopen('php://memory', 'w+b');
// copy stream with appended filter to new deflate body stream
stream_copy_to_stream($response->getBodyStream(), $deflateBodyStream);
// reset body stream on response
$response->setBodyStream($deflateBodyStream);
// set encoding header info
$response->addHeader(Protocol::HEADER_CONTENT_ENCODING, 'deflate');
}
}
}
/**
* Implements module logic for given hook
*
* @param \AppserverIo\Psr\HttpMessage\RequestInterface $request A request object
* @param \AppserverIo\Psr\HttpMessage\ResponseInterface $response A response object
* @param \AppserverIo\Server\Interfaces\RequestContextInterface $requestContext A requests context instance
* @param int $hook The current hook to process logic for
*
* @return bool
* @throws \AppserverIo\Server\Exceptions\ModuleException
*/
public function process(RequestInterface $request, ResponseInterface $response, RequestContextInterface $requestContext, $hook)
{
// In php an interface is, by definition, a fixed contract. It is immutable.
// So we have to declair the right ones afterwards...
/**
* @var $request \AppserverIo\Psr\HttpMessage\RequestInterface
*/
/**
* @var $response \AppserverIo\Psr\HttpMessage\ResponseInterface
*/
// if false hook is comming do nothing
if (ModuleHooks::REQUEST_POST !== $hook) {
return;
}
// set req and res object internally
$this->request = $request;
$this->response = $response;
// get default rewrite maps definitions
$rewriteMaps = $this->rewriteMaps;
// check if there are some volatile rewrite map definitions so add them
if ($requestContext->hasModuleVar(ModuleVars::VOLATILE_REWRITE_MAPS)) {
$volatileRewriteMaps = $requestContext->getModuleVar(ModuleVars::VOLATILE_REWRITE_MAPS);
// merge rewrite maps
$rewriteMaps = array_merge($volatileRewriteMaps, $this->rewriteMaps);
}
// check protocol to be either http or https when secure is going on
$protocol = 'http://';
if ($requestContext->getServerVar(ServerVars::HTTPS) === ServerVars::VALUE_HTTPS_ON) {
$protocol = 'https://';
}
// get clean request path without query string etc...
$requestPath = parse_url($requestContext->getServerVar(ServerVars::X_REQUEST_URI), PHP_URL_PATH);
// init all rewrite mappers by types and do look up
foreach ($rewriteMaps as $rewriteMapType => $rewriteMapParams) {
// Include the requested hostname as a param, some mappers might need it
$rewriteMapParams['headerHost'] = $request->getHeader(Protocol::HEADER_HOST);
// Same for the protocol
$rewriteMapParams['protocol'] = $protocol;
// Get ourselves a rewriteMapper of the right type
$rewriteMapper = new $rewriteMapType($rewriteMapParams);
// lookup by request path
if ($targetUrl = $rewriteMapper->lookup($requestPath)) {
// set enhance uri to response
$response->addHeader(Protocol::HEADER_LOCATION, $targetUrl);
// send redirect status
$response->setStatusCode(301);
// add header to be sure that is was us
$response->addHeader('X-Rewritten-By', __CLASS__);
// set response state to be dispatched after this without calling other modules process
$response->setState(HttpResponseStates::DISPATCH);
// We found something, stop the loop
break;
}
}
return true;
}
/**
* Implements module logic for given hook
*
* @param \AppserverIo\Psr\HttpMessage\RequestInterface $request A request object
* @param \AppserverIo\Psr\HttpMessage\ResponseInterface $response A response object
* @param \AppserverIo\Server\Interfaces\RequestContextInterface $requestContext A requests context instance
* @param int $hook The current hook to process logic for
*
* @return bool
* @throws \AppserverIo\Server\Exceptions\ModuleException
*/
public function process(RequestInterface $request, ResponseInterface $response, RequestContextInterface $requestContext, $hook)
{
// get server context to local ref
$serverContext = $this->getServerContext();
// check if response post is is comming
if (ModuleHooks::RESPONSE_POST === $hook) {
$this->checkShouldDisconnect();
return;
}
// if wrong hook is coming do nothing
if (ModuleHooks::REQUEST_POST !== $hook) {
return;
}
try {
// init upstreamname and transport
$upstreamName = null;
$transport = 'tcp';
// check if we've configured module variables
if ($requestContext->hasModuleVar(ModuleVars::VOLATILE_FILE_HANDLER_VARIABLES)) {
// load the volatile file handler variables and set connection data
$fileHandlerVariables = $requestContext->getModuleVar(ModuleVars::VOLATILE_FILE_HANDLER_VARIABLES);
// check if upstream is set for proxy function
if (isset($fileHandlerVariables['upstream'])) {
$upstreamName = $fileHandlerVariables['upstream'];
}
if (isset($fileHandlerVariables['transport'])) {
$transport = $fileHandlerVariables['transport'];
}
}
// if there was no upstream defined
if (is_null($upstreamName)) {
throw new ModuleException('No upstream configured for proxy filehandler');
}
// get upstream instance by configured upstream name
$upstream = $serverContext->getUpstream($upstreamName);
// find next proxy server by given upstream type
$remoteAddr = $requestContext->getServerVar(ServerVars::REMOTE_ADDR);
$proxyServer = $upstream->findServer(md5($remoteAddr));
// build proxy socket address for connection
$proxySocketAddress = sprintf('%s://%s:%s', $transport, $proxyServer->getAddress(), $proxyServer->getPort());
// check if should reconnect
$this->checkShouldDisconnect();
// check if proxy connection object was initialised but connection resource is not ready
if ($this->connection && $this->connection->getStatus() === false) {
// unset connection if corrupt
$this->connection = null;
}
// check if connection should be established
if ($this->connection === null) {
// create and connect to defined backend
$this->connection = StreamSocket::getClientInstance($proxySocketAddress);
// set proxy connection resource as stream source for body stream directly
// that avoids huge memory consumtion when transferring big files via proxy connections
$response->setBodyStream($this->connection->getConnectionResource());
}
// get connection to local var
$connection = $this->connection;
// build up raw request start line
$rawRequestString = sprintf('%s %s %s' . "\r\n", $request->getMethod(), $request->getUri(), HttpProtocol::VERSION_1_1);
// populate request headers
$headers = $request->getHeaders();
foreach ($headers as $headerName => $headerValue) {
// @todo: make keep-alive available for proxy connections
if ($headerName === HttpProtocol::HEADER_CONNECTION) {
$headerValue = HttpProtocol::HEADER_CONNECTION_VALUE_CLOSE;
}
$rawRequestString .= $headerName . HttpProtocol::HEADER_SEPARATOR . $headerValue . "\r\n";
}
// get current protocol
$reqProto = $requestContext->getServerVar(ServerVars::REQUEST_SCHEME);
// add proxy depending headers
$rawRequestString .= HttpProtocol::HEADER_X_FORWARD_FOR . HttpProtocol::HEADER_SEPARATOR . $remoteAddr . "\r\n";
$rawRequestString .= HttpProtocol::HEADER_X_FORWARDED_PROTO . HttpProtocol::HEADER_SEPARATOR . $reqProto . "\r\n";
$rawRequestString .= "\r\n";
// write headers to proxy connection
$connection->write($rawRequestString);
// copy raw request body stream to proxy connection
$connection->copyStream($request->getBodyStream());
// read status line from proxy connection
$statusLine = $connection->readLine(1024, 5);
// parse start line
list(, $responseStatusCode) = explode(' ', $statusLine);
// map everything from proxy response to our response object
$response->setStatusCode($responseStatusCode);
$line = '';
$messageHeaders = '';
while (!in_array($line, array("\r\n", "\n"))) {
// read next line
$line = $connection->readLine();
// enhance headers
$messageHeaders .= $line;
}
// remove ending CRLF's before parsing
$messageHeaders = trim($messageHeaders);
// check if headers are empty
if (strlen($messageHeaders) === 0) {
throw new HttpException('Missing headers');
}
// delimit headers by CRLF
$headerLines = explode("\r\n", $messageHeaders);
// iterate all headers
foreach ($headerLines as $headerLine) {
// extract header info
$extractedHeaderInfo = explode(HttpProtocol::HEADER_SEPARATOR, trim($headerLine));
if (!$extractedHeaderInfo || $extractedHeaderInfo[0] === $headerLine) {
throw new HttpException('Wrong header format');
}
// split name and value
list($headerName, $headerValue) = $extractedHeaderInfo;
// check header name for server
// @todo: make this configurable
if ($headerName === HttpProtocol::HEADER_SERVER) {
continue;
}
// add header
$response->addHeader(trim($headerName), trim($headerValue));
}
// set flag false by default
$this->shouldDisconnect = false;
// check if connection should be closed as given in connection header
if ($response->getHeader(HttpProtocol::HEADER_CONNECTION) === HttpProtocol::HEADER_CONNECTION_VALUE_CLOSE) {
$this->shouldDisconnect = true;
}
} catch (\AppserverIo\Psr\Socket\SocketReadException $e) {
// close and unset connection and try to process the request again to
// not let a white page get delivered to the client
$this->shouldDisconnect = true;
return $this->process($request, $response, $requestContext, $hook);
} catch (\AppserverIo\Psr\Socket\SocketReadTimeoutException $e) {
// close and unset connection and try to process the request again to
// not let a white page get delivered to the client
$this->shouldDisconnect = true;
return $this->process($request, $response, $requestContext, $hook);
}
// set response to be dispatched at this point
$response->setState(HttpResponseStates::DISPATCH);
}
/**
* Implements module logic for given hook
*
* @param \AppserverIo\Psr\HttpMessage\RequestInterface $request A request object
* @param \AppserverIo\Psr\HttpMessage\ResponseInterface $response A response object
* @param \AppserverIo\Server\Interfaces\RequestContextInterface $requestContext A requests context instance
* @param int $hook The current hook to process logic for
*
* @return bool
* @throws \AppserverIo\Server\Exceptions\ModuleException
*/
public function process(RequestInterface $request, ResponseInterface $response, RequestContextInterface $requestContext, $hook)
{
// if false hook is coming do nothing
if (ModuleHooks::REQUEST_POST !== $hook) {
return;
}
// set req and res object internally
$this->request = $request;
$this->response = $response;
// get server context to local var
$serverContext = $this->getServerContext();
// Get the authentications locally so we do not mess with inter-request configuration
$authenticationSets = array();
// check if there are some volatile rewrite map definitions so add them
if ($requestContext->hasModuleVar(ModuleVars::VOLATILE_AUTHENTICATIONS)) {
$authenticationSets[] = $requestContext->getModuleVar(ModuleVars::VOLATILE_AUTHENTICATIONS);
}
// get the global authentications last, as volatile authentications are prefered here as more specific configurations can lessen security
$authenticationSets[] = $this->authentications;
// get system logger
$systemLogger = $serverContext->getLogger(LoggerUtils::SYSTEM);
// check authentication information if something matches
foreach ($authenticationSets as $authenticationSet) {
foreach ($authenticationSet as $uriPattern => $data) {
// check if pattern matches uri
if (preg_match('/' . $uriPattern . '/', $requestContext->getServerVar(ServerVars::X_REQUEST_URI))) {
// set type Instance to local ref
$typeInstance = $this->getAuthenticationInstance($uriPattern, $data);
// check if auth header is not set in coming request headers
if (!$request->hasHeader(Protocol::HEADER_AUTHORIZATION)) {
// send header for challenge authentication against client
$response->addHeader(Protocol::HEADER_WWW_AUTHENTICATE, $typeInstance->getAuthenticateHeader());
// throw exception for auth required
throw new ModuleException(null, 401);
}
// init type instance by request
$typeInstance->init($request->getHeader(Protocol::HEADER_AUTHORIZATION), $request->getMethod());
try {
// check if auth works
if ($typeInstance->authenticate()) {
// set server vars
$requestContext->setServerVar(ServerVars::REMOTE_USER, $typeInstance->getUsername());
// break out because everything is fine at this point
break;
}
} catch (\Exception $e) {
// log exception as warning to not end up with a 500 response which is not wanted here
$systemLogger->warning($e->getMessage());
}
// send header for challenge authentication against client
$response->addHeader(Protocol::HEADER_WWW_AUTHENTICATE, $typeInstance->getAuthenticateHeader());
// throw exception for auth required
throw new ModuleException(null, 401);
}
}
}
}
/**
* Implements module logic for given hook
*
* @param \AppserverIo\Psr\HttpMessage\RequestInterface $request A request object
* @param \AppserverIo\Psr\HttpMessage\ResponseInterface $response A response object
* @param \AppserverIo\Server\Interfaces\RequestContextInterface $requestContext A requests context instance
* @param int $hook The current hook to process logic for
*
* @return bool
* @throws \AppserverIo\Server\Exceptions\ModuleException
*/
public function process(RequestInterface $request, ResponseInterface $response, RequestContextInterface $requestContext, $hook)
{
// In php an interface is, by definition, a fixed contract. It is immutable.
// So we have to declare the right ones afterwards...
/**
* @var $request \AppserverIo\Psr\HttpMessage\RequestInterface
*/
/**
* @var $response \AppserverIo\Psr\HttpMessage\ResponseInterface
*/
// if false hook is coming do nothing
if (ModuleHooks::REQUEST_POST !== $hook) {
return;
}
// check if core module should still handle this request
// maybe later on this can be overwritten by another core module for some reasons
if ($requestContext->getServerVar(ServerVars::SERVER_HANDLER) !== self::MODULE_NAME) {
// stop processing
return;
}
// populates request context for possible script calling based on file handler configurations
$this->populateRequestContext($requestContext);
// check if file handler is not core module anymore
if ($requestContext->getServerVar(ServerVars::SERVER_HANDLER) !== self::MODULE_NAME) {
// stop processing
return;
}
// if existing file should be served
if ($requestContext->hasServerVar(ServerVars::SCRIPT_FILENAME)) {
$scriptFilename = $requestContext->getServerVar(ServerVars::SCRIPT_FILENAME);
// get file info
$fileInfo = new \SplFileInfo($scriptFilename);
// build etag
$eTag = sprintf('"%x-%x-%x"', $fileInfo->getInode(), $fileInfo->getSize(), (double) str_pad($fileInfo->getMTime(), 16, '0'));
// set last modified header
$response->addHeader(Protocol::HEADER_LAST_MODIFIED, gmdate(DATE_RFC822, $fileInfo->getMTime()));
// set etag header
$response->addHeader(Protocol::HEADER_ETAG, $eTag);
// set correct mimetype header
$response->addHeader(Protocol::HEADER_CONTENT_TYPE, MimeTypes::getMimeTypeByExtension($fileInfo->getExtension()));
// caching checks
if ($request->hasHeader(Protocol::HEADER_IF_NONE_MATCH) && $request->getHeader(Protocol::HEADER_IF_NONE_MATCH) === $eTag) {
// set not modified status without content
$response->setStatusCode(304);
} else {
// serve file by set body stream to file descriptor stream
$response->setBodyStream(fopen($scriptFilename, "r"));
}
// set response state to be dispatched after this without calling other modules process
$response->setState(HttpResponseStates::DISPATCH);
// if we got here its maybe a directory index surfing request if $validDir is same as uri
// todo: implement directory index view and surfing
} else {
// for now we will throw a 404 as well here for non existing index files in directory
throw new ModuleException(sprintf("The requested URL %s was not found on this server.", parse_url($requestContext->getServerVar(ServerVars::X_REQUEST_URI), PHP_URL_PATH)), 404);
}
}
/**
* Implement's module logic for given hook
*
* @param \AppserverIo\Psr\HttpMessage\RequestInterface $request A request object
* @param \AppserverIo\Psr\HttpMessage\ResponseInterface $response A response object
* @param \AppserverIo\Server\Interfaces\RequestContextInterface $requestContext A requests context instance
* @param int $hook The current hook to process logic for
*
* @return bool
* @throws \AppserverIo\Server\Exceptions\ModuleException
*/
public function process(RequestInterface $request, ResponseInterface $response, RequestContextInterface $requestContext, $hook)
{
// In php an interface is, by definition, a fixed contract. It is immutable.
// So we have to declair the right ones afterwards...
/**
* @var $request \AppserverIo\Psr\HttpMessage\RequestInterface
*/
/**
* @var $response \AppserverIo\Psr\HttpMessage\ResponseInterface
*/
// if false hook is comming do nothing
if (ModuleHooks::REQUEST_POST !== $hook) {
return;
}
// set req and res object internally
$this->request = $request;
$this->response = $response;
// get document root
$documentRoot = $requestContext->getServerVar(ServerVars::DOCUMENT_ROOT);
// get url
$url = parse_url($requestContext->getServerVar(ServerVars::X_REQUEST_URI), PHP_URL_PATH);
// get query string with asterisk
$queryString = strstr($requestContext->getServerVar(ServerVars::X_REQUEST_URI), '?');
// get read path to requested uri
$realPath = $documentRoot . $url;
// check if it's a dir
if (is_dir($realPath) || $url === '/') {
// check if uri has trailing slash
if (substr($url, -1) !== '/') {
// set enhance uri with trailing slash to response
$response->addHeader(Protocol::HEADER_LOCATION, $url . '/' . $queryString);
// send redirect status
$response->setStatusCode(301);
// set response state to be dispatched after this without calling other modules process
$response->setState(HttpResponseStates::DISPATCH);
} else {
// check directory index definitions
foreach ($this->getDirectoryIndex() as $index) {
// check if defined index files are found in directory
if (is_file($realPath . $index)) {
// reset uri with indexed filename
$requestContext->setServerVar(ServerVars::X_REQUEST_URI, $url . $index . $queryString);
// break out if index file was found
return true;
}
}
}
}
return true;
}
/**
* Will prepare a response for a redirect.
* This includes setting the new target, the appropriate status code and dispatching it to break the
* module chain
*
* @param \AppserverIo\Server\Interfaces\RequestContextInterface $requestContext The request's context
* @param \AppserverIo\Psr\HttpMessage\ResponseInterface $response The response instance to be prepared
*
* @return void
*/
protected function prepareRedirect($requestContext, ResponseInterface $response)
{
// if we got a specific status code we have to filter it and apply it if possible
$statusCode = 301;
$proposedStatusCode = $this->sortedFlags[RuleFlags::REDIRECT];
if (is_numeric($proposedStatusCode) && $proposedStatusCode >= 300 && $proposedStatusCode < 400) {
$statusCode = $proposedStatusCode;
}
// there might be work to be done depending on whether or not we got a complete URL
if ($this->type === 'relative') {
$newTarget = $requestContext->getServerVar(ServerVars::REQUEST_SCHEME);
$newTarget .= '://';
$newTarget .= $requestContext->getServerVar(ServerVars::HTTP_HOST);
$this->target = $newTarget . $this->getTarget();
}
// set enhance uri to response
$response->addHeader(Protocol::HEADER_LOCATION, $this->target);
// send redirect status
$response->setStatusCode($statusCode);
// set response state to be dispatched after this without calling other modules process
$response->setState(HttpResponseStates::DISPATCH);
}
/**
* Process servlet request.
*
* @param \AppserverIo\Psr\HttpMessage\RequestInterface $request A request object
* @param \AppserverIo\Psr\HttpMessage\ResponseInterface $response A response object
* @param \AppserverIo\Server\Interfaces\RequestContextInterface $requestContext A requests context instance
* @param integer $hook The current hook to process logic for
*
* @return boolean
*
* @throws \AppserverIo\Server\Exceptions\ModuleException
*/
public function process(RequestInterface $request, ResponseInterface $response, RequestContextInterface $requestContext, $hook)
{
// if false hook is coming do nothing
if (ModuleHooks::REQUEST_POST !== $hook) {
return;
}
// check if we are the handler that has to process this request
if ($requestContext->getServerVar(ServerVars::SERVER_HANDLER) !== $this->getModuleName()) {
return;
}
// load the application associated with this request
$application = $this->findRequestedApplication($requestContext);
$application->registerClassLoaders();
// check if the application has already been connected
if ($application->isConnected() === false) {
throw new \Exception(sprintf('Application %s has not connected yet', $application->getName()), 503);
}
// create a copy of the valve instances
$valves = $this->valves;
$handlers = $this->handlers;
// create a new request instance from the HTTP request
$servletRequest = new Request();
$servletRequest->injectHandlers($handlers);
$servletRequest->injectHttpRequest($request);
$servletRequest->injectServerVars($requestContext->getServerVars());
$servletRequest->init();
// initialize servlet response
$servletResponse = new Response();
$servletResponse->init();
// load the session and the authentication manager
$sessionManager = $application->search(SessionManagerInterface::IDENTIFIER);
$authenticationManager = $application->search(AuthenticationManagerInterface::IDENTIFIER);
// inject the sapplication and servlet response
$servletRequest->injectContext($application);
$servletRequest->injectResponse($servletResponse);
$servletRequest->injectSessionManager($sessionManager);
$servletRequest->injectAuthenticationManager($authenticationManager);
// prepare the request instance
$servletRequest->prepare();
// initialize static request and application context
RequestHandler::$requestContext = $servletRequest;
RequestHandler::$applicationContext = $application;
// process the valves
foreach ($valves as $valve) {
$valve->invoke($servletRequest, $servletResponse);
if ($servletRequest->isDispatched() === true) {
break;
}
}
// copy response values to the HTTP response
$response->setState($servletResponse->getState());
$response->setVersion($servletResponse->getVersion());
$response->setStatusCode($servletResponse->getStatusCode());
$response->setStatusReasonPhrase($servletResponse->getStatusReasonPhrase());
// copy the body content to the HTTP response
$response->appendBodyStream($servletResponse->getBodyStream());
// copy headers to the HTTP response
foreach ($servletResponse->getHeaders() as $headerName => $headerValue) {
$response->addHeader($headerName, $headerValue);
}
// copy cookies to the HTTP response
$response->setCookies($servletResponse->getCookies());
// append the servlet engine's signature
$response->addHeader(Protocol::HEADER_X_POWERED_BY, get_class($this), true);
// set response state to be dispatched after this without calling other modules process
$response->setState(HttpResponseStates::DISPATCH);
}
/**
* Process servlet request.
*
* @param \AppserverIo\Psr\HttpMessage\RequestInterface $request A request object
* @param \AppserverIo\Psr\HttpMessage\ResponseInterface $response A response object
* @param \AppserverIo\Server\Interfaces\RequestContextInterface $requestContext A requests context instance
* @param int $hook The current hook to process logic for
*
* @return bool
* @throws \AppserverIo\Server\Exceptions\ModuleException
*/
public function process(RequestInterface $request, ResponseInterface $response, RequestContextInterface $requestContext, $hook)
{
try {
// if false hook is coming do nothing
if (ModuleHooks::REQUEST_POST !== $hook) {
return;
}
// check if we are the handler that has to process this request
if ($requestContext->getServerVar(ServerVars::SERVER_HANDLER) !== $this->getModuleName()) {
return;
}
// initialize servlet session, request + response
$servletRequest = new Request();
$servletRequest->injectHttpRequest($request);
$servletRequest->injectServerVars($requestContext->getServerVars());
// initialize the parts
foreach ($request->getParts() as $part) {
$servletRequest->addPart(Part::fromHttpRequest($part));
}
// set the body content if we can find one
if ($request->getHeader(HttpProtocol::HEADER_CONTENT_LENGTH) > 0) {
$servletRequest->setBodyStream($request->getBodyContent());
}
// prepare the servlet request
$this->prepareServletRequest($servletRequest);
// initialize the servlet response with the Http response values
$servletResponse = new Response();
$servletRequest->injectResponse($servletResponse);
// load the application associated with this request
$application = $this->findRequestedApplication($requestContext);
// prepare and set the applications context path
$servletRequest->setContextPath($contextPath = '/' . $application->getName());
$servletRequest->setServletPath(str_replace($contextPath, '', $servletRequest->getServletPath()));
// prepare the base modifier which allows our apps to provide a base URL
$webappsDir = $this->getServerContext()->getServerConfig()->getDocumentRoot();
$relativeRequestPath = strstr($servletRequest->getServerVar(ServerVars::DOCUMENT_ROOT), $webappsDir);
$proposedBaseModifier = str_replace($webappsDir, '', $relativeRequestPath);
if (strpos($proposedBaseModifier, $contextPath) === 0) {
$servletRequest->setBaseModifier('');
} else {
$servletRequest->setBaseModifier($contextPath);
}
// initialize the request handler instance
$dispatched = false;
$applicationName = $application->getName();
while ($dispatched === false) {
if ($this->requestHandlers[$applicationName][$i = rand(0, 9)]->isWaiting()) {
$this->requestHandlers[$applicationName][$i]->handleRequest($servletRequest, $servletResponse);
$dispatched = true;
break;
}
}
// copy the values from the servlet response back to the HTTP response
$response->setStatusCode($servletResponse->getStatusCode());
$response->setStatusReasonPhrase($servletResponse->getStatusReasonPhrase());
$response->setVersion($servletResponse->getVersion());
$response->setState($servletResponse->getState());
// append the content to the body stream
$response->appendBodyStream($servletResponse->getBodyStream());
// transform the servlet headers back into HTTP headers
$headers = array();
foreach ($servletResponse->getHeaders() as $name => $header) {
$headers[$name] = $header;
}
// set the headers as array (because we don't know if we have to use the append flag)
$response->setHeaders($headers);
// copy the servlet response cookies back to the HTTP response
foreach ($servletResponse->getCookies() as $cookie) {
$response->addCookie(unserialize($cookie));
}
// set response state to be dispatched after this without calling other modules process
$response->setState(HttpResponseStates::DISPATCH);
} catch (ModuleException $me) {
throw $me;
} catch (\Exception $e) {
throw new ModuleException($e, 500);
}
}
/**
* Implement's module logic for given hook
*
* @param \AppserverIo\Psr\HttpMessage\RequestInterface $request A request object
* @param \AppserverIo\Psr\HttpMessage\ResponseInterface $response A response object
* @param \AppserverIo\Server\Interfaces\RequestContextInterface $requestContext A requests context instance
* @param int $hook The current hook to process logic for
*
* @return bool
* @throws \AppserverIo\Server\Exceptions\ModuleException
*/
public function process(RequestInterface $request, ResponseInterface $response, RequestContextInterface $requestContext, $hook)
{
try {
// in php an interface is, by definition, a fixed contract. It is immutable.
// so we have to declair the right ones afterwards...
/**
* @var $request \AppserverIo\Psr\HttpMessage\RequestInterface
*/
/**
* @var $request \AppserverIo\Psr\HttpMessage\ResponseInterface
*/
// if false hook is coming do nothing
if (ModuleHooks::REQUEST_POST !== $hook) {
return;
}
// check if server handler sais php modules should react on this request as file handler
if ($requestContext->getServerVar(ServerVars::SERVER_HANDLER) !== self::MODULE_NAME) {
return;
}
// check if file does not exist
if ($requestContext->hasServerVar(ServerVars::SCRIPT_FILENAME) === false) {
$response->setStatusCode(404);
throw new ModuleException(null, 404);
}
// initialize the event loop
$loop = EventLoopFactory::create();
// invoke the FastCGI request
$this->getFastCgiClient($requestContext, $loop)->done(function (Client $client) use($request, $requestContext, $response) {
// initialize the environment
$env = $this->prepareEnvironment($request, $requestContext);
// initialize the request
$req = $client->newRequest(new RequestParameters($env), new \Crunch\FastCGI\ReaderWriter\StringReader($request->getBodyContent()));
// initialize the response handler
$responseHandler = function ($res) use($response) {
// explode status code, headers and body from the FastCGI response
list($statusCode, $headers, $body) = $this->formatResponse($res->getContent()->read());
// set the headers found in the Fast-CGI response
foreach ($headers as $headerName => $headerValue) {
// if found an array, e. g. for the Set-Cookie header, we add each value
if (is_array($headerValue)) {
foreach ($headerValue as $value) {
$response->addHeader($headerName, $value, true);
}
} else {
$response->addHeader($headerName, $headerValue);
}
}
// initialize the HTTP response with the values
$response->appendBodyStream($body);
$response->setStatusCode($statusCode);
};
// finally send the FastCGI request
$x = $client->sendRequest($req)->then($responseHandler);
// close the FastCGI connection
promise\all([$x])->then(function () use($client) {
$client->close();
});
});
// start the event loop
$loop->run();
// append the X-Powered-By header
$response->addHeader(Protocol::HEADER_X_POWERED_BY, __CLASS__, true);
// set response state to be dispatched after this without calling other modules process
$response->setState(HttpResponseStates::DISPATCH);
} catch (\Exception $e) {
// catch all exceptions
throw new ModuleException($e->getMessage(), $e->getCode());
}
}