jooby-2.2.x - after handle not working with exceptions fix #1405

Author: jknack

docs/asciidoc/routing.adoc

@@ -505,23 +505,25 @@ interface Before {
 
 The javadoc:Route.After[text=after] filter runs after a `handler`.
 
-An `after` filter takes two arguments. The first argument is the `HTTP context`, while the second
-argument is the result/response from a **functional handler** or `null` for **side-effects** handler.
+An `after` filter takes three arguments. The first argument is the `HTTP context`, the second
+argument is the result/response from a **functional handler** or `null` for **side-effects** handler,
+the third and last argument is an exception generates from handler.
+
 It expected to operates via side effects, usually modifying the HTTP response (if possible) or
 for cleaning/trace execution.  
 
 [source,java]
 ----
 interface After {
-  void apply(Context ctx, Object result);
+  void apply(Context ctx, Object result, Throwable failure);
 }
 ----
 
 .Functional Handler:
 [source,java,role="primary"]
 ----
 {
-  after((ctx, result) -> {
+  after((ctx, result, failure) -> {
     System.out.println(result);          <1>
     ctx.setResponseHeader("foo", "bar"); <2>
   });
@@ -558,7 +560,7 @@ For **side effects** handler the after filter is invoked with a `null` value and
 [source,java,role="primary"]
 ----
 {
-  after((ctx, result) -> {
+  after((ctx, result, failure) -> {
     System.out.println(result);          <1>
     ctx.setResponseHeader("foo", "bar"); <2>
   });
@@ -597,7 +599,7 @@ You can check whenever you can modify the response by checking the state of java
 [source,java,role="primary"]
 ----
 {
-  after((ctx, result) -> {
+  after((ctx, result, failure) -> {
     if (ctx.isResponseStarted()) {
       // Don't modify response
     } else {
@@ -621,6 +623,119 @@ You can check whenever you can modify the response by checking the state of java
 }
 ----
 
+[NOTE]
+====
+An after handler is always invoked.
+====
+
+The next examples demonstrate some use cases for dealing with errored responses, but keep in mind
+that an after handler is not a mechanism for handling and reporting exceptions that's is a task for an <<error-handler, Error Handler>>.
+
+.Run code depending of success or failure responses:
+[source,java,role="primary"]
+----
+{
+  after((ctx, result, failure) -> {
+    if (failure == null) {
+      db.commit();                   <1>
+    } else {
+      db.rollback();                 <2>
+    }
+  });
+}
+----
+
+.Kotlin
+[source,kotlin,role="secondary"]
+----
+{
+  after {
+    if (failure == null) {
+      db.commit()                    <1>
+    } else {
+      db.rollback()                  <2>
+    }
+  }
+}
+----
+
+Here the exception is still propagated given the chance to the <<error-handler, Error Handler>> to jump in.
+
+.Recover fom exception and produces an alternative output:
+[source,java,role="primary"]
+----
+{
+  after((ctx, result, failure) -> {
+    if (failure instanceOf MyBusinessException) {
+      ctx.send("Recovering from something");        <1>
+    }
+  });
+}
+----
+
+.Kotlin
+[source,kotlin,role="secondary"]
+----
+{
+  after {
+    if (failure is MyBusinessException) {
+      ctx.send("Recovering from something")         <1>
+    }
+  }
+}
+----
+
+<1> Recover and produces an alternative output
+
+Here the exception wont be propagated due we produces a response, so error handler won't be execute it.
+
+In case where the after handler produces a new exception, that exception will be add to the original exception as suppressed exception.
+
+.Suppressed exceptions:
+[source,java,role="primary"]
+----
+{
+  after((ctx, result, failure) -> {
+    ...
+    throw new AnotherException();
+  });
+
+  get("/", ctx -> {
+    ...
+    throw new OriginalException();
+  });
+
+  error((ctx, failure, code) -> {
+    Throwable originalException = failure;                       <1>
+    Throwable anotherException  = failure.getSuppressed()[0];    <2>
+  });
+}
+----
+
+.Kotlin
+[source,kotlin,role="secondary"]
+----
+{
+  after {
+    ...
+    throw AnotherException();
+  }
+
+  get("/") { ctx ->
+    ...
+    throw OriginalException()
+  }
+
+  error { ctx, failure, code) ->
+    val originalException = failure                              <1>
+    val anotherException  = failure.getSuppressed()[0]           <2>
+  }
+}
+----
+
+<1> Will be `OriginalException`
+<2> Will be `AnotherException`
+
 === Pipeline
 
 Route pipeline (a.k.a route stack) is a composition of one or more decorator(s) tied to a single `handler`:

examples/pom.xml

@@ -119,6 +119,10 @@
       <artifactId>commons-io</artifactId>
       <version>1.3.2</version>
     </dependency>
+    <dependency>
+      <groupId>org.unbescape</groupId>
+      <artifactId>unbescape</artifactId>
+    </dependency>
     <dependency>
       <groupId>org.jdbi</groupId>
       <artifactId>jdbi3-sqlobject</artifactId>

examples/src/main/java/examples/DispatchApp.java

@@ -20,9 +20,6 @@ public class DispatchApp extends Jooby {
       return next.apply(ctx);
     });
 
-    after((ctx, value) -> {
-    });
-
     get("/", ctx -> ctx.query("n").intValue(2));
 
     dispatch(() -> {

examples/src/main/java/examples/HelloApp.java

@@ -22,8 +22,12 @@ public class HelloApp extends Jooby {
 
     setRouterOptions(new RouterOptions().setIgnoreCase(false).setIgnoreTrailingSlash(true));
 
+    after((ctx,  result, failure) -> {
+      throw new RuntimeException("after");
+    });
+
     get("/", ctx -> {
-      return ctx.pathString() + "oo";
+      throw new IllegalArgumentException("handler");
     });
 
     get("/foo/bar", ctx -> {

jooby/src/main/java/io/jooby/Route.java

@@ -193,9 +193,9 @@ public interface After extends Serializable {
      * @return A new filter.
      */
     @Nonnull default After then(@Nonnull After next) {
-      return (ctx, result) -> {
-        next.apply(ctx, result);
-        apply(ctx, result);
+      return (ctx, result, failure) -> {
+        next.apply(ctx, result, failure);
+        apply(ctx, result, failure);
       };
     }
 
@@ -204,9 +204,11 @@ public interface After extends Serializable {
      *
      * @param ctx Web context.
      * @param result Response generated by route handler.
+     * @param failure Uncaught exception generated by route handler.
      * @throws Exception If something goes wrong.
      */
-    void apply(@Nonnull Context ctx, @Nullable Object result) throws Exception;
+    void apply(@Nonnull Context ctx, @Nullable Object result, @Nullable Throwable failure)
+        throws Exception;
   }
 
   /**
@@ -245,14 +247,39 @@ public interface Handler extends Serializable {
      */
     @Nonnull default Handler then(@Nonnull After next) {
       return ctx -> {
-        Object result = apply(ctx);
-        if (ctx.isResponseStarted()) {
-          Context fwd = Context.readOnly(ctx);
-          next.apply(fwd, null);
-          return fwd;
-        } else {
-          next.apply(ctx, result);
+        Throwable cause = null;
+        Object value = null;
+        try {
+          value = apply(ctx);
+        } catch (Throwable x) {
+          cause = x;
+        }
+        Object result;
+        try {
+          if (ctx.isResponseStarted()) {
+            result = Context.readOnly(ctx);
+            next.apply((Context) result, value, cause);
+          } else {
+            result = value;
+            next.apply(ctx, value, cause);
+          }
+        } catch (Throwable x) {
+          result = null;
+          if (cause == null) {
+            cause = x;
+          } else {
+            cause.addSuppressed(x);
+          }
+        }
+
+        if (cause == null) {
           return result;
+        } else {
+          if (ctx.isResponseStarted()) {
+            return ctx;
+          } else {
+            throw SneakyThrows.propagate(cause);
+          }
         }
       };
     }

jooby/src/main/kotlin/io/jooby/HandlerContext.kt

@@ -5,7 +5,7 @@
  */
 package io.jooby
 
-class AfterContext(val ctx: Context, val result: Any?)
+class AfterContext(val ctx: Context, val result: Any?, val failure: Any?)
 
 class DecoratorContext(val ctx: Context, val next: Route.Handler)
 

jooby/src/main/kotlin/io/jooby/Kooby.kt

@@ -134,7 +134,7 @@ open class Kooby constructor() : Jooby() {
 
   @RouterDsl
   fun after(handler: AfterContext.() -> Any): Kooby {
-    super.after { ctx, result -> AfterContext(ctx, result).handler() }
+    super.after { ctx, result, failure -> AfterContext(ctx, result, failure).handler() }
     return this
   }
 

modules/jooby-test/src/test/java/io/jooby/UnitTest.java

@@ -77,7 +77,7 @@ public void pipeline() {
     Jooby app = new Jooby();
 
     app.before(ctx -> ctx.setResponseHeader("before", "<"));
-    app.after((ctx, result) -> ctx.setResponseHeader("after", ">"));
+    app.after((ctx, result, failure) -> ctx.setResponseHeader("after", ">"));
     app.get("/", ctx -> "OK");
 
     MockRouter router = new MockRouter(app)

tests/src/test/java/io/jooby/FeaturedTest.java

@@ -19,7 +19,6 @@
 import okhttp3.Response;
 import okhttp3.ResponseBody;
 import org.junit.jupiter.api.DisplayName;
-import org.junit.jupiter.api.RepeatedTest;
 import org.junit.jupiter.api.Test;
 import reactor.core.publisher.Flux;
 import reactor.core.publisher.Mono;
@@ -650,7 +649,7 @@ public void beforeAfter() {
         ctx.attribute("buff", buff);
       });
 
-      app.after((ctx, value) -> {
+      app.after((ctx, value, failure) -> {
         StringBuilder buff = (StringBuilder) value;
         buff.append("after1:" + ctx.isInIoThread()).append(";");
       });
@@ -661,7 +660,7 @@ public void beforeAfter() {
           buff.append("before2:" + ctx.isInIoThread()).append(";");
         });
 
-        app.after((ctx, value) -> {
+        app.after((ctx, value, failure) -> {
           StringBuilder buff = ctx.attribute("buff");
           buff.append("after2:" + ctx.isInIoThread()).append(";");
         });