env refactor

- remove thread local
- late init for env
- allow app initializer to set the env
- allow custom name for application.properties

Author: jknack

jooby/src/main/java/io/jooby/Env.java

@@ -129,7 +129,7 @@ public static PropertySource parse(String... args) {
     return new PropertySource("args", conf);
   }
 
-  public static PropertySource load(ClassLoader loader, String filename) {
+  private static PropertySource load(ClassLoader loader, String filename) {
     return load(loader, filename, (name, stream) -> {
       try {
         Properties properties = new Properties();
@@ -141,7 +141,7 @@ public static PropertySource load(ClassLoader loader, String filename) {
     });
   }
 
-  public static PropertySource load(ClassLoader loader, String filename,
+  private static PropertySource load(ClassLoader loader, String filename,
       BiFunction<String, InputStream, PropertySource> propertyLoader) {
     AtomicReference<String> fullpath = new AtomicReference<>();
     InputStream stream = findProperties(loader, filename, fullpath::set);
@@ -167,19 +167,20 @@ public static PropertySource systemEnv() {
     return new PropertySource("systemEnv", System.getenv());
   }
 
-  public static Env defaultEnvironment(String... args) {
-    ClassLoader classLoader = Env.class.getClassLoader();
+  public static Env defaultEnvironment(ClassLoader loader) {
+    return defaultEnvironment(loader, "application");
+  }
+
+  public static Env defaultEnvironment(ClassLoader loader, String filename) {
     LinkedList<PropertySource> sources = new LinkedList<>();
-    PropertySource argMap = parse(args);
 
     sources.add(systemEnv());
     sources.add(systemProperties());
-    sources.add(argMap);
 
     String env = fromSource(sources, "application.env", "dev").toLowerCase();
     Stream
-        .of("application." + env + ".properties", "application.properties")
-        .map(filename -> load(classLoader, filename))
+        .of(filename + "." + env + ".properties", filename + ".properties")
+        .map(it -> load(loader, it))
         .filter(props -> props.properties().size() > 0)
         .forEach(sources::addFirst);
 

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

@@ -26,11 +26,10 @@
 import java.nio.file.Path;
 import java.nio.file.Paths;
 import java.util.ArrayList;
-import java.util.HashMap;
+import java.util.Arrays;
 import java.util.Iterator;
 import java.util.LinkedList;
 import java.util.List;
-import java.util.Map;
 import java.util.NoSuchElementException;
 import java.util.ServiceLoader;
 import java.util.Spliterator;
@@ -47,6 +46,8 @@
 
 public class Jooby implements Router, Registry {
 
+  private static final String ENV_KEY = "application.env";
+
   private RouterImpl router;
 
   private ExecutionMode mode;
@@ -61,27 +62,12 @@ public class Jooby implements Router, Registry {
 
   private LinkedList<Throwing.Runnable> stopCallbacks;
 
-  /**
-   * Not ideal but useful. We want to have access to environment properties from instance
-   * initializer. So external method before creating a new Jooby instance does a call to
-   * {@link Jooby#setEnv(Env)} this makes available the env instance in any other Jooby instance
-   * created.
-   */
-  private static ThreadLocal<Env> ENV = new ThreadLocal<>();
-
-  protected Env environment;
+  private Env environment;
 
   private Registry registry;
 
   public Jooby() {
     router = new RouterImpl(new RouteAnalyzer(getClass().getClassLoader(), false));
-    environment = ENV.get();
-    if (environment == null) {
-      // TODO: fallback for now, but probably better if we throws a specific error
-      environment = Env.defaultEnvironment();
-    }
-    tmpdir = Paths.get(environment.get("application.tmpdir").value()).toAbsolutePath();
-
   }
 
   public @Nonnull Env environment() {
@@ -340,14 +326,20 @@ private <T> T require(AttributeKey<T> key) {
     if (serverConfigurer != null) {
       serverConfigurer.accept(server);
     }
+    if (environment == null) {
+      environment = Env.defaultEnvironment(getClass().getClassLoader());
+    }
+    if (tmpdir == null) {
+      tmpdir = Paths.get(environment.get("application.tmpdir").value()).toAbsolutePath();
+    }
     return server.start(this);
   }
 
   public @Nonnull Jooby start(@Nonnull Server server) {
     /** Start router: */
     ensureTmpdir(tmpdir);
-    Logger log = log();
-    log.debug("environment:\n{}", environment);
+
+    log().debug("environment:\n{}", environment);
 
     if (mode == null) {
       mode = ExecutionMode.DEFAULT;
@@ -399,55 +391,51 @@ private <T> T require(AttributeKey<T> key) {
     return router.toString();
   }
 
-  public static void setEnv(@Nonnull Env environment) {
-    ENV.set(environment);
-  }
-
   public static void run(@Nonnull Supplier<Jooby> provider, String... args) {
     run(provider, ExecutionMode.DEFAULT, args);
   }
 
   public static void run(@Nonnull Supplier<Jooby> provider, @Nonnull ExecutionMode mode,
       String... args) {
-    Server server;
-    try {
-      Env environment = Env.defaultEnvironment(args);
-      setEnv(environment);
 
-      logback(environment);
+    /** Dump command line as system properties. */
+    Env.parse(args).properties().forEach(System::setProperty);
 
-      Jooby app = provider.get();
-      if (app.mode == null) {
-        app.mode = mode;
-      }
-      server = app.start();
-    } finally {
-      // clear env
-      setEnv(null);
+    /** Fin application.env: */
+    String env = System.getProperty(ENV_KEY, System.getenv().getOrDefault(ENV_KEY, "dev"))
+        .toLowerCase();
+
+    logback(env);
+
+    Jooby app = provider.get();
+    if (app.mode == null) {
+      app.mode = mode;
     }
+    Server server = app.start();
     server.join();
   }
 
-  public static void logback(@Nonnull Env env) {
-    String setfile = env.get("logback.configurationFile").value((String) null);
-    if (setfile != null) {
-      System.setProperty("logback.configurationFile", setfile);
-      return;
+  public static void logback(@Nonnull String env) {
+    String logfile = System
+        .getProperty("logback.configurationFile", System.getenv().get("logback.configurationFile"));
+    if (logfile != null) {
+      System.setProperty("logback.configurationFile", logfile);
+    } else {
+      Path userdir = Paths.get(System.getProperty("user.dir"));
+      Path conf = userdir.resolve("conf");
+      String logbackenv = "logback." + env + ".xml";
+      String fallback = "logback.xml";
+      Stream.of(
+          /** Env specific inside conf or userdir: */
+          conf.resolve(logbackenv), userdir.resolve(logbackenv),
+          /** Fallback inside conf or userdir: */
+          conf.resolve(fallback), userdir.resolve(fallback)
+      ).filter(Files::exists)
+          .findFirst()
+          .map(Path::toAbsolutePath)
+          .ifPresent(
+              logback -> System.setProperty("logback.configurationFile", logback.toString()));
     }
-    String name = env.name();
-    Path userdir = Paths.get(System.getProperty("user.dir"));
-    Path conf = userdir.resolve("conf");
-    String logbackenv = "logback." + name + ".xml";
-    String fallback = "logback.xml";
-    Stream.of(
-        /** Env specific inside conf or userdir: */
-        conf.resolve(logbackenv), userdir.resolve(logbackenv),
-        /** Fallback inside conf or userdir: */
-        conf.resolve(fallback), userdir.resolve(fallback)
-    ).filter(Files::exists)
-        .findFirst()
-        .map(Path::toAbsolutePath)
-        .ifPresent(logback -> System.setProperty("logback.configurationFile", logback.toString()));
   }
 
   private static void ensureTmpdir(Path tmpdir) {

jooby/src/test/java/io/jooby/EnvTest.java

@@ -9,6 +9,7 @@
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
+import java.util.Properties;
 import java.util.function.Consumer;
 
 import static java.util.Arrays.asList;
@@ -62,15 +63,15 @@ private void env(String dir, Consumer<Env> consumer) {
   }
 
   private void env(String dir, Map<String, String> args, Consumer<Env> consumer) {
-    Path file = Paths.get("env", dir);
-    System.setProperty("env.dir", file.toString());
-    consumer.accept(Env.defaultEnvironment(toArray(args)));
-  }
-
-  private String[] toArray(Map<String, String> args) {
-    List<String> result = new ArrayList<>();
-    args.forEach((k, v) -> result.add(k + "=" + v));
-    return result.toArray(new String[result.size()]);
+    Properties sysprops = new Properties(System.getProperties());
+    try {
+      Path file = Paths.get("env", dir);
+      System.setProperty("env.dir", file.toString());
+      args.forEach((k, v) -> System.setProperty(k, v));
+      consumer.accept(Env.defaultEnvironment(getClass().getClassLoader()));
+    } finally {
+      System.setProperties(sysprops);
+    }
   }
 
   private Map<String, String> mapOf(String... values) {

jooby/src/test/java/io/jooby/JoobyRunner.java

@@ -22,25 +22,20 @@ public class JoobyRunner {
 
   public JoobyRunner(Consumer<Jooby> provider) {
     this.provider = () -> {
-      try {
-        Jooby.setEnv(Env.defaultEnvironment("test"));
-        Jooby app = new Jooby();
-        provider.accept(app);
-        return app;
-      } finally {
-        Jooby.setEnv(null);
-      }
+      Jooby app = new Jooby();
+      app.environment(Env.defaultEnvironment(getClass().getClassLoader(), "test"));
+      provider.accept(app);
+      return app;
     };
   }
 
   public JoobyRunner(Supplier<Jooby> provider) {
     this.provider = () -> {
-      try {
-        Jooby.setEnv(Env.defaultEnvironment("test"));
-        return provider.get();
-      } finally {
-        Jooby.setEnv(null);
+      Jooby app = provider.get();
+      if (app.environment() == null) {
+        app.environment(Env.defaultEnvironment(app.getClass().getClassLoader(), "test"));
       }
+      return app;
     };
   }
 

jooby/src/test/java/io/jooby/MockRouter.java

@@ -13,22 +13,21 @@ public class MockRouter {
 
   public MockRouter(Supplier<Jooby> supplier) {
     this.supplier = () -> {
-      Env env = Env.defaultEnvironment("test");
-      Jooby.setEnv(env);
       Jooby jooby = supplier.get();
-      Jooby.setEnv(null);
+      if (jooby.environment() == null) {
+        jooby.environment(Env.defaultEnvironment(jooby.getClass().getClassLoader(), "test"));
+      }
       return jooby;
     };
   }
 
   public MockRouter(Consumer<Jooby> consumer) {
     this.supplier = () -> {
-      Env env = Env.defaultEnvironment("test");
-      Jooby.setEnv(env);
-      Jooby app = new Jooby();
-      consumer.accept(app);
-      Jooby.setEnv(null);
-      return app;
+      Jooby jooby = new Jooby();
+      Env env = Env.defaultEnvironment(getClass().getClassLoader(), "test");
+      jooby.environment(env);
+      consumer.accept(jooby);
+      return jooby;
     };
   }
 
@@ -114,7 +113,8 @@ private Object route(Jooby router, String method, String path, Consumer<MockCont
     Result result = new Result(value, ctx.statusCode());
 
     /** Content-Type: */
-    result.header("Content-Type", ctx.responseContentType().toContentTypeHeader(ctx.getResponseCharset()));
+    result.header("Content-Type",
+        ctx.responseContentType().toContentTypeHeader(ctx.getResponseCharset()));
 
     /** Length: */
     long responseLength = ctx.getResponseLength();