コード例 #1
0
  public void visitContainerInitializer(
      WebAppContext context, ContainerInitializer containerInitializer) {
    if (containerInitializer == null) return;

    // add the ContainerInitializer to the list of container initializers
    List<ContainerInitializer> containerInitializers =
        (List<ContainerInitializer>)
            context.getAttribute(AnnotationConfiguration.CONTAINER_INITIALIZERS);
    if (containerInitializers == null) {
      containerInitializers = new ArrayList<ContainerInitializer>();
      context.setAttribute(AnnotationConfiguration.CONTAINER_INITIALIZERS, containerInitializers);
    }

    containerInitializers.add(containerInitializer);

    // Ensure a bean is set up on the context that will invoke the ContainerInitializers as the
    // context starts
    ServletContainerInitializersStarter starter =
        (ServletContainerInitializersStarter)
            context.getAttribute(AnnotationConfiguration.CONTAINER_INITIALIZER_STARTER);
    if (starter == null) {
      starter = new ServletContainerInitializersStarter(context);
      context.setAttribute(AnnotationConfiguration.CONTAINER_INITIALIZER_STARTER, starter);
      context.addBean(starter, true);
    }
  }
コード例 #2
0
  /**
   * @see
   *     org.eclipse.jetty.webapp.AbstractConfiguration#postConfigure(org.eclipse.jetty.webapp.WebAppContext)
   */
  @Override
  public void postConfigure(WebAppContext context) throws Exception {
    ConcurrentHashMap<String, ConcurrentHashSet<String>> classMap =
        (ClassInheritanceMap) context.getAttribute(CLASS_INHERITANCE_MAP);
    List<ContainerInitializer> initializers =
        (List<ContainerInitializer>) context.getAttribute(CONTAINER_INITIALIZERS);

    context.removeAttribute(CLASS_INHERITANCE_MAP);
    if (classMap != null) classMap.clear();

    context.removeAttribute(CONTAINER_INITIALIZERS);
    if (initializers != null) initializers.clear();

    if (_discoverableAnnotationHandlers != null) _discoverableAnnotationHandlers.clear();

    _classInheritanceHandler = null;
    if (_containerInitializerAnnotationHandlers != null)
      _containerInitializerAnnotationHandlers.clear();

    if (_parserTasks != null) {
      _parserTasks.clear();
      _parserTasks = null;
    }

    super.postConfigure(context);
  }
コード例 #3
0
  /**
   * @param context
   * @param scis
   * @throws Exception
   */
  public void createServletContainerInitializerAnnotationHandlers(
      WebAppContext context, List<ServletContainerInitializer> scis) throws Exception {
    if (scis == null || scis.isEmpty()) return; // nothing to do

    List<ContainerInitializer> initializers = new ArrayList<ContainerInitializer>();
    context.setAttribute(CONTAINER_INITIALIZERS, initializers);

    for (ServletContainerInitializer service : scis) {
      HandlesTypes annotation = service.getClass().getAnnotation(HandlesTypes.class);
      ContainerInitializer initializer = null;
      if (annotation != null) {
        // There is a HandlesTypes annotation on the on the ServletContainerInitializer
        Class<?>[] classes = annotation.value();
        if (classes != null) {
          initializer = new ContainerInitializer(service, classes);

          // If we haven't already done so, we need to register a handler that will
          // process the whole class hierarchy to satisfy the ServletContainerInitializer
          if (context.getAttribute(CLASS_INHERITANCE_MAP) == null) {
            // MultiMap<String> map = new MultiMap<>();
            ConcurrentHashMap<String, ConcurrentHashSet<String>> map = new ClassInheritanceMap();
            context.setAttribute(CLASS_INHERITANCE_MAP, map);
            _classInheritanceHandler = new ClassInheritanceHandler(map);
          }

          for (Class<?> c : classes) {
            // The value of one of the HandlesTypes classes is actually an Annotation itself so
            // register a handler for it
            if (c.isAnnotation()) {
              if (LOG.isDebugEnabled())
                LOG.debug("Registering annotation handler for " + c.getName());
              _containerInitializerAnnotationHandlers.add(
                  new ContainerInitializerAnnotationHandler(initializer, c));
            }
          }
        } else {
          initializer = new ContainerInitializer(service, null);
          if (LOG.isDebugEnabled())
            LOG.debug("No classes in HandlesTypes on initializer " + service.getClass());
        }
      } else {
        initializer = new ContainerInitializer(service, null);
        if (LOG.isDebugEnabled()) LOG.debug("No annotation on initializer " + service.getClass());
      }

      initializers.add(initializer);
    }

    // add a bean to the context which will call the servletcontainerinitializers when appropriate
    ServletContainerInitializersStarter starter =
        (ServletContainerInitializersStarter) context.getAttribute(CONTAINER_INITIALIZER_STARTER);
    if (starter != null)
      throw new IllegalStateException("ServletContainerInitializersStarter already exists");
    starter = new ServletContainerInitializersStarter(context);
    context.setAttribute(CONTAINER_INITIALIZER_STARTER, starter);
    context.addBean(starter, true);
  }
コード例 #4
0
 @Override
 public void preConfigure(final WebAppContext context) throws Exception {
   _webAppClassNameResolver = new WebAppClassNameResolver(context);
   _containerClassNameResolver = new ContainerClassNameResolver(context);
   String tmp = (String) context.getAttribute(SERVLET_CONTAINER_INITIALIZER_EXCLUSION_PATTERN);
   _sciExcludePattern = (tmp == null ? null : Pattern.compile(tmp));
 }
コード例 #5
0
  /**
   * Jetty-specific extension that allows an ordering to be applied across ALL
   * ServletContainerInitializers.
   *
   * @return
   */
  public ServletContainerInitializerOrdering getInitializerOrdering(WebAppContext context) {
    if (context == null) return null;

    String tmp = (String) context.getAttribute(SERVLET_CONTAINER_INITIALIZER_ORDER);
    if (tmp == null || "".equals(tmp.trim())) return null;

    return new ServletContainerInitializerOrdering(tmp);
  }
コード例 #6
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);
        }
      }
    }
  }
コード例 #7
0
 @Override
 public void deconfigure(WebAppContext context) throws Exception {
   context.removeAttribute(CLASS_INHERITANCE_MAP);
   context.removeAttribute(CONTAINER_INITIALIZERS);
   ServletContainerInitializersStarter starter =
       (ServletContainerInitializersStarter) context.getAttribute(CONTAINER_INITIALIZER_STARTER);
   if (starter != null) {
     context.removeBean(starter);
     context.removeAttribute(CONTAINER_INITIALIZER_STARTER);
   }
 }
コード例 #8
0
 /**
  * Overriden method which, contrary to the original implementation in the parent class, add
  * directly the web-fragment.xml resource to the MetaData, instead of re-creating it with a forced
  * jar prefix.
  */
 @Override
 @SuppressWarnings("unchecked")
 public void findWebFragments(final WebAppContext context, final MetaData metaData)
     throws Exception {
   List<Resource> frags = (List<Resource>) context.getAttribute(FRAGMENT_RESOURCES);
   if (frags != null) {
     for (Resource frag : frags) {
       Resource parentResource = Util.chop(frag.getURL(), "/META-INF/web-fragment.xml");
       metaData.addFragment(parentResource, frag);
     }
   }
 }
コード例 #9
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);
    }
  }
コード例 #10
0
 /**
  * Work out how long we should wait for the async scanning to occur.
  *
  * @param context
  * @return
  */
 protected int getMaxScanWait(WebAppContext context) {
   // try context attribute to get max time in sec to wait for scan completion
   Object o = context.getAttribute(MAX_SCAN_WAIT);
   if (o != null && o instanceof Number) {
     return ((Number) o).intValue();
   }
   // try server attribute to get max time in sec to wait for scan completion
   o = context.getServer().getAttribute(MAX_SCAN_WAIT);
   if (o != null && o instanceof Number) {
     return ((Number) o).intValue();
   }
   // try system property to get max time in sec to wait for scan completion
   return Integer.getInteger(MAX_SCAN_WAIT, DEFAULT_MAX_SCAN_WAIT).intValue();
 }
コード例 #11
0
 public void visitMetaInfResource(WebAppContext context, Resource dir) {
   Collection<Resource> metaInfResources =
       (Collection<Resource>) context.getAttribute(MetaInfConfiguration.METAINF_RESOURCES);
   if (metaInfResources == null) {
     metaInfResources = new HashSet<Resource>();
     context.setAttribute(MetaInfConfiguration.METAINF_RESOURCES, metaInfResources);
   }
   metaInfResources.add(dir);
   // also add to base resource of webapp
   Resource[] collection = new Resource[metaInfResources.size() + 1];
   int i = 0;
   collection[i++] = context.getBaseResource();
   for (Resource resource : metaInfResources) collection[i++] = resource;
   context.setBaseResource(new ResourceCollection(collection));
 }
コード例 #12
0
 /**
  * Check if we should use multiple threads to scan for annotations or not
  *
  * @param context
  * @return
  */
 protected boolean isUseMultiThreading(WebAppContext context) {
   // try context attribute to see if we should use multithreading
   Object o = context.getAttribute(MULTI_THREADED);
   if (o instanceof Boolean) {
     return ((Boolean) o).booleanValue();
   }
   // try server attribute to see if we should use multithreading
   o = context.getServer().getAttribute(MULTI_THREADED);
   if (o instanceof Boolean) {
     return ((Boolean) o).booleanValue();
   }
   // try system property to see if we should use multithreading
   return Boolean.valueOf(
       System.getProperty(MULTI_THREADED, Boolean.toString(DEFAULT_MULTI_THREADED)));
 }
コード例 #13
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);
        }
      }
    }
  }
コード例 #14
0
  /**
   * @param context
   * @param descriptor
   * @param node
   */
  public void visitContextParam(WebAppContext context, Descriptor descriptor, XmlParser.Node node)
      throws Exception {
    String name = node.getString("param-name", false, true);
    String value = node.getString("param-value", false, true);
    List<String> values = new ArrayList<>();

    // extract values
    switch (name) {
      case ServletContext.ORDERED_LIBS:
      case AnnotationConfiguration.CONTAINER_INITIALIZERS:
      case MetaInfConfiguration.METAINF_TLDS:
      case MetaInfConfiguration.METAINF_RESOURCES:
        context.removeAttribute(name);

        QuotedStringTokenizer tok = new QuotedStringTokenizer(value, ",");
        while (tok.hasMoreElements()) values.add(tok.nextToken().trim());

        break;

      default:
        values.add(value);
    }

    // handle values
    switch (name) {
      case ServletContext.ORDERED_LIBS:
        {
          List<Object> libs = new ArrayList<>();
          Object o = context.getAttribute(ServletContext.ORDERED_LIBS);
          if (o instanceof Collection<?>) libs.addAll((Collection<?>) o);
          libs.addAll(values);
          if (libs.size() > 0) context.setAttribute(ServletContext.ORDERED_LIBS, libs);

          break;
        }

      case AnnotationConfiguration.CONTAINER_INITIALIZERS:
        {
          for (String i : values)
            visitContainerInitializer(
                context,
                new ContainerInitializer(Thread.currentThread().getContextClassLoader(), i));
          break;
        }

      case MetaInfConfiguration.METAINF_TLDS:
        {
          List<Object> tlds = new ArrayList<>();
          String war = context.getBaseResource().getURI().toString();
          Object o = context.getAttribute(MetaInfConfiguration.METAINF_TLDS);
          if (o instanceof Collection<?>) tlds.addAll((Collection<?>) o);
          for (String i : values) {
            Resource r = Resource.newResource(i.replace("${WAR}/", war));
            if (r.exists()) tlds.add(r.getURL());
            else throw new IllegalArgumentException("TLD not found: " + r);
          }

          if (tlds.size() > 0) context.setAttribute(MetaInfConfiguration.METAINF_TLDS, tlds);
          break;
        }

      case MetaInfConfiguration.METAINF_RESOURCES:
        {
          String war = context.getBaseResource().getURI().toString();
          for (String i : values) {
            Resource r = Resource.newResource(i.replace("${WAR}/", war));
            if (r.exists()) visitMetaInfResource(context, r);
            else throw new IllegalArgumentException("Resource not found: " + r);
          }
          break;
        }

      default:
    }
  }