Reactive routes - if needed propagate req. context activated by filter

- resolves #13073

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

@@ -0,0 +1,67 @@
+package io.quarkus.vertx.web.filter;
+
+import static org.hamcrest.Matchers.is;
+
+import java.util.concurrent.atomic.AtomicInteger;
+
+import javax.enterprise.context.RequestScoped;
+import javax.inject.Inject;
+
+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.QuarkusUnitTest;
+import io.quarkus.vertx.web.Route;
+import io.quarkus.vertx.web.RouteFilter;
+import io.restassured.RestAssured;
+import io.vertx.ext.web.RoutingContext;
+
+public class UserFilterRequestContextPropagationTest {
+
+    @RegisterExtension
+    static final QuarkusUnitTest config = new QuarkusUnitTest()
+            .setArchiveProducer(() -> ShrinkWrap.create(JavaArchive.class)
+                    .addClasses(FilterAndRoute.class, RequestFoo.class));
+
+    @Test
+    public void test() {
+        RestAssured.post("/hello").then().statusCode(200)
+                .body(is("11"));
+    }
+
+    public static class FilterAndRoute {
+
+        @Inject
+        RequestFoo foo;
+
+        @RouteFilter
+        void filter1(RoutingContext rc) {
+            foo.setState(11);
+            rc.next();
+        }
+
+        @Route(path = "hello")
+        void hello(RoutingContext ctx) {
+            ctx.response().end("" + foo.getState());
+        }
+
+    }
+
+    @RequestScoped
+    static class RequestFoo {
+
+        private AtomicInteger state = new AtomicInteger(-1);
+
+        void setState(int value) {
+            this.state.set(value);
+        }
+
+        public int getState() {
+            return state.get();
+        }
+
+    }
+
+}

extensions/vertx-web/runtime/src/main/java/io/quarkus/vertx/web/runtime/RouteHandler.java

@@ -3,7 +3,7 @@
 import javax.enterprise.event.Event;
 
 import io.quarkus.arc.Arc;
-import io.quarkus.arc.InjectableContext;
+import io.quarkus.arc.InjectableContext.ContextState;
 import io.quarkus.arc.ManagedContext;
 import io.quarkus.security.identity.SecurityIdentity;
 import io.quarkus.vertx.http.runtime.CurrentVertxRequest;
@@ -20,6 +20,8 @@
  */
 public abstract class RouteHandler implements Handler<RoutingContext> {
 
+    private static final String REQUEST_CONTEXT_STATE = "__cdi_req_ctx_state";
+
     private final Event<SecurityIdentity> securityIdentityEvent;
     private final CurrentVertxRequest currentVertxRequest;
 
@@ -47,20 +49,24 @@ public void handle(RoutingContext context) {
             invoke(context);
         } else {
             try {
+                // The context could be activated by a filter - we need to use the same context
+                // Note that for requests that require a BodyHandler the route method is always invoked asynchronously and so if a filter activates the request context we must propagat it manually
+                ContextState state = context.get(REQUEST_CONTEXT_STATE);
                 // Activate the context, i.e. set the thread locals
-                requestContext.activate();
+                requestContext.activate(state);
                 currentVertxRequest.setCurrent(context);
                 if (user != null) {
                     securityIdentityEvent.fire(user.getSecurityIdentity());
                 }
                 // Reactive routes can use async processing (e.g. mutiny Uni/Multi) and context propagation
                 // 1. Store the state (which is basically a shared Map instance)
                 // 2. Terminate the context correcly when the response is disposed or an exception is thrown 
-                InjectableContext.ContextState state = requestContext.getState();
+                final ContextState endState = state != null ? state : requestContext.getState();
+                context.put(REQUEST_CONTEXT_STATE, endState);
                 context.addEndHandler(new Handler<AsyncResult<Void>>() {
                     @Override
                     public void handle(AsyncResult<Void> result) {
-                        requestContext.destroy(state);
+                        requestContext.destroy(endState);
                     }
                 });
                 invoke(context);