Reactive routes - inject throwable for a failure handler

- resolves quarkusio#12249
mkouba · Sep 23, 2020 · 545ad62 · 545ad62
1 parent 77b772c
commit 545ad62
Show file tree

Hide file tree

Showing 9 changed files with 387 additions and 98 deletions.
diff --git a/docs/src/main/asciidoc/reactive-routes.adoc b/docs/src/main/asciidoc/reactive-routes.adoc
@@ -259,6 +259,18 @@ Person createPerson(@Body Person person, @Param("id") Optional<String> primaryKe
 }
 ----
 
+A failure handler can declare a single method parameter whose type extends `Throwable`. 
+The type of the parameter is used to match the result of `RoutingContext#failure()`.
+
+.Failure Handler Example
+[source,java]
+----
+@Route(type = HandlerType.FAILURE)
+void unsupported(UnsupportedOperationException e, HttpServerResponse response) {
+  response.setStatusCode(501).end(e.getMessage());
+}
+----
+
 === Returning Unis
 
 In a reactive route, you can return a `Uni` directly:

diff --git a/extensions/vertx-web/deployment/src/main/java/io/quarkus/vertx/web/deployment/DotNames.java b/extensions/vertx-web/deployment/src/main/java/io/quarkus/vertx/web/deployment/DotNames.java
@@ -47,5 +47,7 @@ final class DotNames {
     static final DotName JSON_OBJECT = DotName.createSimple(JsonObject.class.getName());
     static final DotName JSON_ARRAY = DotName.createSimple(JsonArray.class.getName());
     static final DotName LIST = DotName.createSimple(List.class.getName());
+    static final DotName EXCEPTION = DotName.createSimple(Exception.class.getName());
+    static final DotName THROWABLE = DotName.createSimple(Throwable.class.getName());
 
 }
diff --git a/...vertx-web/deployment/src/main/java/io/quarkus/vertx/web/deployment/HandlerDescriptor.java b/...vertx-web/deployment/src/main/java/io/quarkus/vertx/web/deployment/HandlerDescriptor.java
@@ -5,6 +5,7 @@
 import org.jboss.jandex.Type;
 
 import io.quarkus.hibernate.validator.spi.BeanValidationAnnotationsBuildItem;
+import io.quarkus.vertx.http.runtime.HandlerType;
 
 /**
  * Describe a request handler.
@@ -13,10 +14,12 @@ class HandlerDescriptor {
 
     private final MethodInfo method;
     private final BeanValidationAnnotationsBuildItem validationAnnotations;
+    private final HandlerType handlerType;
 
-    HandlerDescriptor(MethodInfo method, BeanValidationAnnotationsBuildItem bvAnnotations) {
+    HandlerDescriptor(MethodInfo method, BeanValidationAnnotationsBuildItem bvAnnotations, HandlerType handlerType) {
         this.method = method;
         this.validationAnnotations = bvAnnotations;
+        this.handlerType = handlerType;
     }
 
     Type getReturnType() {
@@ -111,4 +114,8 @@ boolean isContentTypeMutinyBuffer() {
         return type.name().equals(DotNames.MUTINY_BUFFER);
     }
 
+    HandlerType getHandlerType() {
+        return handlerType;
+    }
+
 }
diff --git a/extensions/vertx-web/deployment/src/main/java/io/quarkus/vertx/web/deployment/Methods.java b/extensions/vertx-web/deployment/src/main/java/io/quarkus/vertx/web/deployment/Methods.java
@@ -71,12 +71,14 @@ class Methods {
             .ofMethod(HttpServerRequest.class, "params", MultiMap.class);
     static final MethodDescriptor REQUEST_HEADERS = MethodDescriptor
             .ofMethod(HttpServerRequest.class, "headers", MultiMap.class);
-
     static final MethodDescriptor RESPONSE = MethodDescriptor
             .ofMethod(RoutingContext.class, "response", HttpServerResponse.class);
-
     static final MethodDescriptor FAIL = MethodDescriptor
             .ofMethod(RoutingContext.class, "fail", Void.TYPE, Throwable.class);
+    static final MethodDescriptor FAILURE = MethodDescriptor
+            .ofMethod(RoutingContext.class, "failure", Throwable.class);
+    static final MethodDescriptor NEXT = MethodDescriptor
+            .ofMethod(RoutingContext.class, "next", void.class);
 
     static final MethodDescriptor UNI_SUBSCRIBE = MethodDescriptor.ofMethod(Uni.class, "subscribe", UniSubscribe.class);
     static final MethodDescriptor UNI_SUBSCRIBE_WITH = MethodDescriptor
@@ -191,6 +193,10 @@ class Methods {
                     Object.class, Class[].class);
     static final MethodDescriptor SET_IS_EMPTY = MethodDescriptor.ofMethod(Set.class, "isEmpty", Boolean.TYPE);
 
+    static final MethodDescriptor IS_ASSIGNABLE_FROM = MethodDescriptor.ofMethod(Class.class, "isAssignableFrom",
+            boolean.class, Class.class);
+    static final MethodDescriptor GET_CLASS = MethodDescriptor.ofMethod(Object.class, "getClass", Class.class);
+
     private Methods() {
         // Avoid direct instantiation
     }

diff --git a/...vertx-web/deployment/src/main/java/io/quarkus/vertx/web/deployment/VertxWebProcessor.java b/...vertx-web/deployment/src/main/java/io/quarkus/vertx/web/deployment/VertxWebProcessor.java
diff --git a/...s/vertx-web/deployment/src/test/java/io/quarkus/vertx/web/failure/FailureHandlerTest.java b/...s/vertx-web/deployment/src/test/java/io/quarkus/vertx/web/failure/FailureHandlerTest.java
@@ -0,0 +1,53 @@
+package io.quarkus.vertx.web.failure;
+
+import static io.quarkus.vertx.web.Route.HandlerType.FAILURE;
+import static io.restassured.RestAssured.get;
+import static org.hamcrest.Matchers.is;
+
+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.Param;
+import io.quarkus.vertx.web.Route;
+import io.vertx.core.http.HttpServerResponse;
+
+public class FailureHandlerTest {
+
+    @RegisterExtension
+    static final QuarkusUnitTest config = new QuarkusUnitTest()
+            .setArchiveProducer(() -> ShrinkWrap.create(JavaArchive.class)
+                    .addClasses(Routes.class));
+
+    @Test
+    public void test() {
+        get("/fail?type=unsupported").then().statusCode(501).body(is("Unsupported!"));
+        get("/fail").then().statusCode(500).body(is("Unknown!"));
+    }
+
+    public static class Routes {
+
+        @Route
+        void fail(@Param String type) {
+            if ("unsupported".equals(type)) {
+                throw new UnsupportedOperationException("Unsupported!");
+            } else {
+                throw new RuntimeException("Unknown!");
+            }
+        }
+
+        @Route(path = "/fail", type = FAILURE, order = 1)
+        void uoe(UnsupportedOperationException e, HttpServerResponse response) {
+            response.setStatusCode(501).end(e.getMessage());
+        }
+
+        @Route(path = "/*", type = FAILURE, order = 2)
+        void re(RuntimeException e, HttpServerResponse response) {
+            response.setStatusCode(500).end(e.getMessage());
+        }
+
+    }
+
+}
diff --git a/...src/test/java/io/quarkus/vertx/web/failure/MultipleThrowableParamsFailureHandlerTest.java b/...src/test/java/io/quarkus/vertx/web/failure/MultipleThrowableParamsFailureHandlerTest.java
@@ -0,0 +1,37 @@
+package io.quarkus.vertx.web.failure;
+
+import static org.junit.jupiter.api.Assertions.fail;
+
+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.Param;
+import io.quarkus.vertx.web.Route;
+import io.quarkus.vertx.web.Route.HandlerType;
+
+public class MultipleThrowableParamsFailureHandlerTest {
+
+    @RegisterExtension
+    static final QuarkusUnitTest config = new QuarkusUnitTest()
+            .setArchiveProducer(() -> ShrinkWrap.create(JavaArchive.class)
+                    .addClasses(Routes.class))
+            .setExpectedException(IllegalStateException.class);
+
+    @Test
+    public void testValidationFailed() {
+        fail();
+    }
+
+    public static class Routes {
+
+        @Route(type = HandlerType.FAILURE)
+        void fail(UnsupportedOperationException e1, @Param String type, RuntimeException e2) {
+            throw new RuntimeException("Unknown!");
+        }
+
+    }
+
+}
diff --git a/...eployment/src/test/java/io/quarkus/vertx/web/failure/ThrowableParamNormalHandlerTest.java b/...eployment/src/test/java/io/quarkus/vertx/web/failure/ThrowableParamNormalHandlerTest.java
@@ -0,0 +1,36 @@
+package io.quarkus.vertx.web.failure;
+
+import static org.junit.jupiter.api.Assertions.fail;
+
+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.Param;
+import io.quarkus.vertx.web.Route;
+
+public class ThrowableParamNormalHandlerTest {
+
+    @RegisterExtension
+    static final QuarkusUnitTest config = new QuarkusUnitTest()
+            .setArchiveProducer(() -> ShrinkWrap.create(JavaArchive.class)
+                    .addClasses(Routes.class))
+            .setExpectedException(IllegalStateException.class);
+
+    @Test
+    public void testValidationFailed() {
+        fail();
+    }
+
+    public static class Routes {
+
+        @Route
+        void fail(UnsupportedOperationException e, @Param String type) {
+            throw new RuntimeException("Unknown!");
+        }
+
+    }
+
+}
diff --git a/extensions/vertx-web/runtime/src/main/java/io/quarkus/vertx/web/Route.java b/extensions/vertx-web/runtime/src/main/java/io/quarkus/vertx/web/Route.java
@@ -151,11 +151,32 @@ enum HandlerType {
          */
         BLOCKING,
         /**
-         * A failure handler.
-         *
+         * A failure handler can declare a single method parameter whose type extends {@link Throwable}. The type of the
+         * parameter is used to match the result of {@link RoutingContext#failure()}.
+         * 
+         * <pre>
+         * <code>
+         *  class Routes {
+         *     {@literal @Route(type = HandlerType.FAILURE)}
+         *     void unsupported(UnsupportedOperationException e, HttpServerResponse response) {
+         *        response.setStatusCode(501).end(e.getMessage());
+         *     }
+         *  }
+         *  </code>
+         * </pre>
+         * 
          * @see io.vertx.ext.web.Route#failureHandler(Handler)
          */
-        FAILURE
+        FAILURE;
+
+        public static HandlerType from(String value) {
+            for (HandlerType handlerType : values()) {
+                if (handlerType.toString().equals(value)) {
+                    return handlerType;
+                }
+            }
+            return null;
+        }
 
     }