Support Environments Concept in Micronaut Context (#12809)

* Support Environments Concept in Micronaut Context

Implemented a new MicronautYamlPropertySourceLoader which reads environment specific properties from application.yml file based on the current configured environment.

Fixes #12082

* Update GroovyConfigPropertySourceLoaderSpec.groovy

Author: puneetbehl

grails-core/src/main/groovy/org/grails/core/cfg/CustomSafeConstructor.groovy

@@ -0,0 +1,48 @@
+/*
+ * Copyright 2017-2020 original authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.grails.core.cfg
+
+import groovy.transform.Internal
+import io.micronaut.context.env.yaml.ConstructIsoTimestampString
+import org.yaml.snakeyaml.constructor.SafeConstructor
+import org.yaml.snakeyaml.nodes.MappingNode
+import org.yaml.snakeyaml.nodes.SequenceNode
+import org.yaml.snakeyaml.nodes.Tag
+
+/**
+ * Yaml constructor to create containers with sensible
+ * default array bounds.
+ *
+ * @author James Kleeh
+ * @since 6.0.0
+ */
+@Internal
+class CustomSafeConstructor extends SafeConstructor {
+    CustomSafeConstructor() {
+        yamlConstructors.put(Tag.TIMESTAMP, new ConstructIsoTimestampString())
+    }
+
+    @Override
+    protected Map<Object, Object> newMap(MappingNode node) {
+        return createDefaultMap(node.getValue().size())
+    }
+
+    @Override
+    protected List<Object> newList(SequenceNode node) {
+        return createDefaultList(node.getValue().size())
+    }
+}
+

grails-core/src/main/groovy/org/grails/core/cfg/MicronautGroovyPropertySourceLoader.groovy

@@ -1,10 +1,12 @@
 package org.grails.core.cfg
 
+import grails.plugins.GrailsPlugin
 import grails.util.BuildSettings
 import grails.util.Environment
 import grails.util.Metadata
 import groovy.transform.CompileStatic
 import io.micronaut.context.env.AbstractPropertySourceLoader
+import io.micronaut.context.env.MapPropertySource
 import io.micronaut.context.exceptions.ConfigurationException
 import io.micronaut.core.io.ResourceLoader
 import org.grails.config.NavigableMap
@@ -22,7 +24,7 @@ class MicronautGroovyPropertySourceLoader extends AbstractPropertySourceLoader {
 
     @Override
     int getOrder() {
-        return DEFAULT_POSITION
+        return DEFAULT_POSITION + 1
     }
 
     @Override
@@ -37,9 +39,10 @@ class MicronautGroovyPropertySourceLoader extends AbstractPropertySourceLoader {
                 appVersion: Metadata.getCurrent().getApplicationVersion())
             try {
                 def configObject = configSlurper.parse(input.getText("UTF-8"))
-                def propertySource = new NavigableMap()
+                final Map<String, Object> propertySource = new NavigableMap()
                 propertySource.merge(configObject.flatten(), false)
                 finalMap.putAll(propertySource)
+                processEnvironmentSpecificProperties(finalMap, propertySource)
             } catch (Throwable e) {
                 throw new ConfigurationException("Exception occurred reading configuration [" + name + "]: " + e.getMessage(), e)
             }
@@ -68,4 +71,19 @@ class MicronautGroovyPropertySourceLoader extends AbstractPropertySourceLoader {
         return Collections.singleton("groovy")
     }
 
+    @Override
+    protected MapPropertySource createPropertySource(String name, Map<String, Object> map, int order) {
+        return super.createPropertySource("grails.$name", map, order)
+    }
+
+    void processEnvironmentSpecificProperties(finalMap, Map<String, Object> propertySource) {
+        final String environmentName = Environment.current.name
+        if (environmentName != null) {
+            final String environmentPrefix = GrailsPlugin.ENVIRONMENTS + '.' +  environmentName + '.'
+            propertySource.keySet().stream()
+                    .filter(k -> k.startsWith(environmentPrefix))
+                    .forEach(propertyName -> { finalMap[propertyName.substring(environmentPrefix.length())] = propertySource.get(propertyName) })
+        }
+    }
+
 }

grails-core/src/main/groovy/org/grails/core/cfg/MicronautYamlPropertySourceLoader.groovy

@@ -0,0 +1,54 @@
+package org.grails.core.cfg
+
+import grails.plugins.GrailsPlugin
+import grails.util.Environment
+import groovy.transform.CompileStatic
+import io.micronaut.context.env.MapPropertySource
+import io.micronaut.context.env.yaml.YamlPropertySourceLoader
+
+/**
+ * Load properties from a YAML file. This class extends the Micronaut default implementation {@link io.micronaut.context.env.yaml.YamlPropertySourceLoader} where it adds support for Micronaut beans receive configuration from environments block.
+ *
+ * @author Puneet Behl
+ * @since 6.0.0
+ */
+@CompileStatic
+class MicronautYamlPropertySourceLoader extends YamlPropertySourceLoader {
+
+    @Override
+    int getOrder() {
+        return super.getOrder() + 1
+    }
+
+    @Override
+    protected MapPropertySource createPropertySource(String name, Map<String, Object> map, int order) {
+        return super.createPropertySource("grails.$name", map, order)
+    }
+
+    /**
+     * Only process environment specific entries as the other entries are already processed by Micronaut default {@link io.micronaut.context.env.yaml.YamlPropertySourceLoader}
+     *
+     * @param finalMap The map with all the properties processed
+     * @param map The map to process
+     * @param prefix The prefix for the keys
+     */
+    @Override
+    protected void processMap(Map<String, Object> finalMap, Map map, String prefix) {
+        final String env = Environment.current.name
+        if (env != null) {
+            final String grailsEnvironmentPrefix = GrailsPlugin.ENVIRONMENTS + '.' + env + '.'
+            ((Map<String, Object>) map).entrySet().stream()
+                    .filter(e -> e.key instanceof String && (((String) e.key).startsWith(GrailsPlugin.ENVIRONMENTS) || prefix.startsWith(GrailsPlugin.ENVIRONMENTS)))
+                    .forEach(e -> {
+                        Map.Entry entry = (Map.Entry) e
+                        String key = entry.getKey().toString()
+                        Object value = entry.getValue()
+                        if (value instanceof Map && !((Map) value).isEmpty()) {
+                            processMap(finalMap, (Map) value, prefix + key + '.')
+                        } else if ((prefix + key).startsWith(grailsEnvironmentPrefix)) {
+                            finalMap.put((prefix + key).substring(grailsEnvironmentPrefix.length()), value)
+                        }
+                    })
+        }
+    }
+}

grails-core/src/main/resources/META-INF/services/io.micronaut.context.env.PropertySourceLoader

@@ -1 +1,2 @@
+org.grails.core.cfg.MicronautYamlPropertySourceLoader
 org.grails.core.cfg.MicronautGroovyPropertySourceLoader

grails-core/src/test/groovy/org/grails/core/cfg/EnvironmentAwareSpec.groovy

@@ -0,0 +1,23 @@
+package org.grails.core.cfg
+
+import grails.util.Environment
+
+trait EnvironmentAwareSpec {
+
+    Environment previous = null
+
+    void setEnvironment(Environment environment) {
+        if (System.hasProperty(Environment.KEY)) {
+            previous = Environment.getEnvironment(System.getProperty(Environment.KEY))
+        }
+        System.setProperty(Environment.KEY, environment ? environment.getName() : '')
+    }
+
+    void resetEnvironment() {
+        if (previous) {
+            System.setProperty(Environment.KEY, previous.getName())
+        } else {
+            System.setProperty(Environment.KEY, '')
+        }
+    }
+}

grails-core/src/test/groovy/org/grails/core/cfg/GroovyConfigPropertySourceLoaderSpec.groovy

@@ -1,5 +1,6 @@
 package org.grails.core.cfg
 
+import grails.util.Environment
 import org.grails.config.PropertySourcesConfig
 import org.springframework.core.env.MutablePropertySources
 import org.springframework.core.env.PropertySources
@@ -8,7 +9,11 @@ import org.springframework.core.io.Resource
 import spock.lang.Specification
 
 @SuppressWarnings("GrMethodMayBeStatic")
-class GroovyConfigPropertySourceLoaderSpec extends Specification {
+class GroovyConfigPropertySourceLoaderSpec extends Specification implements EnvironmentAwareSpec {
+
+    void setup() {
+        resetEnvironment()
+    }
 
     void "test loading multiple configuration files"() {
         setup:
@@ -17,6 +22,7 @@ class GroovyConfigPropertySourceLoaderSpec extends Specification {
 
         GroovyConfigPropertySourceLoader groovyPropertySourceLoader = new GroovyConfigPropertySourceLoader()
         Map<String, Object> finalMap = [:]
+        environment = Environment.TEST
 
         when:
         PropertySources propertySources = new MutablePropertySources()
@@ -25,8 +31,9 @@ class GroovyConfigPropertySourceLoaderSpec extends Specification {
         def config = new PropertySourcesConfig(propertySources)
 
         then:
-        config.size() == 7
+        config.size() == 9
         config.getProperty("my.local.var", String.class) == "test"
+        config.getProperty("foo.bar", String.class) == "test"
         config.getProperty("userHomeVar", String.class)
 
     }

grails-core/src/test/groovy/org/grails/core/cfg/MicronautContextAwareSpec.groovy

@@ -0,0 +1,67 @@
+package org.grails.core.cfg
+
+import grails.util.Environment
+import grails.util.SupplierUtil
+import io.micronaut.context.ApplicationContext
+import io.micronaut.context.ApplicationContextBuilder
+import io.micronaut.context.ApplicationContextConfigurer
+import io.micronaut.context.annotation.ContextConfigurer
+import io.micronaut.context.env.PropertySource
+import io.micronaut.spring.context.factory.MicronautBeanFactoryConfiguration
+import org.springframework.core.convert.ConversionService
+import org.springframework.core.env.ConfigurableEnvironment
+import org.springframework.core.env.PropertyResolver
+import org.springframework.lang.NonNull
+
+import java.util.function.Supplier
+
+trait MicronautContextAwareSpec {
+
+    ApplicationContext micronautContext
+    String[] environments = new String[5]
+    Supplier<ClassLoader> classLoader = SupplierUtil.memoized(() -> this.getClass().getClassLoader())
+
+    ApplicationContextBuilder micronautContextBuilder() {
+        if (Environment.current != null) {
+            environments[0] = Environment.current.getName()
+        }
+        final ApplicationContextBuilder builder = ApplicationContext.builder()
+                .classLoader(classLoader.get())
+                .deduceEnvironment(false)
+                .propertySources(PropertySource.of("grails-config", [(MicronautBeanFactoryConfiguration.PREFIX + ".bean-excludes"): (Object) beanExcludes]))
+                .environments(environments)
+
+        builder
+    }
+
+    ApplicationContext getMicronautContext() {
+        if (micronautContext == null) {
+            micronautContext = micronautContextBuilder().build()
+        }
+        micronautContext
+    }
+
+    ApplicationContext start() {
+        if (micronautContext != null) {
+            micronautContext.start()
+        }
+    }
+
+    List<Class<?>> getBeanExcludes() {
+        List beanExcludes = []
+        beanExcludes.add(ConversionService.class)
+        beanExcludes.add(org.springframework.core.env.Environment.class)
+        beanExcludes.add(PropertyResolver.class)
+        beanExcludes.add(ConfigurableEnvironment.class)
+        def objectMapper = io.micronaut.core.reflect.ClassUtils.forName("com.fasterxml.jackson.databind.ObjectMapper", classLoader.get()).orElse(null)
+        if (objectMapper != null) {
+            beanExcludes.add(objectMapper)
+        }
+        beanExcludes
+    }
+
+    void setClassLoader(ClassLoader classLoader) {
+        this.classLoader = SupplierUtil.memoized(() -> classLoader)
+    }
+
+}

grails-core/src/test/groovy/org/grails/core/cfg/MicronautGroovyPropertySourceLoaderSpec.groovy

@@ -1,12 +1,47 @@
 package org.grails.core.cfg
 
+import grails.util.Environment
 import grails.util.Metadata
-import io.micronaut.context.exceptions.ConfigurationException
-import org.grails.config.NavigableMap
 import spock.lang.Specification
 
 @SuppressWarnings("GrMethodMayBeStatic")
-class MicronautGroovyPropertySourceLoaderSpec extends Specification {
+class MicronautGroovyPropertySourceLoaderSpec extends Specification implements EnvironmentAwareSpec{
+
+    void setup() {
+        resetEnvironment()
+    }
+
+    void "test read environment specific property" () {
+        setup:
+        final URL resource = getClass().getClassLoader().getResource("test-application.groovy")
+        final MicronautGroovyPropertySourceLoader groovyPropertySourceLoader = new MicronautGroovyPropertySourceLoader()
+        environment = Environment.TEST
+
+        when:
+        final Map<String, Object> finalMap = groovyPropertySourceLoader.read("test-application.groovy", resource.openStream())
+
+        then:
+        finalMap.get("foo.bar") == "test"
+    }
+
+    void "test read environment specific property takes precedence"() {
+        setup:
+        final URL resource = getClass().getClassLoader().getResource("test-application.groovy")
+        final MicronautGroovyPropertySourceLoader groovyPropertySourceLoader = new MicronautGroovyPropertySourceLoader()
+
+        when:
+        final Map<String, Object> finalMap = groovyPropertySourceLoader.read("test-application.groovy", resource.openStream())
+
+        then:
+        finalMap.get("foo.bar") == "default"
+
+        when:
+        environment = Environment.TEST
+
+        then:
+        final Map<String, Object> finalMap2 = groovyPropertySourceLoader.read("test-application.groovy", resource.openStream())
+        finalMap2.get("foo.bar") == "test"
+    }
 
     void "test parsing configuration file with DSL"() {