@Override
protected void runInContext() {
HttpContext context = new BasicHttpContext(null);
try {
while (!Thread.interrupted() && _conn.isOpen()) {
_httpService.handleRequest(_conn, context);
_conn.close();
}
} catch (ConnectionClosedException ex) {
if (s_logger.isTraceEnabled()) {
s_logger.trace("ApiServer: Client closed connection");
}
} catch (IOException ex) {
if (s_logger.isTraceEnabled()) {
s_logger.trace("ApiServer: IOException - " + ex);
}
} catch (HttpException ex) {
s_logger.warn("ApiServer: Unrecoverable HTTP protocol violation" + ex);
} finally {
try {
_conn.shutdown();
} catch (IOException ignore) {
}
}
}
@Override
public void run() {
logger.fine("New Connection Thread");
HttpContext context = new BasicHttpContext();
try {
while (!Thread.interrupted() && connection.isOpen()) {
httpService.handleRequest(connection, context);
}
} catch (ConnectionClosedException e) {
logger.warning("Connection closed: " + e.getMessage());
} catch (IOException e) {
logger.warning("I/O error: " + e.getMessage());
} catch (HttpException e) {
logger.warning("Unrecoverable HTTP protocol violation: " + e.getMessage());
} finally {
try {
connection.shutdown();
} catch (IOException e) {
logger.warning("Failed to shut down connection: " + e.getMessage());
}
}
}
private void handleRequest(RequestObject reqObj) {
final Path path = reqObj.getPath();
final HttpServerConnection conn = reqObj.getConn();
final HttpRequest req = reqObj.getRequest();
WebServerLog.log(this, "Request handler got a request:\n" + req.toString());
if (!req.getRequestLine().getMethod().toUpperCase().equals("GET")) {
return;
}
final HttpResponse response =
new BasicHttpResponse(HttpVersion.HTTP_1_1, HttpStatus.SC_OK, ReasonPhrases.OK);
boolean applyFilters;
applyFilters = handleFileRequest(path, response);
if (applyFilters) {
filterChain.reset(path.toString());
filterChain.doFilter(reqObj.getRequest(), response);
}
try {
proc.process(response, new BasicHttpContext());
addContentType(path, response);
} catch (HttpException | IOException e1) {
WebServerLog.log(this, "Request handler failed to 'process' response after filtering");
e1.printStackTrace();
}
WebServerLog.log(this, "Request handler is sending a response:\n" + response.toString());
try {
conn.sendResponseHeader(response);
conn.sendResponseEntity(response);
} catch (HttpException | IOException e) {
WebServerLog.log(this, "Request handler has encountered error while sending response");
e.printStackTrace();
}
}
/**
* Handles receives one HTTP request over the given connection within the given execution context
* and sends a response back to the client.
*
* @param conn the active connection to the client
* @param context the actual execution context.
* @throws IOException in case of an I/O error.
* @throws HttpException in case of HTTP protocol violation or a processing problem.
*/
public void handleRequest(final HttpServerConnection conn, final HttpContext context)
throws IOException, HttpException {
context.setAttribute(ExecutionContext.HTTP_CONNECTION, conn);
HttpResponse response = null;
try {
HttpRequest request = conn.receiveRequestHeader();
request.setParams(new DefaultedHttpParams(request.getParams(), this.params));
ProtocolVersion ver = request.getRequestLine().getProtocolVersion();
if (!ver.lessEquals(HttpVersion.HTTP_1_1)) {
// Downgrade protocol version if greater than HTTP/1.1
ver = HttpVersion.HTTP_1_1;
}
if (request instanceof HttpEntityEnclosingRequest) {
if (((HttpEntityEnclosingRequest) request).expectContinue()) {
response = this.responseFactory.newHttpResponse(ver, HttpStatus.SC_CONTINUE, context);
response.setParams(new DefaultedHttpParams(response.getParams(), this.params));
if (this.expectationVerifier != null) {
try {
this.expectationVerifier.verify(request, response, context);
} catch (HttpException ex) {
response =
this.responseFactory.newHttpResponse(
HttpVersion.HTTP_1_0, HttpStatus.SC_INTERNAL_SERVER_ERROR, context);
response.setParams(new DefaultedHttpParams(response.getParams(), this.params));
handleException(ex, response);
}
}
if (response.getStatusLine().getStatusCode() < 200) {
// Send 1xx response indicating the server expections
// have been met
conn.sendResponseHeader(response);
conn.flush();
response = null;
conn.receiveRequestEntity((HttpEntityEnclosingRequest) request);
}
} else {
conn.receiveRequestEntity((HttpEntityEnclosingRequest) request);
}
}
if (response == null) {
response = this.responseFactory.newHttpResponse(ver, HttpStatus.SC_OK, context);
response.setParams(new DefaultedHttpParams(response.getParams(), this.params));
context.setAttribute(ExecutionContext.HTTP_REQUEST, request);
context.setAttribute(ExecutionContext.HTTP_RESPONSE, response);
this.processor.process(request, context);
doService(request, response, context);
}
// Make sure the request content is fully consumed
if (request instanceof HttpEntityEnclosingRequest) {
HttpEntity entity = ((HttpEntityEnclosingRequest) request).getEntity();
if (entity != null) {
entity.consumeContent();
}
}
} catch (HttpException ex) {
response =
this.responseFactory.newHttpResponse(
HttpVersion.HTTP_1_0, HttpStatus.SC_INTERNAL_SERVER_ERROR, context);
response.setParams(new DefaultedHttpParams(response.getParams(), this.params));
handleException(ex, response);
}
this.processor.process(response, context);
conn.sendResponseHeader(response);
conn.sendResponseEntity(response);
conn.flush();
if (!this.connStrategy.keepAlive(response, context)) {
conn.close();
}
}
