Callback when the server has started fix #575

Author: jknack

coverage-report/src/test/java/org/jooby/issues/Issue575.java

@@ -0,0 +1,34 @@
+package org.jooby.issues;
+
+import org.jooby.test.ServerFeature;
+import org.junit.Test;
+
+import java.util.concurrent.atomic.AtomicInteger;
+
+public class Issue575 extends ServerFeature {
+
+  {
+    AtomicInteger inc = new AtomicInteger();
+    onStarted(r -> {
+      inc.incrementAndGet();
+    });
+
+    onStarted(() -> {
+      inc.incrementAndGet();
+    });
+
+    use((env, conf, binder) -> {
+      env.onStarted(r -> inc.incrementAndGet());
+      env.onStarted(() -> inc.incrementAndGet());
+    });
+
+    get("/575", () -> inc.get());
+  }
+
+  @Test
+  public void onStartedCallback() throws Exception {
+    request()
+        .get("/575")
+        .expect("4");
+  }
+}

jooby/src/main/java/org/jooby/Env.java

@@ -45,6 +45,7 @@
 
 import javaslang.API;
 import javaslang.control.Option;
+import javaslang.control.Try;
 import javaslang.control.Try.CheckedConsumer;
 
 /**
@@ -265,6 +266,8 @@ default Env build(final Config config) {
 
       private ImmutableList.Builder<CheckedConsumer<Registry>> start = ImmutableList.builder();
 
+      private ImmutableList.Builder<CheckedConsumer<Registry>> started = ImmutableList.builder();
+
       private ImmutableList.Builder<CheckedConsumer<Registry>> shutdown = ImmutableList.builder();
 
       private Map<String, Function<String, String>> xss = new HashMap<>();
@@ -321,11 +324,22 @@ public Env onStart(final CheckedConsumer<Registry> task) {
         return this;
       }
 
+      @Override
+      public LifeCycle onStarted(CheckedConsumer<Registry> task) {
+        this.started.add(task);
+        return this;
+      }
+
       @Override
       public List<CheckedConsumer<Registry>> startTasks() {
         return this.start.build();
       }
 
+      @Override
+      public List<CheckedConsumer<Registry>> startedTasks() {
+        return this.started.build();
+      }
+
       @Override
       public Map<String, Function<String, String>> xss() {
         return Collections.unmodifiableMap(xss);
@@ -518,6 +532,11 @@ default Function<String, String> xss(final String... xss) {
    */
   List<CheckedConsumer<Registry>> startTasks();
 
+  /**
+   * @return List of start tasks.
+   */
+  List<CheckedConsumer<Registry>> startedTasks();
+
   /**
    * @return List of stop tasks.
    */

jooby/src/main/java/org/jooby/Jooby.java

@@ -657,6 +657,7 @@ public EnvDep(final Predicate<String> predicate, final Consumer<Config> callback
 
   /** startup callback . */
   private transient List<CheckedConsumer<Registry>> onStart = new ArrayList<>();
+  private transient List<CheckedConsumer<Registry>> onStarted = new ArrayList<>();
 
   /** stop callback . */
   private transient List<CheckedConsumer<Registry>> onStop = new ArrayList<>();
@@ -771,6 +772,7 @@ private Jooby use(final Optional<String> path, final Jooby app) {
     });
     // start/stop callback
     app.onStart.forEach(this.onStart::add);
+    app.onStarted.forEach(this.onStarted::add);
     app.onStop.forEach(this.onStop::add);
     // mapper
     if (app.mapper != null) {
@@ -799,8 +801,8 @@ public Jooby env(final Env.Builder env) {
 
   @Override
   public Jooby onStart(final CheckedRunnable callback) {
-    requireNonNull(callback, "Callback is required.");
-    return onStart(a -> callback.run());
+    LifeCycle.super.onStart(callback);
+    return this;
   }
 
   @Override
@@ -811,9 +813,22 @@ public Jooby onStart(final CheckedConsumer<Registry> callback) {
   }
 
   @Override
-  public Jooby onStop(final CheckedRunnable callback) {
+  public Jooby onStarted(final CheckedRunnable callback) {
+    LifeCycle.super.onStarted(callback);
+    return this;
+  }
+
+  @Override
+  public Jooby onStarted(final CheckedConsumer<Registry> callback) {
     requireNonNull(callback, "Callback is required.");
-    return onStop(e -> callback.run());
+    onStarted.add(callback);
+    return this;
+  }
+
+  @Override
+  public Jooby onStop(final CheckedRunnable callback) {
+    LifeCycle.super.onStop(callback);
+    return this;
   }
 
   @Override
@@ -1978,6 +1993,11 @@ private void start(final String[] args, final Consumer<List<Route.Definition>> r
         end - start,
         printer);
 
+    // started services
+    for (CheckedConsumer<Registry> onStarted : this.onStarted) {
+      onStarted.accept(this);
+    }
+
     boolean join = conf.hasPath("server.join") ? conf.getBoolean("server.join") : true;
     if (join) {
       server.join();
@@ -2695,6 +2715,7 @@ private Injector bootstrap(final Config args,
     });
 
     onStart.addAll(0, finalEnv.startTasks());
+    onStarted.addAll(0, finalEnv.startedTasks());
     onStop.addAll(finalEnv.stopTasks());
 
     // clear bag and freeze it

jooby/src/main/java/org/jooby/LifeCycle.java

@@ -260,6 +260,20 @@ default LifeCycle lifeCycle(final Class<?> service) {
    */
   LifeCycle onStart(CheckedConsumer<Registry> task);
 
+  /**
+   * Add a started lifecycle event. Started callbacks are executed when the application is ready:
+   * modules and servers has been started.
+   *
+   * You should ONLY call this method while the application is been initialized or while
+   * {@link Jooby.Module#configure(Env, Config, com.google.inject.Binder)}.
+   *
+   * The behavior of this method once application has been initialized is <code>undefined</code>.
+   *
+   * @param task Task to run.
+   * @return This env.
+   */
+  LifeCycle onStarted(CheckedConsumer<Registry> task);
+
   /**
    * Add a start lifecycle event, useful for initialize and/or start services at startup time.
    *
@@ -275,6 +289,22 @@ default LifeCycle onStart(final CheckedRunnable task) {
     return onStart(app -> task.run());
   }
 
+  /**
+   * Add a started lifecycle event. Started callbacks are executed when the application is ready:
+   * modules and servers has been started.
+   *
+   * You should ONLY call this method while the application is been initialized or while
+   * {@link Jooby.Module#configure(Env, Config, com.google.inject.Binder)}.
+   *
+   * The behavior of this method once application has been initialized is <code>undefined</code>.
+   *
+   * @param task Task to run.
+   * @return This env.
+   */
+  default LifeCycle onStarted(final CheckedRunnable task) {
+    return onStarted(app -> task.run());
+  }
+
   /**
    * Add a stop lifecycle event, useful for cleanup and/or stop service at stop time.
    *

jooby/src/test/java/org/jooby/EnvTest.java

@@ -11,6 +11,7 @@
 import java.util.Optional;
 import java.util.function.Function;
 
+import javaslang.control.Try;
 import org.junit.Test;
 
 import com.google.common.collect.ImmutableMap;
@@ -122,6 +123,9 @@ public LifeCycle onStart(final CheckedConsumer<Registry> task) {
         return null;
       }
 
+      @Override
+      public LifeCycle onStarted(CheckedConsumer<Registry> task) { return null; }
+
       @Override
       public LifeCycle onStop(final CheckedConsumer<Registry> task) {
         return null;
@@ -162,6 +166,9 @@ public List<CheckedConsumer<Registry>> startTasks() {
         return null;
       }
 
+      @Override
+      public List<CheckedConsumer<Registry>> startedTasks() { return null; }
+
       @Override
       public List<CheckedConsumer<Registry>> stopTasks() {
         return null;

jooby/src/test/java/org/jooby/JoobyTest.java

@@ -838,6 +838,7 @@ public void customEnv() throws Exception {
           Env env = unit.mock(Env.class);
           expect(env.name()).andReturn("dev").times(2);
           expect(env.startTasks()).andReturn(Collections.emptyList());
+          expect(env.startedTasks()).andReturn(Collections.emptyList());
           expect(env.stopTasks()).andReturn(Collections.emptyList());
 
           Env.Builder builder = unit.get(Env.Builder.class);

md/app.md

@@ -36,9 +36,14 @@ Start/stop callbacks are accessible via application:
    onStart(() -> {
      log.info("starting app");
    });
+
    onStop(() -> {
      log.info("stopping app");
    });
+
+   onStarted(() -> {
+     log.info("app started");
+   });
 }
 ```
 
@@ -52,14 +57,21 @@ public class MyModule implements Jooby.Module {
     env.onStart(() -> {
       log.info("starting module");
     });
+
     env.onStop(() -> {
       log.info("stopping module");
     });
+
+    env.onStarted(() -> {
+      log.info("app started");
+    });
   }
 
 }
 ```
 
+The `onStart` callbacks are part of bootstrap and executed before server is ready. The `onStarted` callbacks are executed when server is ready.
+
 Modules are covered later all you need to know now is that you can start/stop module as you usually do from your application. 
 
 ### order