public static void registerDefaultNodeValidator(AWNodeValidator nv) {
AWNodeManager nm = getNodeManager();
if (nm != null) {
nm.setDefaultNodeValidator(nv);
nm.registerDirectAction(nv);
}
}
public static void registerDefaultComponentActionNodeValidator(AWNodeValidator nv) {
AWNodeManager nm = getNodeManager();
if (nm != null) {
// registerForComponentAction
nm.registerForComponentAction(nv);
}
}
public static AWNodeValidator getComponentActionNodeValidator() {
AWNodeValidator nv = null;
AWNodeManager nm = getNodeManager();
if (nm != null) {
nv = nm.componentActionNodeValidator();
}
return nv;
}
public static AWNodeValidator getDefaultNodeValidator() {
AWNodeValidator nv = null;
AWNodeManager nm = getNodeManager();
if (nm != null) {
nv = nm.defaultNodeValidator();
}
return nv;
}
public static AWNodeValidator getNodeValidatorForDirectAction(
String className, String actionName) {
AWNodeValidator nv = null;
AWNodeManager nm = getNodeManager();
if (nm != null) {
nv = nm.nodeValidatorForDirectAction(className, actionName);
}
return nv;
}
private String[] parseDirectActionRequest(AWRequest request) {
String actionName = DefaultActionName;
String className = DefaultDirectActionClassName;
AWApplication application = application();
Class directActionClass = null;
String[] requestHandlerPathComponents = request.requestHandlerPath();
if (requestHandlerPathComponents != null) {
AWNodeManager nodeManager = application.getNodeManager();
if (nodeManager != null) {
requestHandlerPathComponents =
nodeManager.filterUrlForNodeCallback(requestHandlerPathComponents);
}
int requestHandlerPathComponentsLength = requestHandlerPathComponents.length;
if (requestHandlerPathComponentsLength > 0) {
actionName = requestHandlerPathComponents[0];
}
// Hack -- check explicitly for awres so we can use
// path rather than query string -- for webserver caching of resources --
// example: http://host/ACM/Main/ad/awres/realm/imagename.jpg
// if we can modify the webserver cache to understand query strings
// then we can switch to
// http://host/ACM/Main/ad/awimg?realm=xxxx&filename=xxxx
if (requestHandlerPathComponentsLength > 1
&& !AWDirectAction.AWResActionName.equals(actionName)) {
className = application.directActionClassNameForKey(requestHandlerPathComponents[1]);
// try to find a class for the className
if (StringUtil.nullOrEmptyOrBlankString(className)) {
className = DefaultDirectActionClassName;
} else {
directActionClass = AWUtil.classForName(className);
if (directActionClass == null) {
directActionClass = application.resourceManager().classForName(className);
if (directActionClass == null) {
className = DefaultDirectActionClassName;
}
}
}
}
}
String[] directActionName = new String[2];
directActionName[ClassNameIndex] = className;
directActionName[ActionNameIndex] = actionName;
return directActionName;
}
public AWResponseGenerating processAction(AWRequest request, AWRequestContext requestContext) {
AWApplication application = application();
AWResponseGenerating response = null;
String[] directActionName = parseDirectActionRequest(request);
// isReloadable() returns true if we have hotswap reloading enabled
String className = application.directActionClassNameForKey(directActionName[ClassNameIndex]);
directActionName[ClassNameIndex] = className;
Class directActionClass = application.resourceManager().classForName(className);
if (AWUtil.getClassLoader().isReloadable(className)) {
Class reloadedClass = AWUtil.getClassLoader().checkReloadClass(directActionClass);
if (reloadedClass != directActionClass) {
application.resourceManager().removeClass(className);
directActionClass = reloadedClass;
}
}
String actionName = directActionName[ActionNameIndex];
requestContext.setCurrentDirectAction(className, actionName);
AWDirectAction directAction = null;
try {
directAction = (AWDirectAction) directActionClass.newInstance();
} catch (IllegalAccessException illegalAccessException) {
throw new AWGenericException(illegalAccessException);
} catch (InstantiationException instantiationException) {
throw new AWGenericException(
"*** Error: cannot instantiate direct action class named \""
+ directActionName[ClassNameIndex]
+ "\"",
instantiationException);
}
directAction.init(requestContext);
try {
if (request.formValueForKey(AWRequestContext.RefreshRequestKey) != null) {
// if this is a refresh request (ie. forward track over a redirect from
// another app, then see if we have a valid session and we have a
// page to refresh. Otherwise, this app must have been restarted but
// the other app was not so there is a mismatch in state. In this case,
// actually execute the direct action.
AWSession session = requestContext.session(false);
if (session != null) {
AWPage page = session.restoreCurrentPage();
if (page != null) {
if (page.pageComponent().isBoundary()) {
// need to forward track here and then redirect to
// refresh the page ...
requestContext.setHistoryAction(AWSession.ForwardTrackRequest);
session.initRequestType();
page = session.restoreNextPage(page);
}
AWRedirect redirectComponent =
(AWRedirect) application.createPageWithName(AWRedirect.PageName, requestContext);
String effectiveUrl =
AWComponentActionRequestHandler.SharedInstance.refreshUrl(requestContext);
redirectComponent.setUrl(effectiveUrl);
redirectComponent.setSelfRedirect(true);
requestContext.setPage(redirectComponent.page());
response = requestContext.generateResponse();
}
}
}
if (response == null) {
AWResponseGenerating actionResults = null;
if (!request.hasHandler()) {
// If there is not handler specified, then the user is
// accessing the /Main page and that is the only time
// that we want to execute the filters.
for (int i = 0; i < _defaultRequestFilter.size(); i++) {
AWDefaultRequestFilter filter = (AWDefaultRequestFilter) _defaultRequestFilter.get(i);
filter.execute(requestContext);
}
}
if (!directAction.skipValidation(actionName)) {
if (directAction.shouldValidateTopFrame(actionName)) {
response = directAction.validateTopFramePost(requestContext);
if (response != null) {
return response;
}
}
if (!AWDirectAction.isServerManagementAction(request)
&& directAction.shouldValidateNode(actionName)) {
directAction.validateNode(requestContext, directActionName[ClassNameIndex], actionName);
}
if (directAction.shouldValidateSession(actionName)) {
directAction.validateSession(requestContext);
}
if (directAction.shouldValidateRequest(actionName)) {
directAction.validateRequest(requestContext);
}
}
actionResults = directAction.performActionNamed(directActionName[ActionNameIndex]);
Assert.that(actionResults != null, "Direct action result cannot be null.");
// Allow response to replace itself (see AWRedirect for example)
if (actionResults instanceof AWResponseGenerating.ResponseSubstitution) {
actionResults =
((AWResponseGenerating.ResponseSubstitution) actionResults).replacementResponse();
}
return actionResults;
}
} catch (AWNodeChangeException e) {
AWNodeValidator nv = e.getNodeValidator();
AWResponseGenerating handlerResults = nv.handleNodeValidationException(requestContext);
nv.terminateCurrentSession(requestContext);
response = handlerResults.generateResponse();
} catch (AWSessionValidationException exception) {
try {
if (AWConcreteApplication.IsDebuggingEnabled) {
Log.aribaweb.debug(
"AWDirectActionRequestHandler: handling session " + "validation exception");
}
// if there is a default validator, run it here
AWNodeValidator nv = AWNodeManager.getDefaultNodeValidator();
if (nv != null && !nv.isValid(requestContext)) {
Log.aribaweb_nodeValidate.debug(
"AWDirectActionRequestHandler: invalid node. "
+ "NodeValidator generating response.");
AWResponseGenerating handlerResults = nv.handleNodeValidationException(requestContext);
nv.terminateCurrentSession(requestContext);
response = handlerResults.generateResponse();
} else {
AWResponseGenerating handlerResults =
handleSessionValidationError(requestContext, exception);
// If there is not valid HttpSession, create a new one to enable
// load balancers which use the sessionid.
if (requestContext.httpSession(false) == null) {
// request.getSession(true);
requestContext.createHttpSession();
Log.aribaweb_session.debug("AWDirectActionRequestHandler: create HttpSession");
}
if (exception instanceof AWClearBrowserHistoryException) {
AWComponent actionResultsComponent = (AWComponent) handlerResults;
response = clearBrowserHistory(requestContext, actionResultsComponent);
} else if (requestContext.session(false) != null
&& handlerResults instanceof AWComponent) {
AWComponent actionResultsComponent = (AWComponent) handlerResults;
AWPage actionResultsPage = actionResultsComponent.page();
attemptSavePage(requestContext, actionResultsPage);
}
if (response == null) {
response = handlerResults.generateResponse();
}
}
} catch (RuntimeException e) {
AWGenericException newException =
new AWGenericException(
"Error occurred while handling session validation. Please make"
+ " sure session validation is configured properly.",
e);
return handleException(requestContext, newException).generateResponse();
}
} catch (AWSessionRestorationException exception) {
requestContext.createHttpSession();
response = handleSessionRestorationError(requestContext).generateResponse();
} catch (AWSiteUnavailableException e) {
response = handleSiteUnavailableException(requestContext);
} catch (AWRemoteHostMismatchException exception) {
response = handleRemoteHostMismatchException(requestContext, exception);
} catch (Throwable t) {
response = handleUncaughtException(requestContext, t);
}
return response;
}