Ensure we use the right context.

Author: cescoffier

core/wisdom-vertx-engine/src/main/java/org/wisdom/framework/vertx/ContextFromVertx.java

@@ -75,7 +75,7 @@ public class ContextFromVertx implements Context {
      * @param accessor a structure containing the used services.
      * @param req      the incoming HTTP Request.
      */
-    public ContextFromVertx(Vertx vertx, ServiceAccessor accessor, HttpServerRequest req) {
+    public ContextFromVertx(Vertx vertx, io.vertx.core.Context vertxContext, ServiceAccessor accessor, HttpServerRequest req) {
         id = ids.getAndIncrement();
         services = accessor;
         request = new RequestFromVertx(req);
@@ -84,6 +84,12 @@ public ContextFromVertx(Vertx vertx, ServiceAccessor accessor, HttpServerRequest
         session = new SessionCookieImpl(accessor.getCrypto(), accessor.getConfiguration());
         flash.init(this);
         session.init(this);
+
+        if (vertxContext == null) {
+            throw new IllegalArgumentException("Creating a context from vert.x outside of an event loop");
+        } else {
+            this.vertxContext = vertxContext;
+        }
     }
 
 

core/wisdom-vertx-engine/src/main/java/org/wisdom/framework/vertx/HttpHandler.java

@@ -89,7 +89,7 @@ public HttpHandler(Vertx vertx, ServiceAccessor accessor, Server server) {
     @Override
     public void handle(final HttpServerRequest request) {
         LOGGER.debug("A request has arrived on the server : {} {}", request.method(), request.path());
-        final ContextFromVertx context = new ContextFromVertx(vertx, accessor, request);
+        final ContextFromVertx context = new ContextFromVertx(vertx, vertx.getOrCreateContext(), accessor, request);
 
         if (!server.accept(request.path())) {
             LOGGER.warn("Request on {} denied by {}", request.path(), server.name());

core/wisdom-vertx-engine/src/test/java/org/wisdom/framework/vertx/ContextFromVertxTest.java

@@ -26,6 +26,7 @@
 import io.vertx.core.Vertx;
 import org.junit.After;
 import org.junit.Before;
+import org.junit.Rule;
 import org.junit.Test;
 import org.wisdom.api.Controller;
 import org.wisdom.api.DefaultController;
@@ -45,6 +46,8 @@ public class ContextFromVertxTest {
     private ServiceAccessor accessor;
     private ApplicationConfiguration configuration;
 
+    @Rule
+    public RunOnVertxContext runOnVertxContext = new RunOnVertxContext();
 
     @Before
     public void setUp() {
@@ -65,49 +68,52 @@ public void tearDown() {
     @Test
     public void testId() throws Exception {
         HttpRequest req = new DefaultFullHttpRequest(HttpVersion.HTTP_1_1, HttpMethod.GET, "/");
-        ContextFromVertx context = new ContextFromVertx(vertx, accessor,
+        ContextFromVertx context = new ContextFromVertx(vertx, vertx.getOrCreateContext(),  accessor,
                 RequestFromVertXTest.create(req));
         assertThat(context.id()).isNotNegative();
         long id1 = context.id();
-        context = new ContextFromVertx(vertx, accessor,
+        context = new ContextFromVertx(vertx, vertx.getOrCreateContext(),  accessor,
                 RequestFromVertXTest.create(req));
         assertThat(id1).isLessThan(context.id());
     }
 
     @Test
     public void testRequest() throws Exception {
         HttpRequest req = new DefaultFullHttpRequest(HttpVersion.HTTP_1_1, HttpMethod.GET, "/");
-        ContextFromVertx context = new ContextFromVertx(vertx, accessor,
+        ContextFromVertx context = new ContextFromVertx(vertx, vertx.getOrCreateContext(),  accessor,
                 RequestFromVertXTest.create(req));
         assertThat(context.request()).isNotNull();
     }
 
     @Test
     public void testPath() throws Exception {
         HttpRequest req = new DefaultFullHttpRequest(HttpVersion.HTTP_1_1, HttpMethod.GET, "/");
-        ContextFromVertx context = new ContextFromVertx(vertx, accessor,
+        ContextFromVertx context = new ContextFromVertx(vertx, vertx.getOrCreateContext(),  accessor,
                 RequestFromVertXTest.create(req));
         assertThat(context.path()).isEqualTo("/");
 
         req = new DefaultFullHttpRequest(HttpVersion.HTTP_1_1, HttpMethod.GET, "/foo");
 
-        context = new ContextFromVertx(vertx, accessor,
+        context = new ContextFromVertx(vertx, vertx.getOrCreateContext(),  accessor,
                 RequestFromVertXTest.create(req));
         assertThat(context.path()).isEqualTo("/foo");
 
         req = new DefaultFullHttpRequest(HttpVersion.HTTP_1_1, HttpMethod.GET, "/foo?k=v");
-        context = new ContextFromVertx(vertx, accessor,
+        context = new ContextFromVertx(vertx, vertx.getOrCreateContext(),  accessor,
                 RequestFromVertXTest.create(req));
         assertThat(context.path()).isEqualTo("/foo");
     }
 
     @Test
     public void testCookie() throws Exception {
+
+        System.out.println(Thread.currentThread().getName() + " " + vertx.getOrCreateContext() + " " + Vertx.currentContext());
+
         String c = "mediaWiki.user.id=0kn3VaEP7XG7mbxRPNgBOe5DNfOAGaHL; centralnotice_bucket=0-4.2; " +
                 "uls-previous-languages=%5B%22en%22%5D; mediaWiki.user.sessionId=Mu2OplNdlL98mRoHEwKGlxYsOXbyP1f0; GeoIP=::::v6";
         HttpRequest req = new DefaultFullHttpRequest(HttpVersion.HTTP_1_1, HttpMethod.GET, "/");
         req.headers().set(HeaderNames.COOKIE, c);
-        ContextFromVertx context = new ContextFromVertx(vertx, accessor, RequestFromVertXTest.create(req));
+        ContextFromVertx context = new ContextFromVertx(vertx, vertx.getOrCreateContext(), accessor, RequestFromVertXTest.create(req));
         assertThat(context.cookies().get("mediaWiki.user.id").value()).isEqualTo("0kn3VaEP7XG7mbxRPNgBOe5DNfOAGaHL");
         assertThat(context.cookies().get("GeoIP").value()).isEqualTo("::::v6");
 
@@ -117,7 +123,7 @@ public void testCookie() throws Exception {
         assertThat(context.cookieValue("GeoIP")).isEqualTo("::::v6");
 
         req = new DefaultFullHttpRequest(HttpVersion.HTTP_1_1, HttpMethod.GET, "/");
-        context = new ContextFromVertx(vertx, accessor, RequestFromVertXTest.create(req));
+        context = new ContextFromVertx(vertx, vertx.getOrCreateContext(), accessor, RequestFromVertXTest.create(req));
 
         assertThat(context.cookies().get("GeoIP")).isNull();
         assertThat(context.cookie("GeoIP")).isNull();
@@ -127,7 +133,7 @@ public void testCookie() throws Exception {
     @Test
     public void testParameterFromQuery() throws Exception {
         HttpRequest req = new DefaultFullHttpRequest(HttpVersion.HTTP_1_1, HttpMethod.GET, "/foo?k=v&i=5&b=true");
-        ContextFromVertx context = new ContextFromVertx(vertx, accessor, RequestFromVertXTest.create(req));
+        ContextFromVertx context = new ContextFromVertx(vertx, vertx.getOrCreateContext(),  accessor, RequestFromVertXTest.create(req));
 
         assertThat(context.parameter("k")).isEqualTo("v");
         assertThat(context.parameter("k", "v2")).isEqualTo("v");
@@ -145,7 +151,7 @@ public void testParameterFromQuery() throws Exception {
         assertThat(context.parameterAsBoolean("b2", true)).isTrue();
 
         req = new DefaultFullHttpRequest(HttpVersion.HTTP_1_1, HttpMethod.GET, "/foo?k=v&i=5&b=true&i=6");
-        context = new ContextFromVertx(vertx, accessor, RequestFromVertXTest.create(req));
+        context = new ContextFromVertx(vertx,vertx.getOrCreateContext(),  accessor, RequestFromVertXTest.create(req));
         assertThat(context.parameterMultipleValues("i")).containsExactly("5", "6");
     }
 
@@ -156,7 +162,7 @@ public void testHeader() throws Exception {
         req.headers().add(HeaderNames.ACCEPT_LANGUAGE, "en-US");
         req.headers().add(HeaderNames.ACCEPT_CHARSET, "utf-8");
         req.headers().add("test", "a").add("test", "b");
-        ContextFromVertx context = new ContextFromVertx(vertx, accessor, RequestFromVertXTest.create(req));
+        ContextFromVertx context = new ContextFromVertx(vertx, vertx.getOrCreateContext(),  accessor, RequestFromVertXTest.create(req));
 
         assertThat(context.headers().containsKey(HeaderNames.ACCEPT_LANGUAGE)).isTrue();
         assertThat(context.header(HeaderNames.ACCEPT_LANGUAGE)).isEqualTo("en-US");
@@ -170,13 +176,13 @@ public void testHeader() throws Exception {
     public void testThatColonAreEncodedCorrectly() throws NoSuchMethodException {
         HttpRequest request = new DefaultFullHttpRequest(HttpVersion.HTTP_1_1, HttpMethod.GET,
             "/foo?key=value:value");
-        ContextFromVertx context = new ContextFromVertx(vertx, accessor,
+        ContextFromVertx context = new ContextFromVertx(vertx, vertx.getOrCreateContext(),  accessor,
             RequestFromVertXTest.create(request));
         assertThat(context.path()).isEqualToIgnoringCase("/foo");
 
         request = new DefaultFullHttpRequest(HttpVersion.HTTP_1_1, HttpMethod.GET,
             "/foo/bar:baz/x");
-        context = new ContextFromVertx(vertx, accessor, RequestFromVertXTest.create(request));
+        context = new ContextFromVertx(vertx, vertx.getOrCreateContext(),  accessor, RequestFromVertXTest.create(request));
         Controller controller = new MyController();
         context.route(new Route(org.wisdom.api.http.HttpMethod.GET, "/foo/{p}/x",
             controller, MyController.class.getMethod("action")));

core/wisdom-vertx-engine/src/test/java/org/wisdom/framework/vertx/FileUploadTest.java

@@ -329,7 +329,6 @@ public Result call() throws Exception {
         if (!doneSignal.await(60, TimeUnit.SECONDS)) { // wait for all to finish
             Assert.fail("testFileUploadOfSmallFilesWithAsyncDownload - Client not served in time");
         }
-
         assertThat(failure).isEmpty();
         assertThat(success).hasSize(NUMBER_OF_CLIENTS);
     }

core/wisdom-vertx-engine/src/test/java/org/wisdom/framework/vertx/RunOnVertxContext.java

@@ -0,0 +1,130 @@
+/*
+ * #%L
+ * Wisdom-Framework
+ * %%
+ * Copyright (C) 2013 - 2016 Wisdom Framework
+ * %%
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * #L%
+ */
+package org.wisdom.framework.vertx;
+
+import io.vertx.core.Vertx;
+import io.vertx.core.VertxOptions;
+import org.junit.rules.TestRule;
+import org.junit.runner.Description;
+import org.junit.runners.model.Statement;
+
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicReference;
+import java.util.function.BiConsumer;
+import java.util.function.Consumer;
+import java.util.function.Supplier;
+
+/**
+ * @author <a href="http://escoffier.me">Clement Escoffier</a>
+ */
+public class RunOnVertxContext implements TestRule {
+
+    private volatile Vertx vertx;
+    private final Supplier<Vertx> createVertx;
+    private final BiConsumer<Vertx, CountDownLatch> closeVertx;
+
+    /**
+     * Create a new rule managing a Vertx instance created with default options. The Vert.x instance
+     * is created and closed for each test.
+     */
+    public RunOnVertxContext() {
+        this(new VertxOptions());
+    }
+
+    /**
+     * Create a new rule managing a Vertx instance created with specified options. The Vert.x instance
+     * is created and closed for each test.
+     *
+     * @param options the vertx options
+     */
+    public RunOnVertxContext(VertxOptions options) {
+        this(() -> Vertx.vertx(options));
+    }
+
+    /**
+     * Create a new rule with supplier/consumer for creating/closing a Vert.x instance. The lambda are invoked for each
+     * test. The {@code closeVertx} lambda should invoke the consumer with null when the {@code vertx} instance is closed.
+     *
+     * @param createVertx the create Vert.x supplier
+     * @param closeVertx  the close Vert.x consumer
+     */
+    public RunOnVertxContext(Supplier<Vertx> createVertx, BiConsumer<Vertx, Consumer<Void>> closeVertx) {
+        this.createVertx = createVertx;
+        this.closeVertx = (vertx, latch) -> closeVertx.accept(vertx, v -> latch.countDown());
+    }
+
+    /**
+     * Create a new rule with supplier for creating a Vert.x instance. The lambda are invoked for each
+     * test.
+     *
+     * @param createVertx the create Vert.x supplier
+     */
+    public RunOnVertxContext(Supplier<Vertx> createVertx) {
+        this(createVertx, (vertx, latch) -> vertx.close(ar -> latch.accept(null)));
+    }
+
+    /**
+     * Retrieves the current Vert.x instance, this value varies according to the test life cycle.
+     *
+     * @return the vertx object
+     */
+    public Vertx vertx() {
+        return vertx;
+    }
+
+    @Override
+    public Statement apply(Statement base, Description description) {
+        return new Statement() {
+            @Override
+            public void evaluate() throws Throwable {
+                vertx = createVertx.get();
+                CountDownLatch lock = new CountDownLatch(1);
+                AtomicReference<Throwable> error = new AtomicReference<>();
+                vertx.runOnContext((v) -> {
+                            try {
+                                base.evaluate();
+                            } catch (Throwable throwable) {
+                                error.set(throwable);
+                            } finally {
+                                lock.countDown();
+                            }
+                        }
+
+                );
+
+                lock.await();
+                CountDownLatch latch = new CountDownLatch(1);
+                closeVertx.accept(vertx, latch);
+                try {
+                    if (!latch.await(30 * 1000, TimeUnit.MILLISECONDS)) {
+                        System.err.println("Could not close Vert.x in tme");
+                    }
+                } catch (InterruptedException e) {
+                    Thread.currentThread().interrupt();
+                }
+
+                if (error.get() != null) {
+                    throw error.get();
+                }
+            }
+        };
+    }
+}