Merge pull request #6061 from eclipse-vertx/service-loading-controrl-5.0

Service loading control

Author: vietj

vertx-core/src/main/java/io/vertx/core/impl/VertxBootstrapImpl.java

@@ -15,23 +15,20 @@
 import io.vertx.core.impl.transports.NioTransport;
 import io.vertx.core.internal.VertxBootstrap;
 import io.vertx.core.eventbus.impl.clustered.DefaultNodeSelector;
+import io.vertx.core.spi.*;
 import io.vertx.core.spi.context.executor.EventExecutorProvider;
 import io.vertx.core.spi.file.FileResolver;
 import io.vertx.core.file.impl.FileResolverImpl;
 import io.vertx.core.internal.logging.Logger;
 import io.vertx.core.internal.logging.LoggerFactory;
 import io.vertx.core.json.JsonObject;
 import io.vertx.core.spi.transport.Transport;
-import io.vertx.core.spi.ExecutorServiceFactory;
-import io.vertx.core.spi.VertxMetricsFactory;
-import io.vertx.core.spi.VertxServiceProvider;
-import io.vertx.core.spi.VertxThreadFactory;
-import io.vertx.core.spi.VertxTracerFactory;
 import io.vertx.core.spi.cluster.ClusterManager;
 import io.vertx.core.eventbus.impl.clustered.NodeSelector;
 import io.vertx.core.spi.metrics.VertxMetrics;
 import io.vertx.core.spi.tracing.VertxTracer;
 
+import java.util.ArrayList;
 import java.util.Collection;
 import java.util.List;
 
@@ -51,13 +48,15 @@ public class VertxBootstrapImpl implements VertxBootstrap {
   private EventExecutorProvider eventExecutorProvider;
   private ClusterManager clusterManager;
   private NodeSelector clusterNodeSelector;
+  private List<VertxServiceProvider> serviceProviders;
   private VertxTracerFactory tracerFactory;
   private VertxTracer tracer;
   private VertxThreadFactory threadFactory;
   private ExecutorServiceFactory executorServiceFactory;
   private VertxMetricsFactory metricsFactory;
   private VertxMetrics metrics;
   private FileResolver fileResolver;
+  private List<VerticleFactory> verticleFactories;
 
   public VertxBootstrapImpl(JsonObject config) {
     this(new VertxOptions(config));
@@ -85,7 +84,7 @@ public VertxBootstrap options(VertxOptions options) {
   }
 
   @Override
-  public VertxBootstrap enableShadowContext(boolean option) {
+  public VertxBootstrapImpl enableShadowContext(boolean option) {
     this.enableShadowContext = option;
     return this;
   }
@@ -98,7 +97,7 @@ public JsonObject config() {
   }
 
   @Override
-  public VertxBootstrap eventExecutorProvider(EventExecutorProvider provider) {
+  public VertxBootstrapImpl eventExecutorProvider(EventExecutorProvider provider) {
     this.eventExecutorProvider = provider;
     return this;
   }
@@ -163,6 +162,25 @@ public VertxBootstrapImpl tracerFactory(VertxTracerFactory factory) {
     return this;
   }
 
+  /**
+   * @return the list of service providers to use
+   */
+  public List<VertxServiceProvider> serviceProviders() {
+    return serviceProviders;
+  }
+
+  /**
+   * Set the list of service providers to use, when the list is {@code null}, Java's service loader
+   * mechanism will be used to discover service providers.
+   *
+   * @param providers the service providers
+   * @return this builder instance
+   */
+  public VertxBootstrapImpl serviceProviders(List<VertxServiceProvider> providers) {
+    this.serviceProviders = providers;
+    return this;
+  }
+
   public VertxTracer tracer() {
     return tracer;
   }
@@ -245,7 +263,7 @@ private VertxImpl instantiateVertx(ClusterManager clusterManager, NodeSelector n
 
   public Vertx vertx() {
     VertxImpl vertx = instantiateVertx(null, null);
-    vertx.init();
+    vertx.init(verticleFactories);
     return vertx;
   }
 
@@ -261,27 +279,48 @@ public Future<Vertx> clusteredVertx() {
       nodeSelector = new DefaultNodeSelector();
     }
     VertxImpl vertx = instantiateVertx(clusterManager, nodeSelector);
-    return vertx.initClustered(options);
+    return vertx.initClustered(options, verticleFactories);
   }
 
   /**
-   * Initialize the service providers.
-   * @return this builder instance
+   * @return the verticle factories to use
+   */
+  public List<VerticleFactory> verticleFactories() {
+    return verticleFactories;
+  }
+
+  /**
+   * Set the list of {@code VerticleFactory} to use.
+   *
+   * @param verticleFactories the verticle factories
+   * @return the builder instance
    */
+  public VertxBootstrapImpl verticleFactories(List<VerticleFactory> verticleFactories) {
+    this.verticleFactories = verticleFactories;
+    return this;
+  }
+
+  @Override
   public VertxBootstrapImpl init() {
+    List<VertxServiceProvider> providers = new ArrayList<>();
     initTransport();
     initMetrics();
     initTracing();
-    List<VertxServiceProvider> providers = ServiceHelper.loadFactories(VertxServiceProvider.class);
     initProviders(providers);
     initThreadFactory();
     initExecutorServiceFactory();
     initFileResolver();
+    initVerticleFactories();
     return this;
   }
 
-  private void initProviders(Collection<VertxServiceProvider> providers) {
-    for (VertxServiceProvider provider : providers) {
+  private void initProviders(Collection<VertxServiceProvider> toInit) {
+    List<VertxServiceProvider> serviceProviders = this.serviceProviders;
+    if (serviceProviders == null) {
+      serviceProviders = new ArrayList<>(ServiceHelper.loadFactories(VertxServiceProvider.class));
+    }
+    toInit.addAll(serviceProviders);
+    for (VertxServiceProvider provider : toInit) {
       if (provider instanceof VertxMetricsFactory && (options.getMetricsOptions() == null || !options.getMetricsOptions().isEnabled())) {
         continue;
       } else if (provider instanceof VertxTracerFactory && (options.getTracingOptions() == null)) {
@@ -329,6 +368,13 @@ private void initExecutorServiceFactory() {
     executorServiceFactory = ExecutorServiceFactory.INSTANCE;
   }
 
+  private void initVerticleFactories() {
+    if (verticleFactories != null) {
+      return;
+    }
+    verticleFactories = new ArrayList<>(ServiceHelper.loadFactories(VerticleFactory.class));
+  }
+
   private void checkBeforeInstantiating() {
     checkTracing();
     checkMetrics();

vertx-core/src/main/java/io/vertx/core/impl/VertxImpl.java

@@ -244,20 +244,22 @@ private static ThreadFactory virtualThreadFactory() {
     this.shadowContext = enableShadowContext;
   }
 
-  void init() {
+  void init(List<VerticleFactory> verticleFactories) {
     eventBus.start(Promise.promise());
     if (metrics != null) {
       metrics.vertxCreated(this);
     }
+    verticleManager.init(verticleFactories);
   }
 
-  Future<Vertx> initClustered(VertxOptions options) {
+  Future<Vertx> initClustered(VertxOptions options, List<VerticleFactory> verticleFactories) {
     nodeSelector.init(clusterManager);
     clusterManager.registrationListener(nodeSelector);
     clusterManager.init(this);
     Promise<Void> initPromise = Promise.promise();
     clusterManager.join((res, err) -> {
       if (err == null) {
+        verticleManager.init(verticleFactories);
         createHaManager(options, initPromise);
       } else {
         initPromise.fail(err);

vertx-core/src/main/java/io/vertx/core/impl/verticle/VerticleManager.java

@@ -48,12 +48,12 @@ public VerticleManager(VertxInternal vertx, Logger log, DeploymentManager deploy
     this.vertx = (VertxImpl) vertx;
     this.deploymentManager = deploymentManager;
     this.log = log;
-    loadVerticleFactories();
   }
 
-  private void loadVerticleFactories() {
-    Collection<VerticleFactory> factories = ServiceHelper.loadFactories(VerticleFactory.class);
-    factories.forEach(this::registerVerticleFactory);
+  public void init(List<VerticleFactory> factories) {
+    if (factories != null) {
+      factories.forEach(this::registerVerticleFactory);
+    }
     VerticleFactory defaultFactory = new JavaVerticleFactory();
     defaultFactory.init(vertx);
     defaultFactories.add(defaultFactory);

vertx-core/src/main/java/io/vertx/core/internal/VertxBootstrap.java

@@ -14,15 +14,14 @@
 import io.vertx.core.Vertx;
 import io.vertx.core.VertxOptions;
 import io.vertx.core.impl.VertxBootstrapImpl;
-import io.vertx.core.spi.ExecutorServiceFactory;
-import io.vertx.core.spi.VertxMetricsFactory;
-import io.vertx.core.spi.VertxThreadFactory;
-import io.vertx.core.spi.VertxTracerFactory;
+import io.vertx.core.spi.*;
 import io.vertx.core.spi.cluster.ClusterManager;
 import io.vertx.core.spi.context.executor.EventExecutorProvider;
 import io.vertx.core.spi.file.FileResolver;
 import io.vertx.core.spi.transport.Transport;
 
+import java.util.List;
+
 /**
  * Vertx bootstrap for creating vertx instances with SPI overrides.
  *
@@ -72,8 +71,22 @@ static VertxBootstrap create() {
   EventExecutorProvider eventExecutorProvider();
 
   /**
-   * @return the {@code FileResolver} instance to use
+   * @return the list of service providers to use
+   */
+  List<VertxServiceProvider> serviceProviders();
+
+  /**
+   * Set the list of service providers to use, when the list is {@code null}, Java's service loader
+   * mechanism will be used to discover service providers.
+   *
+   * @param providers the service providers
+   * @return this builder instance
    */
+  VertxBootstrap serviceProviders(List<VertxServiceProvider> providers);
+
+    /**
+     * @return the {@code FileResolver} instance to use
+     */
   FileResolver fileResolver();
 
   /**
@@ -146,7 +159,7 @@ static VertxBootstrap create() {
    * @param transport the transport
    * @return this builder instance
    */
-  VertxBootstrapImpl transport(Transport transport);
+  VertxBootstrap transport(Transport transport);
 
   /**
    * @return the cluster manager to use
@@ -162,6 +175,20 @@ static VertxBootstrap create() {
   VertxBootstrap clusterManager(ClusterManager clusterManager);
 
   /**
+   * @return the verticle factories to use
+   */
+  List<VerticleFactory> verticleFactories();
+
+  /**
+   * Set the list of {@code VerticleFactory} to use.
+   *
+   * @param verticleFactories the verticle factories
+   * @return the builder instance
+   */
+  VertxBootstrap verticleFactories(List<VerticleFactory> verticleFactories);
+
+  /**
+   *
    * Initialize the service providers.
    *
    * @return this builder instance

vertx-core/src/test/java/io/vertx/tests/vertx/VertxBootstrapTest.java

@@ -17,11 +17,8 @@
 import io.vertx.core.internal.VertxInternal;
 import io.vertx.core.metrics.MetricsOptions;
 import io.vertx.core.impl.transports.NioTransport;
+import io.vertx.core.spi.*;
 import io.vertx.core.spi.transport.Transport;
-import io.vertx.core.spi.ExecutorServiceFactory;
-import io.vertx.core.spi.VertxMetricsFactory;
-import io.vertx.core.spi.VertxThreadFactory;
-import io.vertx.core.spi.VertxTracerFactory;
 import io.vertx.core.spi.cluster.ClusterManager;
 import io.vertx.core.tracing.TracingOptions;
 import io.vertx.test.fakecluster.FakeClusterManager;
@@ -38,11 +35,13 @@
 import java.net.URL;
 import java.net.URLClassLoader;
 import java.nio.file.Files;
+import java.util.Collections;
 import java.util.concurrent.CompletableFuture;
 import java.util.concurrent.ExecutorService;
 import java.util.concurrent.Executors;
 import java.util.concurrent.ThreadFactory;
 import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicInteger;
 
 import static org.junit.Assert.*;
 
@@ -181,6 +180,19 @@ public VertxThread newVertxThread(Runnable target, String name, boolean worker,
       .close().await();
   }
 
+  @Test
+  public void testExplicitServiceProviders() {
+    AtomicInteger initialized = new AtomicInteger();
+    VertxServiceProvider provider = builder -> initialized.incrementAndGet();
+    VertxBootstrap factory = VertxBootstrap.create();
+    Vertx vertx = factory
+      .serviceProviders(Collections.singletonList(provider))
+      .init()
+      .vertx();
+    vertx.close();
+    assertEquals(1, initialized.get());
+  }
+
   private class CustomExecutorServiceFactory implements ExecutorServiceFactory {
 
     @Override