feature: #14017 - add optional micronaut support via grails-micronaut

Author: jdaugherty

gradle.properties

@@ -56,10 +56,14 @@ org.gradle.daemon=true
 # this is a future TODO see groovydoc-tool-rewrite branch for experiementations with this
 org.gradle.jvmargs=-Dfile.encoding=UTF-8 -Xmx5G
 
+# micronaut libraries not in the bom due to the potential for spring mismatches
+micronautPlatformVersion=4.9.2
+# note: we do not import the micronaut bom in our tests to avoid spring version mismatches
+micronautHttpClientVersion=4.9.9
+micronautSerdeJacksonVersion=2.11.0
+
 # libraries only specific to test apps, these should not be exposed
 jbossTransactionApiVersion=2.0.0.Final
-micronautVersion=4.6.5
-micronautSerdeJacksonVersion=2.11.0
 grailsSpringSecurityVersion=7.0.0-SNAPSHOT
 
 # This prevents the Grails Gradle Plugin from unnecessarily excluding slf4j-simple in the generated POMs

gradle/publish-root-config.gradle

@@ -65,6 +65,7 @@ def publishedProjects = [
         'grails-interceptors',
         'grails-logging',
         'grails-mimetypes',
+        'grails-micronaut',
         'grails-rest-transforms',
         'grails-scaffolding',
         'grails-services',

grails-core/src/main/groovy/grails/boot/GrailsApp.groovy

@@ -72,10 +72,10 @@ class GrailsApp extends SpringApplication {
      * Create a new {@link GrailsApp} instance. The application context will load
      * beans from the specified sources (see {@link SpringApplication class-level}
      * documentation for details. The instance can be customized before calling
-     * {@link #run(String...)}.
+     * {@link #run(String ...)}.
      * @param sources the bean sources
-     * @see #run(Object, String[])
-     * @see #GrailsApp(org.springframework.core.io.ResourceLoader, Class<?>...)
+     * @see #run(Class [ ], String [ ])
+     * @see #GrailsApp(org.springframework.core.io.ResourceLoader, Class <?> ...)
      */
     GrailsApp(Class<?>... sources) {
         super(sources)
@@ -85,11 +85,11 @@ class GrailsApp extends SpringApplication {
      * Create a new {@link GrailsApp} instance. The application context will load
      * beans from the specified sources (see {@link SpringApplication class-level}
      * documentation for details. The instance can be customized before calling
-     * {@link #run(String...)}.
+     * {@link #run(String ...)}.
      * @param resourceLoader the resource loader to use
      * @param sources the bean sources
-     * @see #run(Object, String[])
-     * @see #GrailsApp(org.springframework.core.io.ResourceLoader, Class<?>...)
+     * @see #run(Class [ ], String [ ])
+     * @see #GrailsApp(org.springframework.core.io.ResourceLoader, Class <?> ...)
      */
     GrailsApp(ResourceLoader resourceLoader, Class<?>... sources) {
         super(resourceLoader, sources)
@@ -100,12 +100,12 @@ class GrailsApp extends SpringApplication {
         ConfigurableApplicationContext applicationContext = super.run(args)
         Environment environment = Environment.getCurrent()
 
-        log.info("Application starting in environment: {}", environment.getName())
-        log.debug("Application directory discovered as: {}", IOUtils.findApplicationDirectory())
-        log.debug("Current base directory is [{}]. Reloading base directory is [{}]", new File("."), BuildSettings.BASE_DIR)
+        log.info('Application starting in environment: {}', environment.getName())
+        log.debug('Application directory discovered as: {}', IOUtils.findApplicationDirectory())
+        log.debug('Current base directory is [{}]. Reloading base directory is [{}]', new File('.'), BuildSettings.BASE_DIR)
 
         if (environment.isReloadEnabled()) {
-            log.debug("Reloading status: {}", environment.isReloadEnabled())
+            log.debug('Reloading status: {}', environment.isReloadEnabled())
             enableDevelopmentModeWatch(environment, applicationContext)
             environment.isDevtoolsRestart()
         }
@@ -152,6 +152,7 @@ class GrailsApp extends SpringApplication {
             Queue<File> newFiles = new ConcurrentLinkedQueue<>()
 
             directoryWatcher.addListener(new FileExtensionFileChangeListener(['groovy', 'java']) {
+
                 @Override
                 void onChange(File file, List<String> extensions) {
                     changedFiles << file.canonicalFile
@@ -162,7 +163,7 @@ class GrailsApp extends SpringApplication {
                     changedFiles << file.canonicalFile
                     // For some bizarre reason Windows fires onNew events even for files that have
                     // just been modified and not created
-                    if (System.getProperty("os.name").toLowerCase().indexOf("windows") != -1) {
+                    if (System.getProperty('os.name').toLowerCase().indexOf('windows') != -1) {
                         return
                     }
                     newFiles << file.canonicalFile
@@ -225,7 +226,6 @@ class GrailsApp extends SpringApplication {
                 }
             }
 
-
             developmentModeActive = true
             Thread.start {
                 CompilerConfiguration compilerConfig = new CompilerConfiguration()
@@ -302,12 +302,12 @@ class GrailsApp extends SpringApplication {
         }
         def baseFileLocation = appDir?.absolutePath ?: location
         compilerConfig.setTargetDirectory(new File(baseFileLocation, BuildSettings.BUILD_CLASSES_PATH))
-        println "File $changedFile changed, recompiling..."
+        printf('File %s changed, recompiling...%n', changedFile)
         if (changedFile.name.endsWith('.java')) {
             if (JavaCompiler.isAvailable()) {
                 JavaCompiler.recompile(compilerConfig, changedFile)
             } else {
-                log.error("Cannot recompile [$changedFile.name], the current JVM is not a JDK (recompilation will not work on a JRE missing the compiler APIs).")
+                log.error('Cannot recompile [{}], the current JVM is not a JDK (recompilation will not work on a JRE missing the compiler APIs).', changedFile.name)
             }
         } else {
             compileGroovyFile(compilerConfig, changedFile)
@@ -335,6 +335,7 @@ class GrailsApp extends SpringApplication {
     protected static DirectoryWatcher.FileChangeListener createPluginManagerListener(ConfigurableApplicationContext applicationContext) {
         def pluginManager = applicationContext.getBean(GrailsPluginManager)
         return new DirectoryWatcher.FileChangeListener() {
+
             @Override
             void onChange(File file) {
                 if (!file.name.endsWith('.groovy') && !file.name.endsWith('.java')) {
@@ -352,9 +353,9 @@ class GrailsApp extends SpringApplication {
     }
 
     protected void configureDirectoryWatcher(DirectoryWatcher directoryWatcher, String location) {
-        directoryWatcher.addWatchDirectory(new File(location, "grails-app"), ['groovy', 'java'])
-        directoryWatcher.addWatchDirectory(new File(location, "src/main/groovy"), ['groovy', 'java'])
-        directoryWatcher.addWatchDirectory(new File(location, "src/main/java"), ['groovy', 'java'])
+        directoryWatcher.addWatchDirectory(new File(location, 'grails-app'), ['groovy', 'java'])
+        directoryWatcher.addWatchDirectory(new File(location, 'src/main/groovy'), ['groovy', 'java'])
+        directoryWatcher.addWatchDirectory(new File(location, 'src/main/java'), ['groovy', 'java'])
     }
 
     protected printRunStatus(ConfigurableApplicationContext applicationContext) {
@@ -363,11 +364,11 @@ class GrailsApp extends SpringApplication {
             String protocol = app.config.getProperty('server.ssl.key-store') ? 'https' : 'http'
             String contextPath = app.config.getProperty('server.servlet.context-path', '')
             String hostName = app.config.getProperty('server.address', 'localhost')
-            int port
+            int port = 0
             if (applicationContext instanceof WebServerApplicationContext) {
                 port = applicationContext.webServer.port
             }
-            println("Grails application running at ${protocol}://${hostName}:${port}${contextPath} in environment: ${Environment.current.name}")
+            printf('Grails application running at %s://%s:%s%s in environment: %s%n', protocol, hostName, port, contextPath, Environment.current.name)
 
         } catch (ignore) {
         }

grails-core/src/main/groovy/grails/boot/config/GrailsApplicationPostProcessor.groovy

@@ -39,6 +39,7 @@ import org.grails.config.PropertySourcesConfig
 import org.grails.core.exceptions.GrailsConfigurationException
 import org.grails.core.lifecycle.ShutdownOperations
 import org.grails.datastore.mapping.model.MappingContext
+import org.grails.plugins.core.CoreAutoConfiguration
 import org.grails.spring.DefaultRuntimeSpringConfiguration
 import org.grails.spring.RuntimeSpringConfigUtilities
 import org.springframework.beans.BeansException

grails-dependencies/starter-web/build.gradle

@@ -47,7 +47,7 @@ def configurations = [
                 ':grails-gsp',
                 ':grails-i18n',
                 ':grails-interceptors',
-                ':grails-layout', // layout will be the default because it's fully functional while sitemesh3 still has issues
+                System.getenv('SITEMESH3_TESTING_ENABLED') == 'true' ? ':grails-sitemesh3' : ':grails-layout',
                 ':grails-logging',
                 ':grails-rest-transforms',
                 ':grails-services',

grails-gradle/plugins/src/main/groovy/org/grails/gradle/plugin/core/GrailsGradlePlugin.groovy

@@ -29,7 +29,6 @@ import io.spring.gradle.dependencymanagement.dsl.DependencyManagementExtension
 import org.apache.grails.gradle.common.PropertyFileUtils
 import org.apache.tools.ant.filters.EscapeUnicode
 import org.apache.tools.ant.filters.ReplaceTokens
-import org.gradle.api.Action
 import org.gradle.api.GradleException
 import org.gradle.api.NamedDomainObjectProvider
 import org.gradle.api.Plugin
@@ -72,10 +71,6 @@ import org.springframework.boot.gradle.tasks.bundling.BootArchive
 import org.springframework.boot.gradle.tasks.run.BootRun
 
 import javax.inject.Inject
-import java.nio.charset.StandardCharsets
-import java.time.LocalDate
-import java.time.ZoneOffset
-import java.util.regex.Pattern
 
 /**
  * The main Grails gradle plugin implementation
@@ -386,17 +381,21 @@ class GrailsGradlePlugin extends GroovyPlugin {
 
     @CompileStatic
     protected void configureMicronaut(Project project) {
-        final String micronautVersion = project.properties['micronautVersion']
-        if (micronautVersion) {
-            project.configurations.configureEach({ Configuration configuration ->
-                configuration.resolutionStrategy.eachDependency({ DependencyResolveDetails details ->
-                    String dependencyName = details.requested.name
-                    String group = details.requested.group
-                    if (group == 'io.micronaut' && dependencyName.startsWith('micronaut')) {
-                        details.useVersion(micronautVersion)
-                    }
-                } as Action<DependencyResolveDetails>)
-            } as Action<Configuration>)
+        project.afterEvaluate {
+            boolean micronautEnabled = project.getConfigurations().getByName("implementation").getDependencies().findAll { Dependency dep -> dep.group == 'org.apache.grails' && dep.name == 'grails-micronaut' } as boolean
+            if (!micronautEnabled) {
+                return
+            }
+            project.logger.lifecycle('Micronaut Support Detected for {} - adding annotation processor dependencies for Micronaut', project.path)
+
+            final String micronautPlatformVersion = project.properties['micronautPlatformVersion']
+            if (!micronautPlatformVersion) {
+                throw new GradleException("`micronautPlatformVersion` property must be set to use the Grails Micronaut plugin.")
+            }
+
+            project.getDependencies().add('annotationProcessor', project.dependencies.platform("io.micronaut.platform:micronaut-platform:$micronautPlatformVersion"))
+            project.getDependencies().add('annotationProcessor', 'io.micronaut:micronaut-inject-java')
+            project.getDependencies().add('annotationProcessor', 'jakarta.annotation:jakarta.annotation-api')
         }
     }
 

grails-gradle/plugins/src/main/groovy/org/grails/gradle/plugin/views/gsp/GroovyPageForkCompileTask.groovy

@@ -133,6 +133,7 @@ abstract class GroovyPageForkCompileTask extends AbstractCompile {
                     void execute(JavaExecSpec javaExecSpec) {
                         javaExecSpec.mainClass.set(getCompilerName())
                         javaExecSpec.setClasspath(getClasspath())
+                        //javaExecSpec.setJvmArgs(['-Xmx2g', '-Xdebug', '-Xnoagent','-Djava.compiler=NONE', '-Xrunjdwp:transport=dt_socket,server=y,suspend=y,address=5005'])
 
                         def jvmArgs = compileOptions.forkOptions.jvmArgs
                         if (jvmArgs) {

grails-micronaut/build.gradle

@@ -0,0 +1,84 @@
+/*
+ *  Licensed to the Apache Software Foundation (ASF) under one
+ *  or more contributor license agreements.  See the NOTICE file
+ *  distributed with this work for additional information
+ *  regarding copyright ownership.  The ASF licenses this file
+ *  to you 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.
+ */
+
+plugins {
+    id 'groovy'
+    id 'java-library'
+    id 'project-report'
+}
+
+version = projectVersion
+group = 'org.apache.grails'
+
+// force a local build version for debugging
+//project.configurations.configureEach({ Configuration configuration ->
+//    configuration.resolutionStrategy.eachDependency({ DependencyResolveDetails details ->
+//        String dependencyName = details.requested.name
+//        String group = details.requested.group
+//        if (group == 'io.micronaut' && dependencyName.startsWith('micronaut-core-processor')) {
+//            logger.lifecycle("Forcing Micronaut Core Processor version to 4.9.99 for Grails Micronaut plugin")
+//            details.useVersion('4.9.99')
+//        }
+//    } as Action<DependencyResolveDetails>)
+//} as Action<Configuration>)
+
+dependencies {
+    annotationProcessor platform(project(':grails-bom'))
+    annotationProcessor platform("io.micronaut.platform:micronaut-platform:$micronautPlatformVersion")
+    annotationProcessor 'io.micronaut:micronaut-inject-java'
+    annotationProcessor 'jakarta.annotation:jakarta.annotation-api'
+
+    compileOnlyApi platform("io.micronaut.platform:micronaut-platform:$micronautPlatformVersion")
+    compileOnlyApi 'io.micronaut:micronaut-inject-groovy'
+    compileOnlyApi 'io.micronaut:micronaut-inject-java'
+
+    api platform("io.micronaut.platform:micronaut-platform:$micronautPlatformVersion")
+    api 'io.micronaut.spring:micronaut-spring-boot-starter'
+    api "io.micronaut.spring:micronaut-spring-context", {
+        // required to load the micronaut environment with plugin configuration
+        exclude group: "org.slf4j", module: "slf4j-simple"
+    }
+    api "io.micronaut.cache:micronaut-cache-core", {
+        exclude group:"org.slf4j", module: "slf4j-simple"
+    }
+
+    implementation platform(project(':grails-bom'))
+    compileOnly project(':grails-core')
+
+    // Logging
+    compileOnly 'org.slf4j:slf4j-api'
+    compileOnly 'org.slf4j:jcl-over-slf4j'
+
+    // Testing
+    testImplementation platform(project(':grails-bom'))
+    testImplementation 'org.slf4j:slf4j-simple'
+    testImplementation('org.spockframework:spock-core') { transitive = false }
+
+    // Required by Spock's Mocking
+    testRuntimeOnly 'net.bytebuddy:byte-buddy'
+    testImplementation 'org.objenesis:objenesis'
+}
+
+apply {
+    // java-configuration must be applied first since tasks are now lazy registered
+    from rootProject.layout.projectDirectory.file('gradle/java-config.gradle')
+    from rootProject.layout.projectDirectory.file('gradle/docs-config.gradle')
+    from rootProject.layout.projectDirectory.file('gradle/publish-config.gradle')
+    from rootProject.layout.projectDirectory.file('gradle/test-config.gradle')
+}

grails-micronaut/src/main/groovy/org/apache/grails/micronaut/GrailsMicronautGrailsPlugin.groovy

@@ -0,0 +1,74 @@
+/*
+ *  Licensed to the Apache Software Foundation (ASF) under one
+ *  or more contributor license agreements.  See the NOTICE file
+ *  distributed with this work for additional information
+ *  regarding copyright ownership.  The ASF licenses this file
+ *  to you 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.apache.grails.micronaut
+
+import grails.plugins.GrailsPlugin
+import grails.plugins.GrailsPluginManager
+import grails.plugins.Plugin
+import groovy.util.logging.Slf4j
+import io.micronaut.context.ConfigurableApplicationContext
+import io.micronaut.context.env.AbstractPropertySourceLoader
+import io.micronaut.context.env.Environment
+import io.micronaut.context.env.PropertySource
+
+@Slf4j
+class GrailsMicronautGrailsPlugin extends Plugin {
+
+    def grailsVersion = '7.0.0-SNAPSHOT > *'
+    def title = 'Grails Micronaut Plugin'
+
+    @Override
+    void doWithApplicationContext() {
+        String[] beanNames = applicationContext.getBeanNamesForType(GrailsPluginManager)
+        GrailsPluginManager pluginManagerFromContext = beanNames.length ?
+                applicationContext.getBean(GrailsPluginManager) :
+                null
+
+        if (!pluginManagerFromContext && !pluginManager) {
+            // No plugin managers to search for plugin configurations
+            return
+        }
+
+        if (!applicationContext.containsBean('micronautApplicationContext')) {
+            throw new IllegalStateException("A Micronaut Application Context should exist prior to the loading of the Grails Micronaut plugin.")
+        }
+
+        ConfigurableApplicationContext micronautContext = applicationContext.getBean('micronautApplicationContext', ConfigurableApplicationContext)
+        Environment micronautEnv = micronautContext.getEnvironment()
+
+        log.debug("Loading configurations from the plugins to the parent Micronaut context")
+        final GrailsPlugin[] plugins = pluginManager.allPlugins
+        final GrailsPlugin[] pluginsFromContext = pluginManagerFromContext ? pluginManagerFromContext.allPlugins : new GrailsPlugin[]{}
+        Integer priority = AbstractPropertySourceLoader.DEFAULT_POSITION
+        [plugins, pluginsFromContext].each { GrailsPlugin[] pluginsToProcess ->
+            Arrays.stream(pluginsToProcess)
+                    .filter({ GrailsPlugin plugin -> plugin.propertySource != null })
+                    .forEach({ GrailsPlugin plugin ->
+                        if (log.isDebugEnabled()) {
+                            log.debug("Loading configurations from {} plugin to the parent Micronaut context", plugin.name)
+                        }
+                        // If invoking the source as `.source`, the NavigableMapPropertySource will return null, while invoking the getter, it will return the correct value
+                        micronautEnv.addPropertySource(PropertySource.of("grails.plugins.$plugin.name", (Map) plugin.propertySource.getSource(), --priority))
+                    })
+        }
+        micronautEnv.refresh()
+//            applicationContext.setParent(parentApplicationContext)
+    }
+}

grails-spring/src/main/groovy/org/grails/spring/GrailsApplicationContext.java

@@ -71,7 +71,13 @@ public GrailsApplicationContext() throws org.springframework.beans.BeansExceptio
 
     @Override
     public boolean containsBeanDefinition(String beanName) {
-        return super.containsBeanDefinition(beanName);
+        if(super.containsBeanDefinition(beanName)) {
+            return true;
+        } else if (getParent() != null && "grailsApplication".equals(beanName)) {
+            return getParent().containsBeanDefinition(beanName);
+        } else {
+            return false;
+        }
     }
 
     public MetaClass getMetaClass() {