Beispiel #1
0
  /**
   * Sort the <code>faces-config</code> documents found on the classpath and those specified by the
   * <code>javax.faces.CONFIG_FILES</code> context init parameter.
   *
   * @param facesDocuments an array of <em>all</em> <code>faces-config</code> documents
   * @param webInfFacesConfig FacesConfigInfo representing the WEB-INF/faces-config.xml for this app
   * @return the sorted documents
   */
  private DocumentInfo[] sortDocuments(
      DocumentInfo[] facesDocuments, FacesConfigInfo webInfFacesConfig) {

    int len =
        (webInfFacesConfig.isWebInfFacesConfig()
            ? facesDocuments.length - 1
            : facesDocuments.length);

    List<String> absoluteOrdering = webInfFacesConfig.getAbsoluteOrdering();

    if (len > 1) {
      List<DocumentOrderingWrapper> list = new ArrayList<DocumentOrderingWrapper>();
      for (int i = 1; i < len; i++) {
        list.add(new DocumentOrderingWrapper(facesDocuments[i]));
      }
      DocumentOrderingWrapper[] ordering = list.toArray(new DocumentOrderingWrapper[list.size()]);
      if (absoluteOrdering == null) {
        DocumentOrderingWrapper.sort(ordering);
        // sorting complete, now update the appropriate locations within
        // the original array with the sorted documentation.
        for (int i = 1; i < len; i++) {
          facesDocuments[i] = ordering[i - 1].getDocument();
        }
        return facesDocuments;
      } else {
        DocumentOrderingWrapper[] result = DocumentOrderingWrapper.sort(ordering, absoluteOrdering);
        DocumentInfo[] ret =
            new DocumentInfo
                [((webInfFacesConfig.isWebInfFacesConfig())
                    ? (result.length + 2)
                    : (result.length + 1))];
        for (int i = 1; i < len; i++) {
          ret[i] = result[i - 1].getDocument();
        }
        // add the impl specific config file
        ret[0] = facesDocuments[0];
        // add the WEB-INF if necessary
        if (webInfFacesConfig.isWebInfFacesConfig()) {
          ret[ret.length - 1] = facesDocuments[facesDocuments.length - 1];
        }
        return ret;
      }
    }

    return facesDocuments;
  }
Beispiel #2
0
  /**
   * Utility method to check if JSF 2.0 Facelets should be disabled. If it's not explicitly disabled
   * by the context init parameter, then check the version of the WEB-INF/faces-config.xml document.
   * If the version is less than 2.0, then override the default value for the context init parameter
   * so that other parts of the system that use that config option will know it has been disabled.
   *
   * <p>NOTE: Since this method overrides a configuration value, it should be called before *any*
   * document parsing is performed the configuration value may be queried by the <code>ConfigParser
   * </code>s.
   *
   * @param webconfig configuration for this application
   * @param facesConfigInfo object representing WEB-INF/faces-config.xml
   * @return <code>true</code> if Facelets should be disabled
   */
  private boolean isFaceletsDisabled(WebConfiguration webconfig, FacesConfigInfo facesConfigInfo) {

    boolean isFaceletsDisabled = webconfig.isOptionEnabled(DisableFaceletJSFViewHandler);
    if (!isFaceletsDisabled) {
      // if not explicitly disabled, make a sanity check against
      // /WEB-INF/faces-config.xml
      isFaceletsDisabled = !facesConfigInfo.isVersionGreaterOrEqual(2.0);
      webconfig.overrideContextInitParameter(DisableFaceletJSFViewHandler, isFaceletsDisabled);
    }
    return isFaceletsDisabled;
  }
Beispiel #3
0
 private void initializeIvars() {
   if (null != uris || null != jarNames) {
     assert (null != uris && null != jarNames);
     return;
   }
   uris = new HashSet<URI>(documentInfos.length);
   jarNames = new HashSet<String>(documentInfos.length);
   for (DocumentInfo docInfo : documentInfos) {
     URI sourceURI = docInfo.getSourceURI();
     Matcher m = JAR_PATTERN.matcher(sourceURI.toString());
     if (m.matches()) {
       String jarName = m.group(2);
       if (!jarNames.contains(jarName)) {
         FacesConfigInfo configInfo = new FacesConfigInfo(docInfo);
         if (!configInfo.isMetadataComplete()) {
           uris.add(sourceURI);
           jarNames.add(jarName);
         }
       }
     }
   }
 }
Beispiel #4
0
  /**
   * This method bootstraps JSF based on the parsed configuration resources.
   *
   * @param sc the <code>ServletContext</code> for the application that requires initialization
   */
  public void initialize(ServletContext sc) {

    if (!hasBeenInitialized(sc)) {
      initializedContexts.add(sc);
      ExecutorService executor = null;
      try {
        WebConfiguration webConfig = WebConfiguration.getInstance(sc);
        boolean validating = webConfig.isOptionEnabled(ValidateFacesConfigFiles);
        if (useThreads(sc)) {
          executor = createExecutorService();
        }

        DocumentInfo[] facesDocuments =
            getConfigDocuments(sc, getFacesConfigResourceProviders(), executor, validating);

        FacesConfigInfo webInfFacesConfigInfo =
            new FacesConfigInfo(facesDocuments[facesDocuments.length - 1]);

        facesDocuments = sortDocuments(facesDocuments, webInfFacesConfigInfo);
        InitFacesContext context = (InitFacesContext) FacesContext.getCurrentInstance();

        InjectionProvider containerConnector =
            InjectionProviderFactory.createInstance(context.getExternalContext());
        context.getAttributes().put(INJECTION_PROVIDER_KEY, containerConnector);

        boolean isFaceletsDisabled = isFaceletsDisabled(webConfig, webInfFacesConfigInfo);
        if (!webInfFacesConfigInfo.isWebInfFacesConfig()
            || !webInfFacesConfigInfo.isMetadataComplete()) {
          // execute the Task responsible for finding annotation classes
          ProvideMetadataToAnnotationScanTask taskMetadata =
              new ProvideMetadataToAnnotationScanTask(facesDocuments, containerConnector);
          Future<Map<Class<? extends Annotation>, Set<Class<?>>>> annotationScan;
          if (executor != null) {
            annotationScan = executor.submit(new AnnotationScanTask(sc, context, taskMetadata));
            pushTaskToContext(sc, annotationScan);
          } else {
            annotationScan =
                new FutureTask<Map<Class<? extends Annotation>, Set<Class<?>>>>(
                    new AnnotationScanTask(sc, context, taskMetadata));
            ((FutureTask) annotationScan).run();
          }
          pushTaskToContext(sc, annotationScan);
        }

        // see if the app is running in a HA enabled env
        if (containerConnector instanceof HighAvailabilityEnabler) {
          ((HighAvailabilityEnabler) containerConnector).enableHighAvailability(sc);
        }
        // process the ordered documents
        FACES_CONFIG_PROCESSOR_CHAIN.process(sc, facesDocuments);
        if (!isFaceletsDisabled) {
          FACELET_TAGLIB_CONFIG_PROCESSOR_CHAIN.process(
              sc,
              getConfigDocuments(sc, getFaceletConfigResourceProviders(), executor, validating));
        }

        publishPostConfigEvent();
      } catch (Exception e) {
        // clear out any configured factories
        releaseFactories();
        Throwable t = e;
        if (!(e instanceof ConfigurationException)) {
          t = new ConfigurationException("CONFIGURATION FAILED! " + t.getMessage(), t);
        }
        throw (ConfigurationException) t;
      } finally {
        if (executor != null) {
          executor.shutdown();
        }
        sc.removeAttribute(ANNOTATIONS_SCAN_TASK_KEY);
      }
    }
  }