Beispiel #1
0
  private Set<String> scanPackages() {

    if (packages.isEmpty()) {
      return Collections.emptySet();
    }

    Set<String> foundClasses = new HashSet<String>();

    for (PackInfo packInfo : packages) {

      ClassLoader cl = packInfo.getClassLoaderRef().get();
      if (cl == null) {
        continue;
      }
      String packName = packInfo.getPackName();
      URL resourceUrl =
          cl.getResource(
              packInfo.getPackClassName().replace('.', '/') + Files.CLASS_FILE_EXTENSION);

      if (resourceUrl != null) {

        WeldSELogger.LOG.scanningPackage(packName, resourceUrl);

        try {
          URI resourceUri = resourceUrl.toURI();

          if (PROCOTOL_FILE.equals(resourceUrl.getProtocol())) {
            // Get the package directory, e.g. "file:///home/weld/org/jboss
            handleDir(
                new File(resourceUri).getParentFile(),
                packInfo.isScanRecursively(),
                packName,
                foundClasses);
          } else if (PROCOTOL_JAR.equals(resourceUrl.getProtocol())) {
            handleJar(resourceUri, packInfo.isScanRecursively(), packName, foundClasses);
          } else {
            WeldSELogger.LOG.resourceUrlProtocolNotSupported(resourceUrl);
          }

        } catch (URISyntaxException e) {
          CommonLogger.LOG.couldNotReadResource(resourceUrl, e);
        }
      } else {
        WeldSELogger.LOG.packageNotFound(packName);
      }
    }
    return foundClasses;
  }
 private Class<?> loadClass(String className) {
   log.trace("Loading class with class loader: " + className);
   Class<?> clazz = null;
   try {
     clazz = classLoader.loadClass(className);
   } catch (ClassNotFoundException ex) {
     throw WeldSELogger.LOG.unableToLoadClass(className);
   }
   return clazz;
 }
Beispiel #3
0
 /**
  * @param id
  * @param manager
  * @param bootstrap
  * @return the initialized Weld container
  */
 static WeldContainer initialize(String id, WeldManager manager, Bootstrap bootstrap) {
   if (SINGLETON.isSet(id)) {
     throw WeldSELogger.LOG.weldContainerAlreadyRunning(id);
   }
   WeldContainer weldContainer = new WeldContainer(id, manager, bootstrap);
   SINGLETON.set(id, weldContainer);
   RUNNING_CONTAINER_IDS.add(id);
   WeldSELogger.LOG.weldContainerInitialized(id);
   manager.fireEvent(new ContainerInitialized(id), InitializedLiteral.APPLICATION);
   // If needed, register one shutdown hook for all containers
   if (isShutdownHookNeeded() && shutdownHook == null) {
     synchronized (LOCK) {
       if (shutdownHook == null) {
         shutdownHook = new ShutdownHook();
         Runtime.getRuntime().addShutdownHook(shutdownHook);
       }
     }
   }
   return weldContainer;
 }
Beispiel #4
0
 /**
  * Shutdown the container.
  *
  * @see Weld#initialize()
  */
 public synchronized void shutdown() {
   if (isRunning()) {
     try {
       manager.fireEvent(new ContainerShutdown(id), DestroyedLiteral.APPLICATION);
     } finally {
       SINGLETON.clear(id);
       RUNNING_CONTAINER_IDS.remove(id);
       // Destroy all the dependent beans correctly
       creationalContext.release();
       bootstrap.shutdown();
       WeldSELogger.LOG.weldContainerShutdown(id);
     }
   } else {
     if (WeldSELogger.LOG.isTraceEnabled()) {
       WeldSELogger.LOG.tracev(
           "Spurious call to shutdown from: {0}",
           (Object[]) Thread.currentThread().getStackTrace());
     }
     throw WeldSELogger.LOG.weldContainerAlreadyShutDown(id);
   }
 }
Beispiel #5
0
  /**
   * Extensions to Weld SE can subclass and override this method to customize the deployment before
   * weld boots up. For example, to add a custom ResourceLoader, you would subclass Weld like so:
   *
   * <pre>
   * public class MyWeld extends Weld {
   *     protected Deployment createDeployment(ResourceLoader resourceLoader, CDI11Bootstrap bootstrap) {
   *         return super.createDeployment(new MyResourceLoader(), bootstrap);
   *     }
   * }
   * </pre>
   *
   * <p>This could then be used as normal:
   *
   * <pre>
   * WeldContainer container = new MyWeld().initialize();
   * </pre>
   *
   * @param resourceLoader
   * @param bootstrap
   */
  protected Deployment createDeployment(ResourceLoader resourceLoader, CDI11Bootstrap bootstrap) {

    final Iterable<Metadata<Extension>> extensions =
        getExtensions(WeldResourceLoader.getClassLoader(), bootstrap);
    final TypeDiscoveryConfiguration typeDiscoveryConfiguration =
        bootstrap.startExtensions(extensions);
    final Deployment deployment;
    final Set<WeldBeanDeploymentArchive> beanArchives = new HashSet<WeldBeanDeploymentArchive>();
    final Map<Class<? extends Service>, Service> additionalServices = new HashMap<>();

    if (discoveryEnabled) {
      DiscoveryStrategy strategy =
          DiscoveryStrategyFactory.create(
              resourceLoader,
              bootstrap,
              ImmutableSet.<Class<? extends Annotation>>builder()
                  .addAll(typeDiscoveryConfiguration.getKnownBeanDefiningAnnotations())
                  // Add ThreadScoped manually as Weld SE doesn't support implicit bean archives
                  // without beans.xml
                  .add(ThreadScoped.class)
                  .build());
      beanArchives.addAll(strategy.performDiscovery());
      ClassFileServices classFileServices = strategy.getClassFileServices();
      if (classFileServices != null) {
        additionalServices.put(ClassFileServices.class, classFileServices);
      }
    }

    if (isSyntheticBeanArchiveRequired()) {
      ImmutableSet.Builder<String> beanClassesBuilder = ImmutableSet.builder();
      beanClassesBuilder.addAll(scanPackages());
      WeldBeanDeploymentArchive syntheticBeanArchive =
          new WeldBeanDeploymentArchive(
              WeldDeployment.SYNTHETIC_BDA_ID,
              beanClassesBuilder.build(),
              buildSyntheticBeansXml(),
              Collections.emptySet(),
              ImmutableSet.copyOf(beanClasses));
      beanArchives.add(syntheticBeanArchive);
    }

    if (beanArchives.isEmpty() && beanBuilders.isEmpty()) {
      throw WeldSELogger.LOG.weldContainerCannotBeInitializedNoBeanArchivesFound();
    }

    Multimap<String, BeanDeploymentArchive> problems =
        BeanArchives.findBeanClassesDeployedInMultipleBeanArchives(beanArchives);
    if (!problems.isEmpty()) {
      // Right now, we only log a warning for each bean class deployed in multiple bean archives
      for (Entry<String, Collection<BeanDeploymentArchive>> entry : problems.entrySet()) {
        WeldSELogger.LOG.beanClassDeployedInMultipleBeanArchives(
            entry.getKey(), WeldCollections.toMultiRowString(entry.getValue()));
      }
    }

    String isolation =
        AccessController.doPrivileged(
            new GetSystemPropertyAction(ARCHIVE_ISOLATION_SYSTEM_PROPERTY));

    if (isolation != null && Boolean.valueOf(isolation).equals(Boolean.FALSE)) {
      Set<WeldBeanDeploymentArchive> flatDeploymentArchives =
          new HashSet<WeldBeanDeploymentArchive>();
      flatDeploymentArchives.add(WeldBeanDeploymentArchive.merge(bootstrap, beanArchives));
      deployment =
          new WeldDeployment(resourceLoader, bootstrap, flatDeploymentArchives, extensions);
      CommonLogger.LOG.archiveIsolationDisabled();
    } else {
      deployment = new WeldDeployment(resourceLoader, bootstrap, beanArchives, extensions);
      CommonLogger.LOG.archiveIsolationEnabled();
    }

    deployment.getServices().addAll(additionalServices.entrySet());
    return deployment;
  }