feature: support multiple application on single server

- Implement multiapp deploy on servers
- TODO: doc

- ref #3645

Author: jknack

jooby/src/main/java/io/jooby/Context.java

@@ -46,6 +46,38 @@
  */
 public interface Context extends Registry {
 
+  interface Selector {
+    Jooby select(List<Jooby> applications, String path);
+
+    static Selector create(List<Jooby> applications) {
+      return applications.size() == 1 ? single() : multiple();
+    }
+
+    static Selector multiple() {
+      return (applications, path) -> {
+        var defaultApp = applications.get(0);
+        for (var app : applications) {
+          var contextPath = app.getContextPath();
+          if ("/".equals(contextPath)) {
+            defaultApp = app;
+          } else if (path.startsWith(contextPath)) {
+            return app;
+          }
+        }
+        return defaultApp;
+      };
+    }
+
+    static Selector single() {
+      return new Selector() {
+        @Override
+        public Jooby select(List<Jooby> applications, String path) {
+          return applications.get(0);
+        }
+      };
+    }
+  }
+
   /** Constant for default HTTP port. */
   int PORT = 80;
 

jooby/src/main/java/io/jooby/Jooby.java

@@ -7,7 +7,6 @@
 
 import static java.util.Collections.singletonList;
 import static java.util.Objects.requireNonNull;
-import static java.util.Spliterators.spliteratorUnknownSize;
 import static java.util.stream.StreamSupport.stream;
 
 import java.io.IOException;
@@ -30,7 +29,6 @@
 import java.util.ServiceConfigurationError;
 import java.util.ServiceLoader;
 import java.util.Set;
-import java.util.Spliterator;
 import java.util.concurrent.Executor;
 import java.util.concurrent.ExecutorService;
 import java.util.concurrent.atomic.AtomicBoolean;
@@ -149,7 +147,9 @@ public Jooby() {
    * Server options or <code>null</code>.
    *
    * @return Server options or <code>null</code>.
+   * @deprecated Use {@link Server#getOptions()}
    */
+  @Deprecated(since = "3.8.0", forRemoval = true)
   public @Nullable ServerOptions getServerOptions() {
     return serverOptions;
   }
@@ -159,7 +159,9 @@ public Jooby() {
    *
    * @param serverOptions Server options.
    * @return This application.
+   * @deprecated Use {@link Server#setOptions(ServerOptions)}
    */
+  @Deprecated(since = "3.8.0", forRemoval = true)
   public @NonNull Jooby setServerOptions(@NonNull ServerOptions serverOptions) {
     this.serverOptions = serverOptions;
     return this;
@@ -970,10 +972,12 @@ public Jooby setStartupSummary(List<StartupSummary> startupSummary) {
    * etc..
    *
    * @return Server.
+   * @deprecated Use {@link Server#start(Jooby[])}
    */
+  @Deprecated(since = "3.8.0", forRemoval = true)
   public @NonNull Server start() {
     if (server == null) {
-      this.server = loadServer();
+      this.server = Server.loadServer();
     }
     if (!server.getLoggerOff().isEmpty()) {
       this.server = MutedServer.mute(this.server);
@@ -1004,31 +1008,6 @@ public Jooby setStartupSummary(List<StartupSummary> startupSummary) {
     }
   }
 
-  /**
-   * Load server from classpath using {@link ServiceLoader}.
-   *
-   * @return A server.
-   */
-  private Server loadServer() {
-    List<Server> servers =
-        stream(
-                spliteratorUnknownSize(
-                    ServiceLoader.load(Server.class).iterator(), Spliterator.ORDERED),
-                false)
-            .toList();
-    if (servers.isEmpty()) {
-      throw new StartupException("Server not found.");
-    }
-    if (servers.size() > 1) {
-      List<String> names =
-          servers.stream()
-              .map(it -> it.getClass().getSimpleName().toLowerCase())
-              .collect(Collectors.toList());
-      getLog().warn("Multiple servers found {}. Using: {}", names, names.get(0));
-    }
-    return servers.get(0);
-  }
-
   /**
    * Call back method that indicates application was deploy it in the given server.
    *
@@ -1277,28 +1256,78 @@ public static void runApp(
       @NonNull String[] args,
       @NonNull ExecutionMode executionMode,
       @NonNull Supplier<Jooby> provider) {
-    createApp(args, executionMode, provider).start();
+    runApp(args, Server.loadServer(), executionMode, List.of(provider));
   }
 
   /**
    * Setup default environment, logging (logback or log4j2) and run application.
    *
    * @param args Application arguments.
-   * @param executionMode Application execution mode.
    * @param provider Application provider.
-   * @return Application.
    */
-  public static Jooby createApp(
+  public static void runApp(@NonNull String[] args, @NonNull List<Supplier<Jooby>> provider) {
+    runApp(args, Server.loadServer(), ExecutionMode.DEFAULT, provider);
+  }
+
+  /**
+   * Setup default environment, logging (logback or log4j2) and run application.
+   *
+   * @param args Application arguments.
+   * @param executionMode Execution mode.
+   * @param provider Application provider.
+   */
+  public static void runApp(
       @NonNull String[] args,
       @NonNull ExecutionMode executionMode,
-      @NonNull Supplier<Jooby> provider) {
+      @NonNull List<Supplier<Jooby>> provider) {
+    runApp(args, Server.loadServer(), executionMode, provider);
+  }
 
-    configurePackage(provider.getClass().getPackage());
+  /**
+   * Setup default environment, logging (logback or log4j2) and run application.
+   *
+   * @param args Application arguments.
+   * @param server Server.
+   * @param provider Application provider.
+   */
+  public static void runApp(
+      @NonNull String[] args, @NonNull Server server, @NonNull List<Supplier<Jooby>> provider) {
+    runApp(args, server, ExecutionMode.DEFAULT, provider);
+  }
 
-    /** Dump command line as system properties. */
+  /**
+   * Setup default environment, logging (logback or log4j2) and run application.
+   *
+   * @param args Application arguments.
+   * @param server Server.
+   * @param executionMode Execution mode.
+   * @param provider Application provider.
+   */
+  public static void runApp(
+      @NonNull String[] args,
+      @NonNull Server server,
+      @NonNull ExecutionMode executionMode,
+      @NonNull List<Supplier<Jooby>> provider) {
+    /* Dump command line as system properties. */
     parseArguments(args).forEach(System::setProperty);
+    var apps = new ArrayList<Jooby>();
+    for (var factory : provider) {
+      apps.add(createApp(executionMode, factory));
+    }
+    server.start(apps.toArray(new Jooby[0]));
+  }
 
-    /** Find application.env: */
+  /**
+   * Setup default environment, logging (logback or log4j2) and run application.
+   *
+   * @param executionMode Application execution mode.
+   * @param provider Application provider.
+   * @return Application.
+   */
+  public static Jooby createApp(
+      @NonNull ExecutionMode executionMode, @NonNull Supplier<Jooby> provider) {
+    configurePackage(provider.getClass().getPackage());
+    /* Find application.env: */
     String logfile =
         LoggingService.configure(
             provider.getClass().getClassLoader(), new EnvironmentOptions().getActiveNames());

jooby/src/main/java/io/jooby/LoggingService.java

@@ -16,6 +16,7 @@
 import java.util.stream.StreamSupport;
 
 import edu.umd.cs.findbugs.annotations.NonNull;
+import edu.umd.cs.findbugs.annotations.Nullable;
 
 /**
  * Describe the underlying logging system. Jooby provides two implementation: jooby-logback and
@@ -62,7 +63,7 @@ public interface LoggingService {
    * @param names Actives environment names. Useful for choosing an environment specific logging
    *     configuration file.
    */
-  static String configure(@NonNull ClassLoader classLoader, @NonNull List<String> names) {
+  static @Nullable String configure(@NonNull ClassLoader classLoader, @NonNull List<String> names) {
     // Supported well-know implementation
     String[] keys = {"logback.configurationFile", "log4j.configurationFile"};
     for (String key : keys) {
@@ -177,7 +178,7 @@ private static List<Object> logFile(
     return result;
   }
 
-  private static String property(String name) {
+  private static @Nullable String property(String name) {
     return System.getProperty(name, System.getenv(name));
   }
 }

jooby/src/main/java/io/jooby/Router.java

@@ -794,11 +794,11 @@ default Object execute(@NonNull Context context) {
    * <p>If no match exists this method returns a route with a <code>404</code> handler. See {@link
    * Route#NOT_FOUND}.
    *
-   * @param method Method to match.
+   * @param pattern Pattern to match.
    * @param path Path to match.
    * @return A route match result.
    */
-  boolean match(@NonNull String method, @NonNull String path);
+  boolean match(@NonNull String pattern, @NonNull String path);
 
   /* Error handler: */
 

jooby/src/main/java/io/jooby/Server.java

@@ -7,20 +7,28 @@
 
 import static java.util.Collections.emptyList;
 import static java.util.Collections.singletonList;
+import static java.util.Spliterators.spliteratorUnknownSize;
+import static java.util.stream.StreamSupport.stream;
 
 import java.io.EOFException;
 import java.io.IOException;
 import java.net.BindException;
 import java.nio.channels.ClosedChannelException;
 import java.util.List;
 import java.util.Optional;
+import java.util.ServiceLoader;
+import java.util.Spliterator;
 import java.util.concurrent.CopyOnWriteArrayList;
 import java.util.concurrent.Executor;
 import java.util.concurrent.atomic.AtomicBoolean;
 import java.util.function.Predicate;
+import java.util.stream.Collectors;
+
+import org.slf4j.LoggerFactory;
 
 import edu.umd.cs.findbugs.annotations.NonNull;
 import edu.umd.cs.findbugs.annotations.Nullable;
+import io.jooby.exception.StartupException;
 import io.jooby.internal.MutedServer;
 
 /**
@@ -145,7 +153,7 @@ protected void addShutdownHook() {
    * @param application Application to start.
    * @return This server.
    */
-  @NonNull Server start(@NonNull Jooby application);
+  @NonNull Server start(@NonNull Jooby... application);
 
   /**
    * Utility method to turn off odd logger. This help to ensure same startup log lines across server
@@ -219,4 +227,30 @@ static boolean isAddressInUse(@Nullable Throwable cause) {
     }
     return false;
   }
+
+  /**
+   * Load server from classpath using {@link ServiceLoader}.
+   *
+   * @return A server.
+   */
+  static Server loadServer() {
+    List<Server> servers =
+        stream(
+                spliteratorUnknownSize(
+                    ServiceLoader.load(Server.class).iterator(), Spliterator.ORDERED),
+                false)
+            .toList();
+    if (servers.isEmpty()) {
+      throw new StartupException("Server not found.");
+    }
+    if (servers.size() > 1) {
+      List<String> names =
+          servers.stream()
+              .map(it -> it.getClass().getSimpleName().toLowerCase())
+              .collect(Collectors.toList());
+      var log = LoggerFactory.getLogger(servers.get(0).getClass());
+      log.warn("Multiple servers found {}. Using: {}", names, names.get(0));
+    }
+    return servers.get(0);
+  }
 }

jooby/src/main/java/io/jooby/internal/MutedServer.java

@@ -65,7 +65,7 @@ public static Server mute(Server server, String... logger) {
     return delegate.getOptions();
   }
 
-  @NonNull public Server start(@NonNull Jooby application) {
+  @NonNull public Server start(@NonNull Jooby... application) {
     loggingService.logOff(mute, () -> delegate.start(application));
     return delegate;
   }

modules/jooby-jetty/src/main/java/io/jooby/internal/jetty/PrefixHandler.java

@@ -0,0 +1,41 @@
+/*
+ * Jooby https://jooby.io
+ * Apache License Version 2.0 https://jooby.io/LICENSE.txt
+ * Copyright 2014 Edgar Espina
+ */
+package io.jooby.internal.jetty;
+
+import java.util.List;
+import java.util.Map;
+
+import org.eclipse.jetty.server.Handler;
+import org.eclipse.jetty.server.Request;
+import org.eclipse.jetty.server.Response;
+import org.eclipse.jetty.util.Callback;
+
+public class PrefixHandler extends Handler.Abstract {
+  private final List<Map.Entry<String, Handler>> mapping;
+  private int defaultHandlerIndex;
+
+  public PrefixHandler(List<Map.Entry<String, Handler>> mapping) {
+    this.mapping = mapping;
+    this.defaultHandlerIndex = 0;
+    for (int i = 0; i < mapping.size(); i++) {
+      if (mapping.get(i).getKey().equals("/")) {
+        defaultHandlerIndex = i;
+        break;
+      }
+    }
+  }
+
+  @Override
+  public boolean handle(Request request, Response response, Callback callback) throws Exception {
+    for (Map.Entry<String, Handler> e : mapping) {
+      var path = request.getHttpURI().getPath();
+      if (path.startsWith(e.getKey())) {
+        return e.getValue().handle(request, response, callback);
+      }
+    }
+    return mapping.get(defaultHandlerIndex).getValue().handle(request, response, callback);
+  }
+}