Fix exception in logs on live reload

extensions/vertx-core/runtime/src/main/java/io/quarkus/vertx/core/runtime/VertxCoreRecorder.java

@@ -9,8 +9,11 @@
 
 import java.io.File;
 import java.time.Duration;
+import java.util.ArrayList;
+import java.util.HashSet;
 import java.util.List;
 import java.util.Optional;
+import java.util.Set;
 import java.util.concurrent.CompletableFuture;
 import java.util.concurrent.CountDownLatch;
 import java.util.concurrent.TimeUnit;
@@ -51,6 +54,12 @@ public class VertxCoreRecorder {
 
     static volatile int blockingThreadPoolSize;
 
+    /**
+     * This is a bit of a hack. In dev mode we undeploy all the verticles on restart, except
+     * for this one
+     */
+    private static volatile String webDeploymentId;
+
     public Supplier<Vertx> configureVertx(VertxConfiguration config,
             LaunchMode launchMode, ShutdownContext shutdown, List<Consumer<VertxOptions>> customizers) {
         if (launchMode != LaunchMode.DEVELOPMENT) {
@@ -72,19 +81,28 @@ public void run() {
             shutdown.addLastShutdownTask(new Runnable() {
                 @Override
                 public void run() {
-                    CountDownLatch latch = new CountDownLatch(1);
+                    List<CountDownLatch> latches = new ArrayList<>();
                     if (vertx.v != null) {
-                        vertx.v.eventBus().close(new Handler<AsyncResult<Void>>() {
-                            @Override
-                            public void handle(AsyncResult<Void> event) {
-                                vertx.v.eventBus().start(new Handler<AsyncResult<Void>>() {
+                        Set<String> ids = new HashSet<>(vertx.v.deploymentIDs());
+                        for (String id : ids) {
+                            if (!id.equals(webDeploymentId)) {
+                                CountDownLatch latch = new CountDownLatch(1);
+                                latches.add(latch);
+                                vertx.v.undeploy(id, new Handler<AsyncResult<Void>>() {
                                     @Override
                                     public void handle(AsyncResult<Void> event) {
                                         latch.countDown();
                                     }
                                 });
                             }
-                        });
+                        }
+                        for (CountDownLatch latch : latches) {
+                            try {
+                                latch.await();
+                            } catch (InterruptedException e) {
+                                LOGGER.error("Failed waiting for verticle undeploy", e);
+                            }
+                        }
                     }
                 }
             });
@@ -391,4 +409,8 @@ VertxOptions customize(VertxOptions options) {
             return options;
         }
     }
+
+    public static void setWebDeploymentId(String webDeploymentId) {
+        VertxCoreRecorder.webDeploymentId = webDeploymentId;
+    }
 }

extensions/vertx-http/deployment/src/test/java/io/quarkus/vertx/http/hotreload/VertxEventBusConsumer.java

@@ -1,20 +1,28 @@
 package io.quarkus.vertx.http.hotreload;
 
+import javax.annotation.PreDestroy;
 import javax.enterprise.context.ApplicationScoped;
 import javax.enterprise.event.Observes;
 import javax.inject.Inject;
 
 import io.quarkus.runtime.StartupEvent;
 import io.vertx.core.Vertx;
+import io.vertx.core.eventbus.MessageConsumer;
 
 @ApplicationScoped
 public class VertxEventBusConsumer {
 
     @Inject
     Vertx vertx;
+    private MessageConsumer<Object> messageConsumer;
 
     public void init(@Observes StartupEvent event) {
-        vertx.eventBus().consumer("my-address", m -> m.reply("hello"));
+        messageConsumer = vertx.eventBus().consumer("my-address", m -> m.reply("hello"));
+    }
+
+    @PreDestroy
+    public void stop() {
+        messageConsumer.unregister();
     }
 
 }

extensions/vertx-http/deployment/src/test/java/io/quarkus/vertx/http/hotreload/VertxEventBusProducer.java

@@ -18,7 +18,6 @@ public class VertxEventBusProducer {
     Vertx vertx;
 
     public void register(@Observes StartupEvent ev) {
-        // Don't use rc.vertx() as it would be the RestEasy instance
         router.get("/").handler(rc -> vertx.eventBus().<String> request("my-address", "", m -> {
             if (m.failed()) {
                 rc.response().end("failed");

extensions/vertx-http/runtime/src/main/java/io/quarkus/vertx/http/runtime/VertxHttpRecorder.java

@@ -436,6 +436,7 @@ public void handle(AsyncResult<String> event) {
         try {
 
             String deploymentId = futureResult.get();
+            VertxCoreRecorder.setWebDeploymentId(deploymentId);
             closeTask = new Runnable() {
                 @Override
                 public synchronized void run() {

extensions/vertx/deployment/src/test/java/io/quarkus/vertx/devmode/MyVerticle.java

@@ -4,16 +4,23 @@
 
 import io.vertx.core.AbstractVerticle;
 import io.vertx.core.Future;
+import io.vertx.core.eventbus.MessageConsumer;
 
 public class MyVerticle extends AbstractVerticle {
 
     private final String id = UUID.randomUUID().toString();
+    private volatile MessageConsumer<Object> messageConsumer;
 
     @Override
     public void start(Future<Void> done) {
-        vertx.eventBus().consumer("address")
-                .handler(m -> m.reply("ok-" + id))
+        messageConsumer = vertx.eventBus().consumer("address")
+                .handler(m -> m.reply("ok-" + id));
+        messageConsumer
                 .completionHandler(ar -> done.handle(ar.mapEmpty()));
     }
 
+    @Override
+    public void stop() throws Exception {
+        messageConsumer.unregister();
+    }
 }