Merge pull request #10176 from stuartwdouglas/9693

Make sure request resumes on correct thread

Author: stuartwdouglas

core/deployment/src/main/java/io/quarkus/deployment/dev/DevModeMain.java

@@ -102,12 +102,14 @@ public void start() throws Exception {
 
             QuarkusBootstrap.Builder bootstrapBuilder = QuarkusBootstrap.builder()
                     .setApplicationRoot(appRoots.build())
-                    .setTargetDirectory(context.getDevModeRunnerJarFile().getParentFile().toPath())
                     .setIsolateDeployment(true)
                     .setLocalProjectDiscovery(context.isLocalProjectDiscovery())
                     .addAdditionalDeploymentArchive(path)
                     .setBaseName(context.getBaseName())
                     .setMode(context.getMode());
+            if (context.getDevModeRunnerJarFile() != null) {
+                bootstrapBuilder.setTargetDirectory(context.getDevModeRunnerJarFile().getParentFile().toPath());
+            }
             if (context.getProjectDir() != null) {
                 bootstrapBuilder.setProjectRoot(context.getProjectDir().toPath());
             } else {

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

@@ -53,8 +53,8 @@ public class VertxCoreRecorder {
 
     public Supplier<Vertx> configureVertx(VertxConfiguration config,
             LaunchMode launchMode, ShutdownContext shutdown, List<Consumer<VertxOptions>> customizers) {
-        vertx = new VertxSupplier(config, customizers);
         if (launchMode != LaunchMode.DEVELOPMENT) {
+            vertx = new VertxSupplier(config, customizers);
             // we need this to be part of the last shutdown tasks because closing it early (basically before Arc)
             // could cause problem to beans that rely on Vert.x and contain shutdown tasks
             shutdown.addLastShutdownTask(new Runnable() {
@@ -63,6 +63,31 @@ public void run() {
                     destroy();
                 }
             });
+        } else {
+            if (vertx == null) {
+                vertx = new VertxSupplier(config, customizers);
+            } else if (vertx.v != null) {
+                tryCleanTccl(vertx.v);
+            }
+            shutdown.addLastShutdownTask(new Runnable() {
+                @Override
+                public void run() {
+                    CountDownLatch latch = new CountDownLatch(1);
+                    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>>() {
+                                    @Override
+                                    public void handle(AsyncResult<Void> event) {
+                                        latch.countDown();
+                                    }
+                                });
+                            }
+                        });
+                    }
+                }
+            });
         }
         return vertx;
     }
@@ -303,7 +328,8 @@ public Supplier<EventLoopGroup> bossSupplier() {
         return new Supplier<EventLoopGroup>() {
             @Override
             public EventLoopGroup get() {
-                return ((VertxImpl) vertx.get()).getAcceptorEventLoopGroup();
+                vertx.get();
+                return ((VertxImpl) vertx.v).getAcceptorEventLoopGroup();
             }
         };
     }

extensions/vertx-http/deployment/src/main/java/io/quarkus/vertx/http/deployment/VertxHttpProcessor.java

@@ -103,11 +103,10 @@ public KubernetesPortBuildItem kubernetes() {
     @Record(ExecutionTime.RUNTIME_INIT)
     VertxWebRouterBuildItem initializeRouter(VertxHttpRecorder recorder,
             CoreVertxBuildItem vertx,
-            List<RouteBuildItem> routes, LaunchModeBuildItem launchModeBuildItem,
+            List<RouteBuildItem> routes,
             ShutdownContextBuildItem shutdown) {
 
-        RuntimeValue<Router> router = recorder.initializeRouter(vertx.getVertx(), launchModeBuildItem.getLaunchMode(),
-                shutdown);
+        RuntimeValue<Router> router = recorder.initializeRouter(vertx.getVertx());
         for (RouteBuildItem route : routes) {
             recorder.addRoute(router, route.getRouteFunction(), route.getHandler(), route.getType());
         }

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

@@ -188,15 +188,10 @@ public Integer get() {
         }
     }
 
-    public RuntimeValue<Router> initializeRouter(final Supplier<Vertx> vertxRuntimeValue,
-            final LaunchMode launchMode, final ShutdownContext shutdownContext) {
+    public RuntimeValue<Router> initializeRouter(final Supplier<Vertx> vertxRuntimeValue) {
 
         Vertx vertx = vertxRuntimeValue.get();
         Router router = Router.router(vertx);
-        if (hotReplacementHandler != null) {
-            router.route().order(Integer.MIN_VALUE).handler(hotReplacementHandler);
-        }
-
         return new RuntimeValue<>(router);
     }
 
@@ -260,7 +255,7 @@ public void finalizeRouter(BeanContainer container, Consumer<Route> defaultRoute
         if (requireBodyHandler) {
             //if this is set then everything needs the body handler installed
             //TODO: config etc
-            router.route().order(Integer.MIN_VALUE).handler(new Handler<RoutingContext>() {
+            router.route().order(Integer.MIN_VALUE + 1).handler(new Handler<RoutingContext>() {
                 @Override
                 public void handle(RoutingContext routingContext) {
                     routingContext.request().resume();
@@ -302,14 +297,14 @@ public void handle(Void e) {
         Handler<HttpServerRequest> root;
         if (rootPath.equals("/")) {
             if (hotReplacementHandler != null) {
-                router.route().order(-1).handler(hotReplacementHandler);
+                router.route().order(Integer.MIN_VALUE).handler(hotReplacementHandler);
             }
             root = router;
         } else {
             Router mainRouter = Router.router(vertx.get());
             mainRouter.mountSubRouter(rootPath, router);
             if (hotReplacementHandler != null) {
-                mainRouter.route().order(-1).handler(hotReplacementHandler);
+                mainRouter.route().order(Integer.MIN_VALUE).handler(hotReplacementHandler);
             }
             root = mainRouter;
         }

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

@@ -7,6 +7,7 @@
 import io.vertx.core.Handler;
 import io.vertx.core.Promise;
 import io.vertx.core.http.HttpServerResponse;
+import io.vertx.core.net.impl.ConnectionBase;
 import io.vertx.ext.web.RoutingContext;
 
 public class VertxHttpHotReplacementSetup implements HotReplacementSetup {
@@ -39,7 +40,8 @@ void handleHotReplacementRequest(RoutingContext routingContext) {
             routingContext.next();
             return;
         }
-        routingContext.vertx().executeBlocking(new Handler<Promise<Boolean>>() {
+        ConnectionBase connectionBase = (ConnectionBase) routingContext.request().connection();
+        connectionBase.getContext().executeBlocking(new Handler<Promise<Boolean>>() {
             @Override
             public void handle(Promise<Boolean> event) {
                 boolean restart = false;

extensions/vertx-web/deployment/src/test/java/io/quarkus/vertx/web/DevModeRoute.java

@@ -0,0 +1,25 @@
+package io.quarkus.vertx.web;
+
+import static io.vertx.core.http.HttpMethod.GET;
+import static io.vertx.core.http.HttpMethod.OPTIONS;
+import static io.vertx.core.http.HttpMethod.POST;
+
+import io.quarkus.vertx.core.runtime.VertxCoreRecorder;
+import io.vertx.ext.web.RoutingContext;
+
+public class DevModeRoute {
+
+    @Route(path = "/test", methods = { GET, OPTIONS, POST })
+    void getRoutes(RoutingContext context) {
+        context.response().setStatusCode(200).end("test route");
+    }
+
+    @Route(path = "/assert", methods = GET)
+    void assertVertx(RoutingContext context) {
+        if (VertxCoreRecorder.getVertx().get() == context.vertx()) {
+            context.response().end("OK");
+        } else {
+            context.fail(new RuntimeException("Incorrect vertx in use"));
+        }
+    }
+}

extensions/vertx-web/deployment/src/test/java/io/quarkus/vertx/web/VertxWebDevModeTestCase.java

@@ -0,0 +1,48 @@
+package io.quarkus.vertx.web;
+
+import java.util.function.Function;
+
+import org.hamcrest.Matchers;
+import org.jboss.shrinkwrap.api.ShrinkWrap;
+import org.jboss.shrinkwrap.api.spec.JavaArchive;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.RegisterExtension;
+
+import io.quarkus.test.QuarkusDevModeTest;
+import io.restassured.RestAssured;
+
+public class VertxWebDevModeTestCase {
+
+    @RegisterExtension
+    static QuarkusDevModeTest runner = new QuarkusDevModeTest()
+            .setArchiveProducer(() -> ShrinkWrap.create(JavaArchive.class)
+                    .addClasses(DevModeRoute.class));
+
+    @Test
+    public void testRunningInDevMode() {
+        RestAssured.given()
+                .body("OK")
+                .post("/test")
+                .then().statusCode(200)
+                .body(Matchers.equalTo("test route"));
+
+        runner.modifySourceFile(DevModeRoute.class, new Function<String, String>() {
+            @Override
+            public String apply(String s) {
+                return s.replace("test route", "new code");
+            }
+        });
+        for (int i = 0; i < 10; ++i) {
+            RestAssured.given()
+                    .body("OK")
+                    .post("/test")
+                    .then().statusCode(200)
+                    .body(Matchers.equalTo("new code"));
+        }
+        RestAssured.given()
+                .get("/assert")
+                .then().statusCode(200)
+                .body(Matchers.equalTo("OK"));
+    }
+
+}