use of org.openecard.apache.http.HttpResponse in project open-ecard by ecsec.
the class IndexHandler method handle.
@Override
public HttpResponse handle(HttpRequest httpRequest) throws HttpException, Exception {
HttpResponse httpResponse = new Http11Response(HttpStatus.SC_SEE_OTHER);
httpResponse.setHeader(HeaderTypes.LOCATION.fieldName(), "/index.html");
return httpResponse;
}
use of org.openecard.apache.http.HttpResponse in project open-ecard by ecsec.
the class StreamHttpClientConnectionTest method consumeEntity.
private void consumeEntity(StreamHttpClientConnection conn, String hostName, int numIt) throws IOException, HttpException {
HttpContext ctx = new BasicHttpContext();
HttpRequestExecutor httpexecutor = new HttpRequestExecutor();
HttpResponse response = null;
DefaultConnectionReuseStrategy reuse = new DefaultConnectionReuseStrategy();
int i = 0;
while (i == 0 || (i < numIt && reuse.keepAlive(response, ctx))) {
i++;
// send request and receive response
HttpRequest request = new BasicHttpRequest("GET", "/");
HttpRequestHelper.setDefaultHeader(request, hostName);
response = httpexecutor.execute(request, conn, ctx);
conn.receiveResponseEntity(response);
HttpEntity entity = response.getEntity();
assertNotNull(entity);
// consume entity
byte[] content = FileUtils.toByteArray(entity.getContent());
// read header and check if content size is correct
Header lengthHeader = response.getFirstHeader("Content-Length");
long length = Long.parseLong(lengthHeader.getValue());
assertNotNull(lengthHeader);
assertEquals(entity.getContentLength(), length);
assertEquals(content.length, length);
// consume everything from the entity and close stream
EntityUtils.consume(entity);
}
}
use of org.openecard.apache.http.HttpResponse in project open-ecard by ecsec.
the class PAOS method sendStartPAOS.
/**
* Sends start PAOS and answers all successor messages to the server associated with this instance.
* Messages are exchanged until the server replies with a {@code StartPAOSResponse} message.
*
* @param message The StartPAOS message which is sent in the first message.
* @return The {@code StartPAOSResponse} message from the server.
* @throws DispatcherException In case there errors with the message conversion or the dispatcher.
* @throws PAOSException In case there were errors in the transport layer.
* @throws PAOSConnectionException
*/
public StartPAOSResponse sendStartPAOS(StartPAOS message) throws DispatcherException, PAOSException, PAOSConnectionException {
Object msg = message;
StreamHttpClientConnection conn = null;
HttpContext ctx = new BasicHttpContext();
HttpRequestExecutor httpexecutor = new HttpRequestExecutor();
DefaultConnectionReuseStrategy reuse = new DefaultConnectionReuseStrategy();
boolean connectionDropped = false;
ResponseBaseType lastResponse = null;
try {
// loop and send makes a computer happy
while (true) {
// set up connection to PAOS endpoint
// if this one fails we may not continue
conn = openHttpStream();
boolean isReusable;
// send as long as connection is valid
try {
do {
// save the last message we sent to the eID-Server.
if (msg instanceof ResponseBaseType) {
lastResponse = (ResponseBaseType) msg;
}
// prepare request
String resource = tlsHandler.getResource();
BasicHttpEntityEnclosingRequest req = new BasicHttpEntityEnclosingRequest("POST", resource);
HttpRequestHelper.setDefaultHeader(req, tlsHandler.getServerAddress());
req.setHeader(HEADER_KEY_PAOS, headerValuePaos);
req.setHeader("Accept", "text/xml, application/xml, application/vnd.paos+xml");
ContentType reqContentType = ContentType.create("application/vnd.paos+xml", "UTF-8");
HttpUtils.dumpHttpRequest(LOG, "before adding content", req);
String reqMsgStr = createPAOSResponse(msg);
StringEntity reqMsg = new StringEntity(reqMsgStr, reqContentType);
req.setEntity(reqMsg);
req.setHeader(reqMsg.getContentType());
req.setHeader("Content-Length", Long.toString(reqMsg.getContentLength()));
// send request and receive response
LOG.debug("Sending HTTP request.");
HttpResponse response = httpexecutor.execute(req, conn, ctx);
LOG.debug("HTTP response received.");
int statusCode = response.getStatusLine().getStatusCode();
try {
checkHTTPStatusCode(statusCode);
} catch (PAOSConnectionException ex) {
// response with error. So check the status of our last response to the eID-Server
if (lastResponse != null) {
WSHelper.checkResult(lastResponse);
}
throw ex;
}
conn.receiveResponseEntity(response);
HttpEntity entity = response.getEntity();
byte[] entityData = FileUtils.toByteArray(entity.getContent());
HttpUtils.dumpHttpResponse(LOG, response, entityData);
// consume entity
Object requestObj = processPAOSRequest(new ByteArrayInputStream(entityData));
// break when message is startpaosresponse
if (requestObj instanceof StartPAOSResponse) {
StartPAOSResponse startPAOSResponse = (StartPAOSResponse) requestObj;
// an ok.
if (lastResponse != null) {
WSHelper.checkResult(lastResponse);
}
WSHelper.checkResult(startPAOSResponse);
return startPAOSResponse;
}
// send via dispatcher
msg = dispatcher.deliver(requestObj);
// check if connection can be used one more time
isReusable = reuse.keepAlive(response, ctx);
connectionDropped = false;
} while (isReusable);
} catch (IOException ex) {
if (!connectionDropped) {
connectionDropped = true;
LOG.warn("PAOS server closed the connection. Trying to connect again.");
} else {
String errMsg = "Error in the link to the PAOS server.";
LOG.error(errMsg);
throw new PAOSException(DELIVERY_FAILED, ex);
}
}
}
} catch (HttpException ex) {
throw new PAOSException(DELIVERY_FAILED, ex);
} catch (SOAPException ex) {
throw new PAOSException(SOAP_MESSAGE_FAILURE, ex);
} catch (MarshallingTypeException ex) {
throw new PAOSDispatcherException(MARSHALLING_ERROR, ex);
} catch (InvocationTargetException ex) {
throw new PAOSDispatcherException(DISPATCHER_ERROR, ex);
} catch (TransformerException ex) {
throw new DispatcherException(ex);
} catch (WSException ex) {
throw new PAOSException(ex);
} finally {
try {
if (conn != null) {
conn.close();
}
} catch (IOException ex) {
// throw new PAOSException(ex);
}
}
}
use of org.openecard.apache.http.HttpResponse in project open-ecard by ecsec.
the class ControlCommonHandler method handle.
/**
* Handles a HTTP request.
*
* @param request HttpRequest
* @param response HttpResponse
* @param context HttpContext
* @throws HttpException
* @throws IOException
*/
@Override
public void handle(HttpRequest request, HttpResponse response, HttpContext context) throws HttpException, IOException {
_logger.debug("HTTP request: {}", request.toString());
HttpResponse httpResponse = null;
try {
// Forward request parameters to response parameters
response.setParams(request.getParams());
httpResponse = handle(request);
} catch (org.openecard.control.binding.http.HttpException e) {
httpResponse = new Http11Response(HttpStatus.SC_BAD_REQUEST);
httpResponse.setEntity(new StringEntity(e.getMessage(), "UTF-8"));
if (e.getMessage() != null && !e.getMessage().isEmpty()) {
httpResponse.setEntity(new StringEntity(e.getMessage(), "UTF-8"));
}
httpResponse.setStatusCode(e.getHTTPStatusCode());
} catch (Exception e) {
httpResponse = new Http11Response(HttpStatus.SC_INTERNAL_SERVER_ERROR);
_logger.error(e.getMessage(), e);
} finally {
Http11Response.copyHttpResponse(httpResponse, response);
_logger.debug("HTTP response: {}", response);
_logger.debug("HTTP request handled by: {}", this.getClass().getName());
}
}
use of org.openecard.apache.http.HttpResponse in project open-ecard by ecsec.
the class ChipGateway method sendMessage.
private <T> T sendMessage(String resource, String msg, Class<T> resClass, boolean tryAgain) throws ConnectionError, InvalidRedirectUrlException, ChipGatewayDataError {
try {
// open initial connection
if (conn == null || !canReuse || (!conn.isOpen() && canReuse)) {
openHttpStream();
}
// prepare request
BasicHttpEntityEnclosingRequest req = new BasicHttpEntityEnclosingRequest("POST", resource);
HttpRequestHelper.setDefaultHeader(req, tlsHandler.getServerAddress());
req.setHeader("Accept", "application/json");
ContentType reqContentType = ContentType.create("application/json", "UTF-8");
if (LOG_HTTP_MESSAGES) {
HttpUtils.dumpHttpRequest(LOG, "before adding content", req);
}
StringEntity reqMsg = new StringEntity(msg, reqContentType);
req.setEntity(reqMsg);
req.setHeader(reqMsg.getContentType());
req.setHeader("Content-Length", Long.toString(reqMsg.getContentLength()));
if (LOG_HTTP_MESSAGES) {
LOG.debug(msg);
}
// send request and receive response
LOG.debug("Sending HTTP request.");
HttpResponse response = httpExecutor.execute(req, conn, httpCtx);
canReuse = reuseStrategy.keepAlive(response, httpCtx);
LOG.debug("HTTP response received.");
int statusCode = response.getStatusLine().getStatusCode();
checkHTTPStatusCode(statusCode);
conn.receiveResponseEntity(response);
HttpEntity entity = response.getEntity();
byte[] entityData = FileUtils.toByteArray(entity.getContent());
if (LOG_HTTP_MESSAGES) {
HttpUtils.dumpHttpResponse(LOG, response, entityData);
}
// convert entity and return it
T resultObj = parseResultObj(entityData, resClass);
return resultObj;
} catch (IOException ex) {
if (!Thread.currentThread().isInterrupted() && tryAgain) {
String errorMsg = "ChipGateway server closed the connection. Trying to connect again.";
if (LOG.isDebugEnabled()) {
LOG.debug(errorMsg, ex);
} else {
LOG.info(errorMsg);
}
canReuse = false;
return sendMessage(resource, msg, resClass, false);
} else {
throw new ConnectionError(token.finalizeErrorAddress(ResultMinor.COMMUNICATION_ERROR), CONNECTION_OPEN_FAILED, ex);
}
} catch (HttpException ex) {
throw new ConnectionError(token.finalizeErrorAddress(ResultMinor.SERVER_ERROR), HTTP_ERROR, ex);
}
}
Aggregations