server/module: vertx support #3778

- Add vertx encoder
- Rename some classes

Author: jknack

modules/jooby-apt/src/main/java/io/jooby/internal/apt/ReactiveType.java

@@ -38,14 +38,22 @@ public static List<ReactiveType> supportedTypes() {
             "io.jooby.ReactiveSupport",
             "concurrent",
             Set.of("java.util.concurrent.Flow", "java.util.concurrent.CompletionStage")),
+        // Vertx
+        new ReactiveType(
+            "io.jooby.vertx.VertxHandler",
+            "vertx",
+            Set.of("io.vertx.core.Future", "io.vertx.core.Promise", "io.vertx.core.buffer.Buffer")),
+        // Mutiny
         new ReactiveType(
             "io.jooby.mutiny.Mutiny",
             "mutiny",
             Set.of("io.smallrye.mutiny.Uni", "io.smallrye.mutiny.Multi")),
+        // Reactor
         new ReactiveType(
             "io.jooby.reactor.Reactor",
             "reactor",
             Set.of("reactor.core.publisher.Flux", "reactor.core.publisher.Mono")),
+        // Rxjava
         new ReactiveType(
             "io.jooby.rxjava3.Reactivex",
             "rx",

modules/jooby-vertx-sql-client/src/main/java/io/jooby/vertx/sqlclient/VertxSqlClientModule.java

@@ -33,7 +33,7 @@ public void install(@NonNull Jooby application) throws Exception {
       options = fromMap(new JsonObject(config.getObject(name).unwrapped()));
     }
 
-    var client = newBuilder().connectingTo(options).using(registry.getOrNull(Vertx.class)).build();
+    var client = newBuilder().connectingTo(options).using(registry.require(Vertx.class)).build();
 
     registry.put(ServiceKey.key(SqlClient.class, name), client);
     registry.putIfAbsent(SqlClient.class, client);

modules/jooby-vertx/src/main/java/io/jooby/internal/vertx/VertxEncoder.java

@@ -0,0 +1,87 @@
+/*
+ * Jooby https://jooby.io
+ * Apache License Version 2.0 https://jooby.io/LICENSE.txt
+ * Copyright 2014 Edgar Espina
+ */
+package io.jooby.internal.vertx;
+
+import java.io.IOException;
+import java.io.OutputStream;
+
+import edu.umd.cs.findbugs.annotations.NonNull;
+import edu.umd.cs.findbugs.annotations.Nullable;
+import io.jooby.Context;
+import io.jooby.MessageEncoder;
+import io.jooby.output.Output;
+import io.vertx.core.Handler;
+import io.vertx.core.buffer.Buffer;
+import io.vertx.core.file.AsyncFile;
+
+public class VertxEncoder implements MessageEncoder {
+  private static class AsyncFileHandler {
+    private Context ctx;
+    private OutputStream out;
+    private boolean errored;
+    private boolean closed;
+
+    public AsyncFileHandler(Context ctx) {
+      this.ctx = ctx;
+      this.out = ctx.responseStream();
+    }
+
+    public Handler<Buffer> toHandler() {
+      return this::handle;
+    }
+
+    public Handler<Void> toEndHandler() {
+      return this::handleEnd;
+    }
+
+    public Handler<Throwable> toErrorHandler() {
+      return this::handleError;
+    }
+
+    private void handleEnd(Void unused) {
+      if (!closed) {
+        closed = true;
+        try {
+          out.close();
+        } catch (IOException ex) {
+          handleError(ex);
+        }
+      }
+    }
+
+    private void handleError(Throwable ex) {
+      if (!errored) {
+        errored = true;
+        ctx.sendError(ex);
+      } else {
+        ctx.getRouter().getLog().error("Async file write resulted in exception", ex);
+      }
+    }
+
+    private void handle(Buffer buffer) {
+      if (!closed) {
+        try {
+          out.write(buffer.getBytes());
+        } catch (IOException ex) {
+          handleError(ex);
+        }
+      }
+    }
+  }
+
+  @Nullable @Override
+  public Output encode(@NonNull Context ctx, @NonNull Object value) {
+    if (value instanceof Buffer buffer) {
+      ctx.send(buffer.getBytes());
+    } else if (value instanceof AsyncFile file) {
+      var handler = new AsyncFileHandler(ctx);
+      file.handler(handler.toHandler());
+      file.endHandler(handler.toEndHandler());
+      file.exceptionHandler(handler.toErrorHandler());
+    }
+    return null;
+  }
+}

…a/io/jooby/vertx/VertxFutureHandler.java …in/java/io/jooby/vertx/VertxHandler.javamodules/jooby-vertx/src/main/java/io/jooby/vertx/VertxFutureHandler.java renamed to modules/jooby-vertx/src/main/java/io/jooby/vertx/VertxHandler.java modules/jooby-vertx/src/main/java/io/jooby/vertx/VertxFutureHandler.java renamed to modules/jooby-vertx/src/main/java/io/jooby/vertx/VertxHandler.java

@@ -10,8 +10,9 @@
 import io.jooby.Route;
 import io.vertx.core.Future;
 import io.vertx.core.Promise;
+import io.vertx.core.buffer.Buffer;
 
-public class VertxFutureHandler implements Route.Filter {
+public class VertxHandler implements Route.Filter {
   @Override
   public @NonNull Route.Handler apply(Route.Handler next) {
     return ctx -> {
@@ -23,11 +24,21 @@ public class VertxFutureHandler implements Route.Filter {
         return futureResult(ctx, promise.future());
       } else if (result instanceof Future<?> future) {
         return futureResult(ctx, future);
+      } else if (result instanceof Buffer buffer) {
+        return bufferResult(ctx, buffer);
       }
       return result;
     };
   }
 
+  public static Route.Filter vertx() {
+    return new VertxHandler();
+  }
+
+  private Context bufferResult(Context ctx, Buffer buffer) {
+    return ctx.render(buffer);
+  }
+
   private static Context futureResult(Context ctx, Future<?> future) {
     future.onComplete(
         ar -> {

modules/jooby-vertx/src/main/java/io/jooby/vertx/VertxModule.java

@@ -5,42 +5,64 @@
  */
 package io.jooby.vertx;
 
+import java.util.function.Function;
+import java.util.function.Supplier;
+
 import edu.umd.cs.findbugs.annotations.NonNull;
 import io.jooby.Extension;
 import io.jooby.Jooby;
+import io.jooby.internal.vertx.VertxEncoder;
+import io.vertx.core.Future;
 import io.vertx.core.Vertx;
 import io.vertx.core.VertxOptions;
 import io.vertx.core.eventbus.EventBus;
+import io.vertx.core.file.FileSystem;
 import io.vertx.core.json.JsonObject;
 
 public class VertxModule implements Extension {
-  private Vertx vertx;
+  private VertxOptions options;
+  private final Function<VertxOptions, Future<Vertx>> vertxFactory;
+
+  public VertxModule() {
+    this(options -> Future.succeededFuture(Vertx.vertx(options)));
+  }
 
   public VertxModule(Vertx vertx) {
-    this.vertx = vertx;
+    this(options -> Future.succeededFuture(vertx));
   }
 
   public VertxModule(VertxOptions options) {
-    this.vertx = Vertx.vertx(options);
+    this(ops -> Future.succeededFuture(Vertx.vertx(ops)));
+    this.options = options;
+  }
+
+  public VertxModule(Function<VertxOptions, Future<Vertx>> vertx) {
+    this.vertxFactory = vertx;
   }
 
-  public VertxModule() {}
+  public VertxModule(Supplier<Future<Vertx>> vertx) {
+    this(options -> vertx.get());
+  }
 
   @Override
   public void install(@NonNull Jooby application) throws Exception {
-    if (vertx == null) {
-      var config = application.getConfig();
-      VertxOptions options;
+    var config = application.getConfig();
+    if (options == null) {
       if (config.hasPath("vertx")) {
         options = new VertxOptions(new JsonObject(config.getObject("vertx").unwrapped()));
       } else {
         options = new VertxOptions();
       }
-      vertx = Vertx.vertx(options);
     }
+    var vertxFuture = vertxFactory.apply(options);
+    var vertx = vertxFuture.await();
     var registry = application.getServices();
     registry.put(Vertx.class, vertx);
     registry.put(EventBus.class, vertx.eventBus());
+    registry.put(FileSystem.class, vertx.fileSystem());
+
+    application.encoder(new VertxEncoder());
+
     application.onStop(() -> vertx.close().await());
   }
 }

modules/jooby-vertx/src/main/java/module-info.java

@@ -8,4 +8,5 @@
   requires io.netty.transport;
   requires org.slf4j;
   requires static com.github.spotbugs.annotations;
+  requires jakarta.inject;
 }

…c/test/java/examples/vertx/VertxApp.java …xamples/vertx/VertxSqlConnectionApp.javatests/src/test/java/examples/vertx/VertxApp.java renamed to tests/src/test/java/examples/vertx/VertxSqlConnectionApp.java tests/src/test/java/examples/vertx/VertxApp.java renamed to tests/src/test/java/examples/vertx/VertxSqlConnectionApp.java

@@ -24,7 +24,7 @@
 import io.vertx.sqlclient.*;
 import io.vertx.sqlclient.impl.SqlClientInternal;
 
-public class VertxApp extends Jooby {
+public class VertxSqlConnectionApp extends Jooby {
   private static final String SELECT_WORLD = "SELECT id, randomnumber from WORLD where id=$1";
   private static final String SELECT_FORTUNE = "SELECT id, message from FORTUNE";
 
@@ -182,6 +182,6 @@ public static void main(String[] args) {
         args,
         new VertxServer().setOptions(new ServerOptions().setIoThreads(2)),
         EVENT_LOOP,
-        VertxApp::new);
+        VertxSqlConnectionApp::new);
   }
 }