コード例 #1
0
  /**
   * Check to see if the ServletContainerIntializer loaded via the ServiceLoader came from a jar
   * that is excluded by the fragment ordering. See ServletSpec 3.0 p.85.
   *
   * @param context
   * @param sci
   * @return true if excluded
   */
  public boolean isFromExcludedJar(
      WebAppContext context, ServletContainerInitializer sci, Resource sciResource)
      throws Exception {
    if (sci == null) throw new IllegalArgumentException("ServletContainerInitializer null");
    if (context == null) throw new IllegalArgumentException("WebAppContext null");

    if (LOG.isDebugEnabled()) LOG.debug("Checking {} for jar exclusion", sci);

    // A ServletContainerInitializer that came from the container's classpath cannot be excluded by
    // an ordering
    // of WEB-INF/lib jars
    if (isFromContainerClassPath(context, sci)) return false;

    List<Resource> orderedJars = context.getMetaData().getOrderedWebInfJars();

    // If no ordering, nothing is excluded
    if (context.getMetaData().getOrdering() == null) return false;

    // there is an ordering, but there are no jars resulting from the ordering, everything excluded
    if (orderedJars.isEmpty()) return true;

    if (sciResource == null)
      return false; // not from a jar therefore not from WEB-INF so not excludable

    URI loadingJarURI = sciResource.getURI();
    boolean found = false;
    Iterator<Resource> itor = orderedJars.iterator();
    while (!found && itor.hasNext()) {
      Resource r = itor.next();
      found = r.getURI().equals(loadingJarURI);
    }

    return !found;
  }
コード例 #2
0
  /**
   * Scan jars in WEB-INF/lib
   *
   * @param context
   * @param parser
   * @throws Exception
   */
  public void parseWebInfLib(final WebAppContext context, final AnnotationParser parser)
      throws Exception {
    List<FragmentDescriptor> frags = context.getMetaData().getFragments();

    // email from Rajiv Mordani jsrs 315 7 April 2010
    // jars that do not have a web-fragment.xml are still considered fragments
    // they have to participate in the ordering
    ArrayList<URI> webInfUris = new ArrayList<URI>();

    List<Resource> jars = context.getMetaData().getOrderedWebInfJars();

    // No ordering just use the jars in any order
    if (jars == null || jars.isEmpty()) jars = context.getMetaData().getWebInfJars();

    _webInfLibStats = new CounterStatistic();

    for (Resource r : jars) {
      // for each jar, we decide which set of annotations we need to parse for
      final Set<Handler> handlers = new HashSet<Handler>();

      FragmentDescriptor f = getFragmentFromJar(r, frags);

      // if its from a fragment jar that is metadata complete, we should skip scanning for
      // @webservlet etc
      // but yet we still need to do the scanning for the classes on behalf of  the
      // servletcontainerinitializers
      // if a jar has no web-fragment.xml we scan it (because it is not excluded by the ordering)
      // or if it has a fragment we scan it if it is not metadata complete
      if (f == null
          || !isMetaDataComplete(f)
          || _classInheritanceHandler != null
          || !_containerInitializerAnnotationHandlers.isEmpty()) {
        // register the classinheritance handler if there is one
        if (_classInheritanceHandler != null) handlers.add(_classInheritanceHandler);

        // register the handlers for the @HandlesTypes values that are themselves annotations if
        // there are any
        handlers.addAll(_containerInitializerAnnotationHandlers);

        // only register the discoverable annotation handlers if this fragment is not metadata
        // complete, or has no fragment descriptor
        if (f == null || !isMetaDataComplete(f)) handlers.addAll(_discoverableAnnotationHandlers);

        if (_parserTasks != null) {
          ParserTask task = new ParserTask(parser, handlers, r, _webAppClassNameResolver);
          _parserTasks.add(task);
          _webInfLibStats.increment();
          if (LOG.isDebugEnabled()) task.setStatistic(new TimeStatistic());
        }
      }
    }
  }
コード例 #3
0
  /**
   * Here is the order in which jars and osgi artifacts are scanned for discoverable annotations.
   *
   * <ol>
   *   <li>The container jars are scanned.
   *   <li>The WEB-INF/classes are scanned
   *   <li>The osgi fragment to the web bundle are parsed.
   *   <li>The WEB-INF/lib are scanned
   *   <li>The required bundles are parsed
   * </ol>
   */
  @Override
  public void parseWebInfLib(
      WebAppContext context, org.eclipse.jetty.annotations.AnnotationParser parser)
      throws Exception {
    AnnotationParser oparser = (AnnotationParser) parser;

    Bundle webbundle = (Bundle) context.getAttribute(OSGiWebappConstants.JETTY_OSGI_BUNDLE);
    Set<Bundle> fragAndRequiredBundles =
        (Set<Bundle>) context.getAttribute(OSGiWebInfConfiguration.FRAGMENT_AND_REQUIRED_BUNDLES);
    if (fragAndRequiredBundles != null) {
      // index and scan fragments
      for (Bundle bundle : fragAndRequiredBundles) {
        // skip bundles that have been uninstalled since we discovered them
        if (bundle.getState() == Bundle.UNINSTALLED) continue;

        Resource bundleRes = oparser.indexBundle(bundle);
        if (!context.getMetaData().getWebInfJars().contains(bundleRes)) {
          context.getMetaData().addWebInfJar(bundleRes);
        }

        if (bundle.getHeaders().get(Constants.FRAGMENT_HOST) != null) {
          // a fragment indeed:
          parseFragmentBundle(context, oparser, webbundle, bundle);
        }
      }
    }
    // scan ourselves
    oparser.indexBundle(webbundle);
    parseWebBundle(context, oparser, webbundle);

    // scan the WEB-INF/lib
    super.parseWebInfLib(context, parser);
    if (fragAndRequiredBundles != null) {
      // scan the required bundles
      for (Bundle requiredBundle : fragAndRequiredBundles) {
        // skip bundles that have been uninstalled since we discovered them
        if (requiredBundle.getState() == Bundle.UNINSTALLED) continue;

        if (requiredBundle.getHeaders().get(Constants.FRAGMENT_HOST) == null) {
          // a bundle indeed:
          parseRequiredBundle(context, oparser, webbundle, requiredBundle);
        }
      }
    }
  }
コード例 #4
0
  /**
   * Scan classes in WEB-INF/classes
   *
   * @param context
   * @param parser
   * @throws Exception
   */
  public void parseWebInfClasses(final WebAppContext context, final AnnotationParser parser)
      throws Exception {
    Set<Handler> handlers = new HashSet<Handler>();
    handlers.addAll(_discoverableAnnotationHandlers);
    if (_classInheritanceHandler != null) handlers.add(_classInheritanceHandler);
    handlers.addAll(_containerInitializerAnnotationHandlers);

    _webInfClassesStats = new CounterStatistic();

    for (Resource dir : context.getMetaData().getWebInfClassesDirs()) {
      if (_parserTasks != null) {
        ParserTask task = new ParserTask(parser, handlers, dir, _webAppClassNameResolver);
        _parserTasks.add(task);
        _webInfClassesStats.increment();
        if (LOG.isDebugEnabled()) task.setStatistic(new TimeStatistic());
      }
    }
  }
コード例 #5
0
  public void doHandle(Class clazz) {
    // Check that the PreDestroy is on a class that we're interested in
    if (Util.supportsPostConstructPreDestroy(clazz)) {
      Method[] methods = clazz.getDeclaredMethods();
      for (int i = 0; i < methods.length; i++) {
        Method m = (Method) methods[i];
        if (m.isAnnotationPresent(PreDestroy.class)) {
          if (m.getParameterTypes().length != 0)
            throw new IllegalStateException(m + " has parameters");
          if (m.getReturnType() != Void.TYPE) throw new IllegalStateException(m + " is not void");
          if (m.getExceptionTypes().length != 0)
            throw new IllegalStateException(m + " throws checked exceptions");
          if (Modifier.isStatic(m.getModifiers()))
            throw new IllegalStateException(m + " is static");

          // ServletSpec 3.0 p80 If web.xml declares even one predestroy then all predestroys
          // in fragments must be ignored. Otherwise, they are additive.
          MetaData metaData = _context.getMetaData();
          Origin origin = metaData.getOrigin("pre-destroy");
          if (origin != null
              && (origin == Origin.WebXml
                  || origin == Origin.WebDefaults
                  || origin == Origin.WebOverride)) return;

          PreDestroyCallback callback = new PreDestroyCallback();
          callback.setTarget(clazz.getName(), m.getName());

          LifeCycleCallbackCollection lifecycles =
              (LifeCycleCallbackCollection)
                  _context.getAttribute(LifeCycleCallbackCollection.LIFECYCLE_CALLBACK_COLLECTION);
          if (lifecycles == null) {
            lifecycles = new LifeCycleCallbackCollection();
            _context.setAttribute(
                LifeCycleCallbackCollection.LIFECYCLE_CALLBACK_COLLECTION, lifecycles);
          }

          lifecycles.add(callback);
        }
      }
    }
  }
コード例 #6
0
  /**
   * Scan jars on container path.
   *
   * @param context
   * @param parser
   * @throws Exception
   */
  public void parseContainerPath(final WebAppContext context, final AnnotationParser parser)
      throws Exception {
    // always parse for discoverable annotations as well as class hierarchy and
    // servletcontainerinitializer related annotations
    final Set<Handler> handlers = new HashSet<Handler>();
    handlers.addAll(_discoverableAnnotationHandlers);
    handlers.addAll(_containerInitializerAnnotationHandlers);
    if (_classInheritanceHandler != null) handlers.add(_classInheritanceHandler);

    _containerPathStats = new CounterStatistic();

    for (Resource r : context.getMetaData().getContainerResources()) {
      // queue it up for scanning if using multithreaded mode
      if (_parserTasks != null) {
        ParserTask task = new ParserTask(parser, handlers, r, _containerClassNameResolver);
        _parserTasks.add(task);
        _containerPathStats.increment();
        if (LOG.isDebugEnabled()) task.setStatistic(new TimeStatistic());
      }
    }
  }
コード例 #7
0
  /**
   * @see
   *     org.eclipse.jetty.webapp.AbstractConfiguration#configure(org.eclipse.jetty.webapp.WebAppContext)
   */
  @Override
  public void configure(WebAppContext context) throws Exception {
    context.addDecorator(new AnnotationDecorator(context));

    // Even if metadata is complete, we still need to scan for ServletContainerInitializers - if
    // there are any

    if (!context.getMetaData().isMetaDataComplete()) {
      // If metadata isn't complete, if this is a servlet 3 webapp or isConfigDiscovered is true, we
      // need to search for annotations
      if (context.getServletContext().getEffectiveMajorVersion() >= 3
          || context.isConfigurationDiscovered()) {
        _discoverableAnnotationHandlers.add(new WebServletAnnotationHandler(context));
        _discoverableAnnotationHandlers.add(new WebFilterAnnotationHandler(context));
        _discoverableAnnotationHandlers.add(new WebListenerAnnotationHandler(context));
      }
    }

    // Regardless of metadata, if there are any ServletContainerInitializers with @HandlesTypes,
    // then we need to scan all the
    // classes so we can call their onStartup() methods correctly
    createServletContainerInitializerAnnotationHandlers(
        context, getNonExcludedInitializers(context));

    if (!_discoverableAnnotationHandlers.isEmpty()
        || _classInheritanceHandler != null
        || !_containerInitializerAnnotationHandlers.isEmpty()) scanForAnnotations(context);

    // Resolve container initializers
    List<ContainerInitializer> initializers =
        (List<ContainerInitializer>)
            context.getAttribute(AnnotationConfiguration.CONTAINER_INITIALIZERS);
    if (initializers != null && initializers.size() > 0) {
      Map<String, Set<String>> map =
          (Map<String, Set<String>>)
              context.getAttribute(AnnotationConfiguration.CLASS_INHERITANCE_MAP);
      if (map == null) LOG.warn("ServletContainerInitializers: detected. Class hierarchy: empty");
      for (ContainerInitializer i : initializers) i.resolveClasses(context, map);
    }
  }
コード例 #8
0
  /**
   * @param context
   * @return list of non-excluded {@link ServletContainerInitializer}s
   * @throws Exception
   */
  public List<ServletContainerInitializer> getNonExcludedInitializers(WebAppContext context)
      throws Exception {
    ArrayList<ServletContainerInitializer> nonExcludedInitializers =
        new ArrayList<ServletContainerInitializer>();

    // We use the ServiceLoader mechanism to find the ServletContainerInitializer classes to inspect
    long start = 0;

    ClassLoader old = Thread.currentThread().getContextClassLoader();
    ServiceLoader<ServletContainerInitializer> loadedInitializers = null;
    try {
      if (LOG.isDebugEnabled()) start = System.nanoTime();
      Thread.currentThread().setContextClassLoader(context.getClassLoader());
      loadedInitializers = ServiceLoader.load(ServletContainerInitializer.class);
    } finally {
      Thread.currentThread().setContextClassLoader(old);
    }

    if (LOG.isDebugEnabled())
      LOG.debug(
          "Service loaders found in {}ms",
          (TimeUnit.MILLISECONDS.convert((System.nanoTime() - start), TimeUnit.NANOSECONDS)));

    Map<ServletContainerInitializer, Resource> sciResourceMap =
        new HashMap<ServletContainerInitializer, Resource>();
    ServletContainerInitializerOrdering initializerOrdering = getInitializerOrdering(context);

    // Get initial set of SCIs that aren't from excluded jars or excluded by the
    // containerExclusionPattern, or excluded
    // because containerInitializerOrdering omits it
    for (ServletContainerInitializer sci : loadedInitializers) {
      if (matchesExclusionPattern(sci)) {
        if (LOG.isDebugEnabled()) LOG.debug("{} excluded by pattern", sci);
        continue;
      }

      Resource sciResource = getJarFor(sci);
      if (isFromExcludedJar(context, sci, sciResource)) {
        if (LOG.isDebugEnabled()) LOG.debug("{} is from excluded jar", sci);
        continue;
      }

      // check containerInitializerOrdering doesn't exclude it
      String name = sci.getClass().getName();
      if (initializerOrdering != null
          && (!initializerOrdering.hasWildcard() && initializerOrdering.getIndexOf(name) < 0)) {
        if (LOG.isDebugEnabled()) LOG.debug("{} is excluded by ordering", sci);
        continue;
      }

      sciResourceMap.put(sci, sciResource);
    }

    // Order the SCIs that are included
    if (initializerOrdering != null && !initializerOrdering.isDefaultOrder()) {
      if (LOG.isDebugEnabled())
        LOG.debug("Ordering ServletContainerInitializers with " + initializerOrdering);

      // There is an ordering that is not just "*".
      // Arrange ServletContainerInitializers according to the ordering of classnames given,
      // irrespective of coming from container or webapp classpaths
      nonExcludedInitializers.addAll(sciResourceMap.keySet());
      Collections.sort(
          nonExcludedInitializers, new ServletContainerInitializerComparator(initializerOrdering));
    } else {
      // No jetty-specific ordering specified, or just the wildcard value "*" specified.
      // Fallback to ordering the ServletContainerInitializers according to:
      // container classpath first, WEB-INF/classes then WEB-INF/lib (obeying any web.xml jar
      // ordering)

      // no web.xml ordering defined, add SCIs in any order
      if (context.getMetaData().getOrdering() == null) {
        if (LOG.isDebugEnabled())
          LOG.debug("No web.xml ordering, ServletContainerInitializers in random order");
        nonExcludedInitializers.addAll(sciResourceMap.keySet());
      } else {
        if (LOG.isDebugEnabled())
          LOG.debug(
              "Ordering ServletContainerInitializers with ordering {}",
              context.getMetaData().getOrdering());
        for (Map.Entry<ServletContainerInitializer, Resource> entry : sciResourceMap.entrySet()) {
          // add in SCIs from the container classpath
          if (entry.getKey().getClass().getClassLoader() == context.getClassLoader().getParent())
            nonExcludedInitializers.add(entry.getKey());
          else if (entry.getValue()
              == null) // add in SCIs not in a jar, as they must be from WEB-INF/classes and can't
                       // be ordered
          nonExcludedInitializers.add(entry.getKey());
        }

        // add SCIs according to the ordering of its containing jar
        for (Resource webInfJar : context.getMetaData().getOrderedWebInfJars()) {
          for (Map.Entry<ServletContainerInitializer, Resource> entry : sciResourceMap.entrySet()) {
            if (webInfJar.equals(entry.getValue())) nonExcludedInitializers.add(entry.getKey());
          }
        }
      }
    }

    if (LOG.isDebugEnabled()) {
      int i = 0;
      for (ServletContainerInitializer sci : nonExcludedInitializers)
        LOG.debug("ServletContainerInitializer: {} {}", (++i), sci.getClass().getName());
    }
    return nonExcludedInitializers;
  }
コード例 #9
0
  /**
   * Perform scanning of classes for annotations
   *
   * @param context
   * @throws Exception
   */
  protected void scanForAnnotations(WebAppContext context) throws Exception {
    AnnotationParser parser = createAnnotationParser();
    _parserTasks = new ArrayList<ParserTask>();

    long start = 0;

    if (LOG.isDebugEnabled())
      LOG.debug(
          "Annotation scanning commencing: webxml={}, metadatacomplete={}, configurationDiscovered={}, multiThreaded={}, maxScanWait={}",
          context.getServletContext().getEffectiveMajorVersion(),
          context.getMetaData().isMetaDataComplete(),
          context.isConfigurationDiscovered(),
          isUseMultiThreading(context),
          getMaxScanWait(context));

    parseContainerPath(context, parser);
    // email from Rajiv Mordani jsrs 315 7 April 2010
    //    If there is a <others/> then the ordering should be
    //          WEB-INF/classes the order of the declared elements + others.
    //    In case there is no others then it is
    //          WEB-INF/classes + order of the elements.
    parseWebInfClasses(context, parser);
    parseWebInfLib(context, parser);

    start = System.nanoTime();

    // execute scan, either effectively synchronously (1 thread only), or asynchronously (limited by
    // number of processors available)
    final Semaphore task_limit =
        (isUseMultiThreading(context)
            ? new Semaphore(Runtime.getRuntime().availableProcessors())
            : new Semaphore(1));
    final CountDownLatch latch = new CountDownLatch(_parserTasks.size());
    final MultiException me = new MultiException();

    for (final ParserTask p : _parserTasks) {
      task_limit.acquire();
      context
          .getServer()
          .getThreadPool()
          .execute(
              new Runnable() {
                @Override
                public void run() {
                  try {
                    p.call();
                  } catch (Exception e) {
                    me.add(e);
                  } finally {
                    task_limit.release();
                    latch.countDown();
                  }
                }
              });
    }

    boolean timeout = !latch.await(getMaxScanWait(context), TimeUnit.SECONDS);

    if (LOG.isDebugEnabled()) {
      for (ParserTask p : _parserTasks)
        LOG.debug(
            "Scanned {} in {}ms",
            p.getResource(),
            TimeUnit.MILLISECONDS.convert(p.getStatistic().getElapsed(), TimeUnit.NANOSECONDS));

      LOG.debug(
          "Scanned {} container path jars, {} WEB-INF/lib jars, {} WEB-INF/classes dirs in {}ms for context {}",
          _containerPathStats.getTotal(),
          _webInfLibStats.getTotal(),
          _webInfClassesStats.getTotal(),
          (TimeUnit.MILLISECONDS.convert(System.nanoTime() - start, TimeUnit.NANOSECONDS)),
          context);
    }

    if (timeout) me.add(new Exception("Timeout scanning annotations"));
    me.ifExceptionThrow();
  }