Beispiel #1
0
 protected static void verifyServices(
     ServiceRegistry services, Set<Class<? extends Service>> requiredServices, Object target) {
   for (Class<? extends Service> serviceType : requiredServices) {
     if (!services.contains(serviceType)) {
       throw BootstrapLogger.LOG.unspecifiedRequiredService(serviceType.getName(), target);
     }
   }
 }
Beispiel #2
0
 private void setupInitialServices() {
   if (initialServices.contains(TypeStore.class)) {
     return;
   }
   // instantiate initial services which we need for this phase
   TypeStore store = new TypeStore();
   SharedObjectCache cache = new SharedObjectCache();
   ReflectionCache reflectionCache = ReflectionCacheFactory.newInstance(store);
   ClassTransformer classTransformer =
       new ClassTransformer(store, cache, reflectionCache, contextId);
   initialServices.add(TypeStore.class, store);
   initialServices.add(SharedObjectCache.class, cache);
   initialServices.add(ReflectionCache.class, reflectionCache);
   initialServices.add(ClassTransformer.class, classTransformer);
 }
Beispiel #3
0
  private void addImplementationServices(ServiceRegistry services) {
    final WeldModules modules = new WeldModules();
    services.add(WeldModules.class, modules);

    final WeldConfiguration configuration = services.get(WeldConfiguration.class);
    services.add(SlimAnnotatedTypeStore.class, new SlimAnnotatedTypeStoreImpl());
    if (services.get(ClassTransformer.class) == null) {
      throw new IllegalStateException(ClassTransformer.class.getSimpleName() + " not installed.");
    }
    services.add(
        MemberTransformer.class, new MemberTransformer(services.get(ClassTransformer.class)));
    services.add(
        MetaAnnotationStore.class, new MetaAnnotationStore(services.get(ClassTransformer.class)));

    BeanIdentifierIndex beanIdentifierIndex = null;
    if (configuration.getBooleanProperty(ConfigurationKey.BEAN_IDENTIFIER_INDEX_OPTIMIZATION)) {
      beanIdentifierIndex = new BeanIdentifierIndex();
      services.add(BeanIdentifierIndex.class, beanIdentifierIndex);
    }

    services.add(ContextualStore.class, new ContextualStoreImpl(contextId, beanIdentifierIndex));
    services.add(CurrentInjectionPoint.class, new CurrentInjectionPoint());
    services.add(CurrentEventMetadata.class, new CurrentEventMetadata());
    services.add(
        SpecializationAndEnablementRegistry.class, new SpecializationAndEnablementRegistry());
    services.add(MissingDependenciesRegistry.class, new MissingDependenciesRegistry());

    /*
     * Setup ExecutorServices
     */
    ExecutorServices executor = services.get(ExecutorServices.class);
    if (executor == null) {
      executor = ExecutorServicesFactory.create(DefaultResourceLoader.INSTANCE, configuration);
      if (executor != null) {
        services.add(ExecutorServices.class, executor);
      }
    }

    services.add(
        RequiredAnnotationDiscovery.class,
        new RequiredAnnotationDiscovery(services.get(ReflectionCache.class)));

    services.add(GlobalEnablementBuilder.class, new GlobalEnablementBuilder());
    if (!services.contains(HttpContextActivationFilter.class)) {
      services.add(
          HttpContextActivationFilter.class, AcceptingHttpContextActivationFilter.INSTANCE);
    }
    services.add(ProtectionDomainCache.class, new ProtectionDomainCache());

    services.add(ProxyInstantiator.class, ProxyInstantiator.Factory.create(configuration));

    services.add(ObserverNotifierFactory.class, DefaultObserverNotifierFactory.INSTANCE);

    services.add(ResourceInjectionFactory.class, new ResourceInjectionFactory());

    modules.postServiceRegistration(contextId, services);

    /*
     * Setup Validator
     */
    if (configuration.getBooleanProperty(ConfigurationKey.CONCURRENT_DEPLOYMENT)
        && services.contains(ExecutorServices.class)) {
      services.add(
          Validator.class, new ConcurrentValidator(modules.getPluggableValidators(), executor));
    } else {
      services.add(Validator.class, new Validator(modules.getPluggableValidators()));
    }

    GlobalObserverNotifierService observerNotificationService =
        new GlobalObserverNotifierService(services, contextId);
    services.add(GlobalObserverNotifierService.class, observerNotificationService);

    /*
     * Preloader for container lifecycle events
     */
    ContainerLifecycleEventPreloader preloader = null;
    int preloaderThreadPoolSize =
        configuration.getIntegerProperty(ConfigurationKey.PRELOADER_THREAD_POOL_SIZE);
    if (preloaderThreadPoolSize > 0 && Permissions.hasPermission(Permissions.MODIFY_THREAD_GROUP)) {
      preloader =
          new ContainerLifecycleEventPreloader(
              preloaderThreadPoolSize,
              observerNotificationService.getGlobalLenientObserverNotifier());
    }
    services.add(
        ContainerLifecycleEvents.class,
        new ContainerLifecycleEvents(preloader, services.get(RequiredAnnotationDiscovery.class)));
    if (isEEModulesAwareEnvironment()) {
      services.add(BeanDeploymentModules.class, new BeanDeploymentModules(contextId, services));
    }
  }
Beispiel #4
0
  public WeldRuntime startContainer(
      String contextId, Environment environment, Deployment deployment) {
    if (deployment == null) {
      throw BootstrapLogger.LOG.deploymentRequired();
    }

    checkApiVersion();

    final ServiceRegistry registry = deployment.getServices();

    // initiate part of registry in order to allow access to WeldConfiguration
    new AdditionalServiceLoader(deployment).loadAdditionalServices(registry);

    // Resource Loader has to be loaded prior to WeldConfiguration
    if (!registry.contains(ResourceLoader.class)) {
      registry.add(ResourceLoader.class, DefaultResourceLoader.INSTANCE);
    }

    WeldConfiguration configuration = new WeldConfiguration(registry, deployment);
    registry.add(WeldConfiguration.class, configuration);

    String finalContextId =
        BeanDeployments.getFinalId(
            contextId,
            registry.get(WeldConfiguration.class).getStringProperty(ROLLING_UPGRADES_ID_DELIMITER));
    this.contextId = finalContextId;
    this.deployment = deployment;
    this.environment = environment;

    if (this.extensions == null) {
      setExtensions(deployment.getExtensions());
    }
    // Add extension to register built-in components
    this.extensions.add(MetadataImpl.from(new WeldExtension()));

    // Add Weld extensions
    String vetoTypeRegex =
        configuration.getStringProperty(
            ConfigurationKey.VETO_TYPES_WITHOUT_BEAN_DEFINING_ANNOTATION);
    if (!vetoTypeRegex.isEmpty()) {
      this.extensions.add(MetadataImpl.from(new WeldVetoExtension(vetoTypeRegex)));
    }

    // Finish the rest of registry init, setupInitialServices() requires already changed
    // finalContextId
    setupInitialServices();
    registry.addAll(initialServices.entrySet());

    if (!registry.contains(ProxyServices.class)) {
      registry.add(ProxyServices.class, new SimpleProxyServices());
    }
    if (!registry.contains(SecurityServices.class)) {
      registry.add(SecurityServices.class, NoopSecurityServices.INSTANCE);
    }

    addImplementationServices(registry);

    verifyServices(registry, environment.getRequiredDeploymentServices(), contextId);
    if (!registry.contains(TransactionServices.class)) {
      BootstrapLogger.LOG.jtaUnavailable();
    }

    this.deploymentManager = BeanManagerImpl.newRootManager(finalContextId, "deployment", registry);

    Container.initialize(
        finalContextId,
        deploymentManager,
        ServiceRegistries.unmodifiableServiceRegistry(deployment.getServices()));
    getContainer().setState(ContainerState.STARTING);

    this.contexts = createContexts(registry);

    this.bdaMapping = new BeanDeploymentArchiveMapping();
    this.deploymentVisitor =
        new DeploymentVisitor(deploymentManager, environment, deployment, contexts, bdaMapping);

    if (deployment instanceof CDI11Deployment) {
      registry.add(
          BeanManagerLookupService.class,
          new BeanManagerLookupService(
              (CDI11Deployment) deployment, bdaMapping.getBdaToBeanManagerMap()));
    } else {
      BootstrapLogger.LOG.legacyDeploymentMetadataProvided();
    }

    // Read the deployment structure, bdaMapping will be the physical structure
    // as caused by the presence of beans.xml
    deploymentVisitor.visit();

    return new WeldRuntime(finalContextId, deploymentManager, bdaMapping.getBdaToBeanManagerMap());
  }