@Override
public void handle(HttpServletRequest request, HttpServletResponse response) throws IOException {
final StatusCodeMatcher matchedCode =
getMatchingStatusCode(String.valueOf(response.getStatus()));
final MutableHttpServletRequest mutableRequest = MutableHttpServletRequest.wrap(request);
MediaRangeProcessor processor =
new MediaRangeProcessor(mutableRequest.getPreferredHeaders("Accept", DEFAULT_TYPE));
if (!isInitialized()) {
response.sendError(
HttpStatusCode.SERVICE_UNAVAIL.intValue(), "Error creating Response Messaging service.");
} else {
if (matchedCode != null) {
HttpLogFormatter formatter = null;
Message message = null;
List<MediaType> mediaTypes = processor.process();
message = MessageFilter.filterByMediaType(matchedCode.getMessage(), mediaTypes);
if (message != null) {
formatter = getHttpLogFormatter(matchedCode, message.getMediaType());
if (formatter != null) {
if (!(configSetToIfEmpty(matchedCode) && hasBody(response))) {
final String formattedOutput = formatter.format("", request, response).trim();
overwriteResponseBody(response, formattedOutput, message.getContentType());
}
} else {
LOG.info(
"No formatter found for message code. Skipping Response Message Service formatting for status code regex "
+ matchedCode.getCodeRegex());
}
} else {
LOG.info(
"Message for Matched code is empty. Matched Code is :" + matchedCode.getCodeRegex());
}
}
}
}
@Override
public FilterDirector handleRequest(
HttpServletRequest request, ReadableHttpServletResponse response) {
final FilterDirector director = new FilterDirectorImpl();
MutableHttpServletRequest mutableRequest = MutableHttpServletRequest.wrap(request);
MediaRangeProcessor processor =
new MediaRangeProcessor(
mutableRequest.getPreferredHeaders(CommonHttpHeader.ACCEPT.toString(), DEFAULT_TYPE));
List<MediaType> mediaTypes = processor.process();
if (requestHasExpectedHeaders(request)) {
originalPreferredAccept = getPreferredMediaType(mediaTypes);
MediaType preferredMediaType = originalPreferredAccept;
final String requestUri = request.getRequestURI();
// request now considered valid with user.
director.setFilterAction(FilterAction.PASS);
// Record limits
final boolean pass = recordLimitedRequest(request, director);
// Does the request match the configured getCurrentLimits API call endpoint?
if (pass && describeLimitsUriPattern.matcher(requestUri).matches()) {
describeLimitsForRequest(request, director, preferredMediaType);
}
} else {
LOG.warn(
"Expected header: "
+ PowerApiHeader.USER.toString()
+ " was not supplied in the request. Rate limiting requires this header to operate.");
// Auto return a 401 if the request does not meet expectations
director.setResponseStatus(HttpStatusCode.UNAUTHORIZED);
director.setFilterAction(FilterAction.RETURN);
}
return director;
}
@Override
public FilterDirector handleRequest(
HttpServletRequest httpRequest, ReadableHttpServletResponse httpResponse) {
MutableHttpServletRequest request = MutableHttpServletRequest.wrap(httpRequest);
MutableHttpServletResponse response =
MutableHttpServletResponse.wrap(httpRequest, httpResponse);
FilterDirector filterDirector = new FilterDirectorImpl();
MediaType contentType = getContentType(request.getHeaderValue("content-type"));
List<MediaType> acceptValues =
getAcceptValues(request.getPreferredHeaders("Accept", DEFAULT_TYPE));
List<XmlChainPool> pools =
getHandlerChainPool(request.getMethod(), contentType, acceptValues, "", requestProcessors);
if (pools.isEmpty()) {
filterDirector.setFilterAction(FilterAction.PROCESS_RESPONSE);
return filterDirector;
}
try {
ServletInputStream in = request.getInputStream();
TranslationResult result = null;
for (XmlChainPool pool : pools) {
final ByteBuffer internalBuffer = new CyclicByteBuffer(DEFAULT_BUFFER_SIZE, true);
result =
pool.executePool(
new TranslationPreProcessor(in, contentType, true).getBodyStream(),
new ByteBufferServletOutputStream(internalBuffer),
getInputParameters(TranslationType.REQUEST, request, response, result));
if (result.isSuccess()) {
in = new ByteBufferInputStream(internalBuffer);
request.setInputStream(in);
result.applyResults(filterDirector);
if (StringUtilities.isNotBlank(pool.getResultContentType())) {
filterDirector
.requestHeaderManager()
.putHeader("content-type", pool.getResultContentType());
contentType = getContentType(pool.getResultContentType());
}
filterDirector.setFilterAction(FilterAction.PROCESS_RESPONSE);
} else {
filterDirector.setResponseStatus(HttpStatusCode.BAD_REQUEST);
filterDirector.setFilterAction(FilterAction.RETURN);
break;
}
}
} catch (IOException ex) {
LOG.error("Error executing request transformer chain", ex);
filterDirector.setResponseStatus(HttpStatusCode.INTERNAL_SERVER_ERROR);
filterDirector.setFilterAction(FilterAction.RETURN);
}
return filterDirector;
}
private List<XsltParameter> getInputParameters(
final TranslationType type,
final MutableHttpServletRequest request,
final MutableHttpServletResponse response,
final TranslationResult lastResult) {
List<XsltParameter> inputs = new ArrayList<XsltParameter>();
inputs.add(new XsltParameter("request", request));
inputs.add(new XsltParameter("response", response));
inputs.add(new XsltParameter("requestId", request.getRequestId()));
inputs.add(new XsltParameter("responseId", response.getResponseId()));
if (lastResult != null) {
if (lastResult.getRequestInfo() != null) {
inputs.add(new XsltParameter("requestInfo", lastResult.getRequestInfo()));
}
if (lastResult.getHeaders() != null) {
inputs.add(new XsltParameter("headers", lastResult.getHeaders()));
}
if (lastResult.getQueryParameters() != null) {
inputs.add(new XsltParameter("queryParams", lastResult.getQueryParameters()));
}
}
final String id;
if (type == TranslationType.REQUEST) {
id = request.getRequestId();
} else {
id = response.getResponseId();
}
/* Input/Output URIs */
inputs.add(new XsltParameter("input-headers-uri", "repose:input:headers:" + id));
inputs.add(new XsltParameter("input-query-uri", "repose:input:query:" + id));
inputs.add(new XsltParameter("input-request-uri", "repose:input:request:" + id));
inputs.add(new XsltParameter("output-headers-uri", "repose:output:headers.xml"));
inputs.add(new XsltParameter("output-query-uri", "repose:output:query.xml"));
inputs.add(new XsltParameter("output-request-uri", "repose:output:request.xml"));
return inputs;
}
@Override
public void route(
MutableHttpServletRequest servletRequest, MutableHttpServletResponse servletResponse)
throws IOException, ServletException, URISyntaxException {
DestinationLocation location = null;
if (!StringUtilities.isBlank(defaultDst)) {
servletRequest.addDestination(defaultDst, servletRequest.getRequestURI(), -1);
}
RouteDestination routingDestination = servletRequest.getDestination();
String rootPath = "";
if (routingDestination != null) {
Destination configDestinationElement =
destinations.get(routingDestination.getDestinationId());
if (configDestinationElement == null) {
LOG.warn(
"Invalid routing destination specified: "
+ routingDestination.getDestinationId()
+ " for domain: "
+ domain.getId());
((HttpServletResponse) servletResponse).setStatus(HttpStatusCode.NOT_FOUND.intValue());
} else {
location =
locationBuilder.build(
configDestinationElement, routingDestination.getUri(), servletRequest);
rootPath = configDestinationElement.getRootPath();
}
}
if (location != null) {
// According to the Java 6 javadocs the routeDestination passed into getContext:
// "The given path [routeDestination] must begin with /, is interpreted relative to the
// server's document root
// and is matched against the context roots of other web applications hosted on this
// container."
final ServletContext targetContext = context.getContext(location.getUri().toString());
if (targetContext != null) {
// Capture this for Location header processing
final HttpServletRequest originalRequest = (HttpServletRequest) servletRequest.getRequest();
String uri =
new DispatchPathBuilder(location.getUri().getPath(), targetContext.getContextPath())
.build();
final RequestDispatcher dispatcher = targetContext.getRequestDispatcher(uri);
servletRequest.setRequestUrl(new StringBuffer(location.getUrl().toExternalForm()));
servletRequest.setRequestUri(location.getUri().getPath());
requestHeaderService.setVia(servletRequest);
requestHeaderService.setXForwardedFor(servletRequest);
if (dispatcher != null) {
LOG.debug("Attempting to route to " + location.getUri());
LOG.debug("Request URL: " + ((HttpServletRequest) servletRequest).getRequestURL());
LOG.debug("Request URI: " + ((HttpServletRequest) servletRequest).getRequestURI());
LOG.debug("Context path = " + targetContext.getContextPath());
final long startTime = System.currentTimeMillis();
try {
reportingService.incrementRequestCount(routingDestination.getDestinationId());
dispatcher.forward(servletRequest, servletResponse);
final long stopTime = System.currentTimeMillis();
reportingService.recordServiceResponse(
routingDestination.getDestinationId(),
servletResponse.getStatus(),
(stopTime - startTime));
responseHeaderService.fixLocationHeader(
originalRequest,
servletResponse,
routingDestination,
location.getUri().toString(),
rootPath);
} catch (ClientHandlerException e) {
if (e.getCause() instanceof ReadLimitReachedException) {
LOG.error("Error reading request content", e);
servletResponse.sendError(
HttpStatusCode.REQUEST_ENTITY_TOO_LARGE.intValue(),
"Error reading request content");
servletResponse.setLastException(e);
} else {
LOG.error("Connection Refused to " + location.getUri() + " " + e.getMessage(), e);
((HttpServletResponse) servletResponse)
.setStatus(HttpStatusCode.SERVICE_UNAVAIL.intValue());
}
}
}
}
}
}
@Override
public FilterDirector handleResponse(
HttpServletRequest httpRequest, ReadableHttpServletResponse httpResponse) {
MutableHttpServletRequest request = MutableHttpServletRequest.wrap(httpRequest);
MutableHttpServletResponse response =
MutableHttpServletResponse.wrap(httpRequest, httpResponse);
final FilterDirector filterDirector = new FilterDirectorImpl();
filterDirector.setFilterAction(FilterAction.PASS);
MediaType contentType = getContentType(response.getHeaderValue("Content-Type"));
List<MediaType> acceptValues =
getAcceptValues(request.getPreferredHeaders("Accept", DEFAULT_TYPE));
List<XmlChainPool> pools =
getHandlerChainPool(
"",
contentType,
acceptValues,
String.valueOf(response.getStatus()),
responseProcessors);
if (pools.isEmpty()) {
filterDirector.setResponseStatusCode(response.getStatus());
return filterDirector;
}
try {
filterDirector.setResponseStatusCode(response.getStatus());
if (response.hasBody()) {
InputStream in = response.getBufferedOutputAsInputStream();
TranslationResult result = null;
for (XmlChainPool pool : pools) {
if (in.available() > 0) {
result =
pool.executePool(
new TranslationPreProcessor(in, contentType, true).getBodyStream(),
filterDirector.getResponseOutputStream(),
getInputParameters(TranslationType.RESPONSE, request, response, result));
if (result.isSuccess()) {
result.applyResults(filterDirector);
if (StringUtilities.isNotBlank(pool.getResultContentType())) {
filterDirector
.requestHeaderManager()
.putHeader("content-type", pool.getResultContentType());
contentType = getContentType(pool.getResultContentType());
}
in = new ByteArrayInputStream(filterDirector.getResponseMessageBodyBytes());
} else {
filterDirector.setResponseStatus(HttpStatusCode.INTERNAL_SERVER_ERROR);
response.setContentLength(0);
filterDirector.responseHeaderManager().removeHeader("Content-Length");
break;
}
}
}
}
} catch (IOException ex) {
LOG.error("Error executing response transformer chain", ex);
filterDirector.setResponseStatus(HttpStatusCode.INTERNAL_SERVER_ERROR);
response.setContentLength(0);
}
return filterDirector;
}
