@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(); } }