Add support for a default environment (micronaut-projects#4027)

* Add support for a default environment

* Add a whats new entry

Author: jameskleeh

inject/src/main/java/io/micronaut/context/ApplicationContextBuilder.java

@@ -102,6 +102,14 @@ public interface ApplicationContextBuilder {
      */
     @NonNull ApplicationContextBuilder environments(@Nullable String... environments);
 
+    /**
+     * The environments to use if no other environments are specified.
+     *
+     * @param environments The environments
+     * @return This builder
+     */
+    @NonNull ApplicationContextBuilder defaultEnvironments(@Nullable String... environments);
+
     /**
      * The packages to include for package scanning.
      *

inject/src/main/java/io/micronaut/context/ApplicationContextConfiguration.java

@@ -21,6 +21,7 @@
 import edu.umd.cs.findbugs.annotations.NonNull;
 import edu.umd.cs.findbugs.annotations.Nullable;
 
+import java.util.Collections;
 import java.util.List;
 import java.util.Optional;
 
@@ -45,6 +46,14 @@ default Optional<Boolean> getDeduceEnvironments() {
         return Optional.empty();
     }
 
+    /**
+     * @return The default environments to be applied if no other environments
+     * are explicitly specified.
+     */
+    default List<String> getDefaultEnvironments() {
+        return Collections.emptyList();
+    }
+
     /**
      * @return True if environment variables should contribute to configuration
      */

inject/src/main/java/io/micronaut/context/DefaultApplicationContextBuilder.java

@@ -38,6 +38,7 @@
 public class DefaultApplicationContextBuilder implements ApplicationContextBuilder, ApplicationContextConfiguration {
     private List<Object> singletons = new ArrayList<>();
     private List<String> environments = new ArrayList<>();
+    private List<String> defaultEnvironments = new ArrayList<>();
     private List<String> packages = new ArrayList<>();
     private Map<String, Object> properties = new LinkedHashMap<>();
     private List<PropertySource> propertySources = new ArrayList<>();
@@ -121,6 +122,14 @@ public ClassLoader getClassLoader() {
         return this;
     }
 
+    @Override
+    public @NonNull ApplicationContextBuilder defaultEnvironments(@Nullable String... environments) {
+        if (environments != null) {
+            this.defaultEnvironments.addAll(Arrays.asList(environments));
+        }
+        return this;
+    }
+
     @Override
     public @NonNull ApplicationContextBuilder packages(@Nullable String... packages) {
         if (packages != null) {
@@ -177,6 +186,11 @@ public Optional<Boolean> getDeduceEnvironments() {
         return environments;
     }
 
+    @Override
+    public @NonNull List<String> getDefaultEnvironments() {
+        return defaultEnvironments;
+    }
+
     @Override
     public boolean isEnvironmentPropertySource() {
         return envPropertySource;

inject/src/main/java/io/micronaut/context/env/DefaultEnvironment.java

@@ -50,6 +50,7 @@
 import java.util.concurrent.ConcurrentLinkedQueue;
 import java.util.concurrent.atomic.AtomicBoolean;
 import java.util.function.Function;
+import java.util.stream.Collectors;
 import java.util.stream.Stream;
 
 /**
@@ -113,6 +114,17 @@ public DefaultEnvironment(@NonNull ApplicationContextConfiguration configuration
         Set<String> environments = new LinkedHashSet<>(3);
         List<String> specifiedNames = configuration.getEnvironments();
 
+        specifiedNames.addAll(0, Stream.of(System.getProperty(ENVIRONMENTS_PROPERTY),
+                System.getenv(ENVIRONMENTS_ENV))
+                .filter(StringUtils::isNotEmpty)
+                .flatMap(s -> Arrays.stream(s.split(",")))
+                .map(String::trim)
+                .collect(Collectors.toList()));
+
+        if (specifiedNames.isEmpty()) {
+            specifiedNames = configuration.getDefaultEnvironments();
+        }
+
         this.deduceEnvironments = configuration.getDeduceEnvironments().orElse(null);
         EnvironmentsAndPackage environmentsAndPackage = getEnvironmentsAndPackage(specifiedNames);
         environments.addAll(environmentsAndPackage.enviroments);
@@ -731,13 +743,6 @@ private static EnvironmentsAndPackage deduceEnvironmentsAndPackage(
             }
         }
 
-        Stream.of(System.getProperty(ENVIRONMENTS_PROPERTY),
-            System.getenv(ENVIRONMENTS_ENV))
-            .filter(StringUtils::isNotEmpty)
-            .flatMap(s -> Arrays.stream(s.split(",")))
-            .map(String::trim)
-            .forEach(environments::add);
-
         return environmentsAndPackage;
     }
 

inject/src/test/groovy/io/micronaut/context/env/DefaultEnvironmentSpec.groovy

@@ -17,6 +17,7 @@ package io.micronaut.context.env
 
 import com.github.stefanbirkner.systemlambda.SystemLambda
 import io.micronaut.context.ApplicationContext
+import io.micronaut.context.ApplicationContextConfiguration
 import io.micronaut.context.exceptions.ConfigurationException
 import io.micronaut.core.naming.NameUtils
 import spock.lang.Specification
@@ -590,6 +591,76 @@ class DefaultEnvironmentSpec extends Specification {
         env.activeNames == ["test", "first", "third", "second"] as Set
     }
 
+    void "test the default environment is applied"() {
+        when:
+        Environment env = new DefaultEnvironment(new ApplicationContextConfiguration() {
+            @Override
+            List<String> getEnvironments() {
+                return []
+            }
+
+            @Override
+            List<String> getDefaultEnvironments() {
+                return ['default']
+            }
+        }).start()
+
+        then:
+        env.activeNames == ['test', 'default'] as Set
+
+        when: 'an environment is specified'
+        env = new DefaultEnvironment(new ApplicationContextConfiguration() {
+            @Override
+            List<String> getEnvironments() {
+                return ['foo']
+            }
+
+            @Override
+            List<String> getDefaultEnvironments() {
+                return ['default']
+            }
+        }).start()
+
+        then: 'the default environment is not applied'
+        env.activeNames == ['test', 'foo'] as Set
+
+        when: 'an environment is specified through env var'
+        SystemLambda.withEnvironmentVariable("MICRONAUT_ENVIRONMENTS", "bar")
+                .execute(() -> {
+                    env = new DefaultEnvironment(new ApplicationContextConfiguration() {
+                        @Override
+                        List<String> getEnvironments() {
+                            return []
+                        }
+
+                        @Override
+                        List<String> getDefaultEnvironments() {
+                            return ['default']
+                        }
+                    }).start()
+                })
+
+        then: 'the default environment is not applied'
+        env.activeNames == ['test', 'bar'] as Set
+
+        when: 'an environment is specified through a system prop'
+        System.setProperty('micronaut.environments', 'xyz')
+        env = new DefaultEnvironment(new ApplicationContextConfiguration() {
+            @Override
+            List<String> getEnvironments() {
+                return []
+            }
+
+            @Override
+            List<String> getDefaultEnvironments() {
+                return ['default']
+            }
+        }).start()
+
+        then: 'the default environment is not applied'
+        env.activeNames == ['test', 'xyz'] as Set
+    }
+
     private static Environment startEnv(String files) {
         new DefaultEnvironment({["test"]}) {
             @Override

runtime/src/main/java/io/micronaut/runtime/Micronaut.java

@@ -231,6 +231,11 @@ protected Micronaut() {
         return (Micronaut) super.environments(environments);
     }
 
+    @Override
+    public @NonNull Micronaut defaultEnvironments(@Nullable String... environments) {
+        return (Micronaut) super.defaultEnvironments(environments);
+    }
+
     @Override
     public @NonNull Micronaut packages(@Nullable String... packages) {
         return (Micronaut) super.packages(packages);

src/main/docs/guide/config/environments.adoc

@@ -46,3 +46,19 @@ $  java -Dmicronaut.env.deduction=false -jar myapp.jar
 Alternatively, you can disable environment deduction using the api:context.ApplicationContextBuilder[]'s `deduceEnvironment` method when setting up your application.
 
 snippet::io.micronaut.docs.context.env.DefaultEnvironmentSpec[tags="disableEnvDeduction",indent=0,title="Using ApplicationContextBuilder to disable environment deduction"]
+
+== Default Environment
+
+Micronaut supports the concept of one or many default environments. A default environment is one that is only applied if no other environments are explicitly specified. Environments can be explicitly specified either through the application context builder `Micronaut.build().environments(...)`, through the `micronaut.environments` system property, or the `MICRONAUT_ENVIRONMENTS` environment variable. If an environment is configured through any of the above means, the default environment will *not* be applied.
+
+To set the default environments, modify your application main method:
+
+[source,java]
+----
+public static void main(String[] args) {
+    Micronaut.build(args)
+            .mainClass(Application.class)
+            .defaultEnvironments("dev")
+            .start();
+}
+----

src/main/docs/guide/introduction/whatsNew.adoc

@@ -22,6 +22,10 @@ Query parameters are now respected and bindable in the Micronaut websocket suppo
 
 Cookies in HTTP responses from the client side are now retrievable on the HttpResponse. These are the cookies found in the `Set-Cookie` header.
 
+==== Default Environment
+
+Micronaut 2.1 introduces the concept of a default environment. One or more default environments can be set and they will apply if no other environments are explicitly specified. See the <<environments, environments documentation>> for information on how to use this new feature.
+
 ==== Mandatory upgrade for Netty tcnative
 
 Due to a new https://github.com/netty/netty/pull/10407[SSL default value introduced in Netty 4.1.52], if you are using tcnative you need to update it to `2.0.33.Final`.