Ejemplo n.º 1
0
 public static void registerDefaultNodeValidator(AWNodeValidator nv) {
   AWNodeManager nm = getNodeManager();
   if (nm != null) {
     nm.setDefaultNodeValidator(nv);
     nm.registerDirectAction(nv);
   }
 }
Ejemplo n.º 2
0
 public static void registerDefaultComponentActionNodeValidator(AWNodeValidator nv) {
   AWNodeManager nm = getNodeManager();
   if (nm != null) {
     // registerForComponentAction
     nm.registerForComponentAction(nv);
   }
 }
Ejemplo n.º 3
0
 public static AWNodeValidator getComponentActionNodeValidator() {
   AWNodeValidator nv = null;
   AWNodeManager nm = getNodeManager();
   if (nm != null) {
     nv = nm.componentActionNodeValidator();
   }
   return nv;
 }
Ejemplo n.º 4
0
 public static AWNodeValidator getDefaultNodeValidator() {
   AWNodeValidator nv = null;
   AWNodeManager nm = getNodeManager();
   if (nm != null) {
     nv = nm.defaultNodeValidator();
   }
   return nv;
 }
Ejemplo n.º 5
0
 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;
  }