/*
Saves the result of the current request on the session, does a 302
redirect into a direct action to clear the browser history. In the
handler of redirect request, it returns the page that was saved on
the request.
*/
protected AWResponse clearBrowserHistory(
AWRequestContext requestContext, AWComponent actionResultsComponent) {
AWPage actionResultsPage = actionResultsComponent.page();
actionResultsPage.ensureAwake(requestContext);
// This rewrites the DirectAction request URL into a ComponentAction
// request URL in the browser by using a redirect.
// Note [sessionless requests]: ordering of condition is important. Let
// component declare "non-refresh" (no cache or no redirect) before
// attempting to interact with the session -- allows for "sessionless"
// direct actions. This is important since we always attempt to
// rendevous with the session id now. Fixes race condition at logout
// in suite integrated mode. LogoutAck from another app starts processing
// before ClientLogout for authenticator is complete. RequestContext for
// LogoutAck starts off with a valid sessionid, but by the time it gets
// here, the session has been invalidated. LogoutAck needs to be
// completely sessionless.
if (AWComponentActionRequestHandler.IsFormPostRedirectEnabled
&& actionResultsComponent.shouldCachePage()
&& actionResultsComponent.shouldRedirect()
&& requestContext.session(false) != null
&& !requestContext.isIncrementalUpdateRequest()) {
// This saves the actual page and not the redirect page. When the
// redirect fires it will restore the saved page, which should be
// treated as a refreshRequest (no applyValues/invokeAction).
// associate a response id with the current request for page
// history maintenance
AWSession session = requestContext.session();
session.incrementResponseId();
AWApplication application = application();
AWRedirect redirectComponent =
(AWRedirect) application.createPageWithName(AWRedirect.PageName, requestContext);
String effectiveUrl =
AWComponentActionRequestHandler.SharedInstance.refreshUrl(requestContext);
effectiveUrl = AWUtil.urlAddingQueryValue(effectiveUrl, DirectActionRedirectKey, "1");
redirectComponent.setUrl(effectiveUrl);
redirectComponent.setSelfRedirect(true);
requestContext.setPage(redirectComponent.page());
actionResultsPage.ensureAsleep();
Log.aribaweb.debug("Sending redirect to clear browser history");
} else {
requestContext.setPage(actionResultsPage);
}
// We need to check for the existence of a session and save the page
// before generateResponse in order to maintain uniformity with
// AWComponentActionRequestHandler.
// Since generateResponse() can cause a new session to be
// associated with the request, we need to make sure we try save
// the page after generateResponse if the page was not already saved.
boolean pageSaved = attemptSavePage(requestContext, actionResultsPage);
AWResponse response = requestContext.generateResponse();
if (!pageSaved) {
attemptSavePage(requestContext, actionResultsPage);
}
return response;
}
private boolean attemptSavePage(AWRequestContext requestContext, AWPage page) {
// attemptSavePage checks for either a valid sessionId or an existing session
// in the requestContext
// session id, no existing session -- normal request that does not cause the
// session to get set in the requestContext during take or invoke
// no session id, existing session (before append) -- request that causes a new
// session to be associated with the requestContext during take, invoke,
// or session validation (aka sso)
// no session id, existing session (after append) -- request that causes a new
// session to be associated with the requestContext during append to response
// see Note [sessionless requests] below
boolean pageSaved = false;
if (page.pageComponent().shouldCachePage()
&& (!StringUtil.nullOrEmptyOrBlankString(requestContext.request().sessionId())
|| requestContext.session(false) != null)) {
Log.aribaweb.debug(
"AWDirectActionRequestHandler: session exists -- saving page for %s",
page.pageComponent().getClass().getName());
requestContext.session().savePage(page);
pageSaved = true;
}
return pageSaved;
}
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;
}