public IgniteRequest Parse(String rawRequest)
{
//Console.Write("IgniteRequestParser@Parse | Starting parsing of request {0}", rawRequest);
String[] hBPartials = rawRequest.Split(ParserConstants.REQUEST_HEADERS_DELIMETER);
String[] partials = hBPartials[0].Split(ParserConstants.REQUEST_META_DELIMETER);
//Console.WriteLine("IgniteRequestParser@Parse | {0}, {1}", hBPartials[0]);
// Console.WriteLine("LENGTH {0}", partials[4]);
String[] coreMetaPart = partials[0].Split(" ");
StringBuilder rawHeaders = new StringBuilder();
for (int i = 1; i < partials.Length; i++)
{
rawHeaders.Append(partials[i]);
if (partials.Length - 1 != i)
{
rawHeaders.Append(HeadersParser.HEADERS_DELIMETER);
}
}
logger.debug("IgniteRequestParser@Parse | raw core meta part {0}, {1}, {2}", coreMetaPart[0], coreMetaPart[1], coreMetaPart[2]);
logger.debug("IgniteRequestParser@Parse | headers part \n{0}", rawHeaders.ToString());
Dictionary <String, String> headers = headersParser.Parse(rawHeaders.ToString());
//Console.WriteLine("IgniteRequestParser@Parse | parsed headers {0}", headers);
IgniteRequest request = IgniteRequestFactory.GetInstance();
request.setMethod(coreMetaPart[0]);
request.setRoute(coreMetaPart[1]);
request.setHttpVersion(coreMetaPart[2]);
request.setHeaders(headers);
// if get request skip body parsing
if (!coreMetaPart[0].Equals(HttpMethod.GET))
{
String rawBody = hBPartials[1];
logger.debug("IgniteRequestParser@Parse | body part {0}", rawBody);
Dictionary <String, String> body = bodyParser.Parse(rawBody);
//Console.WriteLine("IgniteRequestParser@Parse | parsed body {0}", body);
request.setBody(body);
}
//Console.Write("IgniteRequestParser@Parse | created request {0}", request);
return(request);
}
// static http request proccessing logic
public async Task <IgniteResponse> proccess(IgniteRequest request)
{
// get resource name from route
String route = request.getRoute();
String[] routePath = route.Split("/");
if (route == "/")
{
logger.debug("StaticHttpProccessor@proccess | default route, servinc default page {0}", DEFAULT_PATH);
route = DEFAULT_PATH;
}
else if (routePath[routePath.Length - 1].Split(".").Length == 1)
{
// if last path part don't have extension add default
logger.debug("StaticHttpProccessor@proccess | no extension, adding default", DEFAULT_EXTENSION);
route = route + DEFAULT_EXTENSION;
}
// reverse slashes ;)
route = route.Replace("/", "\\");
logger.info("StaticHttpProccessor@proccess | route {0}", route);
// get configured working directory from configuration file
ConfigurationService configService = await ConfigurationService.getInstance();
IgniteConfiguration config = configService.getCoreServerConfig();
//Console.WriteLine("StaticHttpProccessor@proccess | config {0}", config);
String staticDataDir = config.getProperty(STATIC_DIR_PROP_NAME);
// get file by filename
try {
var file = await FileSystemService.readFullFile(staticDataDir + route);
logger.debug("StatichttpProccessor@proccess | file finded", file);
IgniteResponse response = IgniteResponseFactory.getInstance();
response.setBody(file);
// set MIME TYPE
String MIME = MIMEType.getMIMETypeByExtension(getFileExtensionByRoute(route));
response.getHeaders()[HttpHeaders.ContentLength] = " " + file.Length.ToString();
response.getHeaders()[HttpHeaders.ContentType] = " " + MIME;
return(response);
} catch (FileNotFoundException e) {
logger.warn("StaticHttpProccessor@proccess | no file finded by path {0}, reutning 404", staticDataDir + route);
return(IgniteResponseFactory.getInstance(new IgniteResponseStatus(HttpStatus.NOT_FOUND, HttpStatus.NOT_FOUND_MESSAGE)));
}
}
// core request engine low level validation logic
public static IgniteResponseStatus validate(IgniteRequest request)
{
// not valid version
if (!request.getHttpVersion().Equals(validHttpVersion))
{
Console.WriteLine("IgniteERquestValidatorService@validate | http version not valid, sending 400");
return(new IgniteResponseStatus(HttpStatus.BAD_REQUEST, HttpStatus.BAD_REQUEST_MESSAGE));
}
if (request.getRoute().Equals(""))
{
logger.warn("IgniteERquestValidatorService@validate | route not valid, sending 400");
return(new IgniteResponseStatus(HttpStatus.BAD_REQUEST, HttpStatus.BAD_REQUEST_MESSAGE));
}
if (!request.getMethod().Equals(HttpMethod.GET) && !request.getHeaders().ContainsKey(HttpHeaders.ContentLength))
{
logger.warn("IgniteERquestValidatorService@validate | no content length header sending 411");
return(new IgniteResponseStatus(HttpStatus.LENGTH_REQUIRED, HttpStatus.LENGTH_REQUIRED_MESSAGE));
}
// not supported method
if (HttpMethod.getAvalibleMethods().IndexOf(request.getMethod()) == -1)
{
logger.warn("IgniteERquestValidatorService@validate | not allowed method, sending 501");
return(new IgniteResponseStatus(HttpStatus.NOT_IMPLEMENTED, HttpStatus.NOT_IMPLEMENTED_MESSAGE));
}
Dictionary <String, String> headers = request.getHeaders();
foreach (KeyValuePair <String, String> entry in headers)
{
if (entry.Key.Equals("") || entry.Value.Equals(""))
{
logger.warn("IgniteERquestValidatorService@validate | headers not valid, sending 400");
return(new IgniteResponseStatus(HttpStatus.BAD_REQUEST, HttpStatus.BAD_REQUEST_MESSAGE));
}
}
return(new IgniteResponseStatus(HttpStatus.OK, HttpStatus.OK_MESSAGE));
}
public async static void ReadCallback(IAsyncResult ar)
{
String content = String.Empty;
// Retrieve the state object and the handler socket
// from the asynchronous state object.
StateObject state = (StateObject)ar.AsyncState;
Socket handler = state.workSocket;
// Read data from the client socket.
int bytesRead = handler.EndReceive(ar);
//Console.WriteLine("AsyncEngine@ReadCallback | readed bytes {0}", bytesRead);
// catch every exception on server and send 500 if exception occured
try {
if (bytesRead > 0)
{
// There might be more data, so store the data received so far.
state.sb.Append(Encoding.ASCII.GetString(
state.buffer, 0, bytesRead));
// Check for end-of-file tag. If it is not there, read
// more data.
content = state.sb.ToString();
//Console.WriteLine("Content | {0}", content);
// if readed bytes >= BUFFER_SIZE -> read more bytes
if (bytesRead != 1024)
{
// All the data has been read from the
// client. Display it on the console.
logger.info("AsyncEngine@ReadCallback | Read {0} bytes from socket",
content.Length);
logger.info("AsyncEngine@ReadCallback | Raw Request \n{0}", content);
IgniteRequest request = requestParser.Parse(content);
IgniteResponseStatus status = IgniteRequestValidatorService.validate(request);
if (status.getCode() != HttpStatus.OK)
{
logger.warn("AsyncEngine@ReadCallback | request not valid {0}:{1}", status.getCode(), status.getMessage());
IgniteResponse failedResponse = IgniteResponseFactory.getInstance(status);
String rawResponse = responseParser.stringify(failedResponse);
logger.info("\n\nAsyncEngine@ReadCallback | raw response \n {0}", rawResponse);
Send(handler, rawResponse);
}
else
{
//Console.WriteLine("AsyncEngine@ReadCallback | request valid");
//Console.WriteLine("AsyncEngine@ReadCallback | Parsed request {0}", request);
Proccessor proccessor = ProccessorFactory.getInstance();
IgniteResponse response = await proccessor.proccess(request);
String rawResponse = responseParser.stringify(response);
logger.info("AsyncEngine@ReadCallback | raw response \n{0}", rawResponse);
Send(handler, rawResponse);
}
}
else
{
// Not all data received. Get more.
handler.BeginReceive(state.buffer, 0, StateObject.BufferSize, 0,
new AsyncCallback(ReadCallback), state);
}
}
} catch (Exception e) {
logger.error("AsyncEngine@ReadCallback | Server erorr occured {0}", e);
IgniteResponse failedResponse = IgniteResponseFactory.getInstance(new IgniteResponseStatus(HttpStatus.SERVER_ERROR, HttpStatus.SERVER_ERROR_MESSAGE));
String rawResponse = responseParser.stringify(failedResponse);
logger.info("AsyncEngine@ReadCallback | raw response \n", rawResponse);
Send(handler, rawResponse);
}
}
