protected synchronized void setHttpService(HttpService s) {
ahHttpAdapter = new HttpAhBinder();
this.setRootUrl(applicationWebAlias);
Servlet customJsonServlet = new CustomJsonServlet(ahHttpAdapter, "");
Servlet jsonRPC = new JsonRPC(ahHttpAdapter, "");
this.registerResource("/", "webapp/ehdemo");
this.registerResource("/gh", "webapp/gh");
this.registerResource("/post-json", customJsonServlet);
this.registerResource("/json-rpc", jsonRPC);
this.registerResource(
"/JSON-RPC",
new JSONRPCServlet() {
public void init(ServletConfig config) throws ServletException {
super.init(new ServletConfigDisableGZIPWrapper(config));
}
});
this.setHttpContext(this);
this.update(null);
super.bindHttpService(s);
}
/**
* Map a web application exception to a response.
*
* @param e the web application exception.
*/
public void mapWebApplicationException(WebApplicationException e) {
if (e.getResponse().getEntity() != null) {
wa.getResponseListener().onError(Thread.currentThread().getId(), e);
onException(e, e.getResponse(), false);
} else {
if (!mapException(e)) {
onException(e, e.getResponse(), false);
}
}
}
/**
* Map an exception to a response.
*
* @param e the exception.
* @return true if the exception was mapped, otherwise false.
*/
public boolean mapException(Throwable e) {
ExceptionMapper em = wa.getExceptionMapperContext().find(e.getClass());
if (em == null) {
wa.getResponseListener().onError(Thread.currentThread().getId(), e);
return false;
}
wa.getResponseListener().onMappedException(Thread.currentThread().getId(), e, em);
if (request.isTracingEnabled()) {
request.trace(
String.format(
"matched exception mapper: %s -> %s",
ReflectionHelper.objectToString(e), ReflectionHelper.objectToString(em)));
}
try {
Response r = em.toResponse(e);
if (r == null) r = Response.noContent().build();
onException(e, r, true);
} catch (MappableContainerException ex) {
// If the exception mapper throws a MappableContainerException then
// rethrow it to the HTTP container
throw ex;
} catch (RuntimeException ex) {
LOGGER.severe(
"Exception mapper "
+ em
+ " for Throwable "
+ e
+ " threw a RuntimeException when "
+ "attempting to obtain the response");
Response r = Response.serverError().build();
onException(ex, r, false);
}
return true;
}
/** @see javax.servlet.Filter#destroy() */
@Override
public void destroy() {
if (application != null) {
try {
ThreadContext.setApplication(application);
application.internalDestroy();
} finally {
ThreadContext.detach();
application = null;
}
}
if (applicationFactory != null) {
applicationFactory.destroy(this);
}
}
/**
* Servlets and Filters are treated essentially the same with Wicket. This is the entry point for
* both of them.
*
* @see #init(FilterConfig)
* @param isServlet True if Servlet, false if Filter
* @param filterConfig
* @throws ServletException
*/
public void init(final boolean isServlet, final FilterConfig filterConfig)
throws ServletException {
this.filterConfig = filterConfig;
this.isServlet = isServlet;
initIgnorePaths(filterConfig);
final ClassLoader previousClassLoader = Thread.currentThread().getContextClassLoader();
final ClassLoader newClassLoader = getClassLoader();
try {
if (previousClassLoader != newClassLoader) {
Thread.currentThread().setContextClassLoader(newClassLoader);
}
// locate application instance unless it was already specified during construction
if (application == null) {
applicationFactory = getApplicationFactory();
application = applicationFactory.createApplication(this);
}
application.setName(filterConfig.getFilterName());
application.setWicketFilter(this);
// Allow the filterPath to be preset via setFilterPath()
String configureFilterPath = getFilterPath();
if (configureFilterPath == null) {
configureFilterPath = getFilterPathFromConfig(filterConfig);
if (configureFilterPath == null) {
configureFilterPath = getFilterPathFromWebXml(isServlet, filterConfig);
if (configureFilterPath == null) {
configureFilterPath = getFilterPathFromAnnotation(isServlet);
}
}
if (configureFilterPath != null) {
setFilterPath(configureFilterPath);
}
}
if (getFilterPath() == null) {
log.warn(
"Unable to determine filter path from filter init-param, web.xml, "
+ "or servlet 3.0 annotations. Assuming user will set filter path "
+ "manually by calling setFilterPath(String)");
}
ThreadContext.setApplication(application);
try {
application.initApplication();
// Give the application the option to log that it is started
application.logStarted();
} finally {
ThreadContext.detach();
}
} finally {
if (newClassLoader != previousClassLoader) {
Thread.currentThread().setContextClassLoader(previousClassLoader);
}
}
}
/**
* This is Wicket's main method to execute a request
*
* @param request
* @param response
* @param chain
* @return false, if the request could not be processed
* @throws IOException
* @throws ServletException
*/
boolean processRequest(
ServletRequest request, final ServletResponse response, final FilterChain chain)
throws IOException, ServletException {
final ThreadContext previousThreadContext = ThreadContext.detach();
// Assume we are able to handle the request
boolean res = true;
final ClassLoader previousClassLoader = Thread.currentThread().getContextClassLoader();
final ClassLoader newClassLoader = getClassLoader();
try {
if (previousClassLoader != newClassLoader) {
Thread.currentThread().setContextClassLoader(newClassLoader);
}
HttpServletRequest httpServletRequest = (HttpServletRequest) request;
HttpServletResponse httpServletResponse = (HttpServletResponse) response;
// Make sure getFilterPath() gets called before checkIfRedirectRequired()
String filterPath = getFilterPath(httpServletRequest);
if (filterPath == null) {
throw new IllegalStateException("filter path was not configured");
}
if (shouldIgnorePath(httpServletRequest)) {
log.debug("Ignoring request {}", httpServletRequest.getRequestURL());
if (chain != null) {
chain.doFilter(request, response);
}
return false;
}
String redirectURL = checkIfRedirectRequired(httpServletRequest);
if (redirectURL == null) {
// No redirect; process the request
ThreadContext.setApplication(application);
WebRequest webRequest = application.createWebRequest(httpServletRequest, filterPath);
WebResponse webResponse = application.createWebResponse(webRequest, httpServletResponse);
RequestCycle requestCycle = application.createRequestCycle(webRequest, webResponse);
if (!requestCycle.processRequestAndDetach()) {
if (chain != null) {
chain.doFilter(request, response);
}
res = false;
} else {
webResponse.flush();
}
} else {
if (Strings.isEmpty(httpServletRequest.getQueryString()) == false) {
redirectURL += "?" + httpServletRequest.getQueryString();
}
try {
// send redirect - this will discard POST parameters if the request is POST
// - still better than getting an error because of lacking trailing slash
httpServletResponse.sendRedirect(httpServletResponse.encodeRedirectURL(redirectURL));
} catch (IOException e) {
throw new RuntimeException(e);
}
}
} finally {
ThreadContext.restore(previousThreadContext);
if (newClassLoader != previousClassLoader) {
Thread.currentThread().setContextClassLoader(previousClassLoader);
}
if (response.isCommitted()) {
response.flushBuffer();
}
}
return res;
}
/**
* Get the message body workers.
*
* @return the message body workers.
*/
public MessageBodyWorkers getMessageBodyWorkers() {
return wa.getMessageBodyWorkers();
}
