/*
* Creates the URL based on the configured host, port, and services context root path.
*/
private UriBuilder generateEndpointUrl(String path, UriBuilder uriBuilder)
throws UnknownHostException {
UriBuilder builder = uriBuilder;
if (host != null && port != null && servicesContextRoot != null) {
builder = builder.host(host);
try {
int portInt = Integer.parseInt(port);
builder = builder.port(portInt);
} catch (NumberFormatException nfe) {
LOGGER.debug(
"Cannot convert the current DDF port: {} to an integer."
+ " Defaulting to port in invocation.",
port);
throw new UnknownHostException("Unable to determine port DDF is using.");
}
builder = builder.replacePath(path);
} else {
LOGGER.debug("DDF Port is null, unable to determine host DDF is running on.");
throw new UnknownHostException("Unable to determine port DDF is using.");
}
return builder;
}
/**
* Get the URL for an asset on this server
*
* @return the asset URL
*/
protected static URL getAssetURL(UriBuilder builder, String moduleName, String assetPath)
throws MalformedURLException {
// Should we fetch the context prefix from a property? XXX -jslott
String assetPrefix = "webdav/content/modules/installed/";
builder.replacePath(assetPrefix + moduleName + "/" + assetPath);
return builder.build().toURL();
}
private com.sun.jersey.api.client.WebResource makeResource(String path) {
com.sun.jersey.api.client.WebResource resource = resource();
UriBuilder b = resource.getUriBuilder();
if (path.startsWith("/")) {
b.replacePath(path);
} else {
b.path(path);
}
URI uri = b.build();
return resource.uri(uri);
}
private void _test(ClientRequest request, UriBuilder uriBuilder, String path) {
request.clear();
uriBuilder.replacePath(generateURL(path));
try {
ClientResponse<String> response = request.get(String.class);
Assert.assertEquals(HttpResponseCodes.SC_OK, response.getStatus());
MultivaluedMap<String, String> headers = response.getHeaders();
for (Object key : headers.keySet()) {
System.out.println(key + ": " + headers.get(key));
}
response.releaseConnection();
} catch (Exception e) {
throw new RuntimeException(e);
}
}
private Kml createRootNetworkLink(UriInfo uriInfo) throws UnknownHostException {
Kml kml = KmlFactory.createKml();
NetworkLink rootNetworkLink = kml.createAndSetNetworkLink();
rootNetworkLink.setName(this.productName);
rootNetworkLink.setSnippet(KmlFactory.createSnippet().withMaxLines(0));
UriBuilder baseUrlBuidler = UriBuilder.fromUri(uriInfo.getBaseUri());
baseUrlBuidler.replacePath("");
this.baseUrl = baseUrlBuidler.build().toString();
String descriptionHtml = description;
Handlebars handlebars = new Handlebars(templateLoader);
try {
Template template = handlebars.compile("description");
descriptionHtml = template.apply(this);
LOGGER.debug(descriptionHtml);
} catch (IOException e) {
LOGGER.error("Failed to apply description Template", e);
}
rootNetworkLink.setDescription(descriptionHtml);
rootNetworkLink.setOpen(true);
rootNetworkLink.setVisibility(false);
Link link = rootNetworkLink.createAndSetLink();
UriBuilder builder = UriBuilder.fromUri(uriInfo.getBaseUri());
builder =
generateEndpointUrl(
servicesContextRoot
+ FORWARD_SLASH
+ CATALOG_URL_PATH
+ FORWARD_SLASH
+ KML_TRANSFORM_PARAM
+ FORWARD_SLASH
+ "sources",
builder);
link.setHref(builder.build().toString());
link.setViewRefreshMode(ViewRefreshMode.NEVER);
link.setRefreshMode(RefreshMode.ON_INTERVAL);
link.setRefreshInterval(REFRESH_INTERVAL);
return kml;
}
private void doFilter(
HttpServletRequest request,
HttpServletResponse response,
FilterChain chain,
String requestURI,
String servletPath,
String queryString)
throws IOException, ServletException {
// if we match the static content regular expression lets delegate to
// the filter chain to use the default container servlets & handlers
final Pattern p = getStaticContentPattern();
if (p != null && p.matcher(servletPath).matches()) {
chain.doFilter(request, response);
return;
}
if (filterContextPath != null) {
if (!servletPath.startsWith(filterContextPath)) {
throw new ContainerException(
LocalizationMessages.SERVLET_PATH_MISMATCH(servletPath, filterContextPath));
// TODO:
// } else if (servletPath.length() == filterContextPath.length()) {
// // Path does not end in a slash, may need to redirect
// if
// (webComponent.getResourceConfig().getFeature(ResourceConfig.FEATURE_REDIRECT)) {
// URI l = UriBuilder.fromUri(request.getRequestURL().toString()).
// path("/").
// replaceQuery(queryString).build();
//
// response.setStatus(307);
// response.setHeader("Location", l.toASCIIString());
// return;
// } else {
// requestURI += "/";
// }
}
}
final UriBuilder absoluteUriBuilder = UriBuilder.fromUri(request.getRequestURL().toString());
final URI baseUri =
(filterContextPath == null)
? absoluteUriBuilder.replacePath(request.getContextPath()).path("/").build()
: absoluteUriBuilder
.replacePath(request.getContextPath())
.path(filterContextPath)
.path("/")
.build();
final URI requestUri =
absoluteUriBuilder.replacePath(requestURI).replaceQuery(queryString).build();
final int status = service(baseUri, requestUri, request, response).get();
// If forwarding is configured and response is a 404 with no entity
// body then call the next filter in the chain
if (webComponent.forwardOn404 && status == 404 && !response.isCommitted()) {
// lets clear the response to OK before we forward to the next in the chain
// as OK is the default set by servlet containers before filters/servlets do any wor
// so lets hide our footsteps and pretend we were never in the chain at all and let the
// next filter or servlet return the 404 if they can't find anything to return
//
// We could add an optional flag to disable this step if anyone can ever find a case where
// this causes a problem, though I suspect any problems will really be with downstream
// servlets not correctly setting an error status if they cannot find something to return
response.setStatus(HttpServletResponse.SC_OK);
chain.doFilter(request, response);
}
}
/**
* Receives standard HTTP requests from the public {@code service} method and dispatches them to
* the {@code do}<i>XXX</i> methods defined in this class. This method is an HTTP-specific version
* of the {@link javax.servlet.Servlet#service} method. There's no need to override this method.
*
* @param request the {@link HttpServletRequest} object that contains the request the client made
* of the servlet
* @param response the {@link HttpServletResponse} object that contains the response the servlet
* returns to the client
* @throws IOException if an input or output error occurs while the servlet is handling the HTTP
* request
* @throws ServletException if the HTTP request cannot be handled
* @see javax.servlet.Servlet#service
*/
@Override
protected void service(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
/**
* There is an annoying edge case where the service method is invoked for the case when the URI
* is equal to the deployment URL minus the '/', for example
* http://locahost:8080/HelloWorldWebApp
*/
final String servletPath = request.getServletPath();
String pathInfo = request.getPathInfo();
StringBuffer requestURL = request.getRequestURL();
String requestURI = request.getRequestURI();
final boolean checkPathInfo = pathInfo == null || pathInfo.isEmpty() || pathInfo.equals("/");
if (checkPathInfo && !request.getRequestURI().endsWith("/")) {
// Only do this if the last segment of the servlet path does not contain '.'
// This handles the case when the extension mapping is used with the servlet
// see issue 506
// This solution does not require parsing the deployment descriptor,
// however still leaves it broken for the very rare case if a standard path
// servlet mapping would include dot in the last segment (e.g. /.webresources/*)
// and somebody would want to hit the root resource without the trailing slash
int i = servletPath.lastIndexOf('/');
if (servletPath.substring(i + 1).indexOf('.') < 0) {
// TODO (+ handle request URL with invalid characters - see the creation of
// absoluteUriBuilder bellow)
// if
// (webComponent.getResourceConfig().getFeature(ResourceConfig.FEATURE_REDIRECT)) {
// URI l = UriBuilder.fromUri(request.getRequestURL().toString()).
// path("/").
// replaceQuery(request.getQueryString()).build();
//
// response.setStatus(307);
// response.setHeader("Location", l.toASCIIString());
// return;
// } else {
// pathInfo = "/";
// requestURL.append("/");
// requestURI += "/";
// }
}
}
/**
* The HttpServletRequest.getRequestURL() contains the complete URI minus the query and fragment
* components.
*/
UriBuilder absoluteUriBuilder;
try {
absoluteUriBuilder = UriBuilder.fromUri(requestURL.toString());
} catch (IllegalArgumentException iae) {
final Response.Status badRequest = Response.Status.BAD_REQUEST;
if (webComponent.configSetStatusOverSendError) {
response.reset();
response.setStatus(badRequest.getStatusCode(), badRequest.getReasonPhrase());
} else {
response.sendError(badRequest.getStatusCode(), badRequest.getReasonPhrase());
}
return;
}
/**
* The HttpServletRequest.getPathInfo() and HttpServletRequest.getServletPath() are in decoded
* form.
*
* <p>On some servlet implementations the getPathInfo() removed contiguous '/' characters. This
* is problematic if URIs are embedded, for example as the last path segment. We need to work
* around this and not use getPathInfo for the decodedPath.
*/
final String decodedBasePath = request.getContextPath() + servletPath + "/";
final String encodedBasePath = UriComponent.encode(decodedBasePath, UriComponent.Type.PATH);
if (!decodedBasePath.equals(encodedBasePath)) {
throw new ProcessingException(
"The servlet context path and/or the "
+ "servlet path contain characters that are percent encoded");
}
final URI baseUri;
final URI requestUri;
try {
baseUri = absoluteUriBuilder.replacePath(encodedBasePath).build();
String queryParameters = request.getQueryString();
if (queryParameters == null) {
queryParameters = "";
}
requestUri = absoluteUriBuilder.replacePath(requestURI).replaceQuery(queryParameters).build();
} catch (UriBuilderException ex) {
final Response.Status badRequest = Response.Status.BAD_REQUEST;
if (webComponent.configSetStatusOverSendError) {
response.reset();
response.setStatus(badRequest.getStatusCode(), badRequest.getReasonPhrase());
} else {
response.sendError(badRequest.getStatusCode(), badRequest.getReasonPhrase());
}
return;
}
service(baseUri, requestUri, request, response);
}